def sign(x):
    if x > 0:
        return 1
    if x == 0:
        return 0
    return -1
 
>>> sign(3)
1
>>> sign(-3)
-1
>>> sign(0)
0

Comme d’autres de choix étonnants dans l’architecture de Python, il y a une raison raisonnablement raisonnable : il n’existe aucun standard sur ce que doit faire une telle fonction dans les cas ambigües.

En effet, que doit faire la fonction avec NaN ? Avec un complexe ?

Il y a eu un débat sur ce qu’il faut faire dans ce cas, et un consensus n’a PAS été trouvé.

Par contre, il existe un standard international définissant une autre opération : celle de copier un signe. Elle a donc été implémentée :

>>> from math import copysign
>>> copysign(10, -3)
-10.0
>>> copysign(10, 22)
10.0
>>> copysign(10, float('-NaN'))
-10
>>> copysign(10, -2j)
Traceback (most recent call last):
  File "<ipython-input-13-ece93d1317dc>", line 1, in <module>
    copysign(10, -2j)
TypeError: can't convert complex to float

Copier le signe n’est pas la même chose que de retourner quelque chose selon le signe, et donc sémantiquement, choisir quoi retourner était plus facile. Comme la plupart du temps, on veut récupérer -1 ou 1 pour le multiplier avec quelque chose et justement copier le signe, cela résolvait pas mal de problèmes.

Mais même dans le rare cas où on a besoin du résultat que renverrait sign(), il est très facile à obtenir en une ligne :

>>> mon_nombre = 3
>>> mon_nombre and copysign(1, mon_nombre)
1.0
>>> mon_nombre = -3
>>> mon_nombre and copysign(1, mon_nombre)
-1.0
>>> mon_nombre = 0
>>> mon_nombre and copysign(1, mon_nombre)
0

Et pour ce cas de figure, les retours sur des valeurs ambigües sont laissés à la charge du codeur.

P.S: je sais qu’il y a des exemples sur le net montrant cmp(0, mon_nombre) pour obtenir la même fonctionnalité. Sachez que cmp a été retirée de Python 3, donc faites attention si vous l’utilisez.

La conséquence ?

~-2 => 1
~-1 => 0
~0 => -1
~1 => -2
~2 => -3

Or, en javascript on a un problème avec le fait que la seule option pour rechercher un élément dans un ensemble soit des fonctions comme indexOf qui retournent l’index de ce qu’elles trouvent ou -1, les chiennes.

Ce qui fait que:

if ("truc".indexOf('t')) {
    console.log('trouvé')
}

Ne va rien afficher, car 't' est à la première place, renvoyant l’index 0, qui est “faux” dans un contexte booléan. Mais :

if ("truc".indexOf('z')) {
    console.log('trouvé')
}

Va afficher “trouvé” car la fonction renvoit -1 quand elle ne trouve rien. C’est nul. On se retrouve donc à faire du :

if ("truc".indexOf('z') > -1) {
    console.log('trouvé')
}

Ce qui est moche comme ça en peut plus. Mais avec l’opérateur bitwise, 0 devient -1 (donc vrai, comme tous les autres chiffres) et -1 devient zéro.

if (~"truc".indexOf('t')) {
    console.log('trouvé')
}

Et là ça va marcher !

Vous venez officiellement de passer 10 minutes sur un article qui va vous faire gagner 1 seconde sur l’ensemble de votre vie. En fait même pas, car pour garder votre code lisible, je vous recommande de ne pas utiliser cette technique.

De rien.