I can’t understand why Python doesn’t have a sign
function. It has an abs
builtin (which I consider sign
‘s sister), but no sign
.
In python 2.6 there is even a copysign
function (in math), but no sign. Why bother to write a copysign(x,y)
when you could just write a sign
and then get the copysign
directly from abs(x) * sign(y)
? The latter would be much more clear: x with the sign of y, whereas with copysign you have to remember if it’s x with the sign of y or y with the sign of x!
Obviously sign(x)
does not provide anything more than cmp(x,0)
, but it would be much more readable that this too (and for a greatly readable language like python, this would have been a big plus).
If I were a python designer, I would been the other way arond: no cmp
builtin, but a sign
. When you need cmp(x,y)
, you could just do a sign(xy)
(or, even better for nonnumerical stuff, just a x>y – of course this should have required sorted
accepting a boolean instead of an integer comparator). This would also be more clear: positive when x>y
(whereas with cmp
you have to remember the convention positive when the first is bigger, but it could be the other way around). Of course cmp
makes sense in its own for other reasons (e.g. when sorting nonnumerical things, or if you want the sort to be stable, which is not possible using with simply a boolean)
So, the question is: why did the Python designer(s) decide to leave the sign
function out of the language? Why the heck bother with copysign
and not its parent sign
?
Am I missing something?
EDIT – after Peter Hansen comment.
Fair enough that you didn’t use it, but you didn’t say what you use python for. In 7 years that I use python, I needed it countless times, and the last is the straw that broke the camel’s back!
Yes, you can pass cmp around, but 90% of the times that I needed to pass it was in an idiom like
lambda x,y: cmp(score(x),score(y))
that would have worked with sign just fine.
Finally, I hope you agree that sign
would be more useful than copysign
, so even if I bought your view, why bother about defining that in math, instead of sign? How can copysign be so much useful than sign?
9
EDIT:
Indeed there was a patch which included sign()
in math, but it wasn’t accepted, because they didn’t agree on what it should return in all the edge cases (+/0, +/nan, etc)
So they decided to implement only copysign, which (although more verbose) can be used to delegate to the end user the desired behavior for edge cases – which sometimes might require the call to cmp(x,0)
.
I don’t know why it’s not a builtin, but I have some thoughts.
copysign(x,y):
Return x with the sign of y.
Most importantly, copysign
is a superset of sign
! Calling copysign
with x=1 is the same as a sign
function. So you could just use copysign
and forget about it.
>>> math.copysign(1, 4)
1.0
>>> math.copysign(1, 3)
1.0
If you get sick of passing two whole arguments, you can implement sign
this way, and it will still be compatible with the IEEE stuff mentioned by others:
>>> sign = functools.partial(math.copysign, 1) # either of these
>>> sign = lambda x: math.copysign(1, x) # two will work
>>> sign(4)
1.0
>>> sign(3)
1.0
>>> sign(0)
1.0
>>> sign(0.0)
1.0
>>> sign(float('nan'))
1.0
Secondly, usually when you want the sign of something, you just end up multiplying it with another value. And of course that’s basically what copysign
does.
So, instead of:
s = sign(a)
b = b * s
You can just do:
b = copysign(b, a)
And yes, I’m surprised you’ve been using Python for 7 years and think cmp
could be so easily removed and replaced by sign
! Have you never implemented a class with a __cmp__
method? Have you never called cmp
and specified a custom comparator function?
In summary, I’ve found myself wanting a sign
function too, but copysign
with the first argument being 1 will work just fine. I disagree that sign
would be more useful than copysign
, as I’ve shown that it’s merely a subset of the same functionality.
8
 48
Using
[int(copysign(1, zero)) for zero in (0, 0.0, 0.0)]
gives[1, 1, 1]
. That should have been[0, 0, 0]
according to en.wikipedia.org/wiki/Sign_functionJan 1, 2010 at 5:07
 13
@Andrew – @user238424’s calling order is correct.
copysign(a,b)
returns a with the sign of b – b is the varying input, a is the value to normalize to with b’s sign. In this case, the commenter is illustrating that copysign(1,x) as a replacement for sign(x) fails, since it returns 1 for x=0, whereas sign(0) would evaluate to 0.– PaulMcGMar 12, 2011 at 16:32
 7
Floats hold “sign” separate from “value”; 0.0 is a negative number, even if that seems an implementation error. Simply using
cmp()
will give the desired results, probably for nearly every case anyone would care about:[cmp(zero, 0) for zero in (0, 0.0, 0.0, 4, 5)]
==>[0, 0, 0, 1, 1]
.Jun 27, 2013 at 19:24
 16
s = sign(a) b = b * s
is not equivalent tob = copysign(b, a)
! It does not consider the sign of b. E.g. ifa=b=1
the first code will return 1 while the second returns 1Jul 28, 2015 at 13:20
 18
Seeing the false sign() replacement definition, the false equivalent for multiplication with sign(a), the false explanation for the motivation of copysign, and the correct replacement “cmp(x, 0)” being already mentioned in the question – there is not much info and it is unclear to me why this is the “accepted” answer with so many votes.?
– kxrAug 18, 2016 at 10:21
copysign()
is defined by IEEE 754, and part of the C99 specification. That’s why it’s in Python. The function cannot be implemented in full by abs(x) * sign(y)
because of how it’s supposed to handle NaN
values.
>>> import math
>>> math.copysign(1, float("nan"))
1.0
>>> math.copysign(1, float("nan"))
1.0
>>> math.copysign(float("nan"), 1)
nan
>>> math.copysign(float("nan"), 1)
nan
>>> float("nan") * 1
nan
>>> float("nan") * 1
nan
>>>
That makes copysign()
a more useful function than sign()
.
As to specific reasons why IEEE’s signbit(x)
is not available in standard Python, I don’t know. I can make assumptions, but it would be guessing.
The math module itself uses copysign(1, x)
as a way to check if x
is negative or nonnegative. For most cases dealing with mathematical functions that seems more useful than having a sign(x)
which returns 1
, 0
, or 1
because there’s one less case to consider. For example, the following is from Python’s math
module:
static double
m_atan2(double y, double x)
{
if (Py_IS_NAN(x)  Py_IS_NAN(y))
return Py_NAN;
if (Py_IS_INFINITY(y)) {
if (Py_IS_INFINITY(x)) {
if (copysign(1., x) == 1.)
/* atan2(+inf, +inf) == +pi/4 */
return copysign(0.25*Py_MATH_PI, y);
else
/* atan2(+inf, inf) == +pi*3/4 */
return copysign(0.75*Py_MATH_PI, y);
}
/* atan2(+inf, x) == +pi/2 for finite x */
return copysign(0.5*Py_MATH_PI, y);
There you can clearly see that copysign()
is a more effective function than a threevalued sign()
function.
You wrote:
If I were a python designer, I would been the other way around: no
cmp
builtin, but asign
.
That means you don’t know that cmp()
is used for things besides numbers. cmp("This", "That")
cannot be implemented with a sign()
function.
Edit to collate my additional answers elsewhere:
You base your justifications on how abs()
and sign()
are often seen together. As the C standard library does not contain a sign(x)
function of any sort, I don’t know how you justify your views. There’s an abs(int)
and fabs(double)
and fabsf(float)
and fabsl(long)
but no mention of sign()
. There is copysign()
and signbit()
but those only apply to IEEE 754 numbers.
With complex numbers, what would sign(3+4j) return in Python, were it to be implemented? abs(3+4j)
return 5.0. That’s a clear example of how abs()
can be used in places where sign()
makes no sense.
Suppose sign(x)
were added to Python, as a complement to abs(x)
. If x
is an instance of a userdefined class which implements the __abs__(self)
method then abs(x)
will call x.__abs__()
. In order to work correctly, to handle abs(x)
in the same way then Python will have to gain a __sign__(x)
slot.
This is excessive for a relatively unneeded function. Besides, why should sign(x)
exist and nonnegative(x)
and nonpositive(x)
not exist? My snippet from Python’s math module implementation shows how copysign(x, y)
can be used to implement nonnegative()
, which a simple sign(x)
cannot do.
Python should have better support for IEEE 754/C99 math functions. That would add a signbit(x)
function, which would do what you want in the case of floats. It would not work for integers or complex numbers, much less strings, and it wouldn’t have the name you are looking for.
You ask “why”, and the answer is “sign(x)
isn’t useful.” You assert that it is useful. Yet your comments show that you do not know enough to be able to make that assertion, which means you would have to show convincing evidence of its need. Saying that NumPy implements it is not convincing enough. You would need to show cases of how existing code would be improved with a sign()
function.
And that it outside the scope of StackOverflow. Take it instead to one of the Python lists.
5
 5
Well, I don’t if that will make you happy, but Python 3 has neither
cmp()
norsign()
🙂Dec 31, 2009 at 19:25
 5
writing a good sign() function that would work properly with IEEE 754 is not trivial. This would be a good point to include it in the language, rather than leaving it out, even though I didn’t elaborate this point in the question
– DavideDec 31, 2009 at 19:32
 2
Your comment about how “if you want the sort to be stable” means you also don’t know how stable sort works. Your statement that copysign and sign are equivalent show that you didn’t know much about IEEE 754 math before this post. Should Python implement all of the 754 math functions in core? What should it do for nonC99 compilers? Non754 platforms? “isnonnegative” and “isnonpositive” are also useful functions. Should Python also include those? abs(x) defers to x.__abs__(), so should sign(x) defer to x.__sign__() ? There’s little demand or need for it, so why should it be stuck into core?
Dec 31, 2009 at 22:19
 2
math.copysign(1, float(“nan”)) returns 1.0 instead of 1.0 when I try it in 2.7
– dansalmoMay 24, 2013 at 3:39
 2
The sign or signum function is a standard mathematical function defined as sign(z) = z/z. Its meaning for complex numbers is welldefined; just use that same definition with the complex version of division and absolute value. The result is a complex number whose magnitude is 1; e.g. sign(3+4j) is 0.6+0.8j. I don’t see how the function’s absence in C is relevant to its absence from Python. It exists in Microsoft BASIC; does that matter?
Jan 5 at 21:45
Another one liner for sign()
sign = lambda x: (1, 1)[x<0]
If you want it to return 0 for x = 0:
sign = lambda x: x and (1, 1)[x<0]
5
 3
why? The question itself acknowledges that
cmp(x, 0)
is equivalent tosign
, andlambda x: cmp(x, 0)
is more readable than what you suggest.Dec 13, 2013 at 21:21
 1
Indeed, I was wrong. I had assumed that ‘cmp’ was specified to return 1,0,+1, but I see that the spec does not guarantee that.
Jan 20, 2014 at 21:30
Beautiful. Answers the started question: python int or float to 1, 0, 1 ?
– scharfmnMay 8, 2015 at 12:43
 1
Is there any advantage to using lists instead of
1 if x < 0 else 1
?Jun 4, 2018 at 10:28
 13
sign = lambda x: 1 if x < 0 else 1
is 15% faster. Same withsign = lambda x: x and (1 if x < 0 else 1)
.Aug 1, 2018 at 6:51
@dmazzoni: wouldn’t this argument work for all the questions on this site? just close stackoverflow and ask every question to the relevant topic dev or user mailing list!
Dec 31, 2009 at 17:38
The proper place for a question is any place where it’s likely to be answered. Thus, stackoverflow is a proper place.
Dec 31, 2009 at 17:49
1: @Davide: “Why” and “why not” questions generally cannot be answered here. Since most of the principals of Python development don’t answer questions here, you’re rarely (if ever) going to get an answer to a “why” or “why not” question. Further, you don’t have a problem to solve. You sound like you have a rant. If you have a problem (“How do I work around the lack of sign in this example…”) that’s sensible. “Why not” isn’t sensible for this venue.
Dec 31, 2009 at 18:55
The question might be a little emotional, but I don’t think it’s a bad question. I’m sure lots of people have looked for a builtin sign function, so it can be curious why there isn’t one.
Dec 31, 2009 at 19:36
This is a perfectly objective question: “Why” Python lacks any given feature is a legitimate query about the history of language design that can be answered by linking to the appropriate discussion from pythondev or other forums (sometimes blog posts) where the Python core developers happen to hash a topic out. Having tried to Google for bits of history in pythondev myself before, I can understand why a newcomer to the language might hit a dead end and come ask here in the hopes of a more experienced Python person answering!
Nov 22, 2012 at 4:14

Show 4 more comments