Блог

Как используется оператор тильды в Python?

Одна вещь, о которой я могу подумать, — это сделать что-то с обеих сторон строки или списка, например, проверить, является ли строка палиндромной или нет:

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

Есть еще какое-нибудь полезное применение?

Это унарный оператор (принимающий один аргумент), заимствованный из языка Си, где все типы данных-это просто разные способы интерпретации байтов. Это операция «инвертирования» или «дополнения», при которой все биты входных данных меняются местами.

В Python для целых чисел биты представления целого числа с двумя дополнениями меняются местами (как b <- b XOR 1 и для каждого отдельного бита), и результат снова интерпретируется как целое число с двумя дополнениями. Таким образом, для целых ~x чисел это эквивалентно (-x) - 1 .

Овеществленная форма ~ оператора представлена как operator.invert . Чтобы поддержать этот оператор в вашем собственном классе, дайте ему __invert__(self) метод.

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

Любой класс, в котором имеет смысл иметь «дополнение» или «инверсию» экземпляра, который также является экземпляром того же класса, является возможным кандидатом на оператор инвертирования. Однако перегрузка оператора может привести к путанице при неправильном использовании, поэтому убедитесь, что это действительно имеет смысл сделать, прежде чем предоставлять __invert__ метод вашему классу. (Обратите внимание, что байтовые строки [например: 'xff' ] не поддерживают этот оператор, хотя имеет смысл инвертировать все биты байтовой строки.)

~ является побитовым оператором дополнения в python, который по существу вычисляет -x - 1

Таким образом, таблица будет выглядеть так

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

Так что за i = 0 это можно было бы сравнить s[0] с s[len(s) - 1] , за i = 1 , s[1] с s[len(s) - 2] .

Что касается вашего другого вопроса, это может быть полезно для ряда побитовых взломов.

Помимо того, что он является побитовым оператором дополнения, ~ он также может помочь вернуть логическое значение, хотя здесь это не обычный bool тип, скорее, его следует использовать numpy.bool_ .

Это объясняется в,

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

Иногда может быть полезно изменить логическое значение, например, ~ оператор «ниже» используется для очистки вашего набора данных и возврата столбца без 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()]
 

Следует отметить, что в случае индексации array[~i] массива reversed_array[i] это равно . Это можно рассматривать как индексирование, начинающееся с конца массива:

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

Единственный раз, когда я когда-либо использовал это на практике, — это с numpy/pandas . Например, с помощью .isin() метода dataframe.

В документах они показывают этот базовый пример

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

Но что, если вместо этого вы хотите, чтобы все строки не были в [0, 2]?

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

Я решал эту проблему с кодом leet и наткнулся на это прекрасное решение пользователя по имени Цитао Ван.

Проблема заключается в следующем: для каждого элемента в данном массиве найдите произведение всех оставшихся чисел без использования деления и во O(n) времени

Стандартным решением является:

 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 
 

Его решение использует только один цикл for, используя. Он вычисляет левый продукт и правый продукт на лету, используя ~

 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
 

Это незначительное использование-тильда…

 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]
 

приведенный выше код взят из «Практического машинного обучения».

вы используете тильду (~ знак) в качестве альтернативы маркеру индекса знака

точно так же, как вы используете минус — это для целочисленного индекса

бывший)

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

это то же самое, что и

print(array[~1])