wtfpython/translations/README-ru.md

What the f*ck Python! 😱

Изучение и понимание Python с помощью нестандартного поведения и "магического" поведения.

Переводы: English Original Chinese 中文 | Vietnamese Tiếng Việt | Spanish Español | Korean 한국어 | Russian Русский | German Deutsch | Add translation

Альтернативные способы: Интерактивный сайт | Интерактивный Jupiter notebook | CLI

Python, будучи прекрасно спроектированным высокоуровневым языком программирования, предоставляет множество возможностей для удобства программиста. Но иногда результаты работы Python кода могут показаться неочевидными на первый взгляд.

wtfpython задуман как проект, пытающийся объяснить, что именно происходит под капотом некоторых неочевидных фрагментов кода и менее известных возможностей Python.

Если вы опытный программист на Python, вы можете принять это как вызов и правильно объяснить WTF ситуации с первой попытки. Возможно, вы уже сталкивались с некоторыми из них раньше, и я смогу оживить ваши старые добрые воспоминания! 😅

PS: Если вы уже читали wtfpython раньше, с изменениями можно ознакомиться здесь (примеры, отмеченные звездочкой - это примеры, добавленные в последней основной редакции).

Ну что ж, приступим...

Содержание

• Содержание
• Структура примера
• Применение
• 👀 Примеры
  • Секция: Напряги мозги!
    • ▶ Первым делом!
      • 💡 Обьяснение
    • ▶ Строки иногда ведут себя непредсказуемо
      • 💡 Объяснение

Структура примера

Все примеры имеют следующую структуру:

▶ Какой-то заголовок

# Неочевидный фрагмент кода
# Подготовка к магии...

Вывод (Python версия):

>>> triggering_statement
Неожиданные результаты

(Опционально): Краткое описание неожиданного результата

💡 Объяснение

• Краткое объяснение того, что происходит и почему это происходит.

# Код
# Дополнительные примеры для дальнейшего разъяснения (если необходимо)

Вывод (Python версия):

>>> trigger # какой-нибудь пример, позволяющий легко раскрыть магию
# обоснованный вывод

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

Применение

Хороший способ получить максимальную пользу от этих примеров - читать их последовательно, причем для каждого из них важно:

• Внимательно изучить исходный код. Если вы опытный программист на Python, то в большинстве случаев сможете предугадать, что произойдет дальше.
• Прочитать фрагменты вывода и,
  • Проверить, совпадают ли выходные данные с вашими ожиданиями.
  • Убедиться, что вы знаете точную причину, по которой вывод получился именно таким.
    • Если ответ отрицательный (что совершенно нормально), сделать глубокий вдох и прочитать объяснение (а если пример все еще непонятен, и создайте issue здесь).
    • Если "да", ощутите мощь своих познаний в Python и переходите к следующему примеру.

PS: Вы также можете читать WTFPython в командной строке, используя pypi package,

pip install wtfpython -U
wtfpython

👀 Примеры

Секция: Напряги мозги!

▶ Первым делом!

По какой-то причине "моржовый оператор" (англ. walrus) := в Python 3.8 стал довольно популярным. Давайте проверим его,

1.

# Python version 3.8+

>>> a = "wtf_walrus"
>>> a
'wtf_walrus'

>>> a := "wtf_walrus"
File "<stdin>", line 1
    a := "wtf_walrus"
      ^
SyntaxError: invalid syntax

>>> (a := "wtf_walrus") # А этот код работает
'wtf_walrus'
>>> a
'wtf_walrus'

2 .

# Python version 3.8+

>>> a = 6, 9
>>> a
(6, 9)

>>> (a := 6, 9)
(6, 9)
>>> a
6

>>> a, b = 6, 9 # Типичная распаковка
>>> a, b
(6, 9)
>>> (a, b = 16, 19) # Упс
  File "<stdin>", line 1
    (a, b = 16, 19)
          ^
SyntaxError: invalid syntax

>>> (a, b := 16, 19) # На выводе получаем странный кортеж из 3 элементов
(6, 16, 19)

>>> a # Значение переменной остается неизменной?
6

>>> b
16

💡 Обьяснение

Быстрый разбор что такое "моржовый оператор"

"Моржовый оператор" (:=) был представлен в Python 3.8, может быть полезен в ситуациях, когда вы хотите присвоить значения переменным в выражении.

def some_func():
    # Предположим, что здесь выполняются требовательные к ресурсам вычисления
    # time.sleep(1000)
    return 5

# Поэтому вместо,
if some_func():
    print(some_func()) # Плохая практика, поскольку вычисления происходят дважды.

# Или
a = some_func()
if a:
    print(a)

# Можно лаконично написать
if a := some_func():
    print(a)

Вывод (> 3.8):

5
5
5

Использование := сэкономило одну строку кода и неявно предотвратило вызов some_func дважды.

• "выражение присваивания", не обернутое в скобки, иначе говоря использование моржового оператора, ограничено на верхнем уровне, отсюда SyntaxError в выражении a := "wtf_walrus" в первом фрагменте. После оборачивания в скобки, a было присвоено значение, как и ожидалось.

• В то же время оборачивание скобками выражения, содержащего оператор =, не допускается. Отсюда синтаксическая ошибка в (a, b = 6, 9).

• Синтаксис моржового оператора имеет вид NAME:= expr, где NAME - допустимый идентификатор, а expr - допустимое выражение. Следовательно, упаковка и распаковка итерируемых объектов не поддерживается, что означает,

  • (a := 6, 9) эквивалентно ((a := 6), 9) и в конечном итоге (a, 9) (где значение a равно 6)

    >>> (a := 6, 9) == ((a := 6), 9)
    True
    >>> x = (a := 696, 9)
    >>> x
    (696, 9)
    >>> x[0] is a # Оба ссылаются на одну и ту же ячейку памяти
    True
    

  • Аналогично, (a, b := 16, 19) эквивалентно (a, (b := 16), 19), которое есть не что иное, как кортеж из 3 элементов.

---

▶ Строки иногда ведут себя непредсказуемо

1.

>>> a = "some_string"
>>> id(a)
140420665652016
>>> id("some" + "_" + "string") # Обратите внимание, оба идентификатора одинаковы
140420665652016

2.

>>> a = "wtf"
>>> b = "wtf"
>>> a is b
True

>>> a = "wtf!"
>>> b = "wtf!"
>>> a is b
False

3.

>>> a, b = "wtf!", "wtf!"
>>> a is b # Актуально для версий Python, кроме 3.7.x
True

>>> a = "wtf!"; b = "wtf!"
>>> a is b # Выражение вернет True или False в зависимости вызываемой среды (python shell / ipython / скрипт).
False

# На этот раз в файле
a = "wtf!"
b = "wtf!"
print(a is b)

# Выводит True при запуске модуля

4.

Output (< Python3.7 )

>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False

Логично, правда?

💡 Объяснение

• Поведение в первом и втором фрагментах связано с оптимизацией CPython (называемой интернированием строк ((англ. string interning))), которая пытается использовать существующие неизменяемые объекты в некоторых случаях вместо того, чтобы каждый раз создавать новый объект.
• После "интернирования" многие переменные могут ссылаться на один и тот же строковый объект в памяти (тем самым экономя память).
• В приведенных выше фрагментах строки неявно интернированы. Решение о том, когда неявно интернировать строку, зависит от реализации. Правила для интернирования строк следующие:
  • Все строки длиной 0 или 1 символа интернируются.
  • Строки интернируются во время компиляции ('wtf' будет интернирована, но ''.join(['w'', 't', 'f']) - нет)
  • Строки, не состоящие из букв ASCII, цифр или знаков подчеркивания, не интернируются. В примере выше 'wtf!' не интернируется из-за !. Реализацию этого правила в CPython можно найти здесь
• Когда переменные a и b принимают значение "wtf!" в одной строке, интерпретатор Python создает новый объект, а затем одновременно ссылается на вторую переменную. Если это выполняется в отдельных строках, он не "знает", что уже существует "wtf!" как объект (потому что "wtf!" не является неявно интернированным в соответствии с фактами, упомянутыми выше). Это оптимизация во время компиляции, не применяется к версиям CPython 3.7.x (более подробное обсуждение смотрите здесь issue).
• Единица компиляции в интерактивной среде IPython состоит из одного оператора, тогда как в случае модулей она состоит из всего модуля. a, b = "wtf!", "wtf!" - это одно утверждение, тогда как a = "wtf!"; b = "wtf!" - это два утверждения в одной строке. Это объясняет, почему тождества различны в a = "wtf!"; b = "wtf!", но одинаковы при вызове в модуле.
• Резкое изменение в выводе четвертого фрагмента связано с peephole optimization техникой, известной как складывание констант (англ. Constant folding). Это означает, что выражение 'a'*20 заменяется на 'aaaaaaaaaaaaaaaaaaaa' во время компиляции, чтобы сэкономить несколько тактов во время выполнения. Складывание констант происходит только для строк длиной менее 21. (Почему? Представьте себе размер файла .pyc, созданного в результате выполнения выражения 'a'*10**10). Вот исходный текст реализации для этого.
• Примечание: В Python 3.7 складывание констант было перенесено из оптимизатора peephole в новый оптимизатор AST с некоторыми изменениями в логике, поэтому четвертый фрагмент не работает в Python 3.7. Подробнее об изменении можно прочитать здесь.

---

▶ Осторожнее с цепочкой операций

>>> (False == False) in [False] # логично
False
>>> False == (False in [False]) # все еще логично
False
>>> False == False in [False] # а теперь что?

True

>>> True is False == False
False
>>> False is False is False
True

>>> 1 > 0 < 1
True
>>> (1 > 0) < 1
False
>>> 1 > (0 < 1)
False

💡 Объяснение:

Согласно https://docs.python.org/3/reference/expressions.html#comparisons

Формально, если a, b, c, ..., y, z - выражения, а op1, op2, ..., opN - операторы сравнения, то a op1 b op2 c ... y opN z эквивалентно a op1 b и b op2 c и ... y opN z, за исключением того, что каждое выражение оценивается не более одного раза.

Хотя такое поведение может показаться глупым в приведенных выше примерах, оно просто фантастично для таких вещей, как a == b == c и 0 <= x <= 100.

• False is False is False эквивалентно (False is False) и (False is False).
• True is False == False эквивалентно (True is False) and (False == False) и так как первая часть высказывания (True is False) оценивается в False, то все выражение приводится к False.
• 1 > 0 < 1 эквивалентно (1 > 0) и (0 < 1), которое приводится к True.
• Выражение (1 > 0) < 1 эквивалентно True < 1 и

  >>> int(True)
  1
  >>> True + 1 # не относится к данному примеру, но просто для интереса
  2
  

  В итоге, 1 < 1 выполняется и дает результат False

---

▶ Как не надо использовать оператор is

Ниже приведен очень известный пример.

1.

>>> a = 256
>>> b = 256
>>> a is b
True

>>> a = 257
>>> b = 257
>>> a is b
False

2.

>>> a = []
>>> b = []
>>> a is b
False

>>> a = tuple()
>>> b = tuple()
>>> a is b
True

3. Результат

>>> a, b = 257, 257
>>> a is b
True

Вывод (только для Python 3.7.x)

>>> a, b = 257, 257
>>> a is b
False

💡 Объяснение:

Разница между is и ==.

• Оператор is проверяет, ссылаются ли оба операнда на один и тот же объект (т.е. проверяет, совпадают ли идентификаторы операндов или нет).
• Оператор == сравнивает значения обоих операндов и проверяет, одинаковы ли они.
• Таким образом, оператор is предназначен для равенства ссылок, а == - для равенства значений. Пример, чтобы прояснить ситуацию,

  >>> class A: pass
  >>> A() is A() # 2 пустых объекта в разных ячейках памяти
  False
  

256 - существующий объект, а 257 - нет.

При запуске python числа от -5 до 256 записываются в память. Эти числа используются часто, поэтому имеет смысл просто иметь их наготове.

Перевод цитаты из документации

Текущая реализация хранит массив целочисленных объектов для всех целых чисел от -5 до 256, когда вы создаете int в этом диапазоне, вы просто получаете обратно ссылку на существующий объект.

>>> id(256)
10922528
>>> a = 256
>>> b = 256
>>> id(a)
10922528
>>> id(b)
10922528
>>> id(257)
140084850247312
>>> x = 257
>>> y = 257
>>> id(x)
140084850247440
>>> id(y)
140084850247344

Интерпретатор не понимает, что до выполнения выражения y = 257 целое число со значением 257 уже создано, и поэтому он продолжает создавать другой объект в памяти.

Подобная оптимизация применима и к другим изменяемым объектам, таким как пустые кортежи. Поскольку списки являются изменяемыми, поэтому [] is [] вернет False, а () is () вернет True. Это объясняет наш второй фрагмент. Перейдем к третьему,

И a, и b ссылаются на один и тот же объект при инициализации одним и тем же значением в одной и той же строкеi.

Вывод

>>> a, b = 257, 257
>>> id(a)
140640774013296
>>> id(b)
140640774013296
>>> a = 257
>>> b = 257
>>> id(a)
140640774013392
>>> id(b)
140640774013488

• Когда a и b инициализируются со значением 257 в одной строке, интерпретатор Python создает новый объект, а затем одновременно ссылается на него во второй переменной. Если делать это в отдельных строках, интерпретатор не "знает", что объект 257 уже существует.

• Это оптимизация компилятора и относится именно к интерактивной среде. Когда вы вводите две строки в интерпретаторе, они компилируются отдельно, поэтому оптимизируются отдельно. Если выполнить этот пример в файле `.py', поведение будет отличаться, потому что файл компилируется весь сразу. Эта оптимизация не ограничивается целыми числами, она работает и для других неизменяемых типов данных, таких как строки (проверьте пример "Строки - это сложно") и плавающие числа,

  >>> a, b = 257.0, 257.0
  >>> a is b
  True
  

• Почему это не сработало в Python 3.7? Абстрактная причина в том, что такие оптимизации компилятора зависят от реализации (т.е. могут меняться в зависимости от версии, ОС и т.д.). Я все еще выясняю, какое именно изменение реализации вызвало проблему, вы можете проверить этот issue для получения обновлений.

---

▶ Мистическое хэширование

1.

some_dict = {}
some_dict[5.5] = "JavaScript"
some_dict[5.0] = "Ruby"
some_dict[5] = "Python"

Вывод:

>>> some_dict[5.5]
"JavaScript"
>>> some_dict[5.0] # "Python" уничтожил "Ruby"?
"Python"
>>> some_dict[5]
"Python"

>>> complex_five = 5 + 0j
>>> type(complex_five)
complex
>>> some_dict[complex_five]
"Python"

Так почему же Python повсюду?

💡 Объяснение

• Уникальность ключей в словаре Python определяется эквивалентностью, а не тождеством. Поэтому, даже если 5, 5.0 и 5 + 0j являются различными объектами разных типов, поскольку они равны, они не могут находиться в одном и том же dict (или set). Как только вы вставите любой из них, попытка поиска по любому другому, но эквивалентному ключу будет успешной с исходным сопоставленным значением (а не завершится ошибкой KeyError):

  >>> 5 == 5.0 == 5 + 0j
  True
  >>> 5 is not 5.0 is not 5 + 0j
  True
  >>> some_dict = {}
  >>> some_dict[5.0] = "Ruby"
  >>> 5.0 in some_dict
  True
  >>> (5 in some_dict) and (5 + 0j in some_dict)
  True
  

• Это применимо и во время присваения значения элементу. Поэтому, в выражении some_dict[5] = "Python" Python находит существующий элемент с эквивалентным ключом 5.0 -> "Ruby", перезаписывает его значение на место, а исходный ключ оставляет в покое.

  >>> some_dict
  {5.0: 'Ruby'}
  >>> some_dict[5] = "Python"
  >>> some_dict
  {5.0: 'Python'}
  

• Итак, как мы можем обновить ключ до 5 (вместо 5.0)? На самом деле мы не можем сделать это обновление на месте, но что мы можем сделать, так это сначала удалить ключ (del some_dict[5.0]), а затем установить его (some_dict[5]), чтобы получить целое число 5 в качестве ключа вместо плавающего 5.0, хотя это нужно в редких случаях.

• Как Python нашел 5 в словаре, содержащем 5.0? Python делает это за постоянное время без необходимости сканирования каждого элемента, используя хэш-функции. Когда Python ищет ключ foo в словаре, он сначала вычисляет hash(foo) (что выполняется в постоянном времени). Поскольку в Python требуется, чтобы объекты, которые сравниваются одинаково, имели одинаковое хэш-значение (docs здесь), 5, 5.0 и 5 + 0j имеют одинаковое хэш-значение.

  >>> 5 == 5.0 == 5 + 0j
  True
  >>> hash(5) == hash(5.0) == hash(5 + 0j)
  True
  

  Примечание: Обратное не обязательно верно: Объекты с одинаковыми хэш-значениями сами могут быть неравными. (Это вызывает так называемую хэш-коллизию и ухудшает производительность постоянного времени, которую обычно обеспечивает хэширование).

---

▶ В глубине души мы все одинаковы.

class WTF:
  pass

Вывод:

>>> WTF() == WTF() # разные экземпляры класса не могут быть равны
False
>>> WTF() is WTF() # идентификаторы также различаются
False
>>> hash(WTF()) == hash(WTF()) # хэши тоже должны отличаться
True
>>> id(WTF()) == id(WTF())
True

💡 Объяснение:

• При вызове id Python создал объект класса WTF и передал его функции id. Функция id забирает свой id (местоположение в памяти) и выбрасывает объект. Объект уничтожается.

• Когда мы делаем это дважды подряд, Python выделяет ту же самую область памяти и для второго объекта. Поскольку (в CPython) id использует участок памяти в качестве идентификатора объекта, идентификатор двух объектов одинаков.

• Таким образом, id объекта уникален только во время жизни объекта. После уничтожения объекта или до его создания, другой объект может иметь такой же id.

• Но почему выражение с оператором is равно False? Давайте посмотрим с помощью этого фрагмента.

  class WTF(object):
    def __init__(self): print("I")
    def __del__(self): print("D")
  

  Вывод:

  >>> WTF() is WTF()
  I
  I
  D
  D
  False
  >>> id(WTF()) == id(WTF())
  I
  D
  I
  D
  True
  

  Как вы можете заметить, все дело в порядке уничтожения объектов.

---

▶ Беспорядок внутри порядка *

from collections import OrderedDict

dictionary = dict()
dictionary[1] = 'a'; dictionary[2] = 'b';

ordered_dict = OrderedDict()
ordered_dict[1] = 'a'; ordered_dict[2] = 'b';

another_ordered_dict = OrderedDict()
another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';

class DictWithHash(dict):
    """
    A dict that also implements __hash__ magic.
    """
    __hash__ = lambda self: 0

class OrderedDictWithHash(OrderedDict):
    """
    An OrderedDict that also implements __hash__ magic.
    """
    __hash__ = lambda self: 0

Вывод

>>> dictionary == ordered_dict # a == b
True
>>> dictionary == another_ordered_dict # b == c
True
>>> ordered_dict == another_ordered_dict # почему же c != a ??
False

# Мы все знаем, что множество состоит только из уникальных элементов,
# давайте попробуем составить множество из этих словарей и посмотрим, что получится...

>>> len({dictionary, ordered_dict, another_ordered_dict})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'

# Логично, поскольку в словаре не реализовано магический метод __hash__, попробуем использовать
# наши классы-обертки.
>>> dictionary = DictWithHash()
>>> dictionary[1] = 'a'; dictionary[2] = 'b';
>>> ordered_dict = OrderedDictWithHash()
>>> ordered_dict[1] = 'a'; ordered_dict[2] = 'b';
>>> another_ordered_dict = OrderedDictWithHash()
>>> another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';
>>> len({dictionary, ordered_dict, another_ordered_dict})
1
>>> len({ordered_dict, another_ordered_dict, dictionary}) # changing the order
2

Что здесь происходит?

💡 Объяснение:

• Переходное (интрантизивное) равенство между dictionary, ordered_dict и another_ordered_dict не выполняется из-за реализации магического метода __eq__ в классе OrderedDict. Перевод цитаты из документации

  Тесты равенства между объектами OrderedDict чувствительны к порядку и реализуются как list(od1.items())==list(od2.items()). Тесты на равенство между объектами OrderedDict и другими объектами Mapping нечувствительны к порядку, как обычные словари.

• Причина такого поведения равенства в том, что оно позволяет напрямую подставлять объекты OrderedDict везде, где используется обычный словарь.

• Итак, почему изменение порядка влияет на длину генерируемого объекта set? Ответ заключается только в отсутствии переходного равенства. Поскольку множества являются "неупорядоченными" коллекциями уникальных элементов, порядок вставки элементов не должен иметь значения. Но в данном случае он имеет значение. Давайте немного разберемся в этом,

  >>> some_set = set()
  >>> some_set.add(dictionary) # используем объекты из фрагмента кода выше
  >>> ordered_dict in some_set
  True
  >>> some_set.add(ordered_dict)
  >>> len(some_set)
  1
  >>> another_ordered_dict in some_set
  True
  >>> some_set.add(another_ordered_dict)
  >>> len(some_set)
  1
  
  >>> another_set = set()
  >>> another_set.add(ordered_dict)
  >>> another_ordered_dict in another_set
  False
  >>> another_set.add(another_ordered_dict)
  >>> len(another_set)
  2
  >>> dictionary in another_set
  True
  >>> another_set.add(another_ordered_dict)
  >>> len(another_set)
  2
  

  Таким образом, выражение another_ordered_dict в another_set равно False, потому что ordered_dict уже присутствовал в another_set и, как было замечено ранее, ordered_dict == another_ordered_dict равно False.

---

▶ Продолжай пытаться... *

def some_func():
    try:
        return 'from_try'
    finally:
        return 'from_finally'

def another_func():
    for _ in range(3):
        try:
            continue
        finally:
            print("Finally!")

def one_more_func(): # Попался!
    try:
        for i in range(3):
            try:
                1 / i
            except ZeroDivisionError:
                # Вызовем исключение и обработаем его за пределами цикла
                raise ZeroDivisionError("A trivial divide by zero error")
            finally:
                print("Iteration", i)
                break
    except ZeroDivisionError as e:
        print("Zero division error occurred", e)

Результат:

>>> some_func()
'from_finally'

>>> another_func()
Finally!
Finally!
Finally!

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

>>> one_more_func()
Iteration 0

💡 Объяснение:

• Когда один из операторов return, break или continue выполняется в блоке try оператора "try...finally", на выходе также выполняется пункт finally.
• Возвращаемое значение функции определяется последним выполненным оператором return. Поскольку блок finally выполняется всегда, оператор return, выполненный в блоке finally, всегда будет последним.
• Предостережение - если в блоке finally выполняется оператор return или break, то временно сохраненное исключение отбрасывается.

---

▶ Для чего?

some_string = "wtf"
some_dict = {}
for i, some_dict[i] in enumerate(some_string):
    i = 10

Вывод:

>>> some_dict # Словарь с индексами
{0: 'w', 1: 't', 2: 'f'}

💡 Объяснение:

• Оператор for определяется в грамматике Python как:

  for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
  

  Где exprlist - цель присваивания. Это означает, что эквивалент {exprlist} = {next_value} выполняется для каждого элемента в итерируемом объекте. Интересный пример, иллюстрирующий это:

  for i in range(4):
      print(i)
      i = 10
  

  Результат:

  0
  1
  2
  3
  

  Не ожидали, что цикл будет запущен только один раз?

  💡 Объяснение:.

  • Оператор присваивания i = 10 никогда не влияет на итерации цикла из-за того, как циклы for работают в Python. Перед началом каждой итерации следующий элемент, предоставляемый итератором (в данном случае range(4)), распаковывается и присваивается переменной целевого списка (в данном случае i).

• Функция enumerate(some_string) на каждой итерации выдает новое значение i (счетчик-инкремент) и символ из some_string. Затем она устанавливает (только что присвоенный) ключ i словаря some_dict на этот символ. Развертывание цикла можно упростить следующим образом:

  >>> i, some_dict[i] = (0, 'w')
  >>> i, some_dict[i] = (1, 't')
  >>> i, some_dict[i] = (2, 'f')
  >>> some_dict
  

---

▶ Расхождение во времени исполнения

1.

array = [1, 8, 15]
# Типичный генератор
gen = (x for x in array if array.count(x) > 0)
array = [2, 8, 22]

Вывод:

>>> print(list(gen)) # Куда подевались остальные значения?
[8]

2.

array_1 = [1,2,3,4]
gen_1 = (x for x in array_1)
array_1 = [1,2,3,4,5]

array_2 = [1,2,3,4]
gen_2 = (x for x in array_2)
array_2[:] = [1,2,3,4,5]

Вывод:

>>> print(list(gen_1))
[1, 2, 3, 4]

>>> print(list(gen_2))
[1, 2, 3, 4, 5]

3.

array_3 = [1, 2, 3]
array_4 = [10, 20, 30]
gen = (i + j for i in array_3 for j in array_4)

array_3 = [4, 5, 6]
array_4 = [400, 500, 600]

Вывод:

>>> print(list(gen))
[401, 501, 601, 402, 502, 602, 403, 503, 603]

💡 Объяснение

• В выражении генераторе условие in оценивается во время объявления, но условие if оценивается во время выполнения.

• Перед выполнением кода, значение переменной array изменяется на список [2, 8, 22], а поскольку из 1, 8 и 15 только счетчик 8 больше 0, генератор выдает только 8.

• Различия в выводе g1 и g2 во второй части связаны с тем, как переменным array_1 и array_2 присваиваются новые значения.

  • В первом случае array_1 привязывается к новому объекту [1,2,3,4,5], а поскольку in выражение исполняется во время объявления, оно по-прежнему ссылается на старый объект [1,2,3,4] (который не уничтожается).
  • Во втором случае присвоение среза array_2 обновляет тот же старый объект [1,2,3,4] до [1,2,3,4,5]. Следовательно, и g2, и array_2 по-прежнему имеют ссылку на один и тот же объект (который теперь обновлен до [1,2,3,4,5]).

• Хорошо, следуя приведенной выше логике, не должно ли значение list(gen) в третьем фрагменте быть [11, 21, 31, 12, 22, 32, 13, 23, 33]? (потому что array_3 и array_4 будут вести себя так же, как array_1). Причина, по которой (только) значения array_4 обновляются, объясняется в PEP-289

  Только крайнее for-выражение исполняется немедленно, остальные выражения откладываются до запуска генератора.

---

▶ is not ... не является is (not ...)

>>> 'something' is not None
True
>>> 'something' is (not None)
False

💡 Объяснение

• is not является единым бинарным оператором, и его поведение отличается от раздельного использования is и not.
• is not имеет значение False, если переменные по обе стороны оператора указывают на один и тот же объект, и True в противном случае.
• В примере (not None) оценивается в True, поскольку значение None является False в булевом контексте, поэтому выражение становится 'something' is True.

---

▶ Крестики-нолики, где X побеждает с первой попытки!

# Инициализируем переменную row
row = [""] * 3 #row i['', '', '']
# Инициализируем игровую сетку
board = [row] * 3

Результат:

>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>>> board[0]
['', '', '']
>>> board[0][0]
''
>>> board[0][0] = "X"
>>> board
[['X', '', ''], ['X', '', ''], ['X', '', '']]

Мы же не назначили три "Х"?

💡 Объяснение:

Когда мы инициализируем переменную row, эта визуализация объясняет, что происходит в памяти

А когда переменная board инициализируется путем умножения row, вот что происходит в памяти (каждый из элементов board[0], board[1] и board[2] является ссылкой на тот же список, на который ссылается row)

Мы можем избежать этого сценария, не используя переменную row для генерации board. (Подробнее в issue).

>>> board = [['']*3 for _ in range(3)]
>>> board[0][0] = "X"
>>> board
[['X', '', ''], ['', '', ''], ['', '', '']]

---

▶ Переменная Шредингера *

funcs = []
results = []
for x in range(7):
    def some_func():
        return x
    funcs.append(some_func)
    results.append(some_func())  # обратите внимание на вызов функции

funcs_results = [func() for func in funcs]

Вывод (Python version):

>>> results
[0, 1, 2, 3, 4, 5, 6]
>>> funcs_results
[6, 6, 6, 6, 6, 6, 6]

Значения x были разными в каждой итерации до добавления some_func к funcs, но все функции возвращают 6, когда они исполняются после завершения цикла.

>>> powers_of_x = [lambda x: x**i for i in range(10)]
>>> [f(2) for f in powers_of_x]
[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]

💡 Объяснение:

• При определении функции внутри цикла, которая использует переменную цикла в своем теле, цикл функции привязывается к переменной, а не к ее значению. Функция ищет x в окружающем контексте, а не использует значение x на момент создания функции. Таким образом, все функции используют для вычислений последнее значение, присвоенное переменной. Мы можем видеть, что используется x из глобального контекста (т.е. не локальная переменная):

>>> import inspect
>>> inspect.getclosurevars(funcs[0])
ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())

Так как x - глобальная переменная, можно изменить ее значение, которое будет использовано и возвращено из funcs

>>> x = 42
>>> [func() for func in funcs]
[42, 42, 42, 42, 42, 42, 42]

• Чтобы получить желаемое поведение, вы можете передать переменную цикла как именованную переменную в функцию. Почему это работает? Потому что это определит переменную внутри области видимости функции. Она больше не будет обращаться к глобальной области видимости для поиска значения переменной, а создаст локальную переменную, которая будет хранить значение x в данный момент времени.

funcs = []
for x in range(7):
    def some_func(x=x):
        return x
    funcs.append(some_func)

Вывод:

>>> funcs_results = [func() for func in funcs]
>>> funcs_results
[0, 1, 2, 3, 4, 5, 6]

x больше не используется в глобальной области видимости

>>> inspect.getclosurevars(funcs[0])
ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())

---

▶ Проблема курицы и яйца *

1.

>>> isinstance(3, int)
True
>>> isinstance(type, object)
True
>>> isinstance(object, type)
True

Так какой же базовый класс является "окончательным"? Кстати, это еще не все,

2.

>>> class A: pass
>>> isinstance(A, A)
False
>>> isinstance(type, type)
True
>>> isinstance(object, object)
True

3.

>>> issubclass(int, object)
True
>>> issubclass(type, object)
True
>>> issubclass(object, type)
False

💡 Объяснение

• type - это метакласс в Python.
• Все в Python является объектом, что включает в себя как классы, так и их объекты (экземпляры).
• Класс type является метаклассом класса object, и каждый класс (включая type) наследуется прямо или косвенно от object.
• У object и type нет реального базового класса. Путаница в приведенных выше фрагментах возникает потому, что мы думаем об этих отношениях (issubclass и isinstance) в терминах классов Python. Отношения между object и type не могут быть воспроизведены в чистом Python. Точнее говоря, следующие отношения не могут быть воспроизведены в чистом Python,
  • класс A является экземпляром класса B, а класс B является экземпляром класса A.
  • класс A является экземпляром самого себя.
• Эти отношения между object и type (оба являются экземплярами друг друга, а также самих себя) существуют в Python из-за "обмана" на уровне реализации.

---

▶ Отношения между подклассами

Вывод:

>>> from collections import Hashable
>>> issubclass(list, object)
True
>>> issubclass(object, Hashable)
True
>>> issubclass(list, Hashable)
False

Предполагается, что отношения подклассов должны быть транзитивными, верно? (т.е. если A является подклассом B, а B является подклассом C, то A должен быть подклассом C)

💡 Объяснение

• Отношения подклассов не обязательно являются транзитивными в Python. Можно переопределить магический метод __subclasscheck__ в метаклассе.
• Когда вызывается issubclass(cls, Hashable), он просто ищет не-фальшивый метод "__hash__" в cls или во всем, от чего он наследуется.
• Поскольку object является хэшируемым, а list - нехэшируемым, это нарушает отношение транзитивности.
• Более подробное объяснение можно найти [здесь] (https://www.naftaliharris.com/blog/python-subclass-intransitivity/).

---

▶ Равенство и тождество методов

class SomeClass:
    def method(self):
        pass

    @classmethod
    def classm(cls):
        pass

    @staticmethod
    def staticm():
        pass

Результат:

>>> print(SomeClass.method is SomeClass.method)
True
>>> print(SomeClass.classm is SomeClass.classm)
False
>>> print(SomeClass.classm == SomeClass.classm)
True
>>> print(SomeClass.staticm is SomeClass.staticm)
True

Обращаясь к classm дважды, мы получаем одинаковый объект, но не тот же самый? Давайте посмотрим, что происходит с экземплярами SomeClass:

o1 = SomeClass()
o2 = SomeClass()

Вывод:

>>> print(o1.method == o2.method)
False
>>> print(o1.method == o1.method)
True
>>> print(o1.method is o1.method)
False
>>> print(o1.classm is o1.classm)
False
>>> print(o1.classm == o1.classm == o2.classm == SomeClass.classm)
True
>>> print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)
True

Повторный доступ к классу или методу создает одинаковые, но не те же самые объекты для одного и того же экземпляра какого-либо класса.

💡 Объяснение

• Функции являются дескрипторами. Всякий раз, когда к функции обращаются как к атрибута, вызывается дескриптор, создавая объект метода, который "связывает" функцию с объектом, владеющим атрибутом. При вызове метод вызывает функцию, неявно передавая связанный объект в качестве первого аргумента (именно так мы получаем self в качестве первого аргумента, несмотря на то, что не передаем его явно).

>>> o1.method
<bound method SomeClass.method of <__main__.SomeClass object at ...>>

• При многократном обращении к атрибуту каждый раз создается объект метода! Поэтому o1.method is o1.method всегда ложно. Однако доступ к функциям как к атрибутам класса (в отличие от экземпляра) не создает методов; поэтому SomeClass.method is SomeClass.method является истинным.

>>> SomeClass.method
<function SomeClass.method at ...>

• classmethod преобразует функции в методы класса. Методы класса - это дескрипторы, которые при обращении к ним создают объект метода, который связывает класс (тип) объекта, а не сам объект.

>>> o1.classm
<bound method SomeClass.classm of <class '__main__.SomeClass'>>

• В отличие от функций, classmethod будет создавать метод и при обращении к нему как к атрибуту класса (в этом случае они привязываются к классу, а не к его типу). Поэтому SomeClass.classm is SomeClass.classm является ошибочным.

>>> SomeClass.classm
<bound method SomeClass.classm of <class '__main__.SomeClass'>>

• Объект-метод равен, если обе функции равны, а связанные объекты одинаковы. Поэтому o1.method == o1.method является истинным, хотя и не является одним и тем же объектом в памяти.
• staticmethod преобразует функции в дескриптор "no-op", который возвращает функцию как есть. Методы-объекты никогда не создается, поэтому сравнение с is является истинным.

>>> o1.staticm
<function SomeClass.staticm at ...>
>>> SomeClass.staticm
<function SomeClass.staticm at ...>

• Необходимость создавать новые объекты "метод" каждый раз, когда Python вызывает методы экземпляра, и необходимость изменять аргументы каждый раз, чтобы вставить self, сильно сказывается на производительности. CPython 3.7 решил эту проблему, введя новые опкоды, которые работают с вызовом методов без создания временных объектов методов. Это используется только при фактическом вызове функции доступа, так что приведенные здесь фрагменты не затронуты и по-прежнему генерируют методы :)

---

▶ All-true-ation (непереводимая игра слов) *

>>> all([True, True, True])
True
>>> all([True, True, False])
False

>>> all([])
True
>>> all([[]])
False
>>> all([[[]]])
True

Почему это изменение True-False?

💡 Объяснение:

• Реализация функции all:

• def all(iterable):
      for element in iterable:
          if not element:
              return False
      return True
  

• all([]) возвращает True, поскольку итерируемый массив пуст.

• all([[]]) возвращает False, поскольку переданный массив имеет один элемент, [], а в python пустой список является ложным.

• all([[[[]]]) и более высокие рекурсивные варианты всегда True. Это происходит потому, что единственный элемент переданного массива ([[...]]) уже не пуст, а списки со значениями являются истинными.

---

▶ Неожиданная запятая

Вывод (< 3.6):

>>> def f(x, y,):
...     print(x, y)
...
>>> def g(x=4, y=5,):
...     print(x, y)
...
>>> def h(x, **kwargs,):
  File "<stdin>", line 1
    def h(x, **kwargs,):
                     ^
SyntaxError: invalid syntax

>>> def h(*args,):
  File "<stdin>", line 1
    def h(*args,):
                ^
SyntaxError: invalid syntax

💡 Объяснение:

• Запятая в конце списка аргументов функции Python не всегда законна.
• В Python список аргументов определяется частично с помощью ведущих запятых, а частично с помощью запятых в конце списка. Этот конфликт приводит к ситуациям, когда запятая оказывается в середине, и ни одно из правил не выполняется.
• Примечание: Проблема с запятыми в конце списка аргументов исправлена в Python 3.6. Варианты использования запятых в конце выражения приведены в обсуждении.

---

▶ Строки и обратные слэши

Вывод:

>>> print("\"")
"

>>> print(r"\"")
\"

>>> print(r"\")
File "<stdin>", line 1
    print(r"\")
              ^
SyntaxError: EOL while scanning string literal

>>> r'\'' == "\\'"
True

💡 Объяснение

• В обычной строке обратная слэш используется для экранирования символов, которые могут иметь специальное значение (например, одинарная кавычка, двойная кавычка и сам обратный слэш).

  >>> "wt\"f"
  'wt"f'
  

• В необработанном строковом литерале (на что указывает префикс r) обратный слэш передается как есть, вместе с поведением экранирования следующего символа.

  >>> r'wt\"f' == 'wt\\"f'
  True
  >>> print(repr(r'wt\"f')
  'wt\\"f'
  
  >>> print("\n")
  
  >>> print(r"\\n")
  '\\n'
  

• Это означает, что когда синтаксический анализатор встречает обратный слэш в необработанной строке, он ожидает, что за ней последует другой символ. А в нашем случае (print(r"\")) обратная слэш экранирует двойную кавычку, оставив парсер без завершающей кавычки (отсюда SyntaxError). Вот почему обратный слеш не работает в конце необработанной строки.

---