L'opérateur tilde en Python

Quelle est l'utilisation de l'opérateur tilde en Python?

Une chose à laquelle je peux penser est de faire quelque chose des deux côtés d'une chaîne ou d'une liste, comme vérifier si une chaîne est palindromique ou non:

def is_palindromic(s):
    return all(s[i] == s[~i] for i in range(len(s) / 2)) 

Tout autre bon usage?

C'est un opérateur unaire (prenant un seul argument) qui est emprunté à C, où tous les types de données ne sont que des façons différentes d'interpréter les octets. C'est l'opération "inverser" ou "complément", dans laquelle tous les bits des données d'entrée sont inversés.

En Python, pour les entiers, les bits de la représentation à deux compléments de l'entier sont inversés (comme b <- b XOR 1pour chaque bit individuel), et le résultat est à nouveau interprété comme un entier à deux compléments. Donc, pour les entiers, ~xest équivalent à (-x) - 1.

La forme réifiée de l' ~opérateur est fournie en tant que operator.invert. Pour prendre en charge cet opérateur dans votre propre classe, donnez-lui une __invert__(self)méthode.

>>> import operator
>>> class Foo:
...   def __invert__(self):
...     print 'invert'
...
>>> x = Foo()
>>> operator.invert(x)
invert
>>> ~x
invert

Toute classe dans laquelle il est significatif d'avoir un "complément" ou "inverse" d'une instance qui est également une instance de la même classe est un candidat possible pour l'opérateur inversé. Cependant, la surcharge de l'opérateur peut entraîner de la confusion si elle est mal utilisée, alors assurez-vous qu'il est vraiment logique de le faire avant de fournir une __invert__méthode à votre classe. (Notez que les chaînes d'octets [ex: '\xff'] ne prennent pas en charge cet opérateur, même s'il est utile d'inverser tous les bits d'une chaîne d'octets.)

~est l' opérateur de complément au niveau du bit en python qui calcule essentiellement-x - 1

Donc, une table ressemblerait

i  ~i  
0  -1
1  -2
2  -3
3  -4 
4  -5 
5  -6

Donc, i = 0cela se comparerait s[0]avec s[len(s) - 1], car i = 1, s[1]avec s[len(s) - 2].

Quant à votre autre question, cela peut être utile pour une gamme de hacks au niveau du bit .

En plus d'être un opérateur de complément au niveau du bit, il ~peut également aider à rétablir une valeur booléenne , bien que ce ne soit pas le booltype conventionnel ici, vous devez plutôt l'utiliser numpy.bool_.

Ceci est expliqué dans,

import numpy as np
assert ~np.True_ == np.False_

Inverser la valeur logique peut parfois être utile, par exemple, l' ~opérateur ci-dessous est utilisé pour nettoyer votre jeu de données et vous renvoyer une colonne sans NaN.

from numpy import NaN
import pandas as pd

matrix = pd.DataFrame([1,2,3,4,NaN], columns=['Number'], dtype='float64')
# Remove NaN in column 'Number'
matrix['Number'][~matrix['Number'].isnull()]

Il convient de noter que dans le cas de l'indexation de tableaux, array[~i]équivaut à reversed_array[i]. Il peut être vu comme une indexation à partir de la fin du tableau:

[0, 1, 2, 3, 4, 5, 6, 7, 8]
    ^                 ^
    i                ~i

La seule fois où je l'ai utilisé en pratique, c'est avec numpy/pandas. Par exemple, avec la .isin() méthode dataframe .

Dans les documents, ils montrent cet exemple de base

>>> df.isin([0, 2])
        num_legs  num_wings
falcon      True       True
dog        False       True

Mais que se passe-t-il si à la place vous vouliez que toutes les lignes ne soient pas dans [0, 2]?

>>> ~df.isin([0, 2])
        num_legs  num_wings
falcon     False       False
dog        True        False

Je résolvais ce problème de leetcode et je suis tombé sur cette belle solution par un utilisateur nommé Zitao Wang .

Le problème va comme ceci pour chaque élément dans le tableau donné trouver le produit de tous les nombres restants sans faire usage de la division et dans le O(n)temps

La solution standard est:

Pass 1: For all elements compute product of all the elements to the left of it
Pass 2: For all elements compute product of all the elements to the right of it
        and then multiplying them for the final answer 

Sa solution n'en utilise qu'une pour la boucle en faisant usage de. Il calcule le produit gauche et le produit droit à la volée en utilisant~

def productExceptSelf(self, nums):
    res = [1]*len(nums)
    lprod = 1
    rprod = 1
    for i in range(len(nums)):
        res[i] *= lprod
        lprod *= nums[i]
        res[~i] *= rprod
        rprod *= nums[~i]
    return res

Ceci est une utilisation mineure est tilde ...

def split_train_test_by_id(data, test_ratio, id_column):
    ids = data[id_column]
    in_test_set = ids.apply(lambda id_: test_set_check(id_, test_ratio)) 
    return data.loc[~in_test_set], data.loc[in_test_set]

le code ci-dessus provient de "Hands On Machine Learning"

vous utilisez le tilde (signe ~) comme alternative au marqueur d'index de signe

tout comme vous utilisez moins - est pour l'index entier

ex)

array = [1,2,3,4,5,6]
print(array[-1])

est la même chose que

print(array[~1])