Tôi không thể hiểu tại sao Python không có signchức năng. Nó có một absnội trang (mà tôi coi signlà em gái), nhưng không sign.

Trong python 2.6 thậm chí còn có một copysignhàm (trong toán học ), nhưng không có dấu. Tại sao phải viết một copysign(x,y)khi bạn chỉ có thể viết một signvà sau đó nhận được copysigntrực tiếp từ abs(x) * sign(y)? Điều thứ hai sẽ rõ ràng hơn nhiều: x với dấu của y, trong khi với copysign bạn phải nhớ nếu đó là x với dấu của y hoặc y với dấu của x!

Rõ ràng là sign(x)không cung cấp bất cứ điều gì nhiều hơn cmp(x,0), nhưng nó cũng sẽ dễ đọc hơn nhiều (và đối với một ngôn ngữ rất dễ đọc như python, đây sẽ là một điểm cộng lớn).

Nếu tôi là một nhà thiết kế trăn, tôi sẽ là một cách khác: không có cmpnội dung, nhưng a sign. Khi bạn cần cmp(x,y), bạn chỉ có thể làm một sign(x-y)(hoặc, thậm chí tốt hơn cho các công cụ không phải là số, chỉ là x> y - tất nhiên điều này cần phải sortedchấp nhận một boolean thay vì so sánh số nguyên). Điều này cũng sẽ được rõ ràng hơn: tích cực khi x>y(trong khi với cmpbạn phải nhớ dương tính ước khi đầu tiên là lớn hơn , nhưng nó có thể là con đường xung quanh khác). Tất nhiên cmpcó ý nghĩa riêng vì những lý do khác (ví dụ: khi sắp xếp những thứ không phải là số hoặc nếu bạn muốn sắp xếp ổn định, điều này không thể sử dụng chỉ với boolean)

Vì vậy, câu hỏi là: tại sao (các) nhà thiết kế Python quyết định bỏ signchức năng này khỏi ngôn ngữ? Tại sao quái vật bận tâm với copysignvà không phải cha mẹ của nó sign?

Tui bỏ lỡ điều gì vậy?

EDIT - sau khi Peter Hansen bình luận. Đủ công bằng khi bạn không sử dụng nó, nhưng bạn không nói bạn dùng python để làm gì. Trong 7 năm tôi sử dụng trăn, tôi cần nó vô số lần và lần cuối cùng là ống hút làm vỡ lưng con lạc đà!

Vâng, bạn có thể vượt qua cmp xung quanh, nhưng 90% số lần tôi cần để vượt qua nó là trong một thành ngữ như thế lambda x,y: cmp(score(x),score(y))sẽ hoạt động với dấu hiệu tốt.

Cuối cùng, tôi hy vọng bạn đồng ý rằng nó signsẽ hữu ích hơn copysign, vì vậy ngay cả khi tôi đã mua quan điểm của bạn, tại sao phải bận tâm về việc xác định điều đó trong toán học, thay vì ký? Làm thế nào copysign có thể hữu ích hơn nhiều so với dấu hiệu?

BIÊN TẬP:

Thật vậy, có một bản vá bao gồm sign()trong toán học , nhưng nó không được chấp nhận, vì họ không đồng ý về những gì nó sẽ trả về trong tất cả các trường hợp cạnh (+/- 0, +/- nan, v.v.)

Vì vậy, họ quyết định chỉ thực hiện copysign, mà (mặc dù dài dòng hơn) có thể được sử dụng để ủy quyền cho người dùng cuối hành vi mong muốn cho các trường hợp cạnh - đôi khi có thể yêu cầu gọi đếncmp(x,0) .

Tôi không biết tại sao nó không tích hợp, nhưng tôi có một vài suy nghĩ.

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

Quan trọng nhất, copysignlà một superset của sign! Gọi copysignvới x = 1 giống như một signhàm. Vì vậy, bạn chỉ có thể sử dụng copysignvà quên nó .

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

Nếu bạn phát ốm khi chuyển toàn bộ hai đối số, bạn có thể thực hiện signtheo cách này và nó vẫn sẽ tương thích với nội dung của IEEE được đề cập bởi những người khác:

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

Thứ hai, thông thường khi bạn muốn có dấu hiệu của một cái gì đó, cuối cùng bạn sẽ nhân nó với một giá trị khác. Và tất nhiên đó là những gì cơ bản copysign.

Vì vậy, thay vì:

s = sign(a)
b = b * s

Bạn chỉ có thể làm:

b = copysign(b, a)

Và vâng, tôi ngạc nhiên vì bạn đã sử dụng Python được 7 năm và nghĩ rằng cmpcó thể dễ dàng gỡ bỏ và thay thế bằng sign! Bạn đã bao giờ thực hiện một lớp học với một __cmp__phương pháp? Bạn đã bao giờ gọi cmpvà chỉ định một chức năng so sánh tùy chỉnh?

Tóm lại, tôi cũng thấy mình muốn một signhàm, nhưng copysignvới đối số đầu tiên là 1 sẽ hoạt động tốt. Tôi không đồng ý rằng nó signsẽ hữu ích hơn copysign, vì tôi đã chỉ ra rằng nó chỉ là một tập hợp con có cùng chức năng.

"Copysign" được định nghĩa bởi IEEE 754 và là một phần của đặc tả C99. Đó là lý do tại sao nó là Python. Hàm không thể được thực hiện đầy đủ bằng dấu abs (x) * (y) vì cách xử lý các giá trị 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
>>> 

Điều đó làm cho copysign () là một hàm hữu ích hơn dấu ().

Về lý do cụ thể tại sao ký hiệu của IEEE (x) không có sẵn trong Python tiêu chuẩn, tôi không biết. Tôi có thể đưa ra các giả định, nhưng nó sẽ đoán được.

Bản thân mô-đun toán học sử dụng copysign (1, x) như một cách để kiểm tra xem x là âm hay không âm. Đối với hầu hết các trường hợp xử lý các hàm toán học có vẻ hữu ích hơn là có dấu (x) trả về 1, 0 hoặc -1 vì có một trường hợp ít hơn để xem xét. Ví dụ, sau đây là từ mô-đun toán học của 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);

Ở đó bạn có thể thấy rõ rằng copysign () là một hàm hiệu quả hơn hàm có ba dấu () có giá trị.

Bạn đã viết:

Nếu tôi là một nhà thiết kế python, tôi sẽ là một cách khác: không có cmp () dựng sẵn, nhưng một dấu hiệu ()

Điều đó có nghĩa là bạn không biết rằng cmp () được sử dụng cho những thứ ngoài số. cmp ("Điều này", "Điều đó") không thể được thực hiện với hàm dấu ().

Chỉnh sửa để đối chiếu các câu trả lời bổ sung của tôi ở nơi khác :

Bạn căn cứ vào các biện minh của mình về cách abs () và dấu () thường được nhìn thấy cùng nhau. Vì thư viện chuẩn C không chứa chức năng 'dấu (x)', tôi không biết bạn biện minh cho quan điểm của mình như thế nào. Có một abs (int) và fabs (double) và fabsf (float) và fabsl (dài) nhưng không đề cập đến dấu hiệu. Có "copysign ()" và "Signbit ()" nhưng chúng chỉ áp dụng cho các số IEEE 754.

Với các số phức, ký hiệu (-3 + 4j) sẽ trả về trong Python, liệu nó có được thực hiện không? abs (-3 + 4j) trả lại 5.0. Đó là một ví dụ rõ ràng về cách abs () có thể được sử dụng ở những nơi mà dấu () không có ý nghĩa.

Giả sử dấu (x) đã được thêm vào Python, như là một bổ sung cho abs (x). Nếu 'x' là một thể hiện của lớp do người dùng định nghĩa thực hiện phương thức __abs __ (self) thì abs (x) sẽ gọi x .__ abs __ (). Để hoạt động chính xác, để xử lý abs (x) theo cùng một cách thì Python sẽ phải đạt được một dấu (x) khe.

Điều này là quá mức cho một chức năng tương đối không cần thiết. Bên cạnh đó, tại sao ký hiệu (x) tồn tại và không âm (x) và không có chủ đích (x) không tồn tại? Đoạn mã của tôi từ triển khai mô-đun toán học của Python cho thấy cách copybit (x, y) có thể được sử dụng để triển khai nonnegative (), điều mà một dấu hiệu đơn giản (x) không thể làm được.

Python nên hỗ trợ có hỗ trợ tốt hơn cho hàm toán học IEEE 754 / C99. Điều đó sẽ thêm một hàm Signbit (x), sẽ làm những gì bạn muốn trong trường hợp nổi. Nó không hoạt động đối với số nguyên hoặc số phức, chuỗi ít hơn nhiều và nó sẽ không có tên bạn đang tìm kiếm.

Bạn hỏi "tại sao" và câu trả lời là "dấu (x) không hữu ích." Bạn khẳng định rằng nó hữu ích. Tuy nhiên, ý kiến ​​của bạn cho thấy rằng bạn không biết đủ để có thể đưa ra khẳng định đó, điều đó có nghĩa là bạn sẽ phải đưa ra bằng chứng thuyết phục về nhu cầu của nó. Nói rằng NumPy thực hiện nó không đủ sức thuyết phục. Bạn sẽ cần chỉ ra các trường hợp về cách mã hiện tại sẽ được cải thiện với chức năng ký hiệu.

Và nó nằm ngoài phạm vi của StackOverflow. Thay vào đó hãy đến một trong các danh sách Python.

Một lớp lót khác cho dấu ()

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

Nếu bạn muốn nó trả về 0 cho x = 0:

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

Vì cmpđã bị xóa , bạn có thể có được chức năng tương tự với

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

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

Nó hoạt động cho float, intvà thậm chí Fraction. Trong trường hợp float, thông báo sign(float("nan"))bằng không.

Python không yêu cầu các phép so sánh trả về một boolean và do đó, ép buộc các phép so sánh với bool () bảo vệ chống lại việc thực thi cho phép, nhưng không phổ biến:

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

Chỉ có câu trả lời đúng tuân theo định nghĩa Wikipedia

Các định nghĩa trên Wikipedia đọc:

Vì thế,

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

Mà cho tất cả ý định và mục đích có thể được đơn giản hóa để:

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

Định nghĩa hàm này thực thi nhanh và mang lại kết quả chính xác được đảm bảo cho 0, 0.0, -0.0, -4 và 5 (xem bình luận cho các câu trả lời không chính xác khác).

Lưu ý rằng số không (0) không dương hoặc âm .

numpy có chức năng ký hiệu và cũng cung cấp cho bạn phần thưởng của các chức năng khác. Vì thế:

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

Chỉ cần cẩn thận rằng kết quả là một numpy.float64:

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

Đối với những thứ như json, điều này quan trọng, vì json không biết làm thế nào để tuần tự hóa các loại numpy.float64. Trong trường hợp đó, bạn có thể làm:

float(np.sign(y))

để có được một phao thường xuyên.

Hãy thử chạy cái này, trong đó x là bất kỳ số nào

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

Việc ép buộc đối với bool () xử lý khả năng toán tử so sánh không trả về boolean.

Có, một sign()hàm đúng phải ít nhất là trong mô-đun toán học - vì nó ở dạng numpy. Bởi vì người ta thường xuyên cần nó cho mã định hướng toán học.

Nhưng math.copysign()cũng hữu ích độc lập.

cmp()và obj.__cmp__()... nói chung có tầm quan trọng cao một cách độc lập. Không chỉ cho mã định hướng toán học. Xem xét so sánh / sắp xếp các bộ dữ liệu, đối tượng ngày, ...

Các đối số dev tại http://bugs.python.org/su1640 liên quan đến thiếu sót math.sign()là kỳ lạ, bởi vì:

• Không có riêng -NaN
• sign(nan) == nan không phải lo lắng (như exp(nan))
• sign(-0.0) == sign(0.0) == 0 Không lo lắng
• sign(-inf) == -1 Không lo lắng

- vì nó ở trong numpy

Trong Python 2, cmp()trả về một số nguyên: không có yêu cầu nào cho kết quả là -1, 0 hoặc 1, vì vậy sign(x)không giống nhưcmp(x,0) .

Trong Python 3, cmp()đã được loại bỏ để so sánh phong phú. Đối với cmp(), Python 3 gợi ý điều này :

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

cái này tốt cho cmp (), nhưng một lần nữa không thể được sử dụng cho dấu () vì các toán tử so sánh không cần trả về booleans .

Để đối phó với khả năng này, các kết quả so sánh phải được áp dụng cho booleans:

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

Điều này hoạt động cho bất kỳ typethứ gì hoàn toàn được đặt hàng (bao gồm các giá trị đặc biệt như NaNhoặc vô số).

Bạn không cần một cái, bạn chỉ có thể sử dụng:

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

Nó chỉ không.

Cách tốt nhất để khắc phục điều này là:

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

Lý do "dấu hiệu" không được bao gồm là nếu chúng ta đưa mọi lớp lót hữu ích vào danh sách các hàm dựng sẵn, Python sẽ không còn dễ dàng và thiết thực để làm việc nữa. Nếu bạn sử dụng chức năng này thường xuyên như vậy thì tại sao bạn không tự mình thực hiện nó? Nó không giống như nó từ xa khó khăn hoặc thậm chí tẻ nhạt để làm như vậy.