Я не могу понять, почему у Python нет signфункции. Он имеет absвстроенную функцию (которую я считаю signсестрой), но нет sign.

В Python 2.6 есть даже copysignфункция (по математике ), но без знака. Зачем писать, copysign(x,y)когда вы можете просто написать, signа затем получить copysignнепосредственно от abs(x) * sign(y)? Последнее было бы намного понятнее: x со знаком y, тогда как с copysign вы должны помнить, если это x со знаком y или y со знаком x!

Очевидно sign(x), ничего более не дает cmp(x,0), но это было бы гораздо более читабельно, чем это тоже (и для очень удобочитаемого языка, такого как python, это было бы большим плюсом).

Если бы я был дизайнером Python, я был бы по-другому: не cmpвстроенный, а a sign. Когда вам нужно cmp(x,y), вы можете просто сделать a sign(x-y)(или, что еще лучше для нечисловых вещей, просто x> y - конечно, для этого нужно было sortedпринять логическое значение вместо целочисленного компаратора). Это также будет более ясно: положительным , когда x>y( в то время как с cmpвы должны помнить конвенции плюсовой , когда первый является большим , но это может быть наоборот). Конечно, cmpимеет смысл сам по себе по другим причинам (например, при сортировке нечисловых вещей или если вы хотите, чтобы сортировка была стабильной, что невозможно использовать просто с логическим значением)

Итак, вопрос: почему разработчики Python решили оставить signфункцию вне языка? Почему, черт возьми, беспокоиться, copysignа не его родитель sign?

Я что-то упускаю?

РЕДАКТИРОВАТЬ - после комментария Питера Хансена. Достаточно справедливо, что вы не использовали его, но вы не сказали, для чего вы используете python. За 7 лет, что я использую питон, я нуждался в нем бесчисленное количество раз, и последняя - соломинка, которая сломала спину верблюду!

Да, вы можете передавать cmp, но в 90% случаев, когда мне нужно было передать его, была такая идиома lambda x,y: cmp(score(x),score(y)), которая отлично работала бы со знаком.

Наконец, я надеюсь, что вы согласны с тем, что это signбыло бы более полезно, чем copysign, поэтому, даже если бы я купил ваше мнение, зачем беспокоиться об определении этого в математике, а не в знаке? Как может copysign быть настолько полезным, чем sign?

РЕДАКТИРОВАТЬ:

Действительно, был патч, который включал sign()в математику , но он не был принят, потому что они не согласились с тем, что он должен возвращать во всех крайних случаях (+/- 0, +/- nan и т. Д.)

Поэтому они решили реализовать только copysign, который (хотя и более многословный) можно использовать для делегирования конечному пользователю желаемого поведения для крайних случаев - что иногда может потребовать вызоваcmp(x,0) .

Я не знаю, почему он не встроенный, но у меня есть некоторые мысли.

copysign(x,y):
Return x with the sign of y.

Самое главное, copysignэто суперсет из sign! Вызов copysignс x = 1 аналогичен вызову signфункции. Таким образом, вы можете просто использовать copysignи забыть об этом .

>>> math.copysign(1, -4)
-1.0
>>> math.copysign(1, 3)
1.0

Если вам надоело передавать два целых аргумента, вы можете реализовать signэтот способ, и он все равно будет совместим с материалом IEEE, упомянутым другими:

>>> 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

Во-вторых, обычно, когда вам нужен знак чего-либо, вы просто умножаете его на другое значение. И, конечно, это в основном то, что copysignделает.

Итак, вместо:

s = sign(a)
b = b * s

Вы можете просто сделать:

b = copysign(b, a)

И да, я удивлен, что вы используете Python 7 лет и думаете, что cmpего так легко удалить и заменить на sign! Вы никогда не реализовывали класс с помощью __cmp__метода? Вы никогда не вызывали cmpи не указывали пользовательскую функцию сравнения?

Таким образом, я обнаружил, что тоже хочу signфункцию, но copysignс первым аргументом 1 будет работать нормально. Я не согласен, что это signбыло бы более полезно, чем copysign, поскольку я показал, что это просто подмножество той же функциональности.

«copysign» определяется IEEE 754 и частью спецификации C99. Вот почему это в Python. Функция не может быть полностью реализована с помощью abs (x) * sign (y) из-за того, как она должна обрабатывать значения NaN.

>>> 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
>>> 

Это делает copysign () более полезной функцией, чем sign ().

Что касается конкретных причин, по которым IEEE signbit (x) не доступен в стандартном Python, я не знаю. Я могу делать предположения, но это было бы предположение.

Сам математический модуль использует copysign (1, x) как способ проверки, является ли x отрицательным или неотрицательным. В большинстве случаев иметь дело с математическими функциями, которые кажутся более полезными, чем иметь знак (x), который возвращает 1, 0 или -1, потому что есть еще один случай для рассмотрения. Например, следующее из математического модуля Python:

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);

Там вы можете ясно увидеть, что функция copysign () является более эффективной, чем трехзначная функция sign ().

Вы написали:

Если бы я был дизайнером Python, я был бы наоборот: не встроенный cmp (), а sign ()

Это означает, что вы не знаете, что cmp () используется не только для чисел, но и для других вещей. cmp ("This", "That") нельзя реализовать с помощью функции sign ().

Изменить, чтобы сопоставить мои дополнительные ответы в другом месте :

Вы обосновываете, что abs () и sign () часто рассматриваются вместе. Поскольку стандартная библиотека C не содержит какой-либо функции sign (x), я не знаю, как вы обосновываете свои взгляды. Есть abs (int) и fabs (double) и fabsf (float) и fabsl (long), но нет упоминания о знаке. Существуют «copysign ()» и «signbit ()», но они применяются только к номерам IEEE 754.

Что бы сложное число возвращало знак (-3 + 4j) в Python? abs (-3 + 4j) возврат 5.0. Это наглядный пример того, как abs () может использоваться в местах, где sign () не имеет смысла.

Предположим, что знак (x) был добавлен в Python как дополнение к abs (x). Если 'x' является экземпляром пользовательского класса, который реализует метод __abs __ (self), то abs (x) вызовет x .__ abs __ (). Для правильной работы, для обработки abs (x) таким же образом, Python должен получить слот sign (x).

Это чрезмерно для относительно ненужной функции. Кроме того, почему знак (x) должен существовать, а неотрицательный (x) и неположительный (x) не существует? Мой фрагмент из реализации математического модуля Python показывает, как copybit (x, y) можно использовать для реализации nonnegative (), чего не может сделать простой знак (x).

Python должен поддерживать лучшую поддержку математической функции IEEE 754 / C99. Это добавит функцию signbit (x), которая будет делать то, что вы хотите в случае с плавающей точкой. Он не будет работать для целых чисел или комплексных чисел, а тем более для строк, и не будет иметь имя, которое вы ищете.

Вы спрашиваете «почему», а ответ «знак (х) бесполезен». Вы утверждаете, что это полезно. Тем не менее, ваши комментарии показывают, что вы не знаете достаточно, чтобы иметь возможность сделать такое утверждение, а это значит, что вам придется показать убедительные доказательства его необходимости. Сказать, что NumPy реализует это, недостаточно убедительно. Вам нужно будет показать случаи улучшения существующего кода с помощью функции знака.

И что это выходит за рамки StackOverflow. Взять его вместо одного из списков Python.

Еще один лайнер для знака ()

sign = lambda x: (1, -1)[x<0]

Если вы хотите, чтобы он возвращал 0 для x = 0:

sign = lambda x: x and (1, -1)[x<0]

Поскольку cmpбыл удален , вы можете получить ту же функциональность с

def cmp(a, b):
    return (a > b) - (a < b)

def sign(a):
    return (a > 0) - (a < 0)

Она работает float, intи даже Fraction. В случае float, уведомление sign(float("nan"))равно нулю.

Python не требует, чтобы сравнения возвращали логическое значение, и поэтому приведение сравнений к bool () защищает от допустимой, но необычной реализации:

def sign(a):
    return bool(a > 0) - bool(a < 0)

Только правильный ответ, соответствующий определению Википедии

Определение в Википедии гласит:

Следовательно,

sign = lambda x: -1 if x < 0 else (1 if x > 0 else (0 if x == 0 else NaN))

Что для всех намерений и целей может быть упрощено до:

sign = lambda x: -1 if x < 0 else (1 if x > 0 else 0)

Это определение функции выполняется быстро и дает гарантированные правильные результаты для 0, 0.0, -0.0, -4 и 5 (см. Комментарии к другим неправильным ответам).

Обратите внимание, что ноль (0) не является ни положительным, ни отрицательным .

Numpy имеет функцию знака, а также дает вам бонус к другим функциям. Так:

import numpy as np
x = np.sign(y)

Только будьте осторожны, что результатом будет numpy.float64:

>>> type(np.sign(1.0))
<type 'numpy.float64'>

Для таких вещей, как json, это важно, поскольку json не знает, как сериализовать типы numpy.float64. В этом случае вы можете сделать:

float(np.sign(y))

чтобы получить регулярное плавание.

Попробуйте запустить это, где х любое число

int_sign = bool(x > 0) - bool(x < 0)

Приведение к bool () обрабатывает возможность того, что оператор сравнения не возвращает логическое значение.

Да, правильная sign()функция должна быть, по крайней мере, в математическом модуле - как в numpy. Потому что это часто нужно для математического кода.

Но math.copysign()также полезно самостоятельно.

cmp()и obj.__cmp__()... как правило, имеют большое значение независимо друг от друга. Не только для математического кода. Рассмотрите сравнение / сортировку кортежей, объектов даты, ...

Аргументы dev на http://bugs.python.org/issue1640 относительно упущения math.sign()являются странными, потому что:

• Там нет отдельного -NaN
• sign(nan) == nan без беспокойства (как exp(nan))
• sign(-0.0) == sign(0.0) == 0 без беспокойства
• sign(-inf) == -1 без беспокойства

- как это в NumPy

В Python 2 cmp()возвращает целое число: не требуется, чтобы результат был -1, 0 или 1, поэтому sign(x)он не совпадает с cmp(x,0).

В Python 3 cmp()была удалена в пользу богатого сравнения. Для cmp(), Python 3 предлагает это :

def cmp(a, b):
    return (a > b) - (a < b)

что хорошо для cmp (), но опять же не может использоваться для sign (), потому что операторам сравнения не нужно возвращать логические значения .

Чтобы справиться с этой возможностью, результаты сравнения должны быть приведены к логическим значениям:

 def sign(a):
    return bool(x > 0) - bool(x < 0)

Это работает для любого, typeкоторый полностью упорядочен (включая специальные значения как NaNили бесконечности).

Вам не нужно, вы можете просто использовать:

If not number == 0:
    sig = number/abs(number)
else:
    sig = 0

Это просто не так.

Лучший способ это исправить:

sign = lambda x: bool(x > 0) - bool(x < 0)

Причина, по которой «знак» не включен, заключается в том, что если бы мы включили все полезные однострочные символы в список встроенных функций, Python больше не был бы легким и практичным для работы с ним. Если вы используете эту функцию так часто, то почему бы вам не сделать это самостоятельно? Это не так сложно или даже утомительно.