Python известен своей простотой и предсказуемостью, но за этой доступностью скрываются интересные и неочевидные особенности, способные удивить программистов с базовым опытом(а если повезет, то и опытных). В этой статье мы рассмотрим несколько таких "фокусов" и тонкостей, чтобы глубже понять внутреннюю логику и философию языка.

Оператор побитовой инверсии: почему bool(~-True) — это False?

В Python оператор побитовой инверсии (bitwise NOT) обозначается символом ~ и применяется к целым числам, инвертируя каждый бит. Результат операции для положительных чисел соответствует формуле ~x = -(x + 1). Например:

x = 5  # Бинарное представление: 00000101
result = ~x  # Результат: -(x + 1), т.е. -6 (в двоичном представлении: 11111010)
print(result)  # Вывод: -6

Рассмотрим, как из bool(~-True) получается False:

result = bool(~-True)
print(result)  # Вывод: False

Визуально этот процесс можно отобразить так:

Помимо этого, оператор ~ можно использовать, но лучше так конечно не делать, в преобразовании индекса последовательностей, например таких как строки, кортежи и списки. Рассмотрим вот такой код:

# Для списка
lst = [10, 20, 30] 
print(lst[~0]) # Вывод: 30 | list[~0] эквивалентно list[-1]

# Для строки
word = "HABR"
print(word[~1]) # Вывод: B | list[~1] эквивалентно list[-2]

# Для кортежа
tup = (1, 2, 3)
print(tup[~2]) # Вывод: 1 | list[~2] эквивалентно list[-3]

В каком-то смысле, если образно представить, то оператор ~ при работе с индексами можно рассматривать как способ инвертировать направление отсчёта индексов:

Это действительно похоже на то, как если бы отсчёт индексов "поменялся" с начала на конец.

Неочевидное поведение встроенных функций: почему all([]) — True, а any([]) — False?

all() для пустого списка [] возвращает True:

print(all([])) # Вывод: True

Это поведение можно объяснить следующим образом: функция all() для пустого списка [] возвращает True, поскольку в пустом списке нет элементов, которые могли бы быть ложными и опровергнуть утверждение, что все элементы истинны. Если с этим примером всё ясно, то следующий уже можно назвать "парадоксом вложенных списков":

Поговорим о any(). any() для пустого списка [] возвращает False:

print(any([])) # Вывод: False

Это поведение можно объяснить следующим образом: функция any() возвращает True, если хотя бы один элемент последовательности является истинным (не False). Поскольку в пустой последовательности нет элементов, удовлетворяющих этому условию, функция any() возвращает False. Добавим в копилку "парадоксов":

Разбавим статью неочевидностями, которые могут пригодиться в повседневной работе с кодом, с функциями isinstance() и range(). Говоря о isinstance(), нередко встречается такой код:

num = 10

if isinstance(num, int) or isinstance(num, float):
	print("Habr") # Вывод: Habr

Здесь isinstance() используется дважды. Но, эта функция может принимать более одного параметра для проверки типов:

num = 10 

if isinstance(num, (int, float)): 
	print("Habr") # Вывод: Habr

(int, float) — это кортеж, состоящий из двух параметров: типов int и float. Но это ещё не всё. Вместо кортежа можно использовать union operator:

num = 10

if isinstance(num, int | float):
	print("Habr") # Вывод: Habr

Рассмотрим на примере небольшой задачки: дан список с разными типами чисел. Нужно найти сумму всех положительных целых и дробных чисел. Решение может быть следующим:

nums = [42, 3.14, (2+3j), -5, 10, '23']

# Суммируем только положительные целые и дробные числа
result = sum(i for i in nums if isinstance(i, int | float) and i > 0)

print(result)  # Вывод: 55.14

Кроме этого, isinstance() можно использовать в дебаггинге:

num = 10

print(f'{isinstance(num, int) = }') # Вывод: isinstance(num, int) = True
print(f'{isinstance(num, float) = }') # Вывод: isinstance(num, float) = False

Поговорим о range(). В Python с функцией range() можно использовать срезы для получения элементов из последовательности:

result = list(range(20)[::2])
print(result) # Вывод: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]


# Предыдущий код тоже самое, что и:
result = list(range(0, 20, 2))
print(result) # Вывод: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]


# А вот это уже для строк:
text = "Hello Habra World"
for i in range(len(text))[::6]:
	print(text[i], end=' ') # Собрали первую букву каждого слова, Вывод: H H W

Небольшая шпаргалка по срезам в range():

result_step = list(range(15)[::5])
print(result_step) # Вывод: [0, 5, 10]


result_slice = list(range(15)[:5:])
print(result_slice) # Вывод: [0, 1, 2, 3, 4]


result_start = list(range(15)[5::])
print(result_start) # Вывод: [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

И теперь, благодаря срезам, решение первой задачи Проекта Эйлера может претендовать на звание самого элегантного:

print(sum(set(range(1000)[::3]) | set(range(1000)[::5]))) # 233168

Фокусы списков в Python

Рассмотрим вот такой код:

lst = [[]] * 5 
print(lst) # Вывод: [[], [], [], [], []]

Каждый элемент в lst выглядит как отдельный пустой список, но это не так. Все элементы в lst указывают на один и тот же список в памяти:

lst[0].append("Habr")
print(lst) # Вывод: [['Habr'], ['Habr'], ['Habr'], ['Habr'], ['Habr']]

Чтобы окончательно убедиться в этом, можно посмотреть на id каждого элемента внутри списка:

У всех пяти элементов внутри lst один и тот же id. Обойти это можно следующим образом:

lst = [[] for _ in range(5)]
print(lst) # Вывод: [[], [], [], [], []] | id каждого элемента внутри будет разным


lst[0].append("Habr")
print(lst) # Вывод: [['Habr'], [], [], [], []]

А теперь посмотрим, что значит список, содержащий ссылку на самого себя:

lst = []
lst.append(lst)
print(lst) # Вывод: [[...]]

В пустой список lst добавляется сам lst. Теперь список содержит ссылку на самого себя. И при попытке вывести список, Python распознает, что список содержит рекурсивную ссылку, и вместо бесконечного вывода выводит: [[...]]. Мы можем заглянуть внутрь, и удостовериться так ли это или нет:

print(lst[0] is lst) # Вывод: True

Разумеется, продолжать "заглядывать внутрь" можно бесконечно долго:

Двуликие True и False: "скрытая природа" булевых значений

В Python тип bool является подтипом типа int. Это означает, что логические значения True и False представляют собой целые числа 1 и 0 соответственно. Таким образом, объекты типа bool могут использоваться в арифметических операциях так же, как и целые числа. Например:

print(True + False + True) # Вывод: 2
print("Habr"[False]) # Вывод: H
print("Habr"[True+True]) # Вывод: b
print("Habr"[-True]) # Вывод: r
print(False == False in [False]) # Вывод: True

Это свойство булевых значений полезно, например, в подсчете количества элементов, удовлетворяющих условию, с использованием функций вроде sum:

lst = [True, False, True] 
print(sum(lst)) # Вывод: 2

А вот так, например, выглядит вычисление первых десяти чисел последовательности Фибоначчи, используя True и False в качестве первых двух чисел:

def get_fibonacci():
    """Получение первых десяти элементов 
    последовательности Фибоначчи 
    без прямого использования числовых значений."""
    
    nums = []
    a, b = False, True
    
    for _ in range(len("tennumbers")):
        nums.append(a)
        a, b = b, a + b
    
    return [int(i) if isinstance(i, bool) else i for i in nums]
    ''' Здесь хоть мы и конвертируем первые два элемента, 
    но делаем это не для вычисления, а для однотипного вывода результатов. 
    Иначе: [False, True, 1, 2, 3, 5, 8, 13, 21, 34]
    '''


print(get_fibonacci()) # Вывод: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

И даже решение этой задачи в одну строку (вопреки PEP-8 и здравому смыслу, но во имя эксперимента) выдаст желаемый результат:

print((lambda f: [f.append(f[-True] + f[--~True]) or f[-True] for _ in range(len("abcdefjh"))] and f)([int(False), int(True)]))
# Вывод: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Всё это поведение булевых значений можно описать двумя строками кода:

isinstance(True, int) # Вернет True 
isinstance(False, int) # Вернет True

Или даже одной строкой кода:

# Родительский класс bool — это int:
bool.__bases__ # Вернет (<class 'int'>,)

В завершение, стоит отметить важное выражение, отражающее один из ключевых аспектов философии Python:

isinstance(type, object) == isinstance(object, type) # Вывод: True

Это утверждение подчеркивает взаимосвязь между типами и объектами, демонстрируя гибкость и мощь динамической типизации языка.