O operador til em Python

Qual é o uso do operador til no Python?

Uma coisa que posso pensar é fazer algo nos dois lados de uma string ou lista, como verificar se uma string é palindrômica ou não:

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

Algum outro bom uso?

É um operador unário (usando um único argumento) que é emprestado de C, onde todos os tipos de dados são apenas maneiras diferentes de interpretar bytes. É a operação "inverter" ou "complementar", na qual todos os bits dos dados de entrada são revertidos.

Em Python, para números inteiros, os bits da representação de dois complementos do número inteiro são invertidos (como em b <- b XOR 1cada bit individual), e o resultado interpretado novamente como um número inteiro de dois complementos. Portanto, para números inteiros, ~xé equivalente a (-x) - 1.

O formulário reificado do ~operador é fornecido como operator.invert. Para oferecer suporte a esse operador em sua própria classe, forneça um __invert__(self)método.

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

Qualquer classe na qual seja significativo ter um "complemento" ou "inverso" de uma instância que também seja uma instância da mesma classe é um possível candidato ao operador invertido. No entanto, a sobrecarga do operador pode causar confusão se for mal utilizada; portanto, faça sentido antes de fornecer um __invert__método para sua classe. (Observe que as cadeias de bytes [ex: '\xff'] não suportam esse operador, mesmo que seja significativo inverter todos os bits de uma cadeia de bytes.)

~é o operador de complemento bit a bit em python que essencialmente calcula-x - 1

Então, uma tabela se pareceria

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

Então, para i = 0comparar s[0]com s[len(s) - 1], para i = 1,s[1] com s[len(s) - 2].

Quanto à sua outra pergunta, isso pode ser útil para uma variedade de hacks bit a bit .

Além de ser um operador de complemento bit a bit, ~também pode ajudar a reverter um valor booleano , embora não seja o booltipo convencional aqui, você deve usar numpy.bool_.

Isso é explicado em,

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

A reversão do valor lógico pode ser útil algumas vezes, por exemplo, o ~operador abaixo é usado para limpar seu conjunto de dados e retornar uma coluna sem 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()]

Deve-se notar que, no caso de indexação de array, isso array[~i]equivale a reversed_array[i]. Pode ser visto como indexação a partir do final da matriz:

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

A única vez que usei isso na prática é com numpy/pandas. Por exemplo, com o .isin() método dataframe .

Nos documentos, eles mostram este exemplo básico

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

Mas e se você não quisesse todas as linhas em [0, 2]?

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

Eu estava resolvendo esse problema do leetcode e me deparei com essa bela solução de um usuário chamado Zitao Wang .

O problema é o seguinte: para cada elemento na matriz fornecida, encontre o produto de todos os números restantes sem fazer uso da divisão e no O(n)tempo

A solução padrão é:

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 

Sua solução usa apenas um loop para fazer uso de. Ele calcula o produto esquerdo e o produto certo em tempo real usando~

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

Este é um uso menor é til ...

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]

o código acima é de "Hands On Machine Learning"

você usa til (~ sign) como alternativa para - assinar o marcador de índice

assim como você usa menos - é para índice inteiro

ex)

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

é a mesma coisa que

print(array[~1])