Translate Hash brownies and Deep down, we're all the same examples

translations/README-ru.md

@@ -456,3 +456,120 @@ False
 * Почему это не сработало в Python 3.7? Абстрактная причина в том, что такие оптимизации компилятора зависят от реализации (т.е. могут меняться в зависимости от версии, ОС и т.д.). Я все еще выясняю, какое именно изменение реализации вызвало проблему, вы можете проверить этот [issue](https://github.com/satwikkansal/wtfpython/issues/100) для получения обновлений.
 
 ---
+
+
+### ▶ Мистическое хэширование
+<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --->
+1\.
+```py
+some_dict = {}
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
+some_dict[5] = "Python"
+```
+
+**Вывод:**
+
+```py
+>>> 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`):
+  ```py
+  >>> 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"`, перезаписывает его значение на место, а исходный ключ оставляет в покое.
+  ```py
+  >>> 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](https://docs.python.org/3/reference/datamodel.html#object.__hash__) здесь), `5`, `5.0` и `5 + 0j` имеют одинаковое хэш-значение.
+  ```py
+  >>> 5 == 5.0 == 5 + 0j
+  True
+  >>> hash(5) == hash(5.0) == hash(5 + 0j)
+  True
+  ```
+  **Примечание:** Обратное не обязательно верно: Объекты с одинаковыми хэш-значениями сами могут быть неравными. (Это вызывает так называемую [хэш-коллизию](https://en.wikipedia.org/wiki/Collision_(computer_science)) и ухудшает производительность постоянного времени, которую обычно обеспечивает хэширование).
+
+---
+
+
+### ▶ В глубине души мы все одинаковы.
+<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
+```py
+class WTF:
+  pass
+```
+
+**Вывод:**
+```py
+>>> 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`? Давайте посмотрим с помощью этого фрагмента.
+  ```py
+  class WTF(object):
+    def __init__(self): print("I")
+    def __del__(self): print("D")
+  ```
+
+  **Вывод:**
+  ```py
+  >>> WTF() is WTF()
+  I
+  I
+  D
+  D
+  False
+  >>> id(WTF()) == id(WTF())
+  I
+  D
+  I
+  D
+  True
+  ```
+  Как вы можете заметить, все дело в порядке уничтожения объектов.
+
+---