+KeyError: 1
+>>> %timeit another_dict['5']
+38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+```
+왜 같은 검색의 속도가 느려질까요?
+
+#### 💡 설명:
++ CPython은 모든 타입의 키 (`str`, `int`, 모든 오브젝트 ...)에 대해 일반적인 딕셔너리 검색 함수가 있고 흔한 경우인 `str` 키로만 이루어져 있는 딕셔너리에 대한 함수가 있습니다.
++ (CPython에서 이름이 `lookdict_unicode` [소스](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) 함수는 (검색하려는 키를 포함해서) 모든 키가 문자열 인것을 알고, `__eq__` 메소드를 호출하는 대신 빠르고 간단한 문자열 비교를 사용합니다.
++ `dict` 인스턴스가 처음으로 `str`이 아닌 키로 접근되었을 때, 추후 검색은 일반적인 함수를 사용하도록 수정됩니다.
++ 이 과정은 특정 `dict` 인스턴스에 대해서 되돌릴 수 없으며, 키가 딕셔너리 안에 없어도 작동합니다. 그래서 실패한 검색도 같은 효과를 가지게 된 것입니다.
+
+### ▶ `dict` 인스턴스 부풀리기 \*
+
+
+
+```py
+import sys
+
+class SomeClass:
+ def __init__(self):
+ self.some_attr1 = 1
+ self.some_attr2 = 2
+ self.some_attr3 = 3
+ self.some_attr4 = 4
+
+
+def dict_size(o):
+ return sys.getsizeof(o.__dict__)
+
+```
+
+**출력 결과:** (파이썬 3.8, 다른 파이썬 3 버전은 조금 다를 수 있습니다.)
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104
+>>> dict_size(o2)
+104
+>>> del o1.some_attr1
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+>>> dict_size(o1)
+232
+```
+
+새로운 인터프리터에서 다시 시도해볼까요?:
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104 # 예상한 대로 나왔네요
+>>> o1.some_attr5 = 5
+>>> o1.some_attr6 = 6
+>>> dict_size(o1)
+360
+>>> dict_size(o2)
+272
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+```
+
+무엇이 이 딕셔너리들을 부풀리게 했을까요? 그리고 왜 새롭게 생성된 객체도 부풀려질까요?
+
+#### 💡 설명:
+
+- CPython은 다양한 딕셔너리에서 같은 "키" 객체를 재사용할 수 있습니다.
+이것은 특별히 키(인스턴스 속성)들이 주로 모든 인스턴스에서 비슷한 딕셔너리의 인스턴스의 메모리 사용량을 줄이기 위해서 [PEP 412](https://www.python.org/dev/peps/pep-0412/)에서 추가되었습니다.
+- 이 최적화는 인스턴스 딕셔너리에는 원활히 적용되는데, 몇 몇 가정이 만족되지 않게 되면 작동하지 않습니다.
+- 키를 공유하는 딕셔너리는 삭제를 지원하지 않습니다; 만약 어떤 인스턴스 속성이 삭제되었을 때, 그 딕셔너리는 "비공유"가 되고, 후의 그 클래스 인스턴스는 키를 공유하지 않게 됩니다.
+- 추가로, (새로운 키가 삽입되어서) 딕셔너리의 키들의 크기가 조정되었다면, 그 키가 그 딕셔너리에서만 사용되었을 경우에만 계속 공유된 상태를 유지합니다 (이것은 `__init__`에서 인스턴스를 처음 만들 때 "비공유" 상태가 되지 않고 많은 속성을 추가할 수 있게 합니다).
+만약 크기가 조정될 때 다양한 인스턴스가 존재하면, 키를 더 이상 공유하지 않게 되고 후의 그 클래스의 모든 인스턴스에 대해서 공유하지 않게 됩니다: CPython은 그 인스턴스가 같은 속성의 집합을 사용하는지 알 수 없게 되므로, 키를 공유하는 시도를 하지 않게 됩니다.
+- 작은 팁으로, 만약 프로그램의 메모리 공간을 줄이고 싶다면: 인스턴스 속성을 지우지 말고, 꼭 모든 속성을 `__init__`에서 초기화 하세요!
+
+---
+
+### ▶ 사소한 것들 \*
+
+
+
+- `join()` 은 리스트 연산이 아닌 문자열 연산입니다. (처음 보기에는 직관적이지 않습니다.)
+
+ **💡 설명:** `join()`이 문자열의 메소드라면 모든 iterable 자료형 (리스트(list), 튜플(tuple), 반복자(iterators)) 에서 동작할 수 있습니다. 만약 리스트의 메소드라면 모든 타입에 대해 따로 정의해야 합니다. 또한, 일반적인 `list` 객체 API에 문자열 방식의 메소드를 붙이는 것은 별로 말이 되지 않습니다.
+
+- 이상하게 보이지만 의미상 올바른 구문들:
+
+ - `[] = ()` 은 의미상 올바른 구문입니다. (빈 `tuple`을 빈 `list` 안으로 풀어 넣습니다.(unpacking))
+ - `'a'[0][0][0][0][0]` 은 파이썬에서 문자열들이 [sequences](https://docs.python.org/ko/3/glossary.html#term-sequence) (iterables 하고 인덱스로 요소에 접근이 가능합니다) 이므로 의미상 올바른 구문입니다.
+ - `3 --0-- 5 == 8`과 `--5 == 5` 둘다 의미상 올바른 구문이며 결괏값은 `True`입니다.
+
+- `a`을 숫자라고 고려할 때, `++a`와 `--a` 둘 다 파이썬에서 올바른 구문이지만 C, C++, 또는 Java 같은 언어에서 유사한 구문과는 같은 결과를 보이지 않습니다.
+
+ ```py
+ >>> a = 5
+ >>> a
+ 5
+ >>> ++a
+ 5
+ >>> --a
+ 5
+ ```
+
+ **💡 설명:**
+
+ - 파이썬 문법에는 `++` 연산자가 없습니다. 이것은 두 개의 `+` 연산자입니다.
+ - `++a` 는 `+(+a)`로 분석되어 `a`가 됩니다. 마찬가지로 `--a` 도 올바른 구문입니다.
+ - 이 StackOverflow [스레드](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python)에서 파이썬에서 증가 및 감소 연산자가 없는 이유에 대한 토론을 확인할 수 있습니다.
+
+- 파이썬의 Walrus 연산자에 대해 알고 있을 겁니다. 그런데 _space-invader 연산자_ 에 대해 들어보셨나요?
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+ 다른 증가 연산자와 함께, 대체 증가 연산자로 사용됩니다.
+ ```py
+ >>> a +=+ 1
+ >>> a
+ >>> 44
+ ```
+ **💡 설명:** 이 장난은 [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en) 에서 왔습니다. space-invader 연산자는 실제로 `a -= (-1)` 의 잘못된 형식입니다. `a = a - (- 1)`와 같습니다. `a += (+ 1)`도 비슷한 방식으로 적용됩니다.
+- 파이썬은 문서화되지 않은 [converse implication](https://en.wikipedia.org/wiki/Converse_implication) 연산자를 가지고 있습니다.
+
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 설명:** 만약 `False` 와 `True` 을 0과 1로 대체하고 계산을 해보면, 진리표는 converse implication 연산자와 같습니다. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+- 우리는 계속 연산자들을 말하고 있기 때문에, 행렬 곱셈을 위한 `@` 연산자도 있습니다. (걱정하지 마세요, 이번엔 진짜입니다).
+
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 설명:** 파이썬 3.5부터 `@` 연산자를 추가해 과학계를 염두에 두었습니다. 어떤 객체든 `__matmul__` 의 마법 메소드를 오버로드해 이 연산자의 행동을 정의할 수 있습니다.
+
+- 파이썬 3.8 이상에서는 `f'{some_var=}` 와 같은 일반적인 f-string 구문을 사용하여 빠른 디버깅을 할 수 있습니다. 예를 들어,
+
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+- 파이썬은 함수들의 지역 변수 저장소에 2바이트를 사용합니다. 이론적으로, 이것은 함수에서 65536개의 변수만 정의될 수 있는 것을 의미합니다. 하지만 파이썬에는 2^16개 이상의 변수 이름들을 저장하는 데 사용할 수 있는 유용한 해결책이 내장되어 있습니다. 다음 코드는 65536개 이상의 지역 변수가 정의되었을 때 스택에서 발생하는 상황을 보여줍니다. (주의: 이 코드는 약 2^18줄의 텍스트를 출력하므로, 준비하십시오!):
+
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+- 여러 파이썬 스레드들이 동시에 _파이썬 코드_ 를 실행하지 않습니다. (예, 제대로 들으셨습니다!) 여러 개의 스레드를 생성하여 파이썬 코드를 동시에 실행하도록 하는 것이 직관적으로 보일 수 있지만 파이썬의 [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) 때문에 당신이 만들고 실행시키는 스레드들은 같은 코어를 차례대로 동작하게 하는 것뿐입니다. 파이썬의 쓰레드는 IO-bound 작업에 적합하지만, CPU-bound 작업에서 병렬화를 달성하려면 [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) 모듈을 사용하는 것이 좋을 수 있습니다.
+
+- 때때로, `print` 메소드는 값을 바로 출력하지 못할 수 있습니다. 예를 들어,
+
+ ```py
+ # File some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
+
+ 출력 버퍼가 `\n` 에 도달한 후 또는 프로그램의 실행이 끝날 때 출력 버퍼가 플러시 되기 때문에 `end` 인자로 인하여 3초 뒤에 `wtfpython` 을 출력합니다. `flush=True` 인자를 전달하여 버퍼를 강제로 플러시 할 수도 있습니다.
+
+- 범위를 벗어난 리스트 슬라이싱은 에러를 던지지 않습니다.
+
+ ```py
+ >>> some_list = [1, 2, 3, 4, 5]
+ >>> some_list[111:]
+ []
+ ```
+
+- iterable 을 슬라이싱 하면 항상 새로운 객체가 생성되는 것은 아닙니다. 예를 들어,
+
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # False expected because a new object is created.
+ False
+ >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use.
+ True
+ ```
+
+- 파이썬 3 에서 `int('١٢٣٤٥٦٧٨٩')` 는 `123456789` 을 반환합니다. 파이썬에서, 십진수 문자들에는 숫자 문자들과 십진법 숫자들을 형성하는데 사용될 수 있는 모든 문자가 포함됩니다, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. 이 동작과 관련된 [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) 입니다.
+
+- 파이썬 3 이상에서는 더 나은 가독성을 위해 밑줄로 숫자 리터럴을 분리할 수 있습니다.
+
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+- `'abc'.count('') == 4`. 다음은 더 명확하게 만들어 주는 `count` 메소드의 비슷한 구현입니다.
+ ```py
+ def count(s, sub):
+ result = 0
+ for i in range(len(s) + 1 - len(sub)):
+ result += (s[i:i + len(sub)] == sub)
+ return result
+ ```
+ 이 동작은 원래 문자열에서 길이가 0인 슬라이스들에 빈 substring(`''`)이 일치하기 때문입니다.
+
+---
+
+---
+
+# 기여하기
+
+wtfpython에 기여할 수 있는 몇 가지 방법이 있어요,
+
+- 새로운 예제들 추천
+- 번역 돕기 ([issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) 을 보세요.)
+- 오래된 정보, 오타, 서식 오류 등의 작은 수정들
+- 차이점들 식별 (불충분한 설명, 중복된 예제 등등.)
+- 이 프로젝트를 더욱 재미있고 유용하게 만들기 위한 창의적인 제안들
+
+더 많은 정보는 [CONTRIBUTING.md](/CONTRIBUTING.md)을는보세요. 자유롭게 새로운 [issue](https://github.com/satwikkansal/wtfpython/issues/new)를 만들어 토론해보세요.
+
+추신: 역링크 요청으로 연락하지 마세요. 프로젝트와 관련이 높지 않으면 링크를 추가하지 않습니다.
+
+# 감사의 말
+
+이 항목들의 아이디어와 디자인은 Denys Dovhan's 의 멋진 프로젝트 [wtfjs](https://github.com/denysdovhan/wtfjs) 에서 영감을 받았습니다. Pythonista들의 압도적인 지지는 그것의 현재의 모습을 주었습니다.
+
+#### 몇 개의 멋진 링크들!
+
+- https://www.youtube.com/watch?v=sH4XF6pKKmk
+- https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+- https://sopython.com/wiki/Common_Gotchas_In_Python
+- https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+- https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+- https://www.python.org/doc/humor/
+- https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+- https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
+- https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+- WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
+
+# 🎓 License
+
+[![WTFPL 2.0][license-image]][license-url]
+
+© [Satwik Kansal](https://satwikkansal.xyz)
+
+[license-url]: http://www.wtfpl.net
+[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
+
+## 친구들을 놀라게 해보세요!
+
+만약 wtfpython이 마음에 드셨다면, 친구들에게 빠르게 공유하기 위한 퀵 링크들을 사용할 수 있어요.
+
+[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+
+## Need a pdf version?
+
+I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get them as soon as they are finished.
+
+**That's all folks!** For upcoming content like this, you can add your email [here](https://www.satwikkansal.xyz/content-like-wtfpython/).
diff --git a/docs/RU.md b/docs/RU.md
new file mode 100644
index 0000000..17d668d
--- /dev/null
+++ b/docs/RU.md
@@ -0,0 +1,3844 @@
+---
+hide:
+ - toc
+---
+
+
+What the f*ck Python! 😱
+Изучение и понимание Python с помощью нестандартного поведения и "магического" поведения.
+
+Другие переводы: [English Original](https://github.com/satwikkansal/wtfpython) | [Russian Русский](https://github.com/frontdevops/wtfpython) | [Chinese 中文](https://github.com/robertparley/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
+
+Еще способы попробовать: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
+
+Python, будучи прекрасно разработанным языком программирования высокого уровня с интерпретатором, предоставляет нам множество возможностей для удобства программиста. Но иногда результаты работы фрагмента Python могут показаться неочевидными на первый взгляд.
+
+Вот забавный проект, пытающийся объяснить, что именно происходит под капотом некоторых неинтуитивных сниппетов и менее известных возможностей Python.
+
+Хотя некоторые из примеров, которые вы увидите ниже, возможно, не являются WTF в прямом смысле этого слова, но они раскроют некоторые интересные части Python, о которых вы могли не знать. Я считаю, что это хороший способ изучить внутреннее устройство языка программирования, и я верю, что вам это тоже покажется интересным!
+
+Если вы опытный программист на Python, вы можете принять это как вызов, чтобы получить большинство из них правильно с первой попытки. Возможно, вы уже сталкивались с некоторыми из них раньше, и я смогу оживить ваши старые добрые воспоминания! :sweat_smile:
+
+PS: Если вы постоянный читатель, вы можете узнать о новых изменениях [здесь](https://github.com/satwikkansal/wtfpython/releases/) (примеры, отмеченные звездочкой - это примеры, добавленные в последней основной редакции).
+
+Ну чтож, начнем...
+
+# Table of Contents
+
+
+
+- [Структура примеров](#structure-of-the-examples)
+ + [▶ Какое-то модное название](#-some-fancy-title)
+- [Применение](#usage)
+- [👀 Примеры](#-examples)
+ * [Раздел: Напряги мозги!](#section-strain-your-brain)
+ + [▶ Перво-наперво! *](#-first-things-first-)
+ + [▶ Иногда строки могут быть хитрыми](#-strings-can-be-tricky-sometimes)
+ + [▶ Осторожнее с цепочками операций](#-be-careful-with-chained-operations)
+ + [▶ Как не надо использовать оператор `is`](#-how-not-to-use-is-operator)
+ + [▶ Мистика хэширования](#-hash-brownies)
+ + [▶ В глубине души мы все одинаковы](#-deep-down-were-all-the-same)
+ + [▶ Беспорядок внутри порядка *](#-disorder-within-order-)
+ + [▶ Продолжай пытаться... *](#-keep-trying-)
+ + [▶ Для чего?](#-for-what)
+ + [▶ Расхождение во времени оценки](#-evaluation-time-discrepancy)
+ + [▶ `is not ...` не является `is(not ...)`](#-is-not--is-not-is-not-)
+ + [▶ Крестики-нолики, где X побеждает в первой попытке!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+ + [▶ Переменная Шредингера](#-schrödingers-variable-)
+ + [▶ The chicken-egg problem *](#-the-chicken-egg-problem-)
+ + [▶ Отношения подклассов](#-subclass-relationships)
+ + [▶ Методы равенства и тождества](#-methods-equality-and-identity)
+ + [▶ All-true-ation *](#-all-true-ation-)
+ + [▶ Удивительная запятая](#-the-surprising-comma)
+ + [▶ Строки и обратные слеши](#-strings-and-the-backslashes)
+ + [▶ not knot!](#-not-knot)
+ + [▶ Строки с половиной тройных кавычек](#-half-triple-quoted-strings)
+ + [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)
+ + [▶ Атрибуты класса и атрибуты экземпляра](#-class-attributes-and-instance-attributes)
+ + [▶ yielding None](#-yielding-none)
+ + [▶ Yielding из... возврата! *](#-yielding-from-return-)
+ + [▶ NaN-рефлексивность *](#-nan-reflexivity-)
+ + [▶ Мутация неизменного!](#-mutating-the-immutable)
+ + [▶ Исчезающая переменная из внешней области видимости](#-the-disappearing-variable-from-outer-scope)
+ + [▶ Загадочное преобразование типа ключа](#-the-mysterious-key-type-conversion)
+ + [▶ Посмотрим, сможете ли вы угадать это?](#-lets-see-if-you-can-guess-this)
+ + [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion)
+ * [Раздел: Скользкие склоны](#section-slippery-slopes)
+ + [▶ Изменение словаря во время итерации по нему](#-modifying-a-dictionary-while-iterating-over-it)
+ + [▶ Упрямая операция `del`](#-stubborn-del-operation)
+ + [▶ Переменная вне области видимости](#-the-out-of-scope-variable)
+ + [▶ Удаление элемента списка во время итерации](#-deleting-a-list-item-while-iterating)
+ + [▶ zip итераторов с потерями *](#-lossy-zip-of-iterators-)
+ + [▶ Loop variables leak out!](#-loop-variables-leaking-out)
+ + [▶ Остерегайтесь мутабельных аргументов по умолчанию!](#-beware-of-default-mutable-arguments)
+ + [▶ Catching the Exceptions](#-catching-the-exceptions)
+ + [▶ Same operands, different story!](#-same-operands-different-story)
+ + [▶ Разрешение имен, игнорирующее область действия класса](#-name-resolution-ignoring-class-scope)
+ + [▶ Округление как у банкира *](#-rounding-like-a-banker-)
+ + [▶ Needles in a Haystack *](#-needles-in-a-haystack-)
+ + [▶ Splitsies *](#-splitsies-)
+ + [▶ Дикий импорт *](#-wild-imports-)
+ + [▶ Все отсортировано? *](#-all-sorted-)
+ + [▶ Полуночное время не существует?](#-midnight-time-doesnt-exist)
+ * [Раздел: Скрытые сокровища!](#section-the-hidden-treasures)
+ + [▶ О'кей Питон, ты можешь заставить меня летать?](#-okay-python-can-you-make-me-fly)
+ + [▶ `goto`, но почему?](#-goto-but-why)
+ + [▶ Держитесь!](#-brace-yourself)
+ + [▶ Давайте встретимся с дружелюбным языковым дядей на всю жизнь](#-lets-meet-friendly-language-uncle-for-life)
+ + [▶ Даже Python понимает, что любовь - это сложно](#-even-python-understands-that-love-is-complicated)
+ + [▶ Да, это существует!](#-yes-it-exists)
+ + [▶ Многоточие *](#-ellipsis-)
+ + [▶ Inpinity](#-inpinity)
+ + [▶ Let's mangle](#-lets-mangle)
+ * [Раздел: Внешность обманчива!](#section-appearances-are-deceptive)
+ + [▶ Пропускаете строки?](#-skipping-lines)
+ + [▶ Телепортация](#-teleportation)
+ + [▶ Ну, что-то тут нечисто...](#-well-something-is-fishy)
+ * [Раздел: Разное](#section-miscellaneous)
+ + [▶ `+=` быстрее](#--is-faster)
+ + [▶ Давайте создадим гигантскую строку!](#-lets-make-a-giant-string)
+ + [▶ Замедление поиска `dict` *](#-slowing-down-dict-lookups-)
+ + [▶ Раздувание экземпляров словарей *](#-bloating-instance-dicts-)
+ + [▶ Minor Ones *](#-minor-ones-)
+- [Contributing](#contributing)
+- [Благодарности](#acknowledgements)
+- [🎓 Лицензия](#-license)
+ * [Удивите и своих друзей!](#surprise-your-friends-as-well)
+ * [Больше подобных материалов?](#more-content-like-this)
+
+
+# Структура примеров
+
+Все примеры имеют следующую структуру:
+
+> ### ▶ Какой-то заголовок
+>
+> ```py
+> # Код с приколдесами.
+> # Подготовка к магии...
+> ```
+>
+> **Вывод (Python версия(и)):**
+>
+> ```py
+> >>> triggering_statement
+> Неожиданные результаты
+> ```
+> (Опционально): Одна строка, описывающая неожиданный результат
+>
+>
+> #### 💡 Объяснение:
+>
+> * Краткое объяснение того, что происходит и почему это происходит.
+> ```py
+> # Код
+> # Дополнительные примеры для дальнейшего разъяснения (если необходимо)
+> ```
+> **Вывод (Python версия(и)):**
+>
+> ```py
+> >>> trigger # какой-нибудь пример, позволяющий легко раскрыть магию
+> # обоснованный вывод
+> ```
+
+**Важно:** Все примеры протестированы на интерактивном интерпретаторе Python 3.5.2, и они должны работать для всех версий Python, если это явно не указано перед выводом.
+
+# Применение
+
+Хороший способ получить максимальную пользу от этих примеров, на мой взгляд, - читать их в последовательном порядке, причем для каждого примера:
+- Внимательно прочитайте исходный код для настройки примера. Если вы опытный программист на Python, то в большинстве случаев вы сможете предугадать, что произойдет дальше.
+- Прочитайте фрагменты вывода и,
+ + Проверьте, совпадают ли выходные данные с вашими ожиданиями.
+ + Убедитесь, что вы знаете точную причину, по которой вывод получился именно таким.
+ - Если ответ отрицательный (что совершенно нормально), сделайте глубокий вдох и прочитайте объяснение (а если вы все еще не понимаете, крикните! и создайте проблему [здесь](https://github.com/satwikkansal/wtfpython/issues/new)).
+ - Если "да", похлопайте себя по спине и переходите к следующему примеру.
+
+PS: Вы также можете читать WTFPython в командной строке, используя [pypi package](https://pypi.python.org/pypi/wtfpython),
+```sh
+$ pip install wtfpython -U
+$ wtfpython
+```
+---
+
+# 👀 Примеры
+
+## Секция: Напряги мозги!
+
+### ▶ Важное о главном!
+
+
+
+
+По какой-то причине "моржовый оператор"(walrus) (`:=`) в Python 3.8 стал довольно популярным. Давайте проверим его,
+
+1\.
+
+```py
+# Python version 3.8+
+
+>>> a = "wtf_walrus"
+>>> a
+'wtf_walrus'
+
+>>> a := "wtf_walrus"
+File "", line 1
+ a := "wtf_walrus"
+ ^
+SyntaxError: invalid syntax
+
+>>> (a := "wtf_walrus") # This works though
+'wtf_walrus'
+>>> a
+'wtf_walrus'
+```
+
+2 \.
+
+```py
+# Python version 3.8+
+
+>>> a = 6, 9
+>>> a
+(6, 9)
+
+>>> (a := 6, 9)
+(6, 9)
+>>> a
+6
+
+>>> a, b = 6, 9 # Typical unpacking
+>>> a, b
+(6, 9)
+>>> (a, b = 16, 19) # Oops
+ File "", line 1
+ (a, b = 16, 19)
+ ^
+SyntaxError: invalid syntax
+
+>>> (a, b := 16, 19) # This prints out a weird 3-tuple
+(6, 16, 19)
+
+>>> a # a is still unchanged?
+6
+
+>>> b
+16
+```
+
+
+
+#### 💡 Обьяснение
+
+**Быстрый разбор что такое "моржовый оператор" (walrus)**
+
+"Моржовый оператор" (`:=`) была введена в Python 3.8, она может быть полезна в ситуациях, когда вы хотите присвоить значения переменным в выражении.
+
+```py
+def some_func():
+ # Assume some expensive computation here
+ # time.sleep(1000)
+ return 5
+
+# So instead of,
+if some_func():
+ print(some_func()) # Which is bad practice since computation is happening twice
+
+# or
+a = some_func()
+if a:
+ print(a)
+
+# Now you can concisely write
+if a := some_func():
+ print(a)
+```
+
+**Вывод (> 3.8):**
+
+```py
+5
+5
+5
+```
+
+Это сэкономило одну строку кода и неявно предотвратило вызов `some_func` дважды.
+
+- Непарентезированное "выражение присваивания" (использование моржового оператора), ограничено на верхнем уровне, отсюда `SyntaxError` в выражении `a := "wtf_walrus"` первого фрагмента. Расстановка парентез сработала, как и ожидалось, и присвоила `a`.
+
+- Как обычно, выделение скобками выражения, содержащего оператор `=`, не допускается. Отсюда синтаксическая ошибка в `(a, b = 6, 9)`.
+
+- Синтаксис моржового оператора имеет вид `NAME:= expr`, где `NAME` - допустимый идентификатор, а `expr` - допустимое выражение. Следовательно, упаковка и распаковка итерабельных выражений не поддерживается, что означает,
+
+ - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6')
+
+ ```py
+ >>> (a := 6, 9) == ((a := 6), 9)
+ True
+ >>> x = (a := 696, 9)
+ >>> x
+ (696, 9)
+ >>> x[0] is a # Both reference same memory location
+ True
+ ```
+
+ - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple.
+
+---
+
+### ▶ Строки иногда ведут себя непредсказуемо
+
+
+1\.
+
+```py
+>>> a = "some_string"
+>>> id(a)
+140420665652016
+>>> id("some" + "_" + "string") # Notice that both the ids are same.
+140420665652016
+```
+
+2\.
+```py
+>>> a = "wtf"
+>>> b = "wtf"
+>>> a is b
+True
+
+>>> a = "wtf!"
+>>> b = "wtf!"
+>>> a is b
+False
+
+```
+
+3\.
+
+```py
+>>> a, b = "wtf!", "wtf!"
+>>> a is b # Все версии, кроме 3.7.x
+True
+
+>>> a = "wtf!"; b = "wtf!"
+>>> a is b # Это выведет True или False в зависимости от того, где вы вызываете (python shell / ipython / as a script)
+False
+```
+
+```py
+# This time in file some_file.py
+a = "wtf!"
+b = "wtf!"
+print(a is b)
+
+# выводит True при вызове модуля!
+```
+
+4\.
+
+**Результат (< Python3.7 )**
+
+```py
+>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
+True
+>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
+False
+```
+
+Логично, правда?
+
+#### 💡 Объяснение:
++ Поведение в первом и втором фрагментах связано с оптимизацией CPython (называемой интернированием строк), которая пытается использовать существующие неизменяемые объекты в некоторых случаях вместо того, чтобы каждый раз создавать новый объект.
++ После "интернирования" многие переменные могут ссылаться на один и тот же строковый объект в памяти (тем самым экономя память).
++ В приведенных выше фрагментах строки неявно интернированы. Решение о том, когда неявно интернировать строку, зависит от реализации. Существуют некоторые правила, по которым можно определить, будет ли строка интернирована или нет:
+ * Все строки длины 0 и длины 1 интернируются.
+ * Строки интернируются во время компиляции (`'wtf'' будет интернирована, но `''.join(['w'', 't'', 'f'])` не будет интернирована)
+ * Строки, не состоящие из букв ASCII, цифр или знаков подчеркивания, не интернализируются. Это объясняет, почему `'wtf!'` не интернируется из-за `!`. Реализацию этого правила в CPython можно найти [здесь](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
+ 
++ Когда `a` и `b` имеют значение `"wtf!"` в одной строке, интерпретатор Python создает новый объект, а затем одновременно ссылается на вторую переменную. Если вы делаете это в отдельных строках, он не "знает", что уже существует `"wtf!"` как объект (потому что `"wtf!"` не является неявно интернированным в соответствии с фактами, упомянутыми выше). Это оптимизация времени компиляции. Эта оптимизация не применяется к версиям CPython 3.7.x (более подробное обсуждение смотрите здесь [issue](https://github.com/satwikkansal/wtfpython/issues/100)).
++ Единица компиляции в интерактивной среде, такой как IPython, состоит из одного оператора, тогда как в случае модулей она состоит из всего модуля. `a, b = "wtf!", "wtf!"` - это одно утверждение, тогда как `a = "wtf!"; b = "wtf!"` - это два утверждения в одной строке. Это объясняет, почему тождества различны в `a = "wtf!"; b = "wtf!"`, а также объясняет, почему они одинаковы при вызове в `some_file.py`.
++ Резкое изменение в выводе четвертого фрагмента связано с [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) техникой, известной как Constant folding. Это означает, что выражение `'a'*20` заменяется на `'aaaaaaaaaaaaaaaaaaaa'` во время компиляции, чтобы сэкономить несколько тактов во время выполнения. Складывание констант происходит только для строк длиной менее 21. (Почему? Представьте себе размер файла `.pyc`, созданного в результате выражения `'a'*10**10`). [Вот](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) исходный текст реализации для этого.
++ Примечание: В Python 3.7 складывание констант было перенесено из оптимизатора peephole в новый оптимизатор AST с некоторыми изменениями в логике, поэтому четвертый фрагмент не работает в Python 3.7. Подробнее об изменении можно прочитать [здесь](https://bugs.python.org/issue11549).
+
+---
+
+
+### ▶ Be careful with chained operations
+
+```py
+>>> (False == False) in [False] # makes sense
+False
+>>> False == (False in [False]) # makes sense
+False
+>>> False == False in [False] # now what?
+True
+
+>>> True is False == False
+False
+>>> False is False is False
+True
+
+>>> 1 > 0 < 1
+True
+>>> (1 > 0) < 1
+False
+>>> 1 > (0 < 1)
+False
+```
+
+#### 💡 Объяснение:
+
+As per 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` и
+ ```py
+ >>> int(True)
+ 1
+ >>> True + 1 # не имеет значения для данного примера, но просто для интереса
+ 2
+ ```
+ В итоге, `1 < 1` выполняется и дает результат `False`
+
+---
+
+### ▶ Как не надо использовать оператор `is`
+
+Ниже приведен очень известный пример, представленный во всем Интернете.
+
+1\.
+
+```py
+>>> a = 256
+>>> b = 256
+>>> a is b
+True
+
+>>> a = 257
+>>> b = 257
+>>> a is b
+False
+```
+
+2\.
+
+```py
+>>> a = []
+>>> b = []
+>>> a is b
+False
+
+>>> a = tuple()
+>>> b = tuple()
+>>> a is b
+True
+```
+
+3\.
+**Результат**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+True
+```
+
+**Вывод (Python 3.7.x specifically)**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+False
+```
+
+#### 💡 Объяснение:
+
+**Разница между `is` и `==`**.
+
+* Оператор `is` проверяет, ссылаются ли оба операнда на один и тот же объект (т.е. проверяет, совпадают ли идентификаторы операндов или нет).
+* Оператор `==` сравнивает значения обоих операндов и проверяет, одинаковы ли они.
+* Таким образом, оператор `is` предназначен для равенства ссылок, а `==` - для равенства значений. Пример, чтобы прояснить ситуацию,
+ ```py
+ >>> class A: pass
+ >>> A() is A() # These are two empty objects at two different memory locations.
+ False
+ ```
+
+**`256` - существующий объект, а `257` - нет**.
+
+При запуске python будут выделены числа от `-5` до `256`. Эти числа используются часто, поэтому имеет смысл просто иметь их наготове.
+
+Цитирую по https://docs.python.org/3/c-api/long.html
+> Текущая реализация хранит массив целочисленных объектов для всех целых чисел от -5 до 256, когда вы создаете int в этом диапазоне, вы просто получаете обратно ссылку на существующий объект. Поэтому должно быть возможно изменить значение 1. Я подозреваю, что поведение Python в этом случае не определено. :-)
+
+```py
+>>> 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` ссылаются на один и тот же объект при инициализации одним и тем же значением в одной и той же строке*.
+
+**Вывод**
+
+```py
+>>> 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', вы бы не увидели такого же поведения, потому что файл компилируется весь сразу. Эта оптимизация не ограничивается целыми числами, она работает и для других неизменяемых типов данных, таких как строки (проверьте пример "Строки - это сложно") и плавающие числа,
+
+ ```py
+ >>> a, b = 257.0, 257.0
+ >>> a is b
+ True
+ ```
+
+* Почему это не сработало в Python 3.7? Абстрактная причина в том, что такие оптимизации компилятора зависят от реализации (т.е. могут меняться в зависимости от версии, ОС и т.д.). Я все еще выясняю, какое именно изменение реализации вызвало проблему, вы можете проверить этот [issue](https://github.com/satwikkansal/wtfpython/issues/100) для получения обновлений.
+
+---
+
+
+### ▶ Hash brownies
+
+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" destroyed the existence of "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` являются различными объектами разных типов, поскольку они равны, они не могут находиться в одном и том же `дикте` (или `наборе`). Как только вы вставите любой из них, попытка поиска по любому другому, но эквивалентному ключу будет успешной с исходным сопоставленным значением (а не завершится ошибкой `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)) и ухудшает производительность постоянного времени, которую обычно обеспечивает хэширование).
+
+---
+
+### ▶ В глубине души мы все одинаковы.
+
+```py
+class WTF:
+ pass
+```
+
+**Вывод:**
+```py
+>>> WTF() == WTF() # two different instances can't be equal
+False
+>>> WTF() is WTF() # identities are also different
+False
+>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
+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
+ ```
+ Как вы можете заметить, порядок, в котором уничтожаются объекты, имеет значение.
+
+---
+
+### ▶ Нарушение в пределах порядка *
+
+```py
+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
+```
+
+**Вывод**
+```py
+>>> dictionary == ordered_dict # If a == b
+True
+>>> dictionary == another_ordered_dict # and b == c
+True
+>>> ordered_dict == another_ordered_dict # then why isn't c == a ??
+False
+
+# Мы все знаем, что множество состоит только из уникальных элементов,
+# давайте попробуем составить множество из этих словарей и посмотрим, что получится...
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "", line 1, in
+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`. Из [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)
+
+ > Тесты равенства между объектами OrderedDict чувствительны к порядку и реализуются как `list(od1.items())==list(od2.items())`. Тесты на равенство между объектами `OrderedDict` и другими объектами Mapping нечувствительны к порядку, как обычные словари.
+- Причина такого поведения равенства в том, что оно позволяет напрямую подставлять объекты `OrderedDict` везде, где используется обычный словарь.
+- Итак, почему изменение порядка влияет на длину генерируемого объекта `set`? Ответ заключается только в отсутствии интранзитивного равенства. Поскольку множества являются "неупорядоченными" коллекциями уникальных элементов, порядок вставки элементов не должен иметь значения. Но в данном случае он имеет значение. Давайте немного разберемся в этом,
+ ```py
+ >>> some_set = set()
+ >>> some_set.add(dictionary) # these are the mapping objects from the snippets above
+ >>> 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`.
+
+---
+
+### ▶ Keep trying... *
+
+```py
+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(): # A gotcha!
+ try:
+ for i in range(3):
+ try:
+ 1 / i
+ except ZeroDivisionError:
+ # Let's throw it here and handle it outside for loop
+ raise ZeroDivisionError("A trivial divide by zero error")
+ finally:
+ print("Iteration", i)
+ break
+ except ZeroDivisionError as e:
+ print("Zero division error occurred", e)
+```
+
+**Результат:**
+
+```py
+>>> some_func()
+'from_finally'
+
+>>> another_func()
+Finally!
+Finally!
+Finally!
+
+>>> 1 / 0
+Traceback (most recent call last):
+ File "", line 1, in
+ZeroDivisionError: division by zero
+
+>>> one_more_func()
+Iteration 0
+
+```
+
+#### 💡 Объяснение:
+
+- Когда оператор `return`, `break` или `continue` выполняется в наборе `try` оператора "try...finally", на выходе также выполняется пункт `finally`.
+- Возвращаемое значение функции определяется последним выполненным оператором `return`. Поскольку предложение `finally` выполняется всегда, оператор `return`, выполненный в предложении `finally`, всегда будет последним.
+- Оговорка заключается в том, что если в предложении finally выполняется оператор `return` или `break`, то временно сохраненное исключение отбрасывается.
+
+---
+
+
+### ▶ Для чего?
+
+```py
+some_string = "wtf"
+some_dict = {}
+for i, some_dict[i] in enumerate(some_string):
+ i = 10
+```
+
+**Вывод:**
+```py
+>>> some_dict # An indexed dict appears.
+{0: 'w', 1: 't', 2: 'f'}
+```
+
+#### 💡 Объяснение:
+
+* Оператор `for` определяется в [грамматике Python](https://docs.python.org/3/reference/grammar.html) как:
+ ```
+ for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+ ```
+ Где `exprlist` - цель присваивания. Это означает, что эквивалент `{exprlist} = {next_value}` **выполняется для каждого элемента** в итерабле.
+ Интересный пример, иллюстрирующий это:
+ ```py
+ 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` на этот символ. Развертывание цикла можно упростить следующим образом:
+ ```py
+ >>> i, some_dict[i] = (0, 'w')
+ >>> i, some_dict[i] = (1, 't')
+ >>> i, some_dict[i] = (2, 'f')
+ >>> some_dict
+ ```
+
+---
+
+### ▶ Несоответствие времени оценки
+
+1\.
+```py
+array = [1, 8, 15]
+# A typical generator expression
+gen = (x for x in array if array.count(x) > 0)
+array = [2, 8, 22]
+```
+
+**Вывод:**
+
+```py
+>>> print(list(gen)) # Where did the other values go?
+[8]
+```
+
+2\.
+
+```py
+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]
+```
+
+**Вывод:**
+```py
+>>> print(list(gen_1))
+[1, 2, 3, 4]
+
+>>> print(list(gen_2))
+[1, 2, 3, 4, 5]
+```
+
+3\.
+
+```py
+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]
+```
+
+**Вывод:**
+```py
+>>> print(list(gen))
+[401, 501, 601, 402, 502, 602, 403, 503, 603]
+```
+
+#### 💡 Пояснение
+
+- В выражении [generator](https://wiki.python.org/moin/Generators) условие `in` оценивается во время объявления, но условное условие оценивается во время выполнения.
+- Поэтому перед выполнением `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](https://www.python.org/dev/peps/pep-0289/#the-details)
+
+ > Только крайнее for-выражение оценивается немедленно, остальные выражения откладываются до запуска генератора.
+
+---
+
+
+### ▶ `is not ...` is not `is (not ...)`
+
+```py
+>>> '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 побеждает с первой попытки!
+
+
+```py
+# Let's initialize a row
+row = [""] * 3 #row i['', '', '']
+# Let's make a board
+board = [row] * 3
+```
+
+**Результат:**
+
+```py
+>>> 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`. (Вопрос задан в [этом](https://github.com/satwikkansal/wtfpython/issues/68) выпуске).
+
+```py
+>>> board = [['']*3 for _ in range(3)]
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['', '', ''], ['', '', '']]
+```
+
+---
+
+### ▶ Переменная Шредингера *
+
+
+
+```py
+funcs = []
+results = []
+for x in range(7):
+ def some_func():
+ return x
+ funcs.append(some_func)
+ results.append(some_func()) # note the function call here
+
+funcs_results = [func() for func in funcs]
+```
+
+**Вывод (Python version):**
+```py
+>>> results
+[0, 1, 2, 3, 4, 5, 6]
+>>> funcs_results
+[6, 6, 6, 6, 6, 6, 6]
+```
+
+Значения `x` были разными в каждой итерации до добавления `some_func` к `funcs`, но все функции возвращают 6, когда они оцениваются после завершения цикла.
+
+2.
+
+```py
+>>> 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` из окружающего контекста (т.е. *не* локальная переменная):
+```py
+>>> import inspect
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())
+```
+Since `x` is a global value, we can change the value that the `funcs` will lookup and return by updating `x`:
+
+```py
+>>> x = 42
+>>> [func() for func in funcs]
+[42, 42, 42, 42, 42, 42, 42]
+```
+
+* Чтобы получить желаемое поведение, вы можете передать переменную цикла как именованную переменную в функцию. **Почему это работает?** Потому что это определит переменную *внутри* области видимости функции. Она больше не будет обращаться к окружающей (глобальной) области видимости для поиска значения переменной, а создаст локальную переменную, которая будет хранить значение `x` в данный момент времени.
+
+```py
+funcs = []
+for x in range(7):
+ def some_func(x=x):
+ return x
+ funcs.append(some_func)
+```
+
+**Вывод:**
+
+```py
+>>> funcs_results = [func() for func in funcs]
+>>> funcs_results
+[0, 1, 2, 3, 4, 5, 6]
+```
+
+`x` больше не и спользуется в глобальной области видимости
+
+```py
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())
+```
+
+---
+
+### ▶ Проблема курицы и яйца *
+
+1\.
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+Так какой же базовый класс является "окончательным"? Кстати, это еще не все,
+
+2\.
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+
+#### 💡 Объяснение
+
+- `тип` - это [метакласс](https://realpython.com/python-metaclasses/) в Python.
+- **Все** в Python является `объектом`, что включает в себя как классы, так и их объекты (экземпляры).
+- Класс `type` является метаклассом класса `object`, и каждый класс (включая `type`) наследует прямо или косвенно от `object`.
+- Между `object` и `type` нет реального базового класса. Путаница в приведенных выше фрагментах возникает потому, что мы думаем об этих отношениях (`issubclass` и `isinstance`) в терминах классов Python. Отношения между `object` и `type` не могут быть воспроизведены в чистом Python. Точнее говоря, следующие отношения не могут быть воспроизведены в чистом Python,
+ + класс A является экземпляром класса B, а класс B является экземпляром класса A.
+ + класс A является экземпляром самого себя.
+- Эти отношения между `object` и `type` (оба являются экземплярами друг друга, а также самих себя) существуют в Python из-за "обмана" на уровне реализации.
+
+---
+
+### ▶ Отношения между подклассами
+
+**Вывод:**
+```py
+>>> 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/).
+---
+
+### ▶ Methods equality and identity
+
+
+1.
+```py
+class SomeClass:
+ def method(self):
+ pass
+
+ @classmethod
+ def classm(cls):
+ pass
+
+ @staticmethod
+ def staticm():
+ pass
+```
+
+**Результат:**
+```py
+>>> 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`:
+
+2.
+```py
+o1 = SomeClass()
+o2 = SomeClass()
+```
+
+**Вывод:**
+```py
+>>> 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
+```
+
+Двойной доступ к `классу` или `методу` создает одинаковые, но не *одинаковые* объекты для одного и того же экземпляра `какого-либо класса`.
+
+#### 💡 Пояснение.
+* Функции являются [дескрипторами](https://docs.python.org/3/howto/descriptor.html). Всякий раз, когда к функции обращаются как к
+атрибута, вызывается дескриптор, создавая объект метода, который "связывает" функцию с объектом, владеющим атрибутом.
+атрибутом. При вызове метод вызывает функцию, неявно передавая связанный объект в качестве первого аргумента
+(именно так мы получаем `self` в качестве первого аргумента, несмотря на то, что не передаем его явно).
+```py
+>>> o1.method
+>
+```
+* При многократном обращении к атрибуту каждый раз создается объект метода! Поэтому `o1.method is o1.method` является
+никогда не является истиной. Доступ к функциям как к атрибутам класса (в отличие от экземпляра) не создает методов, однако; поэтому
+`SomeClass.method is SomeClass.method` является истинным.
+```py
+>>> SomeClass.method
+
+```
+* `classmethod` преобразует функции в методы класса. Методы класса - это дескрипторы, которые при обращении к ним создают
+объект метода, который связывает *класс* (тип) объекта, а не сам объект.
+```py
+>>> o1.classm
+>
+```
+* В отличие от функций, `classmethod` будет создавать метод и при обращении к нему как к атрибуту класса (в этом случае они
+привязываются к классу, а не к его типу). Поэтому `SomeClass.classm is SomeClass.classm` является ошибочным.
+```py
+>>> SomeClass.classm
+>
+```
+* Объект метода сравнивается с равным, если обе функции равны, а связанные объекты одинаковы. Поэтому
+`o1.method == o1.method` является истинным, хотя и не является одним и тем же объектом в памяти.
+* `staticmethod` преобразует функции в дескриптор "no-op", который возвращает функцию как есть. Никакой метод
+никогда не создается, поэтому сравнение с `is` является истинным.
+```py
+>>> o1.staticm
+
+>>> SomeClass.staticm
+
+```
+* Необходимость создавать новые объекты "метод" каждый раз, когда Python вызывает методы экземпляра, и необходимость изменять аргументы
+каждый раз, чтобы вставить `self`, сильно сказывается на производительности.
+CPython 3.7 [решил эту проблему](https://bugs.python.org/issue26110), введя новые опкоды, которые работают с вызовом методов
+без создания временных объектов методов. Это используется только при фактическом вызове функции доступа, так что
+приведенные здесь фрагменты не затронуты и по-прежнему генерируют методы :)
+
+### ▶ All-true-ation *
+
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+Почему это изменение True-False?
+
+#### 💡 Объяснение:
+
+- Реализация функции `all` эквивалентна
+
+- ```py
+ def all(iterable):
+ for element in iterable:
+ if not element:
+ return False
+ return True
+ ```
+
+- `all([])` возвращает `True`, поскольку итерируемый массив пуст.
+- `all([[]])` возвращает `False`, поскольку переданный массив имеет один элемент, `[]`, а в python пустой список является ложным.
+- `all([[[[]]])` и более высокие рекурсивные варианты всегда `True`. Это происходит потому, что единственный элемент переданного массива (`[[...]]`) уже не пуст, а списки со значениями являются истинными.
+
+---
+
+### ▶ Неожиданная запятая
+
+**Вывод (< 3.6):**
+
+```py
+>>> def f(x, y,):
+... print(x, y)
+...
+>>> def g(x=4, y=5,):
+... print(x, y)
+...
+>>> def h(x, **kwargs,):
+ File "", line 1
+ def h(x, **kwargs,):
+ ^
+SyntaxError: invalid syntax
+
+>>> def h(*args,):
+ File "", line 1
+ def h(*args,):
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Объяснение:
+
+- Запятая в конце списка формальных параметров функции Python не всегда законна.
+- В Python список аргументов определяется частично с помощью ведущих запятых, а частично с помощью проходных запятых. Этот конфликт приводит к ситуациям, когда запятая оказывается в середине, и ни одно правило ее не принимает.
+- **Примечание:** Проблема с запятыми в конце списка аргументов [исправлена в Python 3.6](https://bugs.python.org/issue9232). Замечания в [этом](https://bugs.python.org/issue9232#msg248399) сообщении кратко обсуждают различные варианты использования запятых в Python.
+
+---
+
+### ▶ Строки и обратные слэши
+
+**Вывод:**
+```py
+>>> print("\"")
+"
+
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "", line 1
+ print(r"\")
+ ^
+SyntaxError: EOL while scanning string literal
+
+>>> r'\'' == "\\'"
+True
+```
+
+#### 💡 Пояснение
+
+- В обычной строке python обратная косая черта используется для экранирования символов, которые могут иметь специальное значение (например, одинарная кавычка, двойная кавычка и сама обратная косая черта).
+ ```py
+ >>> "wt\"f"
+ 'wt"f'
+ ```
+- В необработанном строковом литерале (на что указывает префикс `r`) обратные косые черты передаются как есть, вместе с поведением экранирования следующего символа.
+ ```py
+ >>> r'wt\"f' == 'wt\\"f'
+ True
+ >>> print(repr(r'wt\"f')
+ 'wt\\"f'
+
+ >>> print("\n")
+
+ >>> print(r"\\n")
+ '\\n'
+ ```
+- Это означает, что когда синтаксический анализатор встречает обратную косую черту в необработанной строке, он ожидает, что за ней последует другой символ. А в нашем случае (`print(r"\")`) обратная косая черта вырвалась из концевой кавычки, оставив парсер без завершающей кавычки (отсюда `SyntaxError`). Вот почему обратный слеш не работает в конце необработанной строки.
+
+---
+
+### ▶ not knot!
+
+```py
+x = True
+y = False
+```
+
+**Результат:**
+```py
+>>> not x == y
+True
+>>> x == not y
+ File "", line 1
+ x == not y
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Объяснение:
+
+* Старшинство операторов влияет на то, как оценивается выражение, и оператор `==` имеет более высокий приоритет, чем оператор `not` в Python.
+* Поэтому `not x == y` эквивалентно `not (x == y)`, что эквивалентно `not (True == False)`, в итоге оценивающемуся в `True`.
+* Но `x == not y` вызывает `SyntaxError`, потому что его можно считать эквивалентным `(x == not) y`, а не `x == (not y)`, что можно было бы ожидать на первый взгляд.
+* Парсер ожидал, что лексема `not` будет частью оператора `not in` (потому что оба оператора `==` и `not in` имеют одинаковый приоритет), но после того, как он не смог найти лексему `in`, следующую за лексемой `not`, он выдает `SyntaxError`.
+
+---
+
+### ▶ Половина строк в тройных кавычках
+
+**Вывод:**
+```py
+>>> print('wtfpython''')
+wtfpython
+>>> print("wtfpython""")
+wtfpython
+>>> # The following statements raise `SyntaxError`
+>>> # print('''wtfpython')
+>>> # print("""wtfpython")
+ File "", line 3
+ print("""wtfpython")
+ ^
+SyntaxError: EOF while scanning triple-quoted string literal
+```
+
+#### 💡 Объяснение:
++ Python поддерживает неявную [конкатенацию строковых литералов](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Пример,
+ ```
+ >>> print("wtf" "python")
+ wtfpython
+ >>> print("wtf" "") # or "wtf"""
+ wtf
+ ```
++ `'''` and `"""` также являются разделителями строк в Python, что вызывает SyntaxError, поскольку интерпретатор Python ожидал завершающую тройную кавычку в качестве разделителя при сканировании текущего встреченного строкового литерала с тройной кавычкой.
+---
+
+### ▶ Что не так с логическими значениями?
+
+1\.
+
+```py
+# A simple example to count the number of booleans and
+# integers in an iterable of mixed data types.
+mixed_list = [False, 1.0, "some_string", 3, True, [], False]
+integers_found_so_far = 0
+booleans_found_so_far = 0
+
+for item in mixed_list:
+ if isinstance(item, int):
+ integers_found_so_far += 1
+ elif isinstance(item, bool):
+ booleans_found_so_far += 1
+```
+
+**Результат:**
+```py
+>>> integers_found_so_far
+4
+>>> booleans_found_so_far
+0
+```
+
+
+2\.
+```py
+>>> some_bool = True
+>>> "wtf" * some_bool
+'wtf'
+>>> some_bool = False
+>>> "wtf" * some_bool
+''
+```
+
+3\.
+
+```py
+def tell_truth():
+ True = False
+ if True == False:
+ print("I have lost faith in truth!")
+```
+
+**Результат (< 3.x):**
+
+```py
+>>> tell_truth()
+I have lost faith in truth!
+```
+
+
+
+#### 💡 Объяснение:
+
+* `bool` это подкласс класса `int` в Python
+
+ ```py
+ >>> issubclass(bool, int)
+ True
+ >>> issubclass(int, bool)
+ False
+ ```
+
+* И `True` и так же `False` это инстансы класса `int`
+ ```py
+ >>> isinstance(True, int)
+ True
+ >>> isinstance(False, int)
+ True
+ ```
+
+* Целочисленное значение `True` равно `1`, а `False` равно `0`.
+ ```py
+ >>> int(True)
+ 1
+ >>> int(False)
+ 0
+ ```
+
+* Смотри StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) там есть объяснение.
+
+* Изначально в Python не было типа `bool` (использовали 0 для false и ненулевое значение 1 для true). В версиях 2.x были добавлены `True`, `False` и тип `bool`, но для обратной совместимости `True` и `False` нельзя было сделать константами. Они просто были встроенными переменными, и их можно было переназначить.
+
+* Python 3 был несовместим с предыдущими версиями, эту проблему наконец-то исправили, и поэтому последний фрагмент не будет работать с Python 3.x!
+
+---
+
+### ▶ Атрибуты класса и экземпляра
+
+1\.
+```py
+class A:
+ x = 1
+
+class B(A):
+ pass
+
+class C(A):
+ pass
+```
+
+**Результат:**
+```py
+>>> A.x, B.x, C.x
+(1, 1, 1)
+>>> B.x = 2
+>>> A.x, B.x, C.x
+(1, 2, 1)
+>>> A.x = 3
+>>> A.x, B.x, C.x # C.x changed, but B.x didn't
+(3, 2, 3)
+>>> a = A()
+>>> a.x, A.x
+(3, 3)
+>>> a.x += 1
+>>> a.x, A.x
+(4, 3)
+```
+
+2\.
+```py
+class SomeClass:
+ some_var = 15
+ some_list = [5]
+ another_list = [5]
+ def __init__(self, x):
+ self.some_var = x + 1
+ self.some_list = self.some_list + [x]
+ self.another_list += [x]
+```
+
+**Результат:**
+
+```py
+>>> some_obj = SomeClass(420)
+>>> some_obj.some_list
+[5, 420]
+>>> some_obj.another_list
+[5, 420]
+>>> another_obj = SomeClass(111)
+>>> another_obj.some_list
+[5, 111]
+>>> another_obj.another_list
+[5, 420, 111]
+>>> another_obj.another_list is SomeClass.another_list
+True
+>>> another_obj.another_list is some_obj.another_list
+True
+```
+
+#### 💡 Объяснение:
+
+* Переменные класса и переменные экземпляров класса внутренне обрабатываются как словари объекта класса. Если имя переменной не найдено в словаре текущего класса, оно ищется в родительских классах.
+* Оператор += изменяет изменяемый объект на месте, не создавая новый объект. Таким образом, изменение атрибута одного экземпляра влияет на другие экземпляры и атрибут класса также.
+---
+
+### ▶ Возврат None из генератора (yielding None)
+
+```py
+some_iterable = ('a', 'b')
+
+def some_func(val):
+ return "something"
+```
+
+**Результат (<= 3.7.x):**
+
+```py
+>>> [x for x in some_iterable]
+['a', 'b']
+>>> [(yield x) for x in some_iterable]
+ at 0x7f70b0a4ad58>
+>>> list([(yield x) for x in some_iterable])
+['a', 'b']
+>>> list((yield x) for x in some_iterable)
+['a', None, 'b', None]
+>>> list(some_func((yield x)) for x in some_iterable)
+['a', 'something', 'b', 'something']
+```
+
+#### 💡 Объяснение:
+- Это баг в обработке yield в генераторах и списочных выражениях CPython.
+- Исходный код и объяснение можно найти здесь: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
+- Связанный отчет об ошибке: https://bugs.python.org/issue10544
+- В Python 3.8+ yield внутри списочных выражений больше не допускается и выдает SyntaxError.
+
+---
+
+
+### ▶ Yielding from... return! *
+
+1\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ yield from range(x)
+```
+
+**Результат (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Куда исчезло "wtf"? Это связано с каким-то особым эффектом yield from? Давайте проверим это. То же самое, это тоже не сработало.
+
+2\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ for i in range(x):
+ yield i
+```
+
+**Результат:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+То же самое, это тоже не сработало. Что происходит?
+
+#### 💡 Объяснение:
+
++ С Python 3.3 стало возможным использовать оператор return в генераторах с возвращением значения (см. PEP380). В официальной документации говорится, что
+
+> "... return expr в генераторе вызывает исключение StopIteration(expr) при выходе из генератора."
+
++ В случае some_func(3) StopIteration возбуждается в начале из-за оператора return. Исключение StopIteration автоматически перехватывается внутри обертки list(...) и цикла for. Поэтому два вышеприведенных фрагмента приводят к пустому списку.
+
++ Чтобы получить ["wtf"] из генератора some_func, нам нужно перехватить исключение StopIteration.
+
+ ```py
+ try:
+ next(some_func(3))
+ except StopIteration as e:
+ some_string = e.value
+ ```
+
+ ```py
+ >>> some_string
+ ["wtf"]
+ ```
+
+---
+
+### ▶ Nan-reflexivity *
+
+
+
+1\.
+
+```py
+a = float('inf')
+b = float('nan')
+c = float('-iNf') # These strings are case-insensitive
+d = float('nan')
+```
+
+**Результат:**
+
+```py
+>>> a
+inf
+>>> b
+nan
+>>> c
+-inf
+>>> float('some_other_string')
+ValueError: could not convert string to float: some_other_string
+>>> a == -c # inf==inf
+True
+>>> None == None # None == None
+True
+>>> b == d # but nan!=nan
+False
+>>> 50 / a
+0.0
+>>> a / a
+nan
+>>> 23 + b
+nan
+```
+
+2\.
+
+```py
+>>> x = float('nan')
+>>> y = x / x
+>>> y is y # identity holds
+True
+>>> y == y # equality fails of y
+False
+>>> [y] == [y] # but the equality succeeds for the list containing y
+True
+```
+
+
+
+#### 💡 Объяснение:
+
+- `'inf'` и `'nan'` - это специальные строки (без учета регистра), которые при явном приведении к типу float используются для представления математической "бесконечности" и "не число" соответственно.
+
+- Поскольку согласно стандартам IEEE `NaN! = NaN`, соблюдение этого правила нарушает предположение о рефлексивности элемента коллекции в Python, то есть если x является частью коллекции, такой как `list`, реализации, такие как сравнение, основаны на предположении, что `x == x`. Из-за этого предположения сначала сравниваются идентификаторы (так как это быстрее),
+ когда сравниваются два элемента, а значения сравниваются только при несовпадении идентификаторов. Следующий фрагмент сделает вещи более ясными:
+
+ ```py
+ >>> x = float('nan')
+ >>> x == x, [x] == [x]
+ (False, True)
+ >>> y = float('nan')
+ >>> y == y, [y] == [y]
+ (False, True)
+ >>> x == y, [x] == [y]
+ (False, False)
+ ```
+
+ Поскольку идентификаторы `x` и `y` разные, рассматриваются значения, которые также различаются; следовательно, на этот раз сравнение возвращает `False`.
+
+- Интересное чтение: [Рефлексивность и другие основы цивилизации](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+
+---
+
+### ▶ Мутируем немутируемое!
+
+
+
+Это может показаться тривиальным, если вы знаете, как работают ссылки в Python. Но если вы не знаете, то это может быть немного удивительно.
+
+```py
+some_tuple = ("A", "tuple", "with", "values")
+another_tuple = ([1, 2], [3, 4], [5, 6])
+```
+
+**Результат:**
+```py
+>>> some_tuple[2] = "change this"
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple[2].append(1000) #This throws no error
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000])
+>>> another_tuple[2] += [99, 999]
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000, 99, 999])
+```
+
+Но я думал, что кортежи неизменяемы... Что происходит?
+
+#### 💡 Объяснение:
+
+* Цитата из https://docs.python.org/3/reference/datamodel.html
+
+ > Неизменяемые последовательности
+ Объект неизменяемого типа последовательности не может измениться после создания. (Если объект содержит ссылки на другие объекты, эти другие объекты могут быть изменяемыми и могут быть изменены; однако набор объектов, на которые непосредственно ссылается неизменяемый объект, не может изменяться.)
+
+* Оператор `+=` изменяет список на месте. Присваивание элемента не работает, но когда возникает исключение, элемент уже был изменен на месте.
+* Также есть объяснение в официальном [Python FAQ](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works).
+
+---
+
+### ▶ Исчезновение переменной из внешней области видимости
+
+
+```py
+e = 7
+try:
+ raise Exception()
+except Exception as e:
+ pass
+```
+
+**Результат (Python 2.x):**
+```py
+>>> print(e)
+# prints nothing
+```
+
+**Результат (Python 3.x):**
+```py
+>>> print(e)
+NameError: name 'e' is not defined
+```
+
+#### 💡 Объяснение:
+
+* Source: https://docs.python.org/3/reference/compound_stmts.html#except
+
+ When an exception has been assigned using `as` target, it is cleared at the end of the `except` clause. This is as if
+
+ ```py
+ except E as N:
+ foo
+ ```
+
+ was translated into
+
+ ```py
+ except E as N:
+ try:
+ foo
+ finally:
+ del N
+ ```
+
+ This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.
+
+* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this:
+
+ ```py
+ def f(x):
+ del(x)
+ print(x)
+
+ x = 5
+ y = [5, 4, 3]
+ ```
+
+ **Результат:**
+ ```py
+ >>> f(x)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> f(y)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> x
+ 5
+ >>> y
+ [5, 4, 3]
+ ```
+
+* In Python 2.x, the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing.
+
+ **Результат (Python 2.x):**
+ ```py
+ >>> e
+ Exception()
+ >>> print e
+ # Nothing is printed!
+ ```
+
+---
+
+
+### ▶ The mysterious key type conversion
+
+```py
+class SomeClass(str):
+ pass
+
+some_dict = {'s': 42}
+```
+
+**Результат:**
+```py
+>>> type(list(some_dict.keys())[0])
+str
+>>> s = SomeClass('s')
+>>> some_dict[s] = 40
+>>> some_dict # expected: Two different keys-value pairs
+{'s': 40}
+>>> type(list(some_dict.keys())[0])
+str
+```
+
+#### 💡 Объяснение:
+
+* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class.
+* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class.
+* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary.
+* For the desired behavior, we can redefine the `__eq__` method in `SomeClass`
+ ```py
+ class SomeClass(str):
+ def __eq__(self, other):
+ return (
+ type(self) is SomeClass
+ and type(other) is SomeClass
+ and super().__eq__(other)
+ )
+
+ # When we define a custom __eq__, Python stops automatically inheriting the
+ # __hash__ method, so we need to define it as well
+ __hash__ = str.__hash__
+
+ some_dict = {'s':42}
+ ```
+
+ **Результат:**
+ ```py
+ >>> s = SomeClass('s')
+ >>> some_dict[s] = 40
+ >>> some_dict
+ {'s': 40, 's': 42}
+ >>> keys = list(some_dict.keys())
+ >>> type(keys[0]), type(keys[1])
+ (__main__.SomeClass, str)
+ ```
+
+---
+
+### ▶ Посмотрим, сможете ли вы угадать что здесь?
+
+```py
+a, b = a[b] = {}, 5
+```
+
+**Результат:**
+```py
+>>> a
+{5: ({...}, 5)}
+```
+
+#### 💡 Объяснение:
+
+* According to [Python language reference](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), assignment statements have the form
+ ```
+ (target_list "=")+ (expression_list | yield_expression)
+ ```
+ and
+
+> An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
+
+* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`).
+
+* After the expression list is evaluated, its value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`.
+
+* `a` is now assigned to `{}`, which is a mutable object.
+
+* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`).
+
+* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be
+ ```py
+ >>> some_list = some_list[0] = [0]
+ >>> some_list
+ [[...]]
+ >>> some_list[0]
+ [[...]]
+ >>> some_list is some_list[0]
+ True
+ >>> some_list[0][0][0][0][0][0] == some_list
+ True
+ ```
+ Similar is the case in our example (`a[b][0]` is the same object as `a`)
+
+* So to sum it up, you can break the example down to
+ ```py
+ a, b = {}, 5
+ a[b] = a, b
+ ```
+ And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a`
+ ```py
+ >>> a[b][0] is a
+ True
+ ```
+
+### ▶ Exceeds the limit for integer string conversion
+```py
+>>> # Python 3.10.6
+>>> int("2" * 5432)
+>>> # Python 3.10.8
+>>> int("2" * 5432)
+```
+**Вывод:**
+```py
+>>> # Python 3.10.6
+222222222222222222222222222222222222222222222222222222222222222...
+>>> # Python 3.10.8 and Python 3.11
+Traceback (most recent call last):
+ ...
+ValueError: Exceeds the limit (4300) for integer string conversion:
+ value has 5432 digits; use sys.set_int_max_str_digits()
+ to increase the limit.
+```
+#### 💡 Объяснение:
+Этот вызов `int()` прекрасно работает в Python 3.10.6 и вызывает ошибку ValueError в Python 3.10.8, 3.11. Обратите внимание, что Python все еще может работать с большими целыми числами. Ошибка возникает только при преобразовании между целыми числами и строками.
+К счастью, вы можете увеличить предел допустимого количества цифр, если ожидаете, что операция превысит его. Для этого можно воспользоваться одним из следующих способов:
+- -X int_max_str_digits command-line flag
+- set_int_max_str_digits() function from the sys module
+- PYTHONINTMAXSTRDIGITS environment variable
+
+[Смотри документацию](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) для получения более подробной информации об изменении лимита по умолчанию, если вы ожидаете, что ваш код превысит это значение.
+
+---
+
+## Section: Slippery Slopes
+
+### ▶ Modifying a dictionary while iterating over it
+
+```py
+x = {0: None}
+
+for i in x:
+ del x[i]
+ x[i+1] = None
+ print(i)
+```
+
+**Результат (Python 2.7- Python 3.5):**
+
+```
+0
+1
+2
+3
+4
+5
+6
+7
+```
+
+Yes, it runs for exactly **eight** times and stops.
+
+#### 💡 Объяснение:
+
+* Iteration over a dictionary that you edit at the same time is not supported.
+* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
+* How deleted keys are handled and when the resize occurs might be different for different Python implementations.
+* So for Python versions other than Python 2.7 - Python 3.5, the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread.
+* Python 3.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.
+
+---
+
+### ▶ Stubborn `del` operation
+
+
+
+```py
+class SomeClass:
+ def __del__(self):
+ print("Deleted!")
+```
+
+**Результат:**
+1\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x # this should print "Deleted!"
+>>> del y
+Deleted!
+```
+
+Phew, deleted at last. You might have guessed what saved `__del__` from being called in our first attempt to delete `x`. Let's add more twists to the example.
+
+2\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x
+>>> y # check if y exists
+<__main__.SomeClass instance at 0x7f98a1a67fc8>
+>>> del y # Like previously, this should print "Deleted!"
+>>> globals() # oh, it didn't. Let's check all our global variables and confirm
+Deleted!
+{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}
+```
+
+Okay, now it's deleted :confused:
+
+#### 💡 Объяснение:
++ `del x` doesn’t directly call `x.__del__()`.
++ When `del x` is encountered, Python deletes the name `x` from current scope and decrements by 1 the reference count of the object `x` referenced. `__del__()` is called only when the object's reference count reaches zero.
++ In the second output snippet, `__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object (specifically, the `_` magic variable which references the result value of the last non `None` expression on the REPL), thus preventing the reference count from reaching zero when `del y` was encountered.
++ Calling `globals` (or really, executing anything that will have a non `None` result) caused `_` to reference the new result, dropping the existing reference. Now the reference count reached 0 and we can see "Deleted!" being printed (finally!).
+
+---
+
+### ▶ The out of scope variable
+
+
+1\.
+```py
+a = 1
+def some_func():
+ return a
+
+def another_func():
+ a += 1
+ return a
+```
+
+2\.
+```py
+def some_closure_func():
+ a = 1
+ def some_inner_func():
+ return a
+ return some_inner_func()
+
+def another_closure_func():
+ a = 1
+ def another_inner_func():
+ a += 1
+ return a
+ return another_inner_func()
+```
+
+**Результат:**
+```py
+>>> some_func()
+1
+>>> another_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+
+>>> some_closure_func()
+1
+>>> another_closure_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+```
+
+#### 💡 Объяснение:
+* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error.
+* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword.
+ ```py
+ def another_func()
+ global a
+ a += 1
+ return a
+ ```
+
+ **Результат:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+* In `another_closure_func`, `a` becomes local to the scope of `another_inner_func`, but it has not been initialized previously in the same scope, which is why it throws an error.
+* To modify the outer scope variable `a` in `another_inner_func`, use the `nonlocal` keyword. The nonlocal statement is used to refer to variables defined in the nearest outer (excluding the global) scope.
+ ```py
+ def another_func():
+ a = 1
+ def another_inner_func():
+ nonlocal a
+ a += 1
+ return a
+ return another_inner_func()
+ ```
+
+ **Результат:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+* The keywords `global` and `nonlocal` tell the python interpreter to not declare new variables and look them up in the corresponding outer scopes.
+* Read [this](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.
+
+---
+
+### ▶ Deleting a list item while iterating
+
+```py
+list_1 = [1, 2, 3, 4]
+list_2 = [1, 2, 3, 4]
+list_3 = [1, 2, 3, 4]
+list_4 = [1, 2, 3, 4]
+
+for idx, item in enumerate(list_1):
+ del item
+
+for idx, item in enumerate(list_2):
+ list_2.remove(item)
+
+for idx, item in enumerate(list_3[:]):
+ list_3.remove(item)
+
+for idx, item in enumerate(list_4):
+ list_4.pop(idx)
+```
+
+**Результат:**
+```py
+>>> list_1
+[1, 2, 3, 4]
+>>> list_2
+[2, 4]
+>>> list_3
+[]
+>>> list_4
+[2, 4]
+```
+
+Can you guess why the output is `[2, 4]`?
+
+#### 💡 Объяснение:
+
+* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that.
+
+ ```py
+ >>> some_list = [1, 2, 3, 4]
+ >>> id(some_list)
+ 139798789457608
+ >>> id(some_list[:]) # Notice that python creates new object for sliced list.
+ 139798779601192
+ ```
+
+**Difference between `del`, `remove`, and `pop`:**
+* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected).
+* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found.
+* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified.
+
+**Why the output is `[2, 4]`?**
+- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence.
+
+* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example
+* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python.
+
+---
+
+
+### ▶ Lossy zip of iterators *
+
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three))
+[(0, 0), (1, 1), (2, 2)]
+# so far so good, let's zip the remaining
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Where did element `3` go from the `numbers` list?
+
+#### 💡 Объяснение:
+
+- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,
+ ```py
+ def zip(*iterables):
+ sentinel = object()
+ iterators = [iter(it) for it in iterables]
+ while iterators:
+ result = []
+ for it in iterators:
+ elem = next(it, sentinel)
+ if elem is sentinel: return
+ result.append(elem)
+ yield tuple(result)
+ ```
+- So the function takes in arbitrary number of iterable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted.
+- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.
+- The correct way to do the above using `zip` would be,
+ ```py
+ >>> numbers = list(range(7))
+ >>> numbers_iter = iter(numbers)
+ >>> list(zip(first_three, numbers_iter))
+ [(0, 0), (1, 1), (2, 2)]
+ >>> list(zip(remaining, numbers_iter))
+ [(3, 3), (4, 4), (5, 5), (6, 6)]
+ ```
+ The first argument of zip should be the one with fewest elements.
+
+---
+
+### ▶ Loop variables leaking out!
+
+1\.
+```py
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Результат:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+But `x` was never defined outside the scope of for loop...
+
+2\.
+```py
+# This time let's initialize x first
+x = -1
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Результат:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+3\.
+
+**Результат (Python 2.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+4
+```
+
+**Результат (Python 3.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+1
+```
+
+#### 💡 Объяснение:
+
+- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable.
+
+- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog:
+
+ > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope."
+
+---
+
+### ▶ Beware of default mutable arguments!
+
+
+```py
+def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+```
+
+**Результат:**
+```py
+>>> some_func()
+['some_string']
+>>> some_func()
+['some_string', 'some_string']
+>>> some_func([])
+['some_string']
+>>> some_func()
+['some_string', 'some_string', 'some_string']
+```
+
+#### 💡 Объяснение:
+
+- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected.
+
+ ```py
+ def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+ **Результат:**
+ ```py
+ >>> some_func.__defaults__ #This will show the default argument values for the function
+ ([],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string'],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ >>> some_func([])
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ ```
+
+- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example:
+
+ ```py
+ def some_func(default_arg=None):
+ if default_arg is None:
+ default_arg = []
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+---
+
+### ▶ Catching the Exceptions
+
+```py
+some_list = [1, 2, 3]
+try:
+ # This should raise an ``IndexError``
+ print(some_list[4])
+except IndexError, ValueError:
+ print("Caught!")
+
+try:
+ # This should raise a ``ValueError``
+ some_list.remove(4)
+except IndexError, ValueError:
+ print("Caught again!")
+```
+
+**Результат (Python 2.x):**
+```py
+Caught!
+
+ValueError: list.remove(x): x not in list
+```
+
+**Результат (Python 3.x):**
+```py
+ File "", line 3
+ except IndexError, ValueError:
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Объяснение
+
+* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,
+ ```py
+ some_list = [1, 2, 3]
+ try:
+ # This should raise a ``ValueError``
+ some_list.remove(4)
+ except (IndexError, ValueError), e:
+ print("Caught again!")
+ print(e)
+ ```
+ **Результат (Python 2.x):**
+ ```
+ Caught again!
+ list.remove(x): x not in list
+ ```
+ **Результат (Python 3.x):**
+ ```py
+ File "", line 4
+ except (IndexError, ValueError), e:
+ ^
+ IndentationError: unindent does not match any outer indentation level
+ ```
+
+* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,
+ ```py
+ some_list = [1, 2, 3]
+ try:
+ some_list.remove(4)
+
+ except (IndexError, ValueError) as e:
+ print("Caught again!")
+ print(e)
+ ```
+ **Результат:**
+ ```
+ Caught again!
+ list.remove(x): x not in list
+ ```
+
+---
+
+### ▶ Same operands, different story!
+
+1\.
+```py
+a = [1, 2, 3, 4]
+b = a
+a = a + [5, 6, 7, 8]
+```
+
+**Результат:**
+```py
+>>> a
+[1, 2, 3, 4, 5, 6, 7, 8]
+>>> b
+[1, 2, 3, 4]
+```
+
+2\.
+```py
+a = [1, 2, 3, 4]
+b = a
+a += [5, 6, 7, 8]
+```
+
+**Результат:**
+```py
+>>> a
+[1, 2, 3, 4, 5, 6, 7, 8]
+>>> b
+[1, 2, 3, 4, 5, 6, 7, 8]
+```
+
+#### 💡 Объяснение:
+
+* `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this.
+
+* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.
+
+* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.
+
+---
+
+### ▶ Name resolution ignoring class scope
+
+1\.
+```py
+x = 5
+class SomeClass:
+ x = 17
+ y = (x for i in range(10))
+```
+
+**Результат:**
+```py
+>>> list(SomeClass.y)[0]
+5
+```
+
+2\.
+```py
+x = 5
+class SomeClass:
+ x = 17
+ y = [x for i in range(10)]
+```
+
+**Результат (Python 2.x):**
+```py
+>>> SomeClass.y[0]
+17
+```
+
+**Результат (Python 3.x):**
+```py
+>>> SomeClass.y[0]
+5
+```
+
+#### 💡 Объяснение
+- Scopes nested inside class definition ignore names bound at the class level.
+- A generator expression has its own scope.
+- Starting from Python 3.X, list comprehensions also have their own scope.
+
+---
+
+### ▶ Rounding like a banker *
+
+Let's implement a naive function to get the middle element of a list:
+```py
+def get_middle(some_list):
+ mid_index = round(len(some_list) / 2)
+ return some_list[mid_index - 1]
+```
+
+**Python 3.x:**
+```py
+>>> get_middle([1]) # looks good
+1
+>>> get_middle([1,2,3]) # looks good
+2
+>>> get_middle([1,2,3,4,5]) # huh?
+2
+>>> len([1,2,3,4,5]) / 2 # good
+2.5
+>>> round(len([1,2,3,4,5]) / 2) # why?
+2
+```
+It seems as though Python rounded 2.5 to 2.
+
+#### 💡 Объяснение:
+
+- This is not a float precision error, in fact, this behavior is intentional. Since Python 3.0, `round()` uses [banker's rounding](https://en.wikipedia.org/wiki/Rounding#Round_half_to_even) where .5 fractions are rounded to the nearest **even** number:
+
+```py
+>>> round(0.5)
+0
+>>> round(1.5)
+2
+>>> round(2.5)
+2
+>>> import numpy # numpy does the same
+>>> numpy.round(0.5)
+0.0
+>>> numpy.round(1.5)
+2.0
+>>> numpy.round(2.5)
+2.0
+```
+
+- This is the recommended way to round .5 fractions as described in [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules). However, the other way (round away from zero) is taught in school most of the time, so banker's rounding is likely not that well known. Furthermore, some of the most popular programming languages (for example: JavaScript, Java, C/C++, Ruby, Rust) do not use banker's rounding either. Therefore, this is still quite special to Python and may result in confusion when rounding fractions.
+- See the [round() docs](https://docs.python.org/3/library/functions.html#round) or [this stackoverflow thread](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) for more information.
+- Note that `get_middle([1])` only returned 1 because the index was `round(0.5) - 1 = 0 - 1 = -1`, returning the last element in the list.
+
+---
+
+### ▶ Needles in a Haystack *
+
+
+
+I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,
+
+1\.
+
+```py
+x, y = (0, 1) if True else None, None
+```
+
+**Результат:**
+
+```py
+>>> x, y # expected (0, 1)
+((0, 1), None)
+```
+
+2\.
+
+```py
+t = ('one', 'two')
+for i in t:
+ print(i)
+
+t = ('one')
+for i in t:
+ print(i)
+
+t = ()
+print(t)
+```
+
+**Результат:**
+
+```py
+one
+two
+o
+n
+e
+tuple()
+```
+
+3\.
+
+```
+ten_words_list = [
+ "some",
+ "very",
+ "big",
+ "list",
+ "that"
+ "consists",
+ "of",
+ "exactly",
+ "ten",
+ "words"
+]
+```
+
+**Результат**
+
+```py
+>>> len(ten_words_list)
+9
+```
+
+4\. Not asserting strongly enough
+
+```py
+a = "python"
+b = "javascript"
+```
+
+**Результат:**
+
+```py
+# An assert statement with an assertion failure message.
+>>> assert(a == b, "Both languages are different")
+# No AssertionError is raised
+```
+
+5\.
+
+```py
+some_list = [1, 2, 3]
+some_dict = {
+ "key_1": 1,
+ "key_2": 2,
+ "key_3": 3
+}
+
+some_list = some_list.append(4)
+some_dict = some_dict.update({"key_4": 4})
+```
+
+**Результат:**
+
+```py
+>>> print(some_list)
+None
+>>> print(some_dict)
+None
+```
+
+6\.
+
+```py
+def some_recursive_func(a):
+ if a[0] == 0:
+ return
+ a[0] -= 1
+ some_recursive_func(a)
+ return a
+
+def similar_recursive_func(a):
+ if a == 0:
+ return a
+ a -= 1
+ similar_recursive_func(a)
+ return a
+```
+
+**Результат:**
+
+```py
+>>> some_recursive_func([5, 0])
+[0, 0]
+>>> similar_recursive_func(5)
+4
+```
+
+#### 💡 Объяснение:
+
+* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.
+
+* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character.
+
+* `()` is a special token and denotes empty `tuple`.
+
+* In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation,
+
+ ```py
+ >>> ten_words_list
+ ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
+ ```
+
+* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,
+
+ ```py
+ >>> a = "python"
+ >>> b = "javascript"
+ >>> assert a == b
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError
+
+ >>> assert (a == b, "Values are not equal")
+ :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+ >>> assert a == b, "Values are not equal"
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError: Values are not equal
+ ```
+
+* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+
+* Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignment of an immutable (`a -= 1`) is not an alteration of the value.
+
+* Being aware of these nitpicks can save you hours of debugging effort in the long run.
+
+---
+
+
+### ▶ Splitsies *
+
+```py
+>>> 'a'.split()
+['a']
+
+# is same as
+>>> 'a'.split(' ')
+['a']
+
+# but
+>>> len(''.split())
+0
+
+# isn't the same as
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Объяснение:
+
+- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split)
+ > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
+ > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
+- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
+ ```py
+ >>> ' a '.split(' ')
+ ['', 'a', '']
+ >>> ' a '.split()
+ ['a']
+ >>> ''.split(' ')
+ ['']
+ ```
+
+---
+
+### ▶ Wild imports *
+
+
+
+```py
+# File: module.py
+
+def some_weird_name_func_():
+ print("works!")
+
+def _another_weird_name_func():
+ print("works!")
+
+```
+
+**Результат**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Объяснение:
+
+- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime.
+- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred.
+ ```py
+ >>> from module import some_weird_name_func_, _another_weird_name_func
+ >>> _another_weird_name_func()
+ works!
+ ```
+- If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports.
+ ```py
+ __all__ = ['_another_weird_name_func']
+
+ def some_weird_name_func_():
+ print("works!")
+
+ def _another_weird_name_func():
+ print("works!")
+ ```
+ **Результат**
+
+ ```py
+ >>> _another_weird_name_func()
+ "works!"
+ >>> some_weird_name_func_()
+ Traceback (most recent call last):
+ File "", line 1, in
+ NameError: name 'some_weird_name_func_' is not defined
+ ```
+
+---
+
+### ▶ All sorted? *
+
+
+
+```py
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
+
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
+```
+
+#### 💡 Объяснение:
+
+- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python.
+
+- ```py
+ >>> [] == tuple()
+ False
+ >>> x = 7, 8, 9
+ >>> type(x), type(sorted(x))
+ (tuple, list)
+ ```
+
+- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first.
+
+- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list.
+
+ ```py
+ >>> x = 7, 8, 9
+ >>> y = reversed(x)
+ >>> sorted(y), sorted(y)
+ ([7, 8, 9], [])
+ ```
+
+---
+
+### ▶ Midnight time doesn't exist?
+
+```py
+from datetime import datetime
+
+midnight = datetime(2018, 1, 1, 0, 0)
+midnight_time = midnight.time()
+
+noon = datetime(2018, 1, 1, 12, 0)
+noon_time = noon.time()
+
+if midnight_time:
+ print("Time at midnight is", midnight_time)
+
+if noon_time:
+ print("Time at noon is", noon_time)
+```
+
+**Результат (< 3.5):**
+
+```py
+('Time at noon is', datetime.time(12, 0))
+```
+The midnight time is not printed.
+
+#### 💡 Объяснение:
+
+Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of "empty."
+
+---
+---
+
+
+
+## Section: The Hidden treasures!
+
+This section contains a few lesser-known and interesting things about Python that most beginners like me are unaware of (well, not anymore).
+
+### ▶ Okay Python, Can you make me fly?
+
+Well, here you go
+
+```py
+import antigravity
+```
+
+**Результат:**
+Sshh... It's a super-secret.
+
+#### 💡 Объяснение:
++ `antigravity` module is one of the few easter eggs released by Python developers.
++ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python.
++ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/).
+
+---
+
+### ▶ `goto`, but why?
+
+
+```py
+from goto import goto, label
+for i in range(9):
+ for j in range(9):
+ for k in range(9):
+ print("I am trapped, please rescue!")
+ if k == 2:
+ goto .breakout # breaking out from a deeply nested loop
+label .breakout
+print("Freedom!")
+```
+
+**Результат (Python 2.3):**
+```py
+I am trapped, please rescue!
+I am trapped, please rescue!
+Freedom!
+```
+
+#### 💡 Объяснение:
+- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004.
+- Current versions of Python do not have this module.
+- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python.
+
+---
+
+### ▶ Держитесь!
+
+Если вы относитесь к тем людям, которым не нравится использование пробелов в Python для обозначения диапазонов, вы можете использовать C-стиль {} импортировав это,
+
+```py
+from __future__ import braces
+```
+
+**Результат:**
+```py
+ File "some_file.py", line 1
+ from __future__ import braces
+SyntaxError: not a chance
+```
+
+Скобочки? Ни за что! Если это разочаровывало вас, используйте PHP :). Хорошо, еще одна удивительная вещь, можете ли вы найти ошибку
+`SyntaxError` которая вызвана в модуле `__future__` [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)?
+
+#### 💡 Объяснение:
++ The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however, ironic.
++ This is an easter egg concerned with the community's feelings on this issue.
++ The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file.
++ When the CPython compiler encounters a [future statement](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), it first runs the appropriate code in `future.c` before treating it as a normal import statement.
+
+---
+
+### ▶ Давайте познакомимся с дружелюбным Дядей Барри
+
+
+**Результат (Python 3.x)**
+```py
+>>> from __future__ import barry_as_FLUFL
+>>> "Ruby" != "Python" # there's no doubt about it
+ File "some_file.py", line 1
+ "Ruby" != "Python"
+ ^
+SyntaxError: invalid syntax
+
+>>> "Ruby" <> "Python"
+True
+```
+
+Вот так просто.
+
+#### 💡 Объяснение:
+- Это относится к [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means).
+- Цитируя из PEP-401
+
+ > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.
+ Некоторые считают, что оператор неравенства != в Python 3.0 отвратительный (хотя в других языках это вполне привычная и узнаваемая конструкция) и вызывал боль, FLUFL разрешает единственный вариант оператора неравенства в виде ромба <>.
+- У Дяди Барри было еще много чего рассказать в PEP; вы можете прочитать их [здесь](https://www.python.org/dev/peps/pep-0401/).
+- Это работает хорошо в интерактивной среде, но при запуске через файл python вызывает `SyntaxError` (смотри этот [ишью](https://github.com/satwikkansal/wtfpython/issues/94)). Однако вы можете обернуть оператор внутри `eval` или `compile`, чтобы заставить его работать (но зачем?)
+ ```py
+ from __future__ import barry_as_FLUFL
+ print(eval('"Ruby" <> "Python"'))
+ ```
+
+---
+
+### ▶ Даже Python понимает, что любовь - это сложно.
+
+```py
+import this
+```
+
+Подождите, что **это** (this) такое? Это любовь! :heart:
+
+**Результат:**
+```
+Дзен Python, от Тима Петерса
+
+Красивое лучше, чем уродливое.
+Явное лучше, чем неявное.
+Простое лучше, чем сложное.
+Сложное лучше, чем запутанное.
+Плоское лучше, чем вложенное.
+Разреженное лучше, чем плотное.
+Читаемость имеет значение.
+Особые случаи не настолько особые, чтобы нарушать правила.
+При этом практичность важнее безупречности.
+Ошибки никогда не должны замалчиваться.
+Если они не замалчиваются явно.
+Встретив двусмысленность, отбрось искушение угадать.
+Должен существовать один и, желательно, только один очевидный способ сделать это.
+Хотя он поначалу может быть и не очевиден, если вы не голландец [^1].
+Сейчас лучше, чем никогда.
+Хотя никогда зачастую лучше, чем прямо сейчас.
+Если реализацию сложно объяснить — идея плоха.
+Если реализацию легко объяснить — идея, возможно, хороша.
+Пространства имён — отличная штука! Будем делать их больше!
+```
+
+Это Дзен Python!
+
+```py
+>>> love = this
+>>> this is love
+True
+>>> love is True
+False
+>>> love is False
+False
+>>> love is not True or False
+True
+>>> love is not True or False; love is love # Love is complicated
+True
+```
+
+#### 💡 Объяснение:
+
+* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
+* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, **the code for the Zen violates itself** (and that's probably the only place where this happens).
+* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory (if not, please see the examples related to `is` and `is not` operators).
+
+* Модуль `this` в Python - это пасхальное яйцо для The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
+* И если вы думаете, что это уже достаточно интересно, посмотрите реализацию [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Интересно, что **код для дзена нарушает сам себя** (и это, вероятно, единственное место, где это происходит, но это не точно).
+* Что касается утверждения `любовь не является истиной или ложью; любовь - это любовь`, иронично, но это самоочевидно (если нет, пожалуйста, посмотрите примеры, связанные с операторами `is` и `is not`).
+
+---
+
+### ▶ Yes, it exists!
+
+**The `else` clause for loops.** One typical example might be:
+
+```py
+ def does_exists_num(l, to_find):
+ for num in l:
+ if num == to_find:
+ print("Exists!")
+ break
+ else:
+ print("Does not exist")
+```
+
+**Результат:**
+```py
+>>> some_list = [1, 2, 3, 4, 5]
+>>> does_exists_num(some_list, 4)
+Exists!
+>>> does_exists_num(some_list, -1)
+Does not exist
+```
+
+**The `else` clause in exception handling.** An example,
+
+```py
+try:
+ pass
+except:
+ print("Exception occurred!!!")
+else:
+ print("Try block executed successfully...")
+```
+
+**Результат:**
+```py
+Try block executed successfully...
+```
+
+#### 💡 Объяснение:
+- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. You can think of it as a "nobreak" clause.
+- `else` clause after a try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
+
+---
+### ▶ Ellipsis *
+
+```py
+def some_func():
+ Ellipsis
+```
+
+**Результат**
+```py
+>>> some_func()
+# No output, No Error
+
+>>> SomeRandomString
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Объяснение
+- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`.
+ ```py
+ >>> ...
+ Ellipsis
+ ```
+- Ellipsis can be used for several purposes,
+ + As a placeholder for code that hasn't been written yet (just like `pass` statement)
+ + In slicing syntax to represent the full slices in remaining direction
+ ```py
+ >>> import numpy as np
+ >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
+ array([
+ [
+ [0, 1],
+ [2, 3]
+ ],
+
+ [
+ [4, 5],
+ [6, 7]
+ ]
+ ])
+ ```
+ So our `three_dimensional_array` is an array of array of arrays. Let's say we want to print the second element (index `1`) of all the innermost arrays, we can use Ellipsis to bypass all the preceding dimensions
+ ```py
+ >>> three_dimensional_array[:,:,1]
+ array([[1, 3],
+ [5, 7]])
+ >>> three_dimensional_array[..., 1] # using Ellipsis.
+ array([[1, 3],
+ [5, 7]])
+ ```
+ Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`)
+ + In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`))
+ + You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the "no argument passed" and "None value passed" scenarios).
+
+---
+
+### ▶ Inpinity
+
+The spelling is intended. Please, don't submit a patch for this.
+
+**Результат (Python 3.x):**
+```py
+>>> infinity = float('infinity')
+>>> hash(infinity)
+314159
+>>> hash(float('-inf'))
+-314159
+```
+
+#### 💡 Объяснение:
+- Hash of infinity is 10⁵ x π.
+- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2.
+
+---
+
+### ▶ Let's mangle
+
+1\.
+```py
+class Yo(object):
+ def __init__(self):
+ self.__honey = True
+ self.bro = True
+```
+
+**Результат:**
+```py
+>>> Yo().bro
+True
+>>> Yo().__honey
+AttributeError: 'Yo' object has no attribute '__honey'
+>>> Yo()._Yo__honey
+True
+```
+
+2\.
+```py
+class Yo(object):
+ def __init__(self):
+ # Let's try something symmetrical this time
+ self.__honey__ = True
+ self.bro = True
+```
+
+**Результат:**
+```py
+>>> Yo().bro
+True
+
+>>> Yo()._Yo__honey__
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
+Why did `Yo()._Yo__honey` work?
+
+3\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+ def some_func(self):
+ return __variable # not initialized anywhere yet
+```
+
+**Результат:**
+```py
+>>> A().__variable
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> A().some_func()
+'Some value'
+```
+
+
+#### 💡 Объяснение:
+
+* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces.
+* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore a.k.a "dunder") and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front.
+* So, to access `__honey` attribute in the first snippet, we had to append `_Yo` to the front, which would prevent conflicts with the same name attribute defined in any other class.
+* But then why didn't it work in the second snippet? Because name mangling excludes the names ending with double underscores.
+* The third snippet was also a consequence of name mangling. The name `__variable` in the statement `return __variable` was mangled to `_A__variable`, which also happens to be the name of the variable we declared in the outer scope.
+* Also, if the mangled name is longer than 255 characters, truncation will happen.
+
+---
+---
+
+## Section: Appearances are deceptive!
+
+### ▶ Skipping lines?
+
+**Результат:**
+```py
+>>> value = 11
+>>> valuе = 32
+>>> value
+11
+```
+
+Wut?
+
+**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.
+
+#### 💡 Объяснение
+
+Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.
+
+```py
+>>> ord('е') # cyrillic 'e' (Ye)
+1077
+>>> ord('e') # latin 'e', as used in English and typed using standard keyboard
+101
+>>> 'е' == 'e'
+False
+
+>>> value = 42 # latin e
+>>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here
+>>> value
+42
+```
+
+The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.
+
+---
+
+### ▶ Teleportation
+
+
+
+```py
+# `pip install numpy` first.
+import numpy as np
+
+def energy_send(x):
+ # Initializing a numpy array
+ np.array([float(x)])
+
+def energy_receive():
+ # Return an empty numpy array
+ return np.empty((), dtype=np.float).tolist()
+```
+
+**Результат:**
+```py
+>>> energy_send(123.456)
+>>> energy_receive()
+123.456
+```
+
+Where's the Nobel Prize?
+
+#### 💡 Объяснение:
+
+* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate.
+* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).
+
+---
+
+### ▶ Well, something is fishy...
+
+```py
+def square(x):
+ """
+ A simple function to calculate the square of a number by addition.
+ """
+ sum_so_far = 0
+ for counter in range(x):
+ sum_so_far = sum_so_far + x
+ return sum_so_far
+```
+
+**Результат (Python 2.x):**
+
+```py
+>>> square(10)
+10
+```
+
+Shouldn't that be 100?
+
+**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.
+
+#### 💡 Объяснение
+
+* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.
+* This is how Python handles tabs:
+
+ > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
+* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.
+* Python 3 is kind enough to throw an error for such cases automatically.
+
+ **Результат (Python 3.x):**
+ ```py
+ TabError: inconsistent use of tabs and spaces in indentation
+ ```
+
+---
+---
+
+## Section: Miscellaneous
+
+
+### ▶ `+=` is faster
+
+
+```py
+# using "+", three strings:
+>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.25748300552368164
+# using "+=", three strings:
+>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.012188911437988281
+```
+
+#### 💡 Объяснение:
++ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string.
+
+---
+
+### ▶ Let's make a giant string!
+
+```py
+def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s += "xyz"
+ assert len(s) == 3*iters
+
+def add_bytes_with_plus(iters):
+ s = b""
+ for i in range(iters):
+ s += b"xyz"
+ assert len(s) == 3*iters
+
+def add_string_with_format(iters):
+ fs = "{}"*iters
+ s = fs.format(*(["xyz"]*iters))
+ assert len(s) == 3*iters
+
+def add_string_with_join(iters):
+ l = []
+ for i in range(iters):
+ l.append("xyz")
+ s = "".join(l)
+ assert len(s) == 3*iters
+
+def convert_list_to_string(l, iters):
+ s = "".join(l)
+ assert len(s) == 3*iters
+```
+
+**Результат:**
+
+```py
+# Executed in ipython shell using %timeit for better readability of results.
+# You can also use the timeit module in normal python shell/scriptm=, example usage below
+# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())
+
+>>> NUM_ITERS = 1000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
+124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
+211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
+61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
+117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
+10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+Let's increase the number of iterations by a factor of 10.
+
+```py
+>>> NUM_ITERS = 10000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time
+1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # Quadratic increase
+6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # Linear increase
+645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # Linear increase
+1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # Linear increase
+86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+#### 💡 Объяснение
+- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) on these links. They are used to measure the execution time of code pieces.
+- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function)
+- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings).
+- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster.
+- Unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example, `add_string_with_plus` didn't show a quadratic increase in execution time. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic.
+ ```py
+ def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s = s + "x" + "y" + "z"
+ assert len(s) == 3*iters
+
+ >>> %timeit -n100 add_string_with_plus(1000)
+ 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+ >>> %timeit -n100 add_string_with_plus(10000) # Quadratic increase in execution time
+ 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+ ```
+- So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which,
+
+ > There should be one-- and preferably only one --obvious way to do it.
+
+---
+
+### ▶ Slowing down `dict` lookups *
+
+```py
+some_dict = {str(i): 1 for i in range(1_000_000)}
+another_dict = {str(i): 1 for i in range(1_000_000)}
+```
+
+**Результат:**
+```py
+>>> %timeit some_dict['5']
+28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> some_dict[1] = 1
+>>> %timeit some_dict['5']
+37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+>>> %timeit another_dict['5']
+28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> another_dict[1] # Trying to access a key that doesn't exist
+Traceback (most recent call last):
+ File "", line 1, in
+KeyError: 1
+>>> %timeit another_dict['5']
+38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+```
+Why are same lookups becoming slower?
+
+#### 💡 Объяснение:
++ CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys.
++ The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method.
++ The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function.
++ This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect.
+
+
+### ▶ Bloating instance `dict`s *
+
+```py
+import sys
+
+class SomeClass:
+ def __init__(self):
+ self.some_attr1 = 1
+ self.some_attr2 = 2
+ self.some_attr3 = 3
+ self.some_attr4 = 4
+
+
+def dict_size(o):
+ return sys.getsizeof(o.__dict__)
+
+```
+
+**Результат:** (Python 3.8, other Python 3 versions may vary a little)
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104
+>>> dict_size(o2)
+104
+>>> del o1.some_attr1
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+>>> dict_size(o1)
+232
+```
+
+Let's try again... In a new interpreter:
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104 # as expected
+>>> o1.some_attr5 = 5
+>>> o1.some_attr6 = 6
+>>> dict_size(o1)
+360
+>>> dict_size(o2)
+272
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+```
+
+What makes those dictionaries become bloated? And why are newly created objects bloated as well?
+
+#### 💡 Объяснение:
++ CPython is able to reuse the same "keys" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances.
++ This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken.
++ Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is "unshared", and key-sharing is disabled for all future instances of the same class.
++ Additionaly, if the dictionary keys have been resized (because new keys are inserted), they are kept shared *only* if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys.
++ A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`!
+
+
+### ▶ Minor Ones *
+
+* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
+
+ **💡 Объяснение:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API.
+
+* Few weird looking but semantically correct statements:
+ + `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`)
+ + `'a'[0][0][0][0][0]` is also a semantically correct statement as strings are [sequences](https://docs.python.org/3/glossary.html#term-sequence)(iterables supporting element access using integer indices) in Python.
+ + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`.
+
+* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++, or Java.
+ ```py
+ >>> a = 5
+ >>> a
+ 5
+ >>> ++a
+ 5
+ >>> --a
+ 5
+ ```
+
+ **💡 Объяснение:**
+ + There is no `++` operator in Python grammar. It is actually two `+` operators.
+ + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified.
+ + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python.
+
+* You must be aware of the Walrus operator in Python. But have you ever heard about *the space-invader operator*?
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+ It is used as an alternative incrementation operator, together with another one
+ ```py
+ >>> a +=+ 1
+ >>> a
+ >>> 44
+ ```
+ **💡 Объяснение:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
+
+* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator.
+
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 Объяснение:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+* Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real).
+
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 Объяснение:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
+
+* From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example,
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!):
+
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+* Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module.
+
+* Sometimes, the `print` method might not print values immediately. For example,
+
+ ```py
+ # File some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
+
+ This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.
+
+* List slicing with out of the bounds indices throws no errors
+ ```py
+ >>> some_list = [1, 2, 3, 4, 5]
+ >>> some_list[111:]
+ []
+ ```
+
+* Slicing an iterable not always creates a new object. For example,
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # False expected because a new object is created.
+ False
+ >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use.
+ True
+ ```
+
+* `int('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.
+
+* You can separate numeric literals with underscores (for better readability) from Python 3 onwards.
+
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
+ ```py
+ def count(s, sub):
+ result = 0
+ for i in range(len(s) + 1 - len(sub)):
+ result += (s[i:i + len(sub)] == sub)
+ return result
+ ```
+ The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.
+
+---
+---
+
+# Contributing
+
+A few ways in which you can contribute to wtfpython,
+
+- Suggesting new examples
+- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))
+- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc.
+- Identifying gaps (things like inadequate explanation, redundant examples, etc.)
+- Any creative suggestions to make this project more fun and useful
+
+Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things.
+
+PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project.
+
+# Acknowledgements
+
+The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now.
+
+#### Some nice Links!
+* https://www.youtube.com/watch?v=sH4XF6pKKmk
+* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+* https://sopython.com/wiki/Common_Gotchas_In_Python
+* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+* https://www.python.org/doc/humor/
+* https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+* https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
+* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+* WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
+
+# 🎓 License
+
+[![WTFPL 2.0][license-image]][license-url]
+
+© [Satwik Kansal](https://satwikkansal.xyz)
+
+[license-url]: http://www.wtfpl.net
+[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
+
+## Surprise your friends as well!
+
+If you like wtfpython, you can use these quick links to share it with your friends,
+
+[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+
+## Need a pdf version?
+
+I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get them as soon as they are finished.
+
+
+**That's all folks!** For upcoming content like this, you can add your email [here](https://www.satwikkansal.xyz/content-like-wtfpython/).
diff --git a/docs/USA.md b/docs/USA.md
new file mode 100644
index 0000000..581eb9e
--- /dev/null
+++ b/docs/USA.md
@@ -0,0 +1,3855 @@
+---
+hide:
+ - navigation
+ - toc
+---
+
+
+What the f*ck Python! 😱
+Exploring and understanding Python through surprising snippets.
+
+
+Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Russian Русский](https://github.com/frontdevops/wtfpython) | [German Deutsch](https://github.com/BenSt099/wtfpython) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
+
+Other modes: [Interactive Website](https://wtfpython-interactive.vercel.app) | [Interactive Notebook](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
+
+Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight.
+
+Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python.
+
+While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I believe that you'll find it interesting too!
+
+If you're an experienced Python programmer, you can take it as a challenge to get most of them right in the first attempt. You may have already experienced some of them before, and I might be able to revive sweet old memories of yours! :sweat_smile:
+
+PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/) (the examples marked with asterisk are the ones added in the latest major revision).
+
+So, here we go...
+
+# Table of Contents
+
+
+
+
+
+- [Structure of the Examples](#structure-of-the-examples)
+ + [▶ Some fancy Title](#-some-fancy-title)
+- [Usage](#usage)
+- [👀 Examples](#-examples)
+ * [Section: Strain your brain!](#section-strain-your-brain)
+ + [▶ First things first! *](#-first-things-first-)
+ + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
+ + [▶ Be careful with chained operations](#-be-careful-with-chained-operations)
+ + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
+ + [▶ Hash brownies](#-hash-brownies)
+ + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)
+ + [▶ Disorder within order *](#-disorder-within-order-)
+ + [▶ Keep trying... *](#-keep-trying-)
+ + [▶ For what?](#-for-what)
+ + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
+ + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+ + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+ + [▶ Schrödinger's variable](#-schrödingers-variable-)
+ + [▶ The chicken-egg problem *](#-the-chicken-egg-problem-)
+ + [▶ Subclass relationships](#-subclass-relationships)
+ + [▶ Methods equality and identity](#-methods-equality-and-identity)
+ + [▶ All-true-ation *](#-all-true-ation-)
+ + [▶ The surprising comma](#-the-surprising-comma)
+ + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
+ + [▶ not knot!](#-not-knot)
+ + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
+ + [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)
+ + [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes)
+ + [▶ yielding None](#-yielding-none)
+ + [▶ Yielding from... return! *](#-yielding-from-return-)
+ + [▶ Nan-reflexivity *](#-nan-reflexivity-)
+ + [▶ Mutating the immutable!](#-mutating-the-immutable)
+ + [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)
+ + [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion)
+ + [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this)
+ + [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion)
+ * [Section: Slippery Slopes](#section-slippery-slopes)
+ + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
+ + [▶ Stubborn `del` operation](#-stubborn-del-operation)
+ + [▶ The out of scope variable](#-the-out-of-scope-variable)
+ + [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)
+ + [▶ Lossy zip of iterators *](#-lossy-zip-of-iterators-)
+ + [▶ Loop variables leaking out!](#-loop-variables-leaking-out)
+ + [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)
+ + [▶ Catching the Exceptions](#-catching-the-exceptions)
+ + [▶ Same operands, different story!](#-same-operands-different-story)
+ + [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope)
+ + [▶ Rounding like a banker *](#-rounding-like-a-banker-)
+ + [▶ Needles in a Haystack *](#-needles-in-a-haystack-)
+ + [▶ Splitsies *](#-splitsies-)
+ + [▶ Wild imports *](#-wild-imports-)
+ + [▶ All sorted? *](#-all-sorted-)
+ + [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)
+ * [Section: The Hidden treasures!](#section-the-hidden-treasures)
+ + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
+ + [▶ `goto`, but why?](#-goto-but-why)
+ + [▶ Brace yourself!](#-brace-yourself)
+ + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
+ + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
+ + [▶ Yes, it exists!](#-yes-it-exists)
+ + [▶ Ellipsis *](#-ellipsis-)
+ + [▶ Inpinity](#-inpinity)
+ + [▶ Let's mangle](#-lets-mangle)
+ * [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
+ + [▶ Skipping lines?](#-skipping-lines)
+ + [▶ Teleportation](#-teleportation)
+ + [▶ Well, something is fishy...](#-well-something-is-fishy)
+ * [Section: Miscellaneous](#section-miscellaneous)
+ + [▶ `+=` is faster](#--is-faster)
+ + [▶ Let's make a giant string!](#-lets-make-a-giant-string)
+ + [▶ Slowing down `dict` lookups *](#-slowing-down-dict-lookups-)
+ + [▶ Bloating instance `dict`s *](#-bloating-instance-dicts-)
+ + [▶ Minor Ones *](#-minor-ones-)
+- [Contributing](#contributing)
+- [Acknowledgements](#acknowledgements)
+- [🎓 License](#-license)
+ * [Surprise your friends as well!](#surprise-your-friends-as-well)
+ * [More content like this?](#more-content-like-this)
+
+
+
+# Structure of the Examples
+
+All the examples are structured like below:
+
+> ### ▶ Some fancy Title
+>
+> ```py
+> # Set up the code.
+> # Preparation for the magic...
+> ```
+>
+> **Output (Python version(s)):**
+>
+> ```py
+> >>> triggering_statement
+> Some unexpected output
+> ```
+> (Optional): One line describing the unexpected output.
+>
+>
+> #### 💡 Explanation:
+>
+> * Brief explanation of what's happening and why is it happening.
+> ```py
+> # Set up code
+> # More examples for further clarification (if necessary)
+> ```
+> **Output (Python version(s)):**
+>
+> ```py
+> >>> trigger # some example that makes it easy to unveil the magic
+> # some justified output
+> ```
+
+**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified before the output.
+
+# Usage
+
+A nice way to get the most out of these examples, in my opinion, is to read them in sequential order, and for every example:
+- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, you'll successfully anticipate what's going to happen next most of the time.
+- Read the output snippets and,
+ + Check if the outputs are the same as you'd expect.
+ + Make sure if you know the exact reason behind the output being the way it is.
+ - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfpython/issues/new)).
+ - If yes, give a gentle pat on your back, and you may skip to the next example.
+
+PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),
+```sh
+$ pip install wtfpython -U
+$ wtfpython
+```
+---
+
+# 👀 Examples
+
+## Section: Strain your brain!
+
+### ▶ First things first! *
+
+
+
+
+For some reason, the Python 3.8's "Walrus" operator (`:=`) has become quite popular. Let's check it out,
+
+1\.
+
+```py
+# Python version 3.8+
+
+>>> a = "wtf_walrus"
+>>> a
+'wtf_walrus'
+
+>>> a := "wtf_walrus"
+File "", line 1
+ a := "wtf_walrus"
+ ^
+SyntaxError: invalid syntax
+
+>>> (a := "wtf_walrus") # This works though
+'wtf_walrus'
+>>> a
+'wtf_walrus'
+```
+
+2 \.
+
+```py
+# Python version 3.8+
+
+>>> a = 6, 9
+>>> a
+(6, 9)
+
+>>> (a := 6, 9)
+(6, 9)
+>>> a
+6
+
+>>> a, b = 6, 9 # Typical unpacking
+>>> a, b
+(6, 9)
+>>> (a, b = 16, 19) # Oops
+ File "", line 1
+ (a, b = 16, 19)
+ ^
+SyntaxError: invalid syntax
+
+>>> (a, b := 16, 19) # This prints out a weird 3-tuple
+(6, 16, 19)
+
+>>> a # a is still unchanged?
+6
+
+>>> b
+16
+```
+
+
+
+#### 💡 Explanation
+
+**Quick walrus operator refresher**
+
+The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situations where you'd want to assign values to variables within an expression.
+
+```py
+def some_func():
+ # Assume some expensive computation here
+ # time.sleep(1000)
+ return 5
+
+# So instead of,
+if some_func():
+ print(some_func()) # Which is bad practice since computation is happening twice
+
+# or
+a = some_func()
+if a:
+ print(a)
+
+# Now you can concisely write
+if a := some_func():
+ print(a)
+```
+
+**Output (> 3.8):**
+
+```py
+5
+5
+5
+```
+
+This saved one line of code, and implicitly prevented invoking `some_func` twice.
+
+- Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`.
+
+- As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`.
+
+- The syntax of the Walrus operator is of the form `NAME:= expr`, where `NAME` is a valid identifier, and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means,
+
+ - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6')
+
+ ```py
+ >>> (a := 6, 9) == ((a := 6), 9)
+ True
+ >>> x = (a := 696, 9)
+ >>> x
+ (696, 9)
+ >>> x[0] is a # Both reference same memory location
+ True
+ ```
+
+ - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple.
+
+---
+
+### ▶ Strings can be tricky sometimes
+
+
+1\.
+
+```py
+>>> a = "some_string"
+>>> id(a)
+140420665652016
+>>> id("some" + "_" + "string") # Notice that both the ids are same.
+140420665652016
+```
+
+2\.
+```py
+>>> a = "wtf"
+>>> b = "wtf"
+>>> a is b
+True
+
+>>> a = "wtf!"
+>>> b = "wtf!"
+>>> a is b
+False
+
+```
+
+3\.
+
+```py
+>>> a, b = "wtf!", "wtf!"
+>>> a is b # All versions except 3.7.x
+True
+
+>>> a = "wtf!"; b = "wtf!"
+>>> a is b # This will print True or False depending on where you're invoking it (python shell / ipython / as a script)
+False
+```
+
+```py
+# This time in file some_file.py
+a = "wtf!"
+b = "wtf!"
+print(a is b)
+
+# prints True when the module is invoked!
+```
+
+4\.
+
+**Output (< Python3.7 )**
+
+```py
+>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
+True
+>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
+False
+```
+
+Makes sense, right?
+
+#### 💡 Explanation:
++ The behavior in first and second snippets is due to a CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.
++ After being "interned," many variables may reference the same string object in memory (saving memory thereby).
++ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation-dependent. There are some rules that can be used to guess if a string will be interned or not:
+ * All length 0 and length 1 strings are interned.
+ * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f'])` will not be interned)
+ * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. CPython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
+ 
++ When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `"wtf!"` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).
++ A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. `a, b = "wtf!", "wtf!"` is single statement, whereas `a = "wtf!"; b = "wtf!"` are two statements in a single line. This explains why the identities are different in `a = "wtf!"; b = "wtf!"`, and also explain why they are same when invoked in `some_file.py`
++ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 21. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the fourth snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549).
+
+---
+
+
+### ▶ Be careful with chained operations
+
+```py
+>>> (False == False) in [False] # makes sense
+False
+>>> False == (False in [False]) # makes sense
+False
+>>> False == False in [False] # now what?
+True
+
+>>> True is False == False
+False
+>>> False is False is False
+True
+
+>>> 1 > 0 < 1
+True
+>>> (1 > 0) < 1
+False
+>>> 1 > (0 < 1)
+False
+```
+
+#### 💡 Explanation:
+
+As per https://docs.python.org/3/reference/expressions.html#comparisons
+
+> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.
+
+While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.
+
+* `False is False is False` is equivalent to `(False is False) and (False is False)`
+* `True is False == False` is equivalent to `(True is False) and (False == False)` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.
+* `1 > 0 < 1` is equivalent to `(1 > 0) and (0 < 1)` which evaluates to `True`.
+* The expression `(1 > 0) < 1` is equivalent to `True < 1` and
+ ```py
+ >>> int(True)
+ 1
+ >>> True + 1 #not relevant for this example, but just for fun
+ 2
+ ```
+ So, `1 < 1` evaluates to `False`
+
+---
+
+### ▶ How not to use `is` operator
+
+The following is a very famous example present all over the internet.
+
+1\.
+
+```py
+>>> a = 256
+>>> b = 256
+>>> a is b
+True
+
+>>> a = 257
+>>> b = 257
+>>> a is b
+False
+```
+
+2\.
+
+```py
+>>> a = []
+>>> b = []
+>>> a is b
+False
+
+>>> a = tuple()
+>>> b = tuple()
+>>> a is b
+True
+```
+
+3\.
+**Output**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+True
+```
+
+**Output (Python 3.7.x specifically)**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+False
+```
+
+#### 💡 Explanation:
+
+**The difference between `is` and `==`**
+
+* `is` operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not).
+* `==` operator compares the values of both the operands and checks if they are the same.
+* So `is` is for reference equality and `==` is for value equality. An example to clear things up,
+ ```py
+ >>> class A: pass
+ >>> A() is A() # These are two empty objects at two different memory locations.
+ False
+ ```
+
+**`256` is an existing object but `257` isn't**
+
+When you start up python the numbers from `-5` to `256` will be allocated. These numbers are used a lot, so it makes sense just to have them ready.
+
+Quoting from https://docs.python.org/3/c-api/long.html
+> The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behavior of Python, in this case, is undefined. :-)
+
+```py
+>>> 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
+```
+
+Here the interpreter isn't smart enough while executing `y = 257` to recognize that we've already created an integer of the value `257,` and so it goes on to create another object in the memory.
+
+Similar optimization applies to other **immutable** objects like empty tuples as well. Since lists are mutable, that's why `[] is []` will return `False` and `() is ()` will return `True`. This explains our second snippet. Let's move on to the third one,
+
+**Both `a` and `b` refer to the same object when initialized with same value in the same line.**
+
+**Output**
+
+```py
+>>> a, b = 257, 257
+>>> id(a)
+140640774013296
+>>> id(b)
+140640774013296
+>>> a = 257
+>>> b = 257
+>>> id(a)
+140640774013392
+>>> id(b)
+140640774013488
+```
+
+* When a and b are set to `257` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `257` as an object.
+
+* It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a `.py` file, you would not see the same behavior, because the file is compiled all at once. This optimization is not limited to integers, it works for other immutable data types like strings (check the "Strings are tricky example") and floats as well,
+
+ ```py
+ >>> a, b = 257.0, 257.0
+ >>> a is b
+ True
+ ```
+
+* Why didn't this work for Python 3.7? The abstract reason is because such compiler optimizations are implementation specific (i.e. may change with version, OS, etc). I'm still figuring out what exact implementation change cause the issue, you can check out this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for updates.
+
+---
+
+
+### ▶ Hash brownies
+
+1\.
+```py
+some_dict = {}
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
+some_dict[5] = "Python"
+```
+
+**Output:**
+
+```py
+>>> some_dict[5.5]
+"JavaScript"
+>>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"?
+"Python"
+>>> some_dict[5]
+"Python"
+
+>>> complex_five = 5 + 0j
+>>> type(complex_five)
+complex
+>>> some_dict[complex_five]
+"Python"
+```
+
+So, why is Python all over the place?
+
+
+#### 💡 Explanation
+
+* Uniqueness of keys in a Python dictionary is by *equivalence*, not identity. So even though `5`, `5.0`, and `5 + 0j` are distinct objects of different types, since they're equal, they can't both be in the same `dict` (or `set`). As soon as you insert any one of them, attempting to look up any distinct but equivalent key will succeed with the original mapped value (rather than failing with a `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
+ ```
+* This applies when setting an item as well. So when you do `some_dict[5] = "Python"`, Python finds the existing item with equivalent key `5.0 -> "Ruby"`, overwrites its value in place, and leaves the original key alone.
+ ```py
+ >>> some_dict
+ {5.0: 'Ruby'}
+ >>> some_dict[5] = "Python"
+ >>> some_dict
+ {5.0: 'Python'}
+ ```
+* So how can we update the key to `5` (instead of `5.0`)? We can't actually do this update in place, but what we can do is first delete the key (`del some_dict[5.0]`), and then set it (`some_dict[5]`) to get the integer `5` as the key instead of floating `5.0`, though this should be needed in rare cases.
+
+* How did Python find `5` in a dictionary containing `5.0`? Python does this in constant time without having to scan through every item by using hash functions. When Python looks up a key `foo` in a dict, it first computes `hash(foo)` (which runs in constant-time). Since in Python it is required that objects that compare equal also have the same hash value ([docs](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value.
+ ```py
+ >>> 5 == 5.0 == 5 + 0j
+ True
+ >>> hash(5) == hash(5.0) == hash(5 + 0j)
+ True
+ ```
+ **Note:** The inverse is not necessarily true: Objects with equal hash values may themselves be unequal. (This causes what's known as a [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science)), and degrades the constant-time performance that hashing usually provides.)
+
+---
+
+### ▶ Deep down, we're all the same.
+
+```py
+class WTF:
+ pass
+```
+
+**Output:**
+```py
+>>> WTF() == WTF() # two different instances can't be equal
+False
+>>> WTF() is WTF() # identities are also different
+False
+>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
+True
+>>> id(WTF()) == id(WTF())
+True
+```
+
+#### 💡 Explanation:
+
+* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.
+* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.
+* So, the object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
+* But why did the `is` operator evaluate to `False`? Let's see with this snippet.
+ ```py
+ class WTF(object):
+ def __init__(self): print("I")
+ def __del__(self): print("D")
+ ```
+
+ **Output:**
+ ```py
+ >>> WTF() is WTF()
+ I
+ I
+ D
+ D
+ False
+ >>> id(WTF()) == id(WTF())
+ I
+ D
+ I
+ D
+ True
+ ```
+ As you may observe, the order in which the objects are destroyed is what made all the difference here.
+
+---
+
+### ▶ Disorder within order *
+
+```py
+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
+```
+
+**Output**
+```py
+>>> dictionary == ordered_dict # If a == b
+True
+>>> dictionary == another_ordered_dict # and b == c
+True
+>>> ordered_dict == another_ordered_dict # then why isn't c == a ??
+False
+
+# We all know that a set consists of only unique elements,
+# let's try making a set of these dictionaries and see what happens...
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "", line 1, in
+TypeError: unhashable type: 'dict'
+
+# Makes sense since dict don't have __hash__ implemented, let's use
+# our wrapper classes.
+>>> 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
+```
+
+What is going on here?
+
+#### 💡 Explanation:
+
+- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)
+
+ > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.
+- The reason for this equality in behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.
+- Okay, so why did changing the order affect the length of the generated `set` object? The answer is the lack of intransitive equality only. Since sets are "unordered" collections of unique elements, the order in which elements are inserted shouldn't matter. But in this case, it does matter. Let's break it down a bit,
+ ```py
+ >>> some_set = set()
+ >>> some_set.add(dictionary) # these are the mapping objects from the snippets above
+ >>> 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
+ ```
+ So the inconsistency is due to `another_ordered_dict in another_set` being `False` because `ordered_dict` was already present in `another_set` and as observed before, `ordered_dict == another_ordered_dict` is `False`.
+
+---
+
+### ▶ Keep trying... *
+
+```py
+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(): # A gotcha!
+ try:
+ for i in range(3):
+ try:
+ 1 / i
+ except ZeroDivisionError:
+ # Let's throw it here and handle it outside for loop
+ raise ZeroDivisionError("A trivial divide by zero error")
+ finally:
+ print("Iteration", i)
+ break
+ except ZeroDivisionError as e:
+ print("Zero division error occurred", e)
+```
+
+**Output:**
+
+```py
+>>> some_func()
+'from_finally'
+
+>>> another_func()
+Finally!
+Finally!
+Finally!
+
+>>> 1 / 0
+Traceback (most recent call last):
+ File "", line 1, in
+ZeroDivisionError: division by zero
+
+>>> one_more_func()
+Iteration 0
+
+```
+
+#### 💡 Explanation:
+
+- When a `return`, `break` or `continue` statement is executed in the `try` suite of a "try…finally" statement, the `finally` clause is also executed on the way out.
+- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.
+- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.
+
+---
+
+
+### ▶ For what?
+
+```py
+some_string = "wtf"
+some_dict = {}
+for i, some_dict[i] in enumerate(some_string):
+ i = 10
+```
+
+**Output:**
+```py
+>>> some_dict # An indexed dict appears.
+{0: 'w', 1: 't', 2: 'f'}
+```
+
+#### 💡 Explanation:
+
+* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:
+ ```
+ for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+ ```
+ Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.
+ An interesting example that illustrates this:
+ ```py
+ for i in range(4):
+ print(i)
+ i = 10
+ ```
+
+ **Output:**
+ ```
+ 0
+ 1
+ 2
+ 3
+ ```
+
+ Did you expect the loop to run just once?
+
+ **💡 Explanation:**
+
+ - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` in this case) is unpacked and assigned the target list variables (`i` in this case).
+
+* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:
+ ```py
+ >>> i, some_dict[i] = (0, 'w')
+ >>> i, some_dict[i] = (1, 't')
+ >>> i, some_dict[i] = (2, 'f')
+ >>> some_dict
+ ```
+
+---
+
+### ▶ Evaluation time discrepancy
+
+1\.
+```py
+array = [1, 8, 15]
+# A typical generator expression
+gen = (x for x in array if array.count(x) > 0)
+array = [2, 8, 22]
+```
+
+**Output:**
+
+```py
+>>> print(list(gen)) # Where did the other values go?
+[8]
+```
+
+2\.
+
+```py
+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]
+```
+
+**Output:**
+```py
+>>> print(list(gen_1))
+[1, 2, 3, 4]
+
+>>> print(list(gen_2))
+[1, 2, 3, 4, 5]
+```
+
+3\.
+
+```py
+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]
+```
+
+**Output:**
+```py
+>>> print(list(gen))
+[401, 501, 601, 402, 502, 602, 403, 503, 603]
+```
+
+#### 💡 Explanation
+
+- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.
+- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`.
+- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.
+- In the first case, `array_1` is bound to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
+- In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
+- Okay, going by the logic discussed so far, shouldn't be the value of `list(gen)` in the third snippet be `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (because `array_3` and `array_4` are going to behave just like `array_1`). The reason why (only) `array_4` values got updated is explained in [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)
+
+ > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
+
+---
+
+
+### ▶ `is not ...` is not `is (not ...)`
+
+```py
+>>> 'something' is not None
+True
+>>> 'something' is (not None)
+False
+```
+
+#### 💡 Explanation
+
+- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated.
+- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise.
+- In the example, `(not None)` evaluates to `True` since the value `None` is `False` in a boolean context, so the expression becomes `'something' is True`.
+
+---
+
+### ▶ A tic-tac-toe where X wins in the first attempt!
+
+
+```py
+# Let's initialize a row
+row = [""] * 3 #row i['', '', '']
+# Let's make a board
+board = [row] * 3
+```
+
+**Output:**
+
+```py
+>>> board
+[['', '', ''], ['', '', ''], ['', '', '']]
+>>> board[0]
+['', '', '']
+>>> board[0][0]
+''
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['X', '', ''], ['X', '', '']]
+```
+
+We didn't assign three `"X"`s, did we?
+
+#### 💡 Explanation:
+
+When we initialize `row` variable, this visualization explains what happens in the memory
+
+
+
+And when the `board` is initialized by multiplying the `row`, this is what happens inside the memory (each of the elements `board[0]`, `board[1]` and `board[2]` is a reference to the same list referred by `row`)
+
+
+
+We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue).
+
+```py
+>>> board = [['']*3 for _ in range(3)]
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['', '', ''], ['', '', '']]
+```
+
+---
+
+### ▶ Schrödinger's variable *
+
+
+
+```py
+funcs = []
+results = []
+for x in range(7):
+ def some_func():
+ return x
+ funcs.append(some_func)
+ results.append(some_func()) # note the function call here
+
+funcs_results = [func() for func in funcs]
+```
+
+**Output (Python version):**
+```py
+>>> results
+[0, 1, 2, 3, 4, 5, 6]
+>>> funcs_results
+[6, 6, 6, 6, 6, 6, 6]
+```
+
+The values of `x` were different in every iteration prior to appending `some_func` to `funcs`, but all the functions return 6 when they're evaluated after the loop completes.
+
+2.
+
+```py
+>>> 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]
+```
+
+#### 💡 Explanation:
+* When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the *variable*, not its *value*. The function looks up `x` in the surrounding context, rather than using the value of `x` at the time the function is created. So all of the functions use the latest value assigned to the variable for computation. We can see that it's using the `x` from the surrounding context (i.e. *not* a local variable) with:
+```py
+>>> import inspect
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())
+```
+Since `x` is a global value, we can change the value that the `funcs` will lookup and return by updating `x`:
+
+```py
+>>> x = 42
+>>> [func() for func in funcs]
+[42, 42, 42, 42, 42, 42, 42]
+```
+
+* To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why does this work?** Because this will define the variable *inside* the function's scope. It will no longer go to the surrounding (global) scope to look up the variables value but will create a local variable that stores the value of `x` at that point in time.
+
+```py
+funcs = []
+for x in range(7):
+ def some_func(x=x):
+ return x
+ funcs.append(some_func)
+```
+
+**Output:**
+
+```py
+>>> funcs_results = [func() for func in funcs]
+>>> funcs_results
+[0, 1, 2, 3, 4, 5, 6]
+```
+
+It is not longer using the `x` in the global scope:
+
+```py
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())
+```
+
+---
+
+### ▶ The chicken-egg problem *
+
+1\.
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+So which is the "ultimate" base class? There's more to the confusion by the way,
+
+2\.
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+
+#### 💡 Explanation
+
+- `type` is a [metaclass](https://realpython.com/python-metaclasses/) in Python.
+- **Everything** is an `object` in Python, which includes classes as well as their objects (instances).
+- class `type` is the metaclass of class `object`, and every class (including `type`) has inherited directly or indirectly from `object`.
+- There is no real base class among `object` and `type`. The confusion in the above snippets is arising because we're thinking about these relationships (`issubclass` and `isinstance`) in terms of Python classes. The relationship between `object` and `type` can't be reproduced in pure python. To be more precise the following relationships can't be reproduced in pure Python,
+ + class A is an instance of class B, and class B is an instance of class A.
+ + class A is an instance of itself.
+- These relationships between `object` and `type` (both being instances of each other as well as themselves) exist in Python because of "cheating" at the implementation level.
+
+---
+
+### ▶ Subclass relationships
+
+**Output:**
+```py
+>>> from collections.abc import Hashable
+>>> issubclass(list, object)
+True
+>>> issubclass(object, Hashable)
+True
+>>> issubclass(list, Hashable)
+False
+```
+
+The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`)
+
+#### 💡 Explanation:
+
+* Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass.
+* When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey "`__hash__`" method in `cls` or anything it inherits from.
+* Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation.
+* More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).
+
+---
+
+### ▶ Methods equality and identity
+
+
+1.
+```py
+class SomeClass:
+ def method(self):
+ pass
+
+ @classmethod
+ def classm(cls):
+ pass
+
+ @staticmethod
+ def staticm():
+ pass
+```
+
+**Output:**
+```py
+>>> 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
+```
+
+Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens
+with instances of `SomeClass`:
+
+2.
+```py
+o1 = SomeClass()
+o2 = SomeClass()
+```
+
+**Output:**
+```py
+>>> 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
+```
+
+Accessing `classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`.
+
+#### 💡 Explanation
+* Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an
+attribute, the descriptor is invoked, creating a method object which "binds" the function with the object owning the
+attribute. If called, the method calls the function, implicitly passing the bound object as the first argument
+(this is how we get `self` as the first argument, despite not passing it explicitly).
+```py
+>>> o1.method
+>
+```
+* Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is
+never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so
+`SomeClass.method is SomeClass.method` is truthy.
+```py
+>>> SomeClass.method
+
+```
+* `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create
+a method object which binds the *class* (type) of the object, instead of the object itself.
+```py
+>>> o1.classm
+>
+```
+* Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they
+bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy.
+```py
+>>> SomeClass.classm
+>
+```
+* A method object compares equal when both the functions are equal, and the bound objects are the same. So
+`o1.method == o1.method` is truthy, although not the same object in memory.
+* `staticmethod` transforms functions into a "no-op" descriptor, which returns the function as-is. No method
+objects are ever created, so comparison with `is` is truthy.
+```py
+>>> o1.staticm
+
+>>> SomeClass.staticm
+
+```
+* Having to create new "method" objects every time Python calls instance methods and having to modify the arguments
+every time in order to insert `self` affected performance badly.
+CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods
+without creating the temporary method objects. This is used only when the accessed function is actually called, so the
+snippets here are not affected, and still generate methods :)
+
+### ▶ All-true-ation *
+
+
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+Why's this True-False alteration?
+
+#### 💡 Explanation:
+
+- The implementation of `all` function is equivalent to
+
+- ```py
+ def all(iterable):
+ for element in iterable:
+ if not element:
+ return False
+ return True
+ ```
+
+- `all([])` returns `True` since the iterable is empty.
+- `all([[]])` returns `False` because the passed array has one element, `[]`, and in python, an empty list is falsy.
+- `all([[[]]])` and higher recursive variants are always `True`. This is because the passed array's single element (`[[...]]`) is no longer empty, and lists with values are truthy.
+
+---
+
+### ▶ The surprising comma
+
+**Output (< 3.6):**
+
+```py
+>>> def f(x, y,):
+... print(x, y)
+...
+>>> def g(x=4, y=5,):
+... print(x, y)
+...
+>>> def h(x, **kwargs,):
+ File "", line 1
+ def h(x, **kwargs,):
+ ^
+SyntaxError: invalid syntax
+
+>>> def h(*args,):
+ File "", line 1
+ def h(*args,):
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Explanation:
+
+- Trailing comma is not always legal in formal parameters list of a Python function.
+- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.
+- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python.
+
+---
+
+### ▶ Strings and the backslashes
+
+**Output:**
+```py
+>>> print("\"")
+"
+
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "", line 1
+ print(r"\")
+ ^
+SyntaxError: EOL while scanning string literal
+
+>>> r'\'' == "\\'"
+True
+```
+
+#### 💡 Explanation
+
+- In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself).
+ ```py
+ >>> "wt\"f"
+ 'wt"f'
+ ```
+- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character.
+ ```py
+ >>> r'wt\"f' == 'wt\\"f'
+ True
+ >>> print(repr(r'wt\"f')
+ 'wt\\"f'
+
+ >>> print("\n")
+
+ >>> print(r"\\n")
+ '\\n'
+ ```
+- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string.
+
+---
+
+### ▶ not knot!
+
+```py
+x = True
+y = False
+```
+
+**Output:**
+```py
+>>> not x == y
+True
+>>> x == not y
+ File "", line 1
+ x == not y
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Explanation:
+
+* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.
+* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.
+* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight.
+* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`.
+
+---
+
+### ▶ Half triple-quoted strings
+
+**Output:**
+```py
+>>> print('wtfpython''')
+wtfpython
+>>> print("wtfpython""")
+wtfpython
+>>> # The following statements raise `SyntaxError`
+>>> # print('''wtfpython')
+>>> # print("""wtfpython")
+ File "", line 3
+ print("""wtfpython")
+ ^
+SyntaxError: EOF while scanning triple-quoted string literal
+```
+
+#### 💡 Explanation:
++ Python supports implicit [string literal concatenation](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Example,
+ ```
+ >>> print("wtf" "python")
+ wtfpython
+ >>> print("wtf" "") # or "wtf"""
+ wtf
+ ```
++ `'''` and `"""` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.
+
+---
+
+### ▶ What's wrong with booleans?
+
+1\.
+
+```py
+# A simple example to count the number of booleans and
+# integers in an iterable of mixed data types.
+mixed_list = [False, 1.0, "some_string", 3, True, [], False]
+integers_found_so_far = 0
+booleans_found_so_far = 0
+
+for item in mixed_list:
+ if isinstance(item, int):
+ integers_found_so_far += 1
+ elif isinstance(item, bool):
+ booleans_found_so_far += 1
+```
+
+**Output:**
+```py
+>>> integers_found_so_far
+4
+>>> booleans_found_so_far
+0
+```
+
+
+2\.
+```py
+>>> some_bool = True
+>>> "wtf" * some_bool
+'wtf'
+>>> some_bool = False
+>>> "wtf" * some_bool
+''
+```
+
+3\.
+
+```py
+def tell_truth():
+ True = False
+ if True == False:
+ print("I have lost faith in truth!")
+```
+
+**Output (< 3.x):**
+
+```py
+>>> tell_truth()
+I have lost faith in truth!
+```
+
+
+
+#### 💡 Explanation:
+
+* `bool` is a subclass of `int` in Python
+
+ ```py
+ >>> issubclass(bool, int)
+ True
+ >>> issubclass(int, bool)
+ False
+ ```
+
+* And thus, `True` and `False` are instances of `int`
+ ```py
+ >>> isinstance(True, int)
+ True
+ >>> isinstance(False, int)
+ True
+ ```
+
+* The integer value of `True` is `1` and that of `False` is `0`.
+ ```py
+ >>> int(True)
+ 1
+ >>> int(False)
+ 0
+ ```
+
+* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.
+
+* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them
+
+* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!
+
+---
+
+### ▶ Class attributes and instance attributes
+
+1\.
+```py
+class A:
+ x = 1
+
+class B(A):
+ pass
+
+class C(A):
+ pass
+```
+
+**Output:**
+```py
+>>> A.x, B.x, C.x
+(1, 1, 1)
+>>> B.x = 2
+>>> A.x, B.x, C.x
+(1, 2, 1)
+>>> A.x = 3
+>>> A.x, B.x, C.x # C.x changed, but B.x didn't
+(3, 2, 3)
+>>> a = A()
+>>> a.x, A.x
+(3, 3)
+>>> a.x += 1
+>>> a.x, A.x
+(4, 3)
+```
+
+2\.
+```py
+class SomeClass:
+ some_var = 15
+ some_list = [5]
+ another_list = [5]
+ def __init__(self, x):
+ self.some_var = x + 1
+ self.some_list = self.some_list + [x]
+ self.another_list += [x]
+```
+
+**Output:**
+
+```py
+>>> some_obj = SomeClass(420)
+>>> some_obj.some_list
+[5, 420]
+>>> some_obj.another_list
+[5, 420]
+>>> another_obj = SomeClass(111)
+>>> another_obj.some_list
+[5, 111]
+>>> another_obj.another_list
+[5, 420, 111]
+>>> another_obj.another_list is SomeClass.another_list
+True
+>>> another_obj.another_list is some_obj.another_list
+True
+```
+
+#### 💡 Explanation:
+
+* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.
+* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.
+
+---
+
+### ▶ yielding None
+
+```py
+some_iterable = ('a', 'b')
+
+def some_func(val):
+ return "something"
+```
+
+**Output (<= 3.7.x):**
+
+```py
+>>> [x for x in some_iterable]
+['a', 'b']
+>>> [(yield x) for x in some_iterable]
+ at 0x7f70b0a4ad58>
+>>> list([(yield x) for x in some_iterable])
+['a', 'b']
+>>> list((yield x) for x in some_iterable)
+['a', None, 'b', None]
+>>> list(some_func((yield x)) for x in some_iterable)
+['a', 'something', 'b', 'something']
+```
+
+#### 💡 Explanation:
+- This is a bug in CPython's handling of `yield` in generators and comprehensions.
+- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
+- Related bug report: https://bugs.python.org/issue10544
+- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.
+
+---
+
+
+### ▶ Yielding from... return! *
+
+1\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ yield from range(x)
+```
+
+**Output (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
+
+2\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ for i in range(x):
+ yield i
+```
+
+**Output:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+The same result, this didn't work either.
+
+#### 💡 Explanation:
+
++ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that,
+
+> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
+
++ In the case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically caught inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
+
++ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
+
+ ```py
+ try:
+ next(some_func(3))
+ except StopIteration as e:
+ some_string = e.value
+ ```
+
+ ```py
+ >>> some_string
+ ["wtf"]
+ ```
+
+---
+
+### ▶ Nan-reflexivity *
+
+
+
+1\.
+
+```py
+a = float('inf')
+b = float('nan')
+c = float('-iNf') # These strings are case-insensitive
+d = float('nan')
+```
+
+**Output:**
+
+```py
+>>> a
+inf
+>>> b
+nan
+>>> c
+-inf
+>>> float('some_other_string')
+ValueError: could not convert string to float: some_other_string
+>>> a == -c # inf==inf
+True
+>>> None == None # None == None
+True
+>>> b == d # but nan!=nan
+False
+>>> 50 / a
+0.0
+>>> a / a
+nan
+>>> 23 + b
+nan
+```
+
+2\.
+
+```py
+>>> x = float('nan')
+>>> y = x / x
+>>> y is y # identity holds
+True
+>>> y == y # equality fails of y
+False
+>>> [y] == [y] # but the equality succeeds for the list containing y
+True
+```
+
+
+
+#### 💡 Explanation:
+
+- `'inf'` and `'nan'` are special strings (case-insensitive), which, when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
+
+- Since according to IEEE standards ` NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`. Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer,
+
+ ```py
+ >>> x = float('nan')
+ >>> x == x, [x] == [x]
+ (False, True)
+ >>> y = float('nan')
+ >>> y == y, [y] == [y]
+ (False, True)
+ >>> x == y, [x] == [y]
+ (False, False)
+ ```
+
+ Since the identities of `x` and `y` are different, the values are considered, which are also different; hence the comparison returns `False` this time.
+
+- Interesting read: [Reflexivity, and other pillars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+
+---
+
+### ▶ Mutating the immutable!
+
+
+
+This might seem trivial if you know how references work in Python.
+
+```py
+some_tuple = ("A", "tuple", "with", "values")
+another_tuple = ([1, 2], [3, 4], [5, 6])
+```
+
+**Output:**
+```py
+>>> some_tuple[2] = "change this"
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple[2].append(1000) #This throws no error
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000])
+>>> another_tuple[2] += [99, 999]
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000, 99, 999])
+```
+
+But I thought tuples were immutable...
+
+#### 💡 Explanation:
+
+* Quoting from https://docs.python.org/3/reference/datamodel.html
+
+ > Immutable sequences
+ An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.)
+
+* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place.
+* There's also an explanation in [official Python FAQ](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works).
+
+---
+
+### ▶ The disappearing variable from outer scope
+
+
+```py
+e = 7
+try:
+ raise Exception()
+except Exception as e:
+ pass
+```
+
+**Output (Python 2.x):**
+```py
+>>> print(e)
+# prints nothing
+```
+
+**Output (Python 3.x):**
+```py
+>>> print(e)
+NameError: name 'e' is not defined
+```
+
+#### 💡 Explanation:
+
+* Source: https://docs.python.org/3/reference/compound_stmts.html#except
+
+ When an exception has been assigned using `as` target, it is cleared at the end of the `except` clause. This is as if
+
+ ```py
+ except E as N:
+ foo
+ ```
+
+ was translated into
+
+ ```py
+ except E as N:
+ try:
+ foo
+ finally:
+ del N
+ ```
+
+ This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.
+
+* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this:
+
+ ```py
+ def f(x):
+ del(x)
+ print(x)
+
+ x = 5
+ y = [5, 4, 3]
+ ```
+
+ **Output:**
+ ```py
+ >>> f(x)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> f(y)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> x
+ 5
+ >>> y
+ [5, 4, 3]
+ ```
+
+* In Python 2.x, the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing.
+
+ **Output (Python 2.x):**
+ ```py
+ >>> e
+ Exception()
+ >>> print e
+ # Nothing is printed!
+ ```
+
+---
+
+
+### ▶ The mysterious key type conversion
+
+```py
+class SomeClass(str):
+ pass
+
+some_dict = {'s': 42}
+```
+
+**Output:**
+```py
+>>> type(list(some_dict.keys())[0])
+str
+>>> s = SomeClass('s')
+>>> some_dict[s] = 40
+>>> some_dict # expected: Two different keys-value pairs
+{'s': 40}
+>>> type(list(some_dict.keys())[0])
+str
+```
+
+#### 💡 Explanation:
+
+* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class.
+* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class.
+* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary.
+* For the desired behavior, we can redefine the `__eq__` method in `SomeClass`
+ ```py
+ class SomeClass(str):
+ def __eq__(self, other):
+ return (
+ type(self) is SomeClass
+ and type(other) is SomeClass
+ and super().__eq__(other)
+ )
+
+ # When we define a custom __eq__, Python stops automatically inheriting the
+ # __hash__ method, so we need to define it as well
+ __hash__ = str.__hash__
+
+ some_dict = {'s':42}
+ ```
+
+ **Output:**
+ ```py
+ >>> s = SomeClass('s')
+ >>> some_dict[s] = 40
+ >>> some_dict
+ {'s': 40, 's': 42}
+ >>> keys = list(some_dict.keys())
+ >>> type(keys[0]), type(keys[1])
+ (__main__.SomeClass, str)
+ ```
+
+---
+
+### ▶ Let's see if you can guess this?
+
+```py
+a, b = a[b] = {}, 5
+```
+
+**Output:**
+```py
+>>> a
+{5: ({...}, 5)}
+```
+
+#### 💡 Explanation:
+
+* According to [Python language reference](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), assignment statements have the form
+ ```
+ (target_list "=")+ (expression_list | yield_expression)
+ ```
+ and
+
+> An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
+
+* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`).
+
+* After the expression list is evaluated, its value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`.
+
+* `a` is now assigned to `{}`, which is a mutable object.
+
+* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`).
+
+* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be
+ ```py
+ >>> some_list = some_list[0] = [0]
+ >>> some_list
+ [[...]]
+ >>> some_list[0]
+ [[...]]
+ >>> some_list is some_list[0]
+ True
+ >>> some_list[0][0][0][0][0][0] == some_list
+ True
+ ```
+ Similar is the case in our example (`a[b][0]` is the same object as `a`)
+
+* So to sum it up, you can break the example down to
+ ```py
+ a, b = {}, 5
+ a[b] = a, b
+ ```
+ And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a`
+ ```py
+ >>> a[b][0] is a
+ True
+ ```
+
+
+---
+
+### ▶ Exceeds the limit for integer string conversion
+```py
+>>> # Python 3.10.6
+>>> int("2" * 5432)
+
+>>> # Python 3.10.8
+>>> int("2" * 5432)
+```
+
+**Output:**
+```py
+>>> # Python 3.10.6
+222222222222222222222222222222222222222222222222222222222222222...
+
+>>> # Python 3.10.8
+Traceback (most recent call last):
+ ...
+ValueError: Exceeds the limit (4300) for integer string conversion:
+ value has 5432 digits; use sys.set_int_max_str_digits()
+ to increase the limit.
+```
+
+#### 💡 Explanation:
+This call to `int()` works fine in Python 3.10.6 and raises a ValueError in Python 3.10.8. Note that Python can still work with large integers. The error is only raised when converting between integers and strings.
+
+Fortunately, you can increase the limit for the allowed number of digits when you expect an operation to exceed it. To do this, you can use one of the following:
+- The -X int_max_str_digits command-line flag
+- The set_int_max_str_digits() function from the sys module
+- The PYTHONINTMAXSTRDIGITS environment variable
+
+[Check the documentation](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) for more details on changing the default limit if you expect your code to exceed this value.
+
+
+---
+
+
+## Section: Slippery Slopes
+
+### ▶ Modifying a dictionary while iterating over it
+
+```py
+x = {0: None}
+
+for i in x:
+ del x[i]
+ x[i+1] = None
+ print(i)
+```
+
+**Output (Python 2.7- Python 3.5):**
+
+```
+0
+1
+2
+3
+4
+5
+6
+7
+```
+
+Yes, it runs for exactly **eight** times and stops.
+
+#### 💡 Explanation:
+
+* Iteration over a dictionary that you edit at the same time is not supported.
+* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
+* How deleted keys are handled and when the resize occurs might be different for different Python implementations.
+* So for Python versions other than Python 2.7 - Python 3.5, the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread.
+* Python 3.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.
+
+---
+
+### ▶ Stubborn `del` operation
+
+
+
+```py
+class SomeClass:
+ def __del__(self):
+ print("Deleted!")
+```
+
+**Output:**
+1\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x # this should print "Deleted!"
+>>> del y
+Deleted!
+```
+
+Phew, deleted at last. You might have guessed what saved `__del__` from being called in our first attempt to delete `x`. Let's add more twists to the example.
+
+2\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x
+>>> y # check if y exists
+<__main__.SomeClass instance at 0x7f98a1a67fc8>
+>>> del y # Like previously, this should print "Deleted!"
+>>> globals() # oh, it didn't. Let's check all our global variables and confirm
+Deleted!
+{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}
+```
+
+Okay, now it's deleted :confused:
+
+#### 💡 Explanation:
++ `del x` doesn’t directly call `x.__del__()`.
++ When `del x` is encountered, Python deletes the name `x` from current scope and decrements by 1 the reference count of the object `x` referenced. `__del__()` is called only when the object's reference count reaches zero.
++ In the second output snippet, `__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object (specifically, the `_` magic variable which references the result value of the last non `None` expression on the REPL), thus preventing the reference count from reaching zero when `del y` was encountered.
++ Calling `globals` (or really, executing anything that will have a non `None` result) caused `_` to reference the new result, dropping the existing reference. Now the reference count reached 0 and we can see "Deleted!" being printed (finally!).
+
+---
+
+### ▶ The out of scope variable
+
+
+1\.
+```py
+a = 1
+def some_func():
+ return a
+
+def another_func():
+ a += 1
+ return a
+```
+
+2\.
+```py
+def some_closure_func():
+ a = 1
+ def some_inner_func():
+ return a
+ return some_inner_func()
+
+def another_closure_func():
+ a = 1
+ def another_inner_func():
+ a += 1
+ return a
+ return another_inner_func()
+```
+
+**Output:**
+```py
+>>> some_func()
+1
+>>> another_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+
+>>> some_closure_func()
+1
+>>> another_closure_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+```
+
+#### 💡 Explanation:
+* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error.
+* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword.
+ ```py
+ def another_func()
+ global a
+ a += 1
+ return a
+ ```
+
+ **Output:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+* In `another_closure_func`, `a` becomes local to the scope of `another_inner_func`, but it has not been initialized previously in the same scope, which is why it throws an error.
+* To modify the outer scope variable `a` in `another_inner_func`, use the `nonlocal` keyword. The nonlocal statement is used to refer to variables defined in the nearest outer (excluding the global) scope.
+ ```py
+ def another_func():
+ a = 1
+ def another_inner_func():
+ nonlocal a
+ a += 1
+ return a
+ return another_inner_func()
+ ```
+
+ **Output:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+* The keywords `global` and `nonlocal` tell the python interpreter to not declare new variables and look them up in the corresponding outer scopes.
+* Read [this](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.
+
+---
+
+### ▶ Deleting a list item while iterating
+
+```py
+list_1 = [1, 2, 3, 4]
+list_2 = [1, 2, 3, 4]
+list_3 = [1, 2, 3, 4]
+list_4 = [1, 2, 3, 4]
+
+for idx, item in enumerate(list_1):
+ del item
+
+for idx, item in enumerate(list_2):
+ list_2.remove(item)
+
+for idx, item in enumerate(list_3[:]):
+ list_3.remove(item)
+
+for idx, item in enumerate(list_4):
+ list_4.pop(idx)
+```
+
+**Output:**
+```py
+>>> list_1
+[1, 2, 3, 4]
+>>> list_2
+[2, 4]
+>>> list_3
+[]
+>>> list_4
+[2, 4]
+```
+
+Can you guess why the output is `[2, 4]`?
+
+#### 💡 Explanation:
+
+* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that.
+
+ ```py
+ >>> some_list = [1, 2, 3, 4]
+ >>> id(some_list)
+ 139798789457608
+ >>> id(some_list[:]) # Notice that python creates new object for sliced list.
+ 139798779601192
+ ```
+
+**Difference between `del`, `remove`, and `pop`:**
+* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected).
+* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found.
+* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified.
+
+**Why the output is `[2, 4]`?**
+- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence.
+
+* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example
+* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python.
+
+---
+
+
+### ▶ Lossy zip of iterators *
+
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three))
+[(0, 0), (1, 1), (2, 2)]
+# so far so good, let's zip the remaining
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Where did element `3` go from the `numbers` list?
+
+#### 💡 Explanation:
+
+- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,
+ ```py
+ def zip(*iterables):
+ sentinel = object()
+ iterators = [iter(it) for it in iterables]
+ while iterators:
+ result = []
+ for it in iterators:
+ elem = next(it, sentinel)
+ if elem is sentinel: return
+ result.append(elem)
+ yield tuple(result)
+ ```
+- So the function takes in arbitrary number of iterable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted.
+- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.
+- The correct way to do the above using `zip` would be,
+ ```py
+ >>> numbers = list(range(7))
+ >>> numbers_iter = iter(numbers)
+ >>> list(zip(first_three, numbers_iter))
+ [(0, 0), (1, 1), (2, 2)]
+ >>> list(zip(remaining, numbers_iter))
+ [(3, 3), (4, 4), (5, 5), (6, 6)]
+ ```
+ The first argument of zip should be the one with fewest elements.
+
+---
+
+### ▶ Loop variables leaking out!
+
+1\.
+```py
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Output:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+But `x` was never defined outside the scope of for loop...
+
+2\.
+```py
+# This time let's initialize x first
+x = -1
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Output:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+3\.
+
+**Output (Python 2.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+4
+```
+
+**Output (Python 3.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+1
+```
+
+#### 💡 Explanation:
+
+- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable.
+
+- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog:
+
+ > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope."
+
+---
+
+### ▶ Beware of default mutable arguments!
+
+
+```py
+def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+```
+
+**Output:**
+```py
+>>> some_func()
+['some_string']
+>>> some_func()
+['some_string', 'some_string']
+>>> some_func([])
+['some_string']
+>>> some_func()
+['some_string', 'some_string', 'some_string']
+```
+
+#### 💡 Explanation:
+
+- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected.
+
+ ```py
+ def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+ **Output:**
+ ```py
+ >>> some_func.__defaults__ #This will show the default argument values for the function
+ ([],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string'],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ >>> some_func([])
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ ```
+
+- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example:
+
+ ```py
+ def some_func(default_arg=None):
+ if default_arg is None:
+ default_arg = []
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+---
+
+### ▶ Catching the Exceptions
+
+```py
+some_list = [1, 2, 3]
+try:
+ # This should raise an ``IndexError``
+ print(some_list[4])
+except IndexError, ValueError:
+ print("Caught!")
+
+try:
+ # This should raise a ``ValueError``
+ some_list.remove(4)
+except IndexError, ValueError:
+ print("Caught again!")
+```
+
+**Output (Python 2.x):**
+```py
+Caught!
+
+ValueError: list.remove(x): x not in list
+```
+
+**Output (Python 3.x):**
+```py
+ File "", line 3
+ except IndexError, ValueError:
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Explanation
+
+* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,
+ ```py
+ some_list = [1, 2, 3]
+ try:
+ # This should raise a ``ValueError``
+ some_list.remove(4)
+ except (IndexError, ValueError), e:
+ print("Caught again!")
+ print(e)
+ ```
+ **Output (Python 2.x):**
+ ```
+ Caught again!
+ list.remove(x): x not in list
+ ```
+ **Output (Python 3.x):**
+ ```py
+ File "", line 4
+ except (IndexError, ValueError), e:
+ ^
+ IndentationError: unindent does not match any outer indentation level
+ ```
+
+* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,
+ ```py
+ some_list = [1, 2, 3]
+ try:
+ some_list.remove(4)
+
+ except (IndexError, ValueError) as e:
+ print("Caught again!")
+ print(e)
+ ```
+ **Output:**
+ ```
+ Caught again!
+ list.remove(x): x not in list
+ ```
+
+---
+
+### ▶ Same operands, different story!
+
+1\.
+```py
+a = [1, 2, 3, 4]
+b = a
+a = a + [5, 6, 7, 8]
+```
+
+**Output:**
+```py
+>>> a
+[1, 2, 3, 4, 5, 6, 7, 8]
+>>> b
+[1, 2, 3, 4]
+```
+
+2\.
+```py
+a = [1, 2, 3, 4]
+b = a
+a += [5, 6, 7, 8]
+```
+
+**Output:**
+```py
+>>> a
+[1, 2, 3, 4, 5, 6, 7, 8]
+>>> b
+[1, 2, 3, 4, 5, 6, 7, 8]
+```
+
+#### 💡 Explanation:
+
+* `a += b` doesn't always behave the same way as `a = a + b`. Classes *may* implement the *`op=`* operators differently, and lists do this.
+
+* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.
+
+* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.
+
+---
+
+### ▶ Name resolution ignoring class scope
+
+1\.
+```py
+x = 5
+class SomeClass:
+ x = 17
+ y = (x for i in range(10))
+```
+
+**Output:**
+```py
+>>> list(SomeClass.y)[0]
+5
+```
+
+2\.
+```py
+x = 5
+class SomeClass:
+ x = 17
+ y = [x for i in range(10)]
+```
+
+**Output (Python 2.x):**
+```py
+>>> SomeClass.y[0]
+17
+```
+
+**Output (Python 3.x):**
+```py
+>>> SomeClass.y[0]
+5
+```
+
+#### 💡 Explanation
+- Scopes nested inside class definition ignore names bound at the class level.
+- A generator expression has its own scope.
+- Starting from Python 3.X, list comprehensions also have their own scope.
+
+---
+
+### ▶ Rounding like a banker *
+
+Let's implement a naive function to get the middle element of a list:
+```py
+def get_middle(some_list):
+ mid_index = round(len(some_list) / 2)
+ return some_list[mid_index - 1]
+```
+
+**Python 3.x:**
+```py
+>>> get_middle([1]) # looks good
+1
+>>> get_middle([1,2,3]) # looks good
+2
+>>> get_middle([1,2,3,4,5]) # huh?
+2
+>>> len([1,2,3,4,5]) / 2 # good
+2.5
+>>> round(len([1,2,3,4,5]) / 2) # why?
+2
+```
+It seems as though Python rounded 2.5 to 2.
+
+#### 💡 Explanation:
+
+- This is not a float precision error, in fact, this behavior is intentional. Since Python 3.0, `round()` uses [banker's rounding](https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even) where .5 fractions are rounded to the nearest **even** number:
+
+```py
+>>> round(0.5)
+0
+>>> round(1.5)
+2
+>>> round(2.5)
+2
+>>> import numpy # numpy does the same
+>>> numpy.round(0.5)
+0.0
+>>> numpy.round(1.5)
+2.0
+>>> numpy.round(2.5)
+2.0
+```
+
+- This is the recommended way to round .5 fractions as described in [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Rounding_rules). However, the other way (round away from zero) is taught in school most of the time, so banker's rounding is likely not that well known. Furthermore, some of the most popular programming languages (for example: JavaScript, Java, C/C++, Ruby, Rust) do not use banker's rounding either. Therefore, this is still quite special to Python and may result in confusion when rounding fractions.
+- See the [round() docs](https://docs.python.org/3/library/functions.html#round) or [this stackoverflow thread](https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior) for more information.
+- Note that `get_middle([1])` only returned 1 because the index was `round(0.5) - 1 = 0 - 1 = -1`, returning the last element in the list.
+
+---
+
+### ▶ Needles in a Haystack *
+
+
+
+I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,
+
+1\.
+
+```py
+x, y = (0, 1) if True else None, None
+```
+
+**Output:**
+
+```py
+>>> x, y # expected (0, 1)
+((0, 1), None)
+```
+
+2\.
+
+```py
+t = ('one', 'two')
+for i in t:
+ print(i)
+
+t = ('one')
+for i in t:
+ print(i)
+
+t = ()
+print(t)
+```
+
+**Output:**
+
+```py
+one
+two
+o
+n
+e
+tuple()
+```
+
+3\.
+
+```
+ten_words_list = [
+ "some",
+ "very",
+ "big",
+ "list",
+ "that"
+ "consists",
+ "of",
+ "exactly",
+ "ten",
+ "words"
+]
+```
+
+**Output**
+
+```py
+>>> len(ten_words_list)
+9
+```
+
+4\. Not asserting strongly enough
+
+```py
+a = "python"
+b = "javascript"
+```
+
+**Output:**
+
+```py
+# An assert statement with an assertion failure message.
+>>> assert(a == b, "Both languages are different")
+# No AssertionError is raised
+```
+
+5\.
+
+```py
+some_list = [1, 2, 3]
+some_dict = {
+ "key_1": 1,
+ "key_2": 2,
+ "key_3": 3
+}
+
+some_list = some_list.append(4)
+some_dict = some_dict.update({"key_4": 4})
+```
+
+**Output:**
+
+```py
+>>> print(some_list)
+None
+>>> print(some_dict)
+None
+```
+
+6\.
+
+```py
+def some_recursive_func(a):
+ if a[0] == 0:
+ return
+ a[0] -= 1
+ some_recursive_func(a)
+ return a
+
+def similar_recursive_func(a):
+ if a == 0:
+ return a
+ a -= 1
+ similar_recursive_func(a)
+ return a
+```
+
+**Output:**
+
+```py
+>>> some_recursive_func([5, 0])
+[0, 0]
+>>> similar_recursive_func(5)
+4
+```
+
+#### 💡 Explanation:
+
+* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.
+
+* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character.
+
+* `()` is a special token and denotes empty `tuple`.
+
+* In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation,
+
+ ```py
+ >>> ten_words_list
+ ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
+ ```
+
+* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,
+
+ ```py
+ >>> a = "python"
+ >>> b = "javascript"
+ >>> assert a == b
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError
+
+ >>> assert (a == b, "Values are not equal")
+ :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+ >>> assert a == b, "Values are not equal"
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError: Values are not equal
+ ```
+
+* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+
+* Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignment of an immutable (`a -= 1`) is not an alteration of the value.
+
+* Being aware of these nitpicks can save you hours of debugging effort in the long run.
+
+---
+
+
+### ▶ Splitsies *
+
+```py
+>>> 'a'.split()
+['a']
+
+# is same as
+>>> 'a'.split(' ')
+['a']
+
+# but
+>>> len(''.split())
+0
+
+# isn't the same as
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Explanation:
+
+- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split)
+ > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
+ > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
+- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
+ ```py
+ >>> ' a '.split(' ')
+ ['', 'a', '']
+ >>> ' a '.split()
+ ['a']
+ >>> ''.split(' ')
+ ['']
+ ```
+
+---
+
+### ▶ Wild imports *
+
+
+
+```py
+# File: module.py
+
+def some_weird_name_func_():
+ print("works!")
+
+def _another_weird_name_func():
+ print("works!")
+
+```
+
+**Output**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Explanation:
+
+- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime.
+- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred.
+ ```py
+ >>> from module import some_weird_name_func_, _another_weird_name_func
+ >>> _another_weird_name_func()
+ works!
+ ```
+- If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports.
+ ```py
+ __all__ = ['_another_weird_name_func']
+
+ def some_weird_name_func_():
+ print("works!")
+
+ def _another_weird_name_func():
+ print("works!")
+ ```
+ **Output**
+
+ ```py
+ >>> _another_weird_name_func()
+ "works!"
+ >>> some_weird_name_func_()
+ Traceback (most recent call last):
+ File "", line 1, in
+ NameError: name 'some_weird_name_func_' is not defined
+ ```
+
+---
+
+### ▶ All sorted? *
+
+
+
+```py
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
+
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
+```
+
+#### 💡 Explanation:
+
+- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python.
+
+- ```py
+ >>> [] == tuple()
+ False
+ >>> x = 7, 8, 9
+ >>> type(x), type(sorted(x))
+ (tuple, list)
+ ```
+
+- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first.
+
+- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list.
+
+ ```py
+ >>> x = 7, 8, 9
+ >>> y = reversed(x)
+ >>> sorted(y), sorted(y)
+ ([7, 8, 9], [])
+ ```
+
+---
+
+### ▶ Midnight time doesn't exist?
+
+```py
+from datetime import datetime
+
+midnight = datetime(2018, 1, 1, 0, 0)
+midnight_time = midnight.time()
+
+noon = datetime(2018, 1, 1, 12, 0)
+noon_time = noon.time()
+
+if midnight_time:
+ print("Time at midnight is", midnight_time)
+
+if noon_time:
+ print("Time at noon is", noon_time)
+```
+
+**Output (< 3.5):**
+
+```py
+('Time at noon is', datetime.time(12, 0))
+```
+The midnight time is not printed.
+
+#### 💡 Explanation:
+
+Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of "empty."
+
+---
+---
+
+
+
+## Section: The Hidden treasures!
+
+This section contains a few lesser-known and interesting things about Python that most beginners like me are unaware of (well, not anymore).
+
+### ▶ Okay Python, Can you make me fly?
+
+Well, here you go
+
+```py
+import antigravity
+```
+
+**Output:**
+Sshh... It's a super-secret.
+
+#### 💡 Explanation:
++ `antigravity` module is one of the few easter eggs released by Python developers.
++ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python.
++ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/).
+
+---
+
+### ▶ `goto`, but why?
+
+
+```py
+from goto import goto, label
+for i in range(9):
+ for j in range(9):
+ for k in range(9):
+ print("I am trapped, please rescue!")
+ if k == 2:
+ goto .breakout # breaking out from a deeply nested loop
+label .breakout
+print("Freedom!")
+```
+
+**Output (Python 2.3):**
+```py
+I am trapped, please rescue!
+I am trapped, please rescue!
+Freedom!
+```
+
+#### 💡 Explanation:
+- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004.
+- Current versions of Python do not have this module.
+- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python.
+
+---
+
+### ▶ Brace yourself!
+
+If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing,
+
+```py
+from __future__ import braces
+```
+
+**Output:**
+```py
+ File "some_file.py", line 1
+ from __future__ import braces
+SyntaxError: not a chance
+```
+
+Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)?
+
+#### 💡 Explanation:
++ The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however, ironic.
++ This is an easter egg concerned with the community's feelings on this issue.
++ The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file.
++ When the CPython compiler encounters a [future statement](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), it first runs the appropriate code in `future.c` before treating it as a normal import statement.
+
+---
+
+### ▶ Let's meet Friendly Language Uncle For Life
+
+**Output (Python 3.x)**
+```py
+>>> from __future__ import barry_as_FLUFL
+>>> "Ruby" != "Python" # there's no doubt about it
+ File "some_file.py", line 1
+ "Ruby" != "Python"
+ ^
+SyntaxError: invalid syntax
+
+>>> "Ruby" <> "Python"
+True
+```
+
+There we go.
+
+#### 💡 Explanation:
+- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means).
+- Quoting from the PEP-401
+
+ > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.
+- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/).
+- It works well in an interactive environment, but it will raise a `SyntaxError` when you run via python file (see this [issue](https://github.com/satwikkansal/wtfpython/issues/94)). However, you can wrap the statement inside an `eval` or `compile` to get it working,
+ ```py
+ from __future__ import barry_as_FLUFL
+ print(eval('"Ruby" <> "Python"'))
+ ```
+
+---
+
+### ▶ Even Python understands that love is complicated
+
+```py
+import this
+```
+
+Wait, what's **this**? `this` is love :heart:
+
+**Output:**
+```
+The Zen of Python, by Tim Peters
+
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it.
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than *right* now.
+If the implementation is hard to explain, it's a bad idea.
+If the implementation is easy to explain, it may be a good idea.
+Namespaces are one honking great idea -- let's do more of those!
+```
+
+It's the Zen of Python!
+
+```py
+>>> love = this
+>>> this is love
+True
+>>> love is True
+False
+>>> love is False
+False
+>>> love is not True or False
+True
+>>> love is not True or False; love is love # Love is complicated
+True
+```
+
+#### 💡 Explanation:
+
+* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
+* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, **the code for the Zen violates itself** (and that's probably the only place where this happens).
+* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory (if not, please see the examples related to `is` and `is not` operators).
+
+---
+
+### ▶ Yes, it exists!
+
+**The `else` clause for loops.** One typical example might be:
+
+```py
+ def does_exists_num(l, to_find):
+ for num in l:
+ if num == to_find:
+ print("Exists!")
+ break
+ else:
+ print("Does not exist")
+```
+
+**Output:**
+```py
+>>> some_list = [1, 2, 3, 4, 5]
+>>> does_exists_num(some_list, 4)
+Exists!
+>>> does_exists_num(some_list, -1)
+Does not exist
+```
+
+**The `else` clause in exception handling.** An example,
+
+```py
+try:
+ pass
+except:
+ print("Exception occurred!!!")
+else:
+ print("Try block executed successfully...")
+```
+
+**Output:**
+```py
+Try block executed successfully...
+```
+
+#### 💡 Explanation:
+- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. You can think of it as a "nobreak" clause.
+- `else` clause after a try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
+
+---
+### ▶ Ellipsis *
+
+```py
+def some_func():
+ Ellipsis
+```
+
+**Output**
+```py
+>>> some_func()
+# No output, No Error
+
+>>> SomeRandomString
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Explanation
+- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`.
+ ```py
+ >>> ...
+ Ellipsis
+ ```
+- Ellipsis can be used for several purposes,
+ + As a placeholder for code that hasn't been written yet (just like `pass` statement)
+ + In slicing syntax to represent the full slices in remaining direction
+ ```py
+ >>> import numpy as np
+ >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
+ array([
+ [
+ [0, 1],
+ [2, 3]
+ ],
+
+ [
+ [4, 5],
+ [6, 7]
+ ]
+ ])
+ ```
+ So our `three_dimensional_array` is an array of array of arrays. Let's say we want to print the second element (index `1`) of all the innermost arrays, we can use Ellipsis to bypass all the preceding dimensions
+ ```py
+ >>> three_dimensional_array[:,:,1]
+ array([[1, 3],
+ [5, 7]])
+ >>> three_dimensional_array[..., 1] # using Ellipsis.
+ array([[1, 3],
+ [5, 7]])
+ ```
+ Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`)
+ + In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`))
+ + You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the "no argument passed" and "None value passed" scenarios).
+
+---
+
+### ▶ Inpinity
+
+The spelling is intended. Please, don't submit a patch for this.
+
+**Output (Python 3.x):**
+```py
+>>> infinity = float('infinity')
+>>> hash(infinity)
+314159
+>>> hash(float('-inf'))
+-314159
+```
+
+#### 💡 Explanation:
+- Hash of infinity is 10⁵ x π.
+- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2.
+
+---
+
+### ▶ Let's mangle
+
+1\.
+```py
+class Yo(object):
+ def __init__(self):
+ self.__honey = True
+ self.bro = True
+```
+
+**Output:**
+```py
+>>> Yo().bro
+True
+>>> Yo().__honey
+AttributeError: 'Yo' object has no attribute '__honey'
+>>> Yo()._Yo__honey
+True
+```
+
+2\.
+```py
+class Yo(object):
+ def __init__(self):
+ # Let's try something symmetrical this time
+ self.__honey__ = True
+ self.bro = True
+```
+
+**Output:**
+```py
+>>> Yo().bro
+True
+
+>>> Yo()._Yo__honey__
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
+Why did `Yo()._Yo__honey` work?
+
+3\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+ def some_func(self):
+ return __variable # not initialized anywhere yet
+```
+
+**Output:**
+```py
+>>> A().__variable
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> A().some_func()
+'Some value'
+```
+
+
+#### 💡 Explanation:
+
+* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces.
+* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore a.k.a "dunder") and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front.
+* So, to access `__honey` attribute in the first snippet, we had to append `_Yo` to the front, which would prevent conflicts with the same name attribute defined in any other class.
+* But then why didn't it work in the second snippet? Because name mangling excludes the names ending with double underscores.
+* The third snippet was also a consequence of name mangling. The name `__variable` in the statement `return __variable` was mangled to `_A__variable`, which also happens to be the name of the variable we declared in the outer scope.
+* Also, if the mangled name is longer than 255 characters, truncation will happen.
+
+---
+---
+
+## Section: Appearances are deceptive!
+
+### ▶ Skipping lines?
+
+**Output:**
+```py
+>>> value = 11
+>>> valuе = 32
+>>> value
+11
+```
+
+Wut?
+
+**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.
+
+#### 💡 Explanation
+
+Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.
+
+```py
+>>> ord('е') # cyrillic 'e' (Ye)
+1077
+>>> ord('e') # latin 'e', as used in English and typed using standard keyboard
+101
+>>> 'е' == 'e'
+False
+
+>>> value = 42 # latin e
+>>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here
+>>> value
+42
+```
+
+The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.
+
+---
+
+### ▶ Teleportation
+
+
+
+```py
+# `pip install numpy` first.
+import numpy as np
+
+def energy_send(x):
+ # Initializing a numpy array
+ np.array([float(x)])
+
+def energy_receive():
+ # Return an empty numpy array
+ return np.empty((), dtype=np.float).tolist()
+```
+
+**Output:**
+```py
+>>> energy_send(123.456)
+>>> energy_receive()
+123.456
+```
+
+Where's the Nobel Prize?
+
+#### 💡 Explanation:
+
+* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate.
+* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).
+
+---
+
+### ▶ Well, something is fishy...
+
+```py
+def square(x):
+ """
+ A simple function to calculate the square of a number by addition.
+ """
+ sum_so_far = 0
+ for counter in range(x):
+ sum_so_far = sum_so_far + x
+ return sum_so_far
+```
+
+**Output (Python 2.x):**
+
+```py
+>>> square(10)
+10
+```
+
+Shouldn't that be 100?
+
+**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.
+
+#### 💡 Explanation
+
+* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.
+* This is how Python handles tabs:
+
+ > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
+* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.
+* Python 3 is kind enough to throw an error for such cases automatically.
+
+ **Output (Python 3.x):**
+ ```py
+ TabError: inconsistent use of tabs and spaces in indentation
+ ```
+
+---
+---
+
+## Section: Miscellaneous
+
+
+### ▶ `+=` is faster
+
+
+```py
+# using "+", three strings:
+>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.25748300552368164
+# using "+=", three strings:
+>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.012188911437988281
+```
+
+#### 💡 Explanation:
++ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string.
+
+---
+
+### ▶ Let's make a giant string!
+
+```py
+def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s += "xyz"
+ assert len(s) == 3*iters
+
+def add_bytes_with_plus(iters):
+ s = b""
+ for i in range(iters):
+ s += b"xyz"
+ assert len(s) == 3*iters
+
+def add_string_with_format(iters):
+ fs = "{}"*iters
+ s = fs.format(*(["xyz"]*iters))
+ assert len(s) == 3*iters
+
+def add_string_with_join(iters):
+ l = []
+ for i in range(iters):
+ l.append("xyz")
+ s = "".join(l)
+ assert len(s) == 3*iters
+
+def convert_list_to_string(l, iters):
+ s = "".join(l)
+ assert len(s) == 3*iters
+```
+
+**Output:**
+
+```py
+# Executed in ipython shell using %timeit for better readability of results.
+# You can also use the timeit module in normal python shell/scriptm=, example usage below
+# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())
+
+>>> NUM_ITERS = 1000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
+124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
+211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
+61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
+117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
+10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+Let's increase the number of iterations by a factor of 10.
+
+```py
+>>> NUM_ITERS = 10000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time
+1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # Quadratic increase
+6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # Linear increase
+645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # Linear increase
+1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # Linear increase
+86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+#### 💡 Explanation
+- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) on these links. They are used to measure the execution time of code pieces.
+- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function)
+- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings).
+- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster.
+- Unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example, `add_string_with_plus` didn't show a quadratic increase in execution time. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic.
+ ```py
+ def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s = s + "x" + "y" + "z"
+ assert len(s) == 3*iters
+
+ >>> %timeit -n100 add_string_with_plus(1000)
+ 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+ >>> %timeit -n100 add_string_with_plus(10000) # Quadratic increase in execution time
+ 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+ ```
+- So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which,
+
+ > There should be one-- and preferably only one --obvious way to do it.
+
+---
+
+### ▶ Slowing down `dict` lookups *
+
+```py
+some_dict = {str(i): 1 for i in range(1_000_000)}
+another_dict = {str(i): 1 for i in range(1_000_000)}
+```
+
+**Output:**
+```py
+>>> %timeit some_dict['5']
+28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> some_dict[1] = 1
+>>> %timeit some_dict['5']
+37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+>>> %timeit another_dict['5']
+28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> another_dict[1] # Trying to access a key that doesn't exist
+Traceback (most recent call last):
+ File "", line 1, in
+KeyError: 1
+>>> %timeit another_dict['5']
+38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+```
+Why are same lookups becoming slower?
+
+#### 💡 Explanation:
++ CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys.
++ The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method.
++ The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function.
++ This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect.
+
+
+### ▶ Bloating instance `dict`s *
+
+```py
+import sys
+
+class SomeClass:
+ def __init__(self):
+ self.some_attr1 = 1
+ self.some_attr2 = 2
+ self.some_attr3 = 3
+ self.some_attr4 = 4
+
+
+def dict_size(o):
+ return sys.getsizeof(o.__dict__)
+
+```
+
+**Output:** (Python 3.8, other Python 3 versions may vary a little)
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104
+>>> dict_size(o2)
+104
+>>> del o1.some_attr1
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+>>> dict_size(o1)
+232
+```
+
+Let's try again... In a new interpreter:
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104 # as expected
+>>> o1.some_attr5 = 5
+>>> o1.some_attr6 = 6
+>>> dict_size(o1)
+360
+>>> dict_size(o2)
+272
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+```
+
+What makes those dictionaries become bloated? And why are newly created objects bloated as well?
+
+#### 💡 Explanation:
++ CPython is able to reuse the same "keys" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances.
++ This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken.
++ Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is "unshared", and key-sharing is disabled for all future instances of the same class.
++ Additionally, if the dictionary keys have been resized (because new keys are inserted), they are kept shared *only* if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys.
++ A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`!
+
+
+### ▶ Minor Ones *
+
+* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
+
+ **💡 Explanation:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API.
+
+* Few weird looking but semantically correct statements:
+ + `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`)
+ + `'a'[0][0][0][0][0]` is also semantically correct, because Python doesn't have a character data type like other languages branched from C. So selecting a single character from a string returns a single-character string.
+ + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`.
+
+* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++, or Java.
+ ```py
+ >>> a = 5
+ >>> a
+ 5
+ >>> ++a
+ 5
+ >>> --a
+ 5
+ ```
+
+ **💡 Explanation:**
+ + There is no `++` operator in Python grammar. It is actually two `+` operators.
+ + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified.
+ + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python.
+
+* You must be aware of the Walrus operator in Python. But have you ever heard about *the space-invader operator*?
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+ It is used as an alternative incrementation operator, together with another one
+ ```py
+ >>> a +=+ 1
+ >>> a
+ >>> 44
+ ```
+ **💡 Explanation:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
+
+* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator.
+
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+* Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real).
+
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
+
+* From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example,
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!):
+
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+* Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module.
+
+* Sometimes, the `print` method might not print values immediately. For example,
+
+ ```py
+ # File some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
+
+ This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.
+
+* List slicing with out of the bounds indices throws no errors
+ ```py
+ >>> some_list = [1, 2, 3, 4, 5]
+ >>> some_list[111:]
+ []
+ ```
+
+* Slicing an iterable not always creates a new object. For example,
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # False expected because a new object is created.
+ False
+ >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use.
+ True
+ ```
+
+* `int('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.
+
+* You can separate numeric literals with underscores (for better readability) from Python 3 onwards.
+
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
+ ```py
+ def count(s, sub):
+ result = 0
+ for i in range(len(s) + 1 - len(sub)):
+ result += (s[i:i + len(sub)] == sub)
+ return result
+ ```
+ The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.
+
+---
+---
+
+# Contributing
+
+A few ways in which you can contribute to wtfpython,
+
+- Suggesting new examples
+- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))
+- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc.
+- Identifying gaps (things like inadequate explanation, redundant examples, etc.)
+- Any creative suggestions to make this project more fun and useful
+
+Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things.
+
+PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project.
+
+# Acknowledgements
+
+The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now.
+
+#### Some nice Links!
+* https://www.youtube.com/watch?v=sH4XF6pKKmk
+* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+* https://sopython.com/wiki/Common_Gotchas_In_Python
+* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+* https://www.python.org/doc/humor/
+* https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+* WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
+
+# 🎓 License
+
+[![WTFPL 2.0][license-image]][license-url]
+
+© [Satwik Kansal](https://satwikkansal.xyz)
+
+[license-url]: http://www.wtfpl.net
+[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
+
+## Surprise your friends as well!
+
+If you like wtfpython, you can use these quick links to share it with your friends,
+
+[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+
+## Need a pdf version?
+
+I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://form.jotform.com/221593245656057) to get them as soon as they are finished.
+
+
+**That's all folks!** For upcoming content like this, you can add your email [here](https://form.jotform.com/221593598380062).
diff --git a/docs/VI.md b/docs/VI.md
new file mode 100644
index 0000000..989f684
--- /dev/null
+++ b/docs/VI.md
@@ -0,0 +1,3531 @@
+---
+hide:
+ - toc
+---
+
+
+What the f*ck Python! 😱
+
+English
+| Tiếng Việt
+
+Cùng khám phá và tìm hiểu Python thông qua các đoạn mã khiến bạn bất ngờ.
+
+
+
+Các bản dịch tiếng nước ngoài khác: [Tiếng Trung 中文](https://github.com/leisurelicht/wtfpython-cn) | [Thêm bản dịch](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
+
+Bạn có thể tham khảo các đoạn mã với: [Chế độ trực quan](https://colab.research.google.com/github/vuduclyunitn/wtfptyhon-vi/blob/master/irrelevant/wtf.ipynb) | [Giao diện dòng lệnh](https://pypi.python.org/pypi/wtfpython)
+
+
+Python là một ngôn ngữ cấp cao, với các mã được thông dịch thay vì biên dịch như các ngôn ngữ khác như C hay Java. Python có rất nhiều các tính năng giúp việc lập trình dễ dàng, thuận tiện. Tuy nhiên, các đoạn mã viết bằng Python thỉnh thoảng cho ra kết quả không rõ ràng, gây khó hiểu khi mới nhìn vào.
+
+
+wtfpython được tạo ra với mong muốn giải thích chính xác cách hoạt động của các đoạn mã thoạt nhìn khó hiểu và các tính năng ít được biết tới trong Python.
+
+
+Một vài ví dụ có thể không làm bạn quá ngạc nhiên, tuy vậy bạn sẽ khám phá được những điều hay ho về Python mà có thể bạn chưa từng biết tới. Học lập trình thông qua những ví dụ như vậy giúp bạn hiểu sâu hơn những thứ nằm bên trong của một ngôn ngữ lập trình, khi đó bạn sẽ thấy hứng thú hơn trong quá trình học.
+
+
+Nếu độc giả là một lập trình viên có thâm niên, hãy thử thức mình với các đoạn mã sắp tới, cố gắng làm đúng mỗi thử thách ngay trong lần đầu tiên. Độc giả có thể đã thử quả một vài trong số các bài toán trước đó, đọc và làm các bài toán dưới đây có thể giúp bạn ôn lại chúng.
+
+
+PS: Nếu bạn đã đọc bài này trước đó, bạn có thể muốn xem những thay đổi mới [ở đây](https://github.com/satwikkansal/wtfpython/releases/).
+
+
+
+Nào ta bắt đầu ...
+
+# Những nội dung chính
+
+
+
+
+- [Cấu trúc của các ví dụ](#structure-of-the-examples)
+ + [▶ Some fancy Title](#-some-fancy-title)
+- [Cách sử dụng](#usage)
+- [👀 Các ví dụ](#-examples)
+ * [Section: Strain your brain!](#section-strain-your-brain)
+ + [▶ First things first! *](#-first-things-first-)
+ + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
+ + [▶ Be careful with chained operations](#-be-careful-with-chained-operations)
+ + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
+ + [▶ Hash brownies](#-hash-brownies)
+ + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)
+ + [▶ Disorder within order *](#-disorder-within-order-)
+ + [▶ Keep trying... *](#-keep-trying-)
+ + [▶ For what?](#-for-what)
+ + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
+ + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+ + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+ + [▶ The sticky output function](#-the-sticky-output-function)
+ + [▶ The chicken-egg problem *](#-the-chicken-egg-problem-)
+ + [▶ Subclass relationships](#-subclass-relationships)
+ + [▶ All-true-ation *](#-all-true-ation-)
+ + [▶ The surprising comma](#-the-surprising-comma)
+ + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
+ + [▶ not knot!](#-not-knot)
+ + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
+ + [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)
+ + [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes)
+ + [▶ Non-reflexive class method *](#-non-reflexive-class-method-)
+ + [▶ yielding None](#-yielding-none)
+ + [▶ Yielding from... return! *](#-yielding-from-return-)
+ + [▶ Nan-reflexivity *](#-nan-reflexivity-)
+ + [▶ Mutating the immutable!](#-mutating-the-immutable)
+ + [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)
+ + [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion)
+ + [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this)
+ * [Section: Slippery Slopes](#section-slippery-slopes)
+ + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
+ + [▶ Stubborn `del` operation](#-stubborn-del-operation)
+ + [▶ The out of scope variable](#-the-out-of-scope-variable)
+ + [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)
+ + [▶ Lossy zip of iterators *](#-lossy-zip-of-iterators-)
+ + [▶ Loop variables leaking out!](#-loop-variables-leaking-out)
+ + [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)
+ + [▶ Catching the Exceptions](#-catching-the-exceptions)
+ + [▶ Same operands, different story!](#-same-operands-different-story)
+ + [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope)
+ + [▶ Needles in a Haystack *](#-needles-in-a-haystack-)
+ + [▶ Splitsies *](#-splitsies-)
+ + [▶ Wild imports *](#-wild-imports-)
+ + [▶ All sorted? *](#-all-sorted-)
+ + [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)
+ * [Section: The Hidden treasures!](#section-the-hidden-treasures)
+ + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
+ + [▶ `goto`, but why?](#-goto-but-why)
+ + [▶ Brace yourself!](#-brace-yourself)
+ + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
+ + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
+ + [▶ Yes, it exists!](#-yes-it-exists)
+ + [▶ Ellipsis *](#-ellipsis-)
+ + [▶ Inpinity](#-inpinity)
+ + [▶ Let's mangle](#-lets-mangle)
+ * [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
+ + [▶ Skipping lines?](#-skipping-lines)
+ + [▶ Teleportation](#-teleportation)
+ + [▶ Well, something is fishy...](#-well-something-is-fishy)
+ * [Section: Miscellaneous](#section-miscellaneous)
+ + [▶ `+=` is faster](#--is-faster)
+ + [▶ Let's make a giant string!](#-lets-make-a-giant-string)
+ + [▶ Minor Ones *](#-minor-ones-)
+- [Contributing](#contributing)
+- [Acknowledgements](#acknowledgements)
+- [🎓 License](#-license)
+ * [Surprise your friends as well!](#surprise-your-friends-as-well)
+ * [More content like this?](#more-content-like-this)
+
+
+
+# Cấu trúc của các ví dụ
+
+Tất cả các các ví dụ được trình bày với cấu trúc như sau:
+> ### ▶ Một tiêu đề hấp dẫn
+>
+> ```py
+> # Đoạn mã tạo dựng ví dụ.
+> # Đoạn mã chủ thể cần khám phá...
+> ```
+>
+> **Kết quả (Các phiên bản Python):**
+>
+> ```py
+> >>> câu lệnh kích hoạt?
+> Một vài kết quả bất ngờ, không như mong đợi
+> ```
+> (Có thể có hay không): Một dòng mô tả kết quả
+>
+>
+> #### 💡 Giải thích:
+>
+> * Giải thích những điều đang diễn ra và tại sao.
+> ```py
+> # Đoạn mã tạo dựng ví dụ
+> # Trong trường hợp cần thiết, chúng tôi liệt kê thêm nhiều ví dụ khác để giúp bạn hiểu rõ hơn
+> ```
+> **Kết quả (Các phiên bản Python):**
+>
+> ```py
+> >>> trigger # some example that makes it easy to unveil the magic
+> >>> trigger # Một vài ví dụ giúp bạn hiểu các đoạn mã
+> # some justified output
+> ```
+
+**Lưu ý:** Tất cả các ví dụ đã được chứng minh chạy thành công trên trình thông dịch Python 3.5.2 chế độ tương tác, với các phiên bản Python khác các ví dụ sẽ vẫn chạy bình thường, ngoại trừ một số ví dụ chúng tôi sẽ lưu ý trước phần kết quả.
+# Cách dùng các ví dụ
+
+Theo tôi, để học các ví dụ trong bài, bạn nên đọc theo trình tự thời gian, và đối với mỗi ví dụ hãy:
+- Đọc kĩ đoạn mã tạo dựng nên ví dụ. Nếu bạn đã lập trình lâu rồi, bạn sẽ đoán được những điều sắp tới ngay.
+- Đọc kết quả của các ví dụ và thực hiện hai việc sau:
+ + Kiểm tra xem kết quả có giống như bạn nghĩ hay không.
+ + Một khi đọc xong, hãy hỏi chính bạn xem mình đã hiểu thông suốt lý do mà có kết quả như vậy chưa.
+ - Nếu câu trả lời là "chưa, tôi chưa hiểu" (không sao cả), hít một hơi thật sau, và đọc phần giải thích (nếu bạn vẫn chưa hiểu, hãy tạo một issue [ở dây](https://github.com/satwikkansal/wtfpython/issues/new)).
+ - Nếu câu trả lời là "có, tôi đã hiểu", bạn có thể đọc ví dụ tiếp theo.
+PS: Bạn có thể đọc WTFPython dùng chế độ dòng lệnh sử dụng [pypi package](https://pypi.python.org/pypi/wtfpython),
+```sh
+$ pip install wtfpython -U
+$ wtfpython
+```
+---
+
+# 👀 Các ví dụ
+
+## Chương 1: Hack não!
+
+### ▶ Món khai vị! *
+
+
+
+
+Kí hiệu "con hà mã" ("Walrus" operator), được giới thiệu trong phiên bản Python 3.8 đã trở nên khá phổ biến vì một vài lý do. Hãy thử qua nó xem
+1\.
+
+```py
+# Phiên bản Python 3.8+
+
+>>> a = "wtf_walrus"
+>>> a
+'wtf_walrus'
+
+>>> a := "wtf_walrus"
+File "", line 1
+ a := "wtf_walrus"
+ ^
+SyntaxError: invalid syntax (Lỗi về cú pháp: Cú pháp không hợp lệ)
+
+>>> (a := "wtf_walrus") # This works though
+>>> a
+'wtf_walrus'
+```
+
+2 \.
+
+```py
+# Phiên bản Python 3.8+
+
+>>> a = 6, 9
+>>> a
+(6, 9)
+
+>>> (a := 6, 9)
+>>> a
+6
+
+>>> a, b = 6, 9 # Phân rã (unpacking) các giá trị, hay còn gọi là câu lệnh gán đa giá trị (multiple assignments)
+>>> a, b
+(6, 9)
+>>> (a, b = 16, 19) # Có
+ File "", line 1
+ (a, b = 6, 9)
+ ^
+SyntaxError: invalid syntax (Lỗi cú pháp: cú pháp không hợp lệ)
+
+>>> (a, b := 16, 19) # Câu lệnh này in ra một tuple có 3 phần tử không như mong đợi (đáng lẽ là 2 phần tử 16 và 19)
+(6, 16, 19)
+
+>>> a # a được được gán lại giá trị trước đó, nhưng giá trị phía dưới vẫn giữ nguyên, là sao?
+6
+
+>>> b
+16
+```
+
+
+
+#### 💡 Giải thích
+
+**Ôn lại một chút về kí hiệu "con hà mã"**
+
+Kí hiệu con hà mã (`:=`) lần đầu tiên được giới thiệu trong phiên bản Python 3.8, nó hữu dụng khi bạn muốn gán giá trị cho các biến bên trong một biểu diễn (expression).
+
+```py
+def some_func():
+ # Giả định rằng ta thực hiện một vài phép tính tốn nhiều tài nguyên (thời gian, I/O) ở đây
+ # time.sleep(1000)
+ return 5
+
+# Thay vì thực hiện việc kiểm tra kết quả trả về của hàm trên,
+if some_func():
+ print(some_func()) # Và gọi lại hàm đó trong thân điều kiện, nghĩa là thực hiện các tính toán trong hàm 2 lần.
+# Hay tốt hơn, ta có thể tiết kiệm một lời gọi hàm thông qua việc lấy về giá trị trả về ở một lần gọi và thực hiện so sánh trên giá trị đó:
+a = some_func()
+if a:
+ print(a)
+
+# Dùng kĩ hiệu con hà mã bạn có thể viết ngắn gọn hơn như dưới đây, phép gán được sử dụng như mệnh đề điều kiện và ta có thể sử dụng biến được gán giá trị trong thân câu điều kiện if:
+if a := some_func():
+ print(a)
+```
+
+**Kết quả (> 3.8):**
+
+```py
+5
+5
+5
+```
+
+Sử dụng kí hiệu con hà mã giúp ta rút ngắn được đoạn mã đi một dòng và tránh được việc gọi `some_func` hai lần.
+
+- Ta chỉ được sử dụng phép gán có kí hiệu hà mã ở cấp độ cao nhất do đó lỗi cú pháp (`SyntaxError`) trong câu lệnh `a := "wtf_walrus"` xảy ra. Khi ta cho phép gán này vào hai dấu ngoặc đơn `()` thì sẽ không bị lỗi nữa.
+
+- Thông thường, câu lệnh có dấu bằng `=` sẽ không được phép đặt trong dấu ngoặc đơn. Do vậy câu lệnh `(a, b = 6, 9)` bị lỗi cú pháp.
+
+- Cú pháp của kí hiệu gán con hà mã như sau: `NAME:= expr`, ở đó `NAME` là một tên biến hợp lệ, và `expr` là một biểu diễn hợp lệ. Do vậy, việc sử dụng các phép gộp (packing) hay phân rã trong trường hợp này sẽ không được hỗ trợ, nghãi là
+ - `(a := 6, 9)` tương đương với `((a := 6), 9)` và buổi diễn cuối cùng là `(a, 9) ` (ở đó giá trị của `a` là 6). Bạn có thể kiểm tra lại với các dòng lệnh dưới đây
+
+ ```py
+ >>> (a := 6, 9) == ((a := 6), 9)
+ True # Biểu diễn bên trái bằng bên phải do phép phân rã không được phép (như đã giải thích phía trên)
+ >>> x = (a := 696, 9)
+ >>> x
+ (696, 9)
+ >>> x[0] is a # Cả x[0] và a cùng trỏ về chung một địa chỉ trong bộ nhớ
+ True
+ ```
+
+ - Tương tự, `(a, b := 16, 19)` tương đương với `(a, (b := 16), 19)` khi ta có 3 giá trị trong một tuple.
+
+---
+
+### ▶ Strings thỉnh thoảng có thể khá oái oăm
+
+
+1\.
+
+```py
+>>> a = "some_string"
+>>> id(a)
+140420665652016
+>>> id("some" + "_" + "string") # Để ý rằng cả hai giá trị id đều giống nhau (140420665652016).
+140420665652016
+```
+
+2\.
+```py
+>>> a = "wtf"
+>>> b = "wtf"
+>>> a is b
+True # a và b cùng trỏ tới một địa chỉ trong bộ nhớ
+
+>>> a = "wtf!"
+>>> b = "wtf!"
+>>> a is b
+False # a và b không cùng trỏ tới một địa chỉ trong bộ nhớ
+
+```
+
+3\.
+
+```py
+>>> a, b = "wtf!", "wtf!"
+>>> a is b # Áp dụng cho tất cả các phiên bản Python, ngoại trừ các phiên bản 3.7.x
+True # a và b cùng trỏ tới một địa chỉ trong bộ nhớ
+
+>>> a = "wtf!"; b = "wtf!"
+>>> a is b # Kết quả là True hoặc False tuỳ thuộc vào môi trường bên chạy đoạn mã (python shell / ipython / as a script)
+False
+```
+
+```py
+# Tạo một file tên some_file.py, chứa ba dòng code dưới đây:
+a = "wtf!"
+b = "wtf!"
+print(a is b)
+
+# Khi file này được chạy kết quả in ra là True
+
+```
+
+4\.
+
+**Kết quả (< Python3.7 )**
+
+```py
+>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
+True
+>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
+False
+```
+
+Có gì đó sai sai?
+
+#### 💡Giải thích:
++ Những điều xảy ra trong các đoạn mã đầu tiên và thứ hai đến từ một tối ưu của CPython (được gọi là string interning), tối ưu này cố gắng sử dụng các đối tượng không thể thay đổi giá trị hiện tồn tại trong một vài trường hợp thay vì việc tạo ra một đối tượng mới mỗi lần.
++ Sau khi được "interned," nhiều biến có thể tham chiếu tới cùng một đối tượng string trong bộ nhớ (do vậy mà tiết kiệm bộ nhớ).
++ Trong các đoạn mã phía trên, các strings được interned một cách ngầm. Quyết định ki nào thì intern một cách ngầm là phụ thuộc vào mỗi triển khai Python. Có một vài luật có thể được sử dụng để đoán biết một string sẽ được intern hay không:
+ * Tất cả strings có độ dài bằng 0 và 1 được intern.
+ * Các strings được intern tại thời điểm biên dịch (`'wtf'` sẽ được intern nhưng `''.join(['w', 't', 'f'])` sẽ không được intern).
+ * Các strings không được tạo thành từ các mẫu tự ASCII, số, hoặc dấu gạch chân, sẽ không được intern. Điều đó giải thích tại sao `'wtf!'` không được intern bởi vì kí tự `!`. Triển khai Cpython cho luật này có thể tìm thấy [ở đây](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
+ 
++ Khi `a` and `b` được cho nhận giá trị `"wtf!"` trên cùng một dòng, trình thông dịch Python sẽ tạo một đối tượng mới, sau đó tham chiếu tới biến thứ hai tại cùng một thời điểm. Nếu bạn làm các phép gán trên các dòng riêng biệt, trình thông dịch sẽ không biết rằng đã có `"wtf!"` tồn tại như một đối tượng (bởi vì `"wtf!"` không được intern ngầm như điều được trình bày trên). Đây là một tối ưu tại thời điểm biên dịch. Tối ưu này không áp dụng cho các phiên bản CPython 3.7.x (xem thêm về vấn đề này [ở đây] (https://github.com/satwikkansal/wtfpython/issues/100)).
++ Một đơn vị biên dịch trong môi trường tương tác như IPython bao gồm chỉ một câu lệnh đơn, trái lại `a = "wtf!"; b = "wtf!"`là hai câu lệnh. Điều này giải thích tại sao các danh định (identities) lại khác nhau trong `a = "wtf!"; b = "wtf!"`, và cũng giải thích tại sao chúng lại giống nhau trong `some_file.py`.
++ Sự thay đổi đột ngột trong đoạn mã thứ tư là do một kĩ thuật [Tối ưu peephole](https://en.wikipedia.org/wiki/Peephole_optimization) hay còn được biết đến như sự gấp hằng số. Điều này có nghĩa là biểu diễn `'a'*20` được thay thế bở `'aaaaaaaaaaaaaaaaaaaa'` trong quá trình biên dịch tiết kiệm một vài chu kì đồng hồ trong suốt thời gian chạy . Sự gấp hằng số chỉ xảy ra đối với các strings có độ dài nhỏ hơn 20 (Tại sao? tưởng tượng kích thước của file `.pyc` sinh ra bởi biểu diễn `'a'*10**10`). [Link này](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) dẫn tới triển khai của tối ưu được đề cập.
++ Chú ý rằng: trong Python 3.7, gấp hằng số được chuyển từ bộ tối ưu peephole sang bộ tối ưu mới AST với một vài thay đổi luận lý, nên đoạn mã thứ tư không chạy được trong Python 3.7. Bạn có thể đọc thêm về sự thay đổi này [ở ](https://bugs.python.org/issue11549).
+
+---
+
+
+### ▶ Be careful with chained operations
+
+```py
+>>> (False == False) in [False] # makes sense
+False
+>>> False == (False in [False]) # makes sense
+False
+>>> False == False in [False] # now what?
+True
+
+>>> True is False == False
+False
+>>> False is False is False
+True
+
+>>> 1 > 0 < 1
+True
+>>> (1 > 0) < 1
+False
+>>> 1 > (0 < 1)
+False
+```
+
+#### 💡 Giải thích:
+
+As per https://docs.python.org/2/reference/expressions.html#not-in
+
+
+> Nếu a, b, c, ..., y, z là các biểu diễn (expressions) và op1, op2, ..., opN là các phép so sánh, khi đó op1 b op2 c ... y opN z tương đương với op1 b and b op2 c and ... y opN, ngoại trì việc mỗi biểu diễn được thực hiện hay đánh giá nhiều nhât một lần
+
+Trong khi những điều ta thấy phía trên có thể hơi ngớ ngẩn đối với bạn, ta có thể làm những thứ thú vị hơn như `a == b == c` và `0 <= x <= 100`.
+
+* `False is False is False` tương đương `(False is False) and (False is False)`
+* `True is False == False` tương đương với `True is False and False == False` và do phần so sánh đầu tiên (`True is False`) cho ra kết quả `False`, do đó kết quả cuối cùng là `False`.
+* `1 > 0 < 1` tương đương với `1 > 0 and 0 < 1` và cho ra kết quả là `True`.
+* Biểu diễn `(1 > 0) < 1` tương đương với `True < 1` và
+ ```py
+ >>> int(True)
+ 1
+ >>> True + 1 #làm cho vui thôi, chứ không liên quan
+ 2
+ ```
+ do đó, `1 < 1` cho ra kết quả`False`
+
+---
+
+### ▶ How not to use `is` operator
+
+Ví dụ dươi đây rất nổi tiếng trên Internet
+1\.
+
+```py
+>>> a = 256
+>>> b = 256
+>>> a is b
+True
+
+>>> a = 257
+>>> b = 257
+>>> a is b
+False
+```
+
+2\.
+
+```py
+>>> a = []
+>>> b = []
+>>> a is b
+False
+
+>>> a = tuple()
+>>> b = tuple()
+>>> a is b
+True
+```
+
+3\.
+**Kết quả**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+True
+```
+
+**Kết qủa (Chỉ áp dụng cho Python 3.7.x )**
+
+```py
+>>> a, b = 257, 257
+>> a is b
+False
+```
+
+#### 💡 Giải thích:
+
+**Sự khác biệt giữa `is` và `==`**
+
+* `is` kiểm tra xem cả hai phần tử so sánh có trỏ về cùng một đôi tượng (ví dụ, `is` kiểm tra định danh của cả hai thành phần được so sánh có khớp với nhau hay không)
+* `==` so sánh giá trị của hai phần tử xem chúng có bằng nhau hay không
+* Vì thế `is` được dùng cho việc so sánh tham chiếu và `==` được dùng cho so sánh tham trị. Hãy xem ví dụ dưới đây để hiểu rõ hơn
+ ```py
+ >>> class A: pass
+ >>> A() is A() # Hai đối tượng rỗng nhưng nằm ở hai vị trí khác nhau trong bộ nhớ.
+ False
+ ```
+** `256` là một đối tượng hiện hữu nhưng `257` lại không phải là một đối tượng hiện hữu.
+
+Khi bạn khởi chạy python các số từ `-5` tới `256` sẽ được cấp phát. Những sô nay được sử dụng rất nhiều, do đó việc cấp phát này là hợp lý.
+Tham khảo từ https://docs.python.org/3/c-api/long.html
+
+> Cách triển khai hiện hành của Python duy trì một mảng các đối tượng sô nguyên từ -5 tới 256, khi bạn tạo một số nguyên trong dải này bạn sẽ quay trở về lại một tham chiếu tới một đôi tượng tồn tại. Do vậy ta vẫn có thể thay đổi giá trị của 1.
+
+```py
+>>> 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 trình thông dịch không đủ thông minh khi thực thi `y = 257` và nhận ra rằng chúng ta đã tạo một số nguyên có giá trị là `257,` rồi, do đó nó tiếp tục tạo một đôi tượng khác trong bộ nhớ.
+
+Một tối ưu tương tự áp dụng cho các đối tượng bất biến (**immutable**) khác như là các tuples. Bởi vì lists có thể biến đổi được, do đó ta hiểu tại sao `[] is []` sẽ trả về `False` và `() is ()` sẽ trả về `True`. Điều này giải thích đoạn mã thứ hai. Nào hãy cùng đi qua ví dụ thứ 3.
+
+** Cả `a` và `b` đều trỏ về cùng một đối tượng khi được khởi tạo với cung một giá trị và trên cùng một dòng code**
+**Kết quả**
+
+```py
+>>> a, b = 257, 257
+>>> id(a)
+140640774013296
+>>> id(b)
+140640774013296
+>>> a = 257
+>>> b = 257
+>>> id(a)
+140640774013392
+>>> id(b)
+140640774013488
+```
+
+
+* Trên cùng một dòng code nơi cả a va b được gán cho giá trị `257`, trinh thông dịch Python tạo một đôi tượng mới, sau đó trỏ tới biến thứ hai cùng một lúc. Nếu bạn thực hiện việc gán trên các dòng riêng biệt, Python sẽ không biết rằng đã có săn một đối tượng `257`
+
+* Đây là một tối ưu của trình biên dịch, và áp dụng cụ thể cho môi trường tương tác (interactive environment). Khi bạn nhập hai dòng code trong phiên thôn dịch động, chúng được biên dịch riêng, do đó được tối ưu riêng. Nếu bạn thử ví dụ này trong một file `.py` bạn sẽ không thấy điều trên xảy ra do file code được biên dịch một lần. Tối ưu nay không chỉ giơi hạn cho các số nguyên, nó còn hoạt động được với các kiểu dữ liệu bất biến khác như strings (xem "Strings are tricky example") và floats.
+ ```py
+ >>> a, b = 257.0, 257.0
+ >>> a is b
+ True
+ ```
+
+* Tại sao ví dụ nay lại không chạy được trên Python 3.7? Đại khái lý do là bởi vì các tối ưu của trình biên dịch áp dụng cho các trường hợp cụ thể (ví dụ. một cách tối ưu có thể thay đổi tuỳ theo phiên bản, hệ điều hành, vân vân). Tôi vân đang tìm hiểu các thay đổi cụ thể trong code triểu khai, bạn có thể xem thêm [tại đây](https://github.com/satwikkansal/wtfpython/issues/100)
+---
+
+
+### ▶ Hash brownies
+
+1\.
+```py
+some_dict = {}
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
+some_dict[5] = "Python"
+```
+
+**Kết quả:**
+
+```py
+>>> some_dict[5.5]
+"JavaScript"
+>>> some_dict[5.0] # "Python" chiếm lấy khoá (key) của "Ruby"?
+"Python"
+>>> some_dict[5]
+"Python"
+
+>>> complex_five = 5 + 0j
+>>> type(complex_five)
+complex
+>>> some_dict[complex_five]
+"Python"
+```
+
+Thế quái nào mà toàn in ra Python?
+
+
+#### 💡 Giải thích
+
+* Tính duy nhất của các khoá (keys) trong cấu trúc dữ liệu từ điển của được xác định bởi *sự tương đương*, chứ không phải dựa trên danh tính. Do đó dẫu cho `5`, `5.0`, và `5 + 0j` là các đối tượng riêng biệt có kiểu khác nhau, nhưng bởi vì chúng băng nhau nên không thể tồn tại như một khoá riêng của `dict` (hoặc `set`). Khi bạn thêm các khoá này vào từ điển sau đó tra giá trị của khoá đó dựa trên giả định về sự tương đương thì Python chỉ trả về giá trị của khoá được chèn vào ban đầu (thay vì trả lại lỗi về truy xuất khoá `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
+ ```
+* Nguyên lý trên cũng áp dụng khi bạn gán giá trị cho khoá. Khi bạn thực hiện phép gán `some_dict[5] = "Python"`, Python tìm phần tử có sẵn trong từ điển có khoá tương đương, trong trường hợp này nè `5.0 -> "Ruby"`, ghi đè lên giá trị của khoá này ngay, và lờ đi khoá tương đương mà bạn mới cung cấp.
+ ```py
+ >>> some_dict
+ {5.0: 'Ruby'}
+ >>> some_dict[5] = "Python"
+ >>> some_dict
+ {5.0: 'Python'}
+ ```
+
+* Vậy làm sao để cập nhật khoá `5` vào từ điển (thay vì `5.0`)? Thực sự là chúng ta không thể làm điều đó vơi một thao tác, nhưng ta có thể xoá đi khoá cũ (`del some_dict[5.0]`), và sau đó thiết lập khoá mới(`some_dict[5]`) để có thể lấy được khoá `5` thay vì `5.0`, tuy nhiên cách này ít ai xài tới lắm.
+
+
+* Làm thế nào Python tìm khoá `5` trong từ điển có chứa sẵn khoá `5.0`? Nó làm được điều đó mà không phải dò qua mọi phần tử trong từ điển thông qua sử dụng các hàm băm (hash functions), do đó tốn thời gian chạy hằng số (constant time). Khi Python tra khoá tên `foo` trong một tư điển, đầu tiên nó thực hiện hàm băm `hash(foo)` (với thời gian chạy hằng số). Bởi vì trong Python các đối tượng băng nhau khi chúng có chung một giá trị băm ([đọc thêm ở đây](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value.
+ ```py
+ >>> 5 == 5.0 == 5 + 0j
+ True
+ >>> hash(5) == hash(5.0) == hash(5 + 0j)
+ True
+ ```
+ **Ghi chú:** Các đối tượng có giá trị băm băng nhau chưa chắc đã bằng nhau. (Vẫn đề này được biết tới với tên gọi [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science)), và giảm đi hiệu năng với thời gian hằng số qua việc dùng hàm băm.)
+
+---
+
+### ▶ Deep down, we're all the same.
+
+```py
+class WTF:
+ pass
+```
+
+**Kết quả:**
+```py
+>>> WTF() == WTF() # two different instances can't be equal
+False
+>>> WTF() is WTF() # identities are also different
+False
+>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
+True
+>>> id(WTF()) == id(WTF())
+True
+```
+
+#### 💡 Giải thích:
+
+* Khi `id` được gọi, Python tạo một đối tượng lớp `WTF` và truyền đối tượng này cho hàm `id`. Hàm `id` lấy `id` của đối tượng (vùng nhớ của đối tượng), và vứt đối tượng này đi. Do đó đối tượng bị tiêu huỷ.
+* Khi chúng ta gọi `id` hai lần, Python cấp phát cùng một vùng nhơ cho đối tượng thư hai. Bởi vi (trong CPython) `id` sử dụng vùng nhớ cho id của đối tượng, id của hai đối tượng này là giống nhau.
+* Vì vậy, id của đối tượng chỉ duy nhất trong vòng đời của đối tượng đó. Sau khi đối tượng bị tiêu hiểu, hay trước khi nó được tạo, những thứ khác có thể có cùng id với nó.
+* Nhưng tại sao phép `is` lại cho ra kết quả `False`? Hãy nhìn ví dụ dưới đây
+```py
+ class WTF(object):
+ def __init__(self): print("I")
+ def __del__(self): print("D")
+ ```
+ **Kết quả:**
+ ```py
+ >>> WTF() is WTF()
+ I
+ I
+ D
+ D
+ False
+ >>> id(WTF()) == id(WTF())
+ I
+ D
+ I
+ D
+ True
+ ```
+ Như bạn quan sát thấy, có sự khác biệt ở thứ tự tiêu hiểu các đối tượng, và đó tạo ra sự khác biệt.
+
+---
+
+### ▶ Vô trật tự trong trật tự *
+
+```py
+from collections import OrderedDict
+
+
+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
+```
+
+**Kết quả**
+```py
+>>> dictionary == ordered_dict # Nếu a == b
+True
+>>> dictionary == another_ordered_dict # and b == c
+True
+>>> ordered_dict == another_ordered_dict # thế sao c != a ??
+False
+
+# ta biết răng set chỉ chứa các phần tử độc nhất,
+# thử tạo một set chứa 3 từ điển phía trên xem sao...
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "", line 1, in
+TypeError: unhashable type: 'dict' (Lỗi về kiểu: kiểu không thể hash được)
+
+# Lỗi trên xảy ra là điều dê hiểu do từ điển không được tran bị __hash__,
+# sử dụng các lớp bọc (wrapper classes) ta xây dựng phía trên thử xem.
+>>> 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}) # xáo trộn thứ tự cá phần tử trong set
+2
+```
+
+Cái quái gì đang xảy ra?
+
+#### 💡 Giải thích:
+
+- Lý do tại sao quy tắc so sánh bắc cầu không áp dụng được khi so sánh `dictionary`, `ordered_dict` và `another_ordered_dict` là do cách triển khai phương thức `__eq__` trong lớp `OrderedDict` . Xem thêm [tài liệu](https://docs.python.org/3/library/collections.html#ordereddict-objects)
+
+ > Các phép so sánh bằng giữa các đối tượng OrderedDict tuôn theo thư tự và được thực hiện như sau. Còn phép so sánh băng giữa cá đối tượng `OrderedDict` và các đối tượng ánh xạ khác (mapping objects) thì không tuân theo thứ tự như là các từ điển thông thường..
+
+- Lý do ở đây là các đối tượng `OrderedDict` được cho phép bị thay thế trực tiếp tại bất cứ vị trí nao một từ điển thông thường được sử dụng.
+- Vậy tại sao thay đổi thư tự của các từ điển lại ảnh hưởng tới đối tượng `set` được sinh ra? Câu trả lời là do thiếu sự so sánh nội đối tượng (intrasitive) . Do sets là các tập hợp không có thứ tự của các phần tử độc nhất, thứ tự các phần tử khi chèn vào không có nghĩa lý gì cả. Nhưng trong trường hợp này, nó lại có vấn đề. Hãy tìm hiểu thêm xem sao
+
+ ```py
+ >>> some_set = set()
+ >>> some_set.add(dictionary) # these are the mapping objects from the snippets above
+ >>> 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
+ ```
+ Sự bất nhất ở đây `another_ordered_dict in another_set` cho kết quả là `False` bởi vì `ordered_dict` đã tồn tại trong `another_set` trước đó, `ordered_dict == another_ordered_dict` trở thành `False`.
+
+
+---
+
+### ▶ Cố thêm chút nữa... *
+
+```py
+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(): # A gotcha!
+ try:
+ for i in range(3):
+ try:
+ 1 / i
+ except ZeroDivisionError:
+ # Let's throw it here and handle it outside for loop
+ raise ZeroDivisionError("A trivial divide by zero error")
+ finally:
+ print("Iteration", i)
+ break
+ except ZeroDivisionError as e:
+ print("Zero division error occurred", e)
+```
+
+**Kết quả:**
+
+```py
+>>> some_func()
+'from_finally'
+
+>>> another_func()
+Finally!
+Finally!
+Finally!
+
+>>> 1 / 0
+Traceback (most recent call last):
+ File "", line 1, in
+ZeroDivisionError: division by zero (Ngoại lệ sinh ra bởi chia một số cho số 0)
+
+>>> one_more_func()
+Iteration 0
+
+```
+
+#### 💡 Giải thích:
+
+- Khi câu lệnh `return`, `break` hay `continue` được thực hiện trong phần `try` của khối "try…finally", phần `finally` cũng được thực hiện.
+- Giá trị trả về của một hàm được xác định bởi câu lệnh `return` cuối cung được thực hiện. Bởi vì phần `finally` luôn được thực hiện, câu lệnh `return` trong phần `finally` sẽ luôn là câu lệnh trả về gia trị cuối cùng.
+- Tuy nhiên nếu phần finally thực hiện câu lệnh `return` hay `break` thì phần ngoại lệ tồn tại sẽ bị bỏ qua.
+
+---
+
+
+### ▶ For what?
+
+```py
+some_string = "wtf"
+some_dict = {}
+for i, some_dict[i] in enumerate(some_string):
+ i = 10
+```
+
+**Kết quả:**
+```py
+>>> some_dict # An indexed dict appears.
+{0: 'w', 1: 't', 2: 'f'}
+```
+
+#### 💡 Giải thích:
+
+* Câu lệnh `for` được định nghĩa trong [ngữ pháp Python](https://docs.python.org/3/reference/grammar.html) như sau:
+ ```
+ for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+ ```
+
+ Ở đó `exprlist` là biến mục tiêu của phép gán. Điều đó co nghĩa là câu lệnh gán `{exprlist} = {next_value}` được **thực hiện đối với mỗi phần tử** trong đối tượng lặp (iterable)
+ An interesting example that illustrates this:
+ ```py
+ for i in range(4):
+ print(i)
+ i = 10
+ ```
+
+ **Kết quả:**
+ ```
+ 0
+ 1
+ 2
+ 3
+ ```
+
+ Bạn có nghĩ răng vòng lặp trên chỉ chạy có một lần?
+
+ **💡 Giải thích:**
+
+- Câu lệnh gán `i = 10` không bao giờ ảnh hưởng tới các vòng lặp do cách thức hoạt động của vòng lặp for tron Python. Trước điểm khởi đầu của mỗi vòng lặp, phần tử tiếp theo được đưa ra bởi trình sinh (iterator, trong trường hợp nay là `range(4)`), phần tử này được giải nén ra (unpacked) và gán cho các biến chạy (trong trường hợp nay là `i`)
+
+* Hàm `enumerate(some_string)` sinh ra giá trị mới `i` (biến đếm) và một kí tự từ `some_string` tại mỗi lần lặp. Sau đó nó gán khoá `i` của từ điển `some_dict` cho kí tự đó. Trình tự được thể hiện đơn giản như dưới đây:
+ ```py
+ >>> i, some_dict[i] = (0, 'w')
+ >>> i, some_dict[i] = (1, 't')
+ >>> i, some_dict[i] = (2, 'f')
+ >>> some_dict
+ ```
+
+---
+
+### ▶ Sự khác biệt đến từ thời điểm đánh giá
+
+1\.
+```py
+array = [1, 8, 15]
+# Một biểu diễn generator thông thường
+gen = (x for x in array if array.count(x) > 0)
+array = [2, 8, 22]
+```
+
+**Kết quả:**
+
+```py
+>>> print(list(gen)) # Các giá trị khác đi đâu mất rồi?
+[8]
+```
+
+2\.
+
+```py
+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]
+```
+
+**Kết quả:**
+```py
+>>> print(list(gen_1))
+[1, 2, 3, 4]
+
+>>> print(list(gen_2))
+[1, 2, 3, 4, 5]
+```
+
+3\.
+
+```py
+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]
+```
+
+**Kết quả:**
+```py
+>>> print(list(gen))
+[401, 501, 601, 402, 502, 602, 403, 503, 603]
+```
+
+#### 💡 Lý giải
+
+- Trong một biểu diễn [generator](https://wiki.python.org/moin/Generators), câu `in` được thực hiện tại thời điểm khai báo, nhưng câu điều kiện được thực hiện tại thời điểm chạy (runtime).
+- Do trước thời điểm chạy, `array` được gán cho giá trị `[2, 8, 22]`, và trong ba số được gán trước đó `1`, `8` and `15`, chỉ có `8` có số lần xuất hiện trong mảng mới và do đó số lần xuât hiện lớn hơn `0`, nên generator chỉ cho ra số `8`.
+- Sự khác biệt giữa kết quả của `g1` and `g2` trong phần thứ hai là do cách các biến `array_1` và `array_2` được gán lại các giá trị.
+- Trong trường hợp đầu tiên, `array_1` được gán cho một đối tượng mới `[1,2,3,4,5]` và vì câu `in` được thực hiện tại thời điểm khai báo nên nó vẫn trỏ tới đối tượng cũ `[1,2,3,4]` (đối tượng này chưa bị mất đi).
+- Trong trường hợp thư hai, phép gán lát cắt (slice assignment) `array_2` cập nhật đối tượng cũ `[1,2,3,4]` thành `[1,2,3,4,5]`. Hiển nhiên cả `g2` và `array_2` đều trỏ tới cung một đối tượng (đối tượng đã được cập nhật thành `[1,2,3,4,5]`).
+ - Okay, với những gì ta quan sát trên, co phải giá trị trả về từ `list(g)` trong phần thứ ba phải là `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (bởi vì `array_3` và `array_4` sẽ giống như `array_1`). Lý do chỉ `array_4` được cập nhật được giải thích ở đây [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)
+ >Chỉ có vòng for ngoài cùng được thực hiện ngay lập tức, các lệnh khác được trì hoãn cho đến khi generator được chạy.
+---
+
+
+### ▶ `is not ...` không phải là `is (not ...)`
+
+
+```py
+>>> 'something' is not None
+True
+>>> 'something' is (not None)
+False
+```
+
+#### 💡 Giải thích
+
+- `is not` là một toán tử nhị phân đơn, và khi thực hiện sẽ cho kết quả khác với sử dụng `is` và `not` riêng biệt.
+- `is not` cho ra kết quả `False` khi các biến ở hai đầu của nó trỏ về cùng một đối tượng , và nếu hai biến này trỏ về khác đối tượng, kết quả sẽ là `True`. Cụ thể, `None` và `something` trỏ về hai biến khác nhau nên kết quả là `True`
+- Trong ví dụ trên, `(not None)` sẽ cho ra kết quả `True` bởi vì khi sử dụng trong phép so sánh luận lý `None` tương đương với `False`, do đó dòng mã trên sẽ trở thành `'something' is True`. Cụ thể, do `something` và `True` trỏ về hai đối tượng khác nhau nên kết quả là `False`
+
+---
+
+### ▶ A tic-tac-toe where X wins in the first attempt!
+
+
+```py
+# Khởi tạo một hàng
+row = [""] * 3 #row i['', '', '']
+# Và tạo một bảng gồm các hàng
+board = [row] * 3
+```
+
+**Kết quả:**
+
+```py
+>>> board
+[['', '', ''], ['', '', ''], ['', '', '']]
+>>> board[0]
+['', '', '']
+>>> board[0][0]
+''
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['X', '', ''], ['X', '', '']]
+```
+
+Chúng ta đã gán `"X"` cho ba vị trí trong bảng này chăng?
+
+#### 💡 Giải thích:
+
+Khi chúng ta khởi tạoi biến `row`, hình mô phỏng dưới đây cho ta biết những gì diễn ra trong bộ nhớ
+
+
+
+
+Khi `board` được khởi tạo băng việc nhân bản `row`, minh hoạ phía dưới mô tả những gì diên ra trong bộ nhớ (mỗi thành phần của bảng `board[0]`, `board[1]` và `board[2]` là một tham chiếu tới cung một danh sách trỏ bởi `row`)
+
+
+
+Chúng ta có thể tránh điều trên xảy ra bằng cách không dùng biến `row` để sinh ra `board`. (Tim hiểu thêm tại (https://github.com/satwikkansal/wtfpython/issues/68) )
+```py
+>>> board = [['']*3 for _ in range(3)]
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['', '', ''], ['', '', '']]
+```
+
+---
+
+### ▶ The sticky output function
+
+
+1\.
+
+```py
+funcs = []
+results = []
+for x in range(7):
+ def some_func():
+ return x
+ funcs.append(some_func)
+ results.append(some_func()) # Chú ý lời gọi hàm ở đây
+
+funcs_results = [func() for func in funcs]
+```
+
+**kết quả:**
+
+```py
+>>> results
+[0, 1, 2, 3, 4, 5, 6]
+>>> funcs_results
+[6, 6, 6, 6, 6, 6, 6]
+```
+Ngay cả khi các giá trị `x` khác nhau trong mọi vòng lặp trước khi đặt `some_func` vào trong danh sách `funcs`, tất cả các hàm đều trả về 6.
+
+2\.
+
+```py
+>>> 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]
+```
+
+#### 💡 Lý giải
+
+- Khi định nghia một hàm bên trong một vòng lặp, vòng lặp có biến lặp được sử dụng trong thân hàm, closure của hàm này được giơi hạn cho biến, chư không phải là giá trị. Vì vậy tất cả các ham sử dụng giá trị cuối cung được gán cho biến này để thực hiện tính toán. Để rõ hơn ta thấy được rằng biến lặp `x` (và giá trị của cung của nó nhận được là `6`) trong ví dụ thứ nhất được sử dụng cho tất cả các hàm `func()`, hàm này sẽ luôn trả về giá trị là `6`
+
+- Để thực hiện được tính toán mong muốn bạn có thể truyền biến lặp như là biến được đặt tên (named variable) cho hàm. **Sao mà nó lại chạy đúng được?** ởi vì việc truyền biến như vậy sẽ định nghĩa lại biến nay bên trong phạm vi của hàm.
+
+ ```py
+ funcs = []
+ for x in range(7):
+ def some_func(x=x):
+ return x
+ funcs.append(some_func)
+ ```
+
+ **Kết quả:**
+ ```py
+ >>> funcs_results = [func() for func in funcs]
+ >>> funcs_results
+ [0, 1, 2, 3, 4, 5, 6]
+ ```
+
+---
+
+### ▶ Bài toán con gà và quả trứng *
+
+1\.
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+Đâu là lớp cơ bản cuối cùng ? Còn nhiều thứ gây khó hiểu hơn nữa sau đây
+
+2\.
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+
+#### 💡 Giải thích
+
+- `type` là một [metaclass](https://realpython.com/python-metaclasses/) trong Python.
+- **Mọi thứ** đều là một đối tượng `object` trong Python, bao gồm cả các lớp (classes) cũng như là các hiện thực của chúng (instances).
+- Lớp `type` là metaclass của lớp `object`, do đó mọi lớp (gồm cả `type`) thừa hưởng trực tiếp hay gián tiếp từ `object`.
+- Không có một lớp nào nằm giữa lớp `object` và `type`. Vấn đề đối với các đoạn mã phía trên nằm ở cách ta tìm các mối quan hệ giữa các lớp trong Python (dùng `issubclass` và `isinstance`). Mỗi quan hệ giữa `object` và `type` không thể được định nghĩa trong Python đơn thuần. Chính xác hơn, nghĩa là,
+ + Lớp A là một hiện thực của lớp B, và lớp B là một hiện thực của lớp A.
+ + Lớp A là một hiện thực của chính nó.
+- Các mối quan hệ giữa `object` và `type` (ở cả hai cấp độ hiện thực cũng như chính lớp đó) tồn tại là do việc "ăn gian" khi triển khai các lớp này.
+---
+
+### ▶ Các mối quan hệ của lơp con (subclass)
+
+
+**Kết quả:**
+```py
+>>> from collections import Hashable
+>>> issubclass(list, object)
+True
+>>> issubclass(object, Hashable)
+True
+>>> issubclass(list, Hashable)
+False
+```
+
+Mối quan hệ giữa các lớp con có tính bắc cầu không?(ví dụ, nếu `A` là lớp con của `B`, và `B` là lớp con của `C`, vậy `A` _nên_ là lớp con của `C`)
+
+#### 💡 Lý giải:
+
+* Trong Python mối quan hệ giữa cá lớp con không nhất thiết phải mang tính bắc cầu. Bất cứ ai cũng được phép định nghĩa một lớp `__subclasscheck__` riêng, tuỳ ý trong một siêu lớp (metaclass).
+* Khi `issubclass(cls, Hashable)` được gọi, nó chỉ tìm phương thức non-Falsey "`__hash__`" trong `cls` hoặc bất cư thư gì nó thừa hưởng từ đó.
+* Bởi vì `object` là một đối tượng có thể băm (hashable), còn `list` thi không, nên nó phá vỡ tính bắc cầu.
+* Giải thích chi tiết có thể xem [ở đây](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).
+
+---
+
+### ▶ All-true-ation *
+
+
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+Lý do vì sao mà lúc thì True mà lúc thì lại False
+
+#### 💡 Giải thích:
+
+- Hàm `all` tương đương như đoạn mã dưới
+
+- ```py
+ def all(iterable):
+ for element in iterable:
+ if not element:
+ return False
+ return True
+ ```
+
+- `all([])` trả về `True` bởi vì danh sách nay rỗng.
+- `all([[]])` trả về `False` bởi vì `not []` là `True` tương đương với `not False` bởi vì danh sách phía trong rỗng.
+- `all([[[]]])` và các biến thể đệ quy cao hơn luôn trả về `True` bởi vì `not [[]]`, `not [[[]]]`, tương đương với`not True`.
+---
+
+### ▶ Dấu phẩy lạ lùng
+
+**Kết quả (< 3.6):**
+
+```py
+>>> def f(x, y,):
+... print(x, y)
+...
+>>> def g(x=4, y=5,):
+... print(x, y)
+...
+>>> def h(x, **kwargs,):
+ File "", line 1
+ def h(x, **kwargs,):
+ ^
+SyntaxError: invalid syntax (Lỗi cú pháp không hợp lệ)
+
+>>> def h(*args,):
+ File "", line 1
+ def h(*args,):
+ ^
+SyntaxError: invalid syntax (Lỗi cú pháp không hợp lệ)
+```
+
+#### 💡 Lý giải:
+
+- Dấu phẩy nằm ở cuối danh sách các tham số của một hàm không phải bao giờ cũng hợp lệ.
+- Trong Python, danh sách tham số được định nghĩa bởi một phần các dấu phẩy nằm phía trước và một phần các dấy phẩy nằm phía sau. Điều nay mâu thuẫn với các tình huống ở đó một dấu phẩy bị mắc kẹt ở giữa danh sách, và chẳng có một luật nào chấp nhận điều này cả.
+- **Chú ý:** Vấn đề về dâu phẩy ở cuối [đã được sửa trong Python 3.6](https://bugs.python.org/issue9232). Thảo luận [ở đây](https://bugs.python.org/issue9232#msg248399) cung cấp những cách dung khác nhau của dây phẩy ở cuối.
+
+---
+
+### ▶ Strings and the backslashes
+
+**Kết quả:**
+```py
+>>> print("\"")
+"
+
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "", line 1
+ print(r"\")
+ ^
+SyntaxError: EOL while scanning string literal
+
+>>> r'\'' == "\\'"
+True
+```
+
+#### 💡 Giải thích
+
+- Trong một string thông thường, dấu xuyệc ngược được dùng để "escape" các kí tự có một ý nghĩa đặc biệt (như là dấu trích dẫn đơn, dấu trích dẫn kép, va chính dấu xuyệc ngược).
+ ```py
+ >>> "wt\"f"
+ 'wt"f'
+ ```
+- Đối với một string thô (raw string) (được chỉ định bởi tiếp đầu ngữ `r`), dấu xuyệc ngược.
+ ```py
+ >>> r'wt\"f' == 'wt\\"f'
+ True
+ >>> print(repr(r'wt\"f')
+ 'wt\\"f'
+
+ >>> print("\n")
+
+ >>> print(r"\\n")
+ '\\\\n'
+ ```
+- Có nghĩa là khi một trình phân tích cú pháp gặp một dấu xuyệc ngược tron một string thô, trình này mong đợi một kí tự khác phía sau nó. Và tron trường hợp của chúng ta `print(r"\")`, dấu xuyệc ngược vô hiệu hoá (escape) dấu trích dẫn ở đuôi, để lại cho trình thông dịch xử lý mà không có dấu trích dẫn kết thúc (do đó gây ra lỗi về cú pháp `SyntaxError`). Đó là lý do tại sao các dấu xuyệc ngược không chạy được khi ở cuối một string thô.
+
+---
+
+### ▶ not knot!
+
+```py
+x = True
+y = False
+```
+
+**Kết quả:**
+```py
+>>> not x == y
+True
+>>> x == not y
+ File "", line 1
+ x == not y
+ ^
+SyntaxError: invalid syntax (Lỗi về cú pháp)
+```
+
+#### 💡 Giải thích:
+
+* Thứ tự ưu tiên của các phép toán ảnh hưởng tơi cách một câu lệnh được thực thi, và phép `==` có độ ưu tiên cao hơn phép `not` trong Python.
+* Vì vậy `not x == y` tương đương với `not (x == y)` rồi tương đương với `not (True == False)` và kết quả là`True`.
+* Nhưng `x == not y` gây ra lỗi cú pháp `SyntaxError` bởi vì Python nghĩ rằng nó sẽ thực hiện `(x == not) y` chứ không phải là `x == (not y)` do đó bạn mới gặp lỗi về cú pháp.
+* Trình phân tích cú pháp mong đợi `not` là một phần của phép toán `not in` (bởi vì cả `==` và `not in` có cùng độ ưu tiên), nhưng do trong trương hợp của chúng ta, trình xử lý không tìm thấy `in` đằng sau `not`, nên nó gây ra `SyntaxError`.
+
+---
+
+### ▶ Các chuỗi rưỡi trích dẫn
+
+**Kết quả:**
+```py
+>>> print('wtfpython''')
+wtfpython
+>>> print("wtfpython""")
+wtfpython
+>>> # Các câu lệnh phía dưới gặp lỗi cú pháp `SyntaxError` khi thực thi
+>>> # print('''wtfpython')
+>>> # print("""wtfpython")
+ File "", line 3
+ print("""wtfpython")
+ ^
+SyntaxError: EOF while scanning triple-quoted string literal (Lỗi cú pháp khi sử lý chuỗi được bao bởi dấu trích dẫn)
+```
+
+#### 💡 Giải thích:
++ Python hỗ trợ ngầm [ghép chuỗi](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), ví dụ,
+ ```
+ >>> print("wtf" "python")
+ wtfpython
+ >>> print("wtf" "") # or "wtf"""
+ wtf
+ ```
+
++ `'''` và `"""` là các kí hiệu phân cách chuỗi trong Python, chúng tạo ra lỗi SyntaxError bởi vì trình thông dịch Python chơ đợi kí hiệu phân cách kết thúc khi nó dò tìm chuỗi kí tự trích dẫn có ba dấu nháy .
+---
+
+### ▶ Có gì sai sai với các giá trị luận lý (booleans)?
+
+1\.
+
+```py
+# Một ví dụ tính toán số lượng các giá trị luận lý và
+# sô nguyên trong một danh sách lẫn lộn các kiểu phần tử khác nhau.
+mixed_list = [False, 1.0, "some_string", 3, True, [], False]
+integers_found_so_far = 0
+booleans_found_so_far = 0
+
+for item in mixed_list:
+ if isinstance(item, int):
+ integers_found_so_far += 1
+ elif isinstance(item, bool):
+ booleans_found_so_far += 1
+```
+
+**Kết quả:**
+```py
+>>> integers_found_so_far
+4
+>>> booleans_found_so_far
+0
+```
+
+
+2\.
+```py
+>>> some_bool = True
+>>> "wtf" * some_bool
+'wtf'
+>>> some_bool = False
+>>> "wtf" * some_bool
+''
+```
+
+3\.
+
+```py
+def tell_truth():
+ True = False
+ if True == False:
+ print("I have lost faith in truth!")
+```
+
+**Kết quả (< 3.x):**
+
+```py
+>>> tell_truth()
+I have lost faith in truth!
+```
+
+#### 💡 Lý giải:
+
+* `bool` là lơp con của `int` trong Python
+
+ ```py
+ >>> issubclass(bool, int)
+ True
+ >>> issubclass(int, bool)
+ False
+ ```
+
+* Và do vậy, `True` và `False` là các hiện thực (instances) của `int`
+ ```py
+ >>> isinstance(True, int)
+ True
+ >>> isinstance(False, int)
+ True
+ ```
+
+* Giá trị dạng số nguyên của `True` là `1` và của `False` là `0`.
+ ```py
+ >>> int(True)
+ 1
+ >>> int(False)
+ 0
+ ```
+
+* Xem trên [câu trả lời] trên StackOverflow(https://stackoverflow.com/a/8169049/4354153) để biết lý do.
+
+* Lúc đầu, Python không có kiểu `bool` (người ta dung 0 cho false và các giá trị khác không như 1 cho true). `True`, `False`, va kiểu `bool` được bổ sung trong cá phiên bản 2.x, nhưng vi lý do hỗ trợ tương thích ngược (backward compatibility), `True` và `False` không thể trơ thành các hăng số (constants). Chúng chỉ là các biến được tích hợp sẵn trong Python, và ta có thể gán lại giá trị cho chúng.
+
+* Python 3 không hỗ trợ tương thích ngược, và do vậy các đoạn mã cuối cung không chạy được trên Python 3.x!
+---
+
+### ▶ Class attributes and instance attributes
+
+1\.
+```py
+class A:
+ x = 1
+
+class B(A):
+ pass
+
+class C(A):
+ pass
+```
+
+**Kết quả:**
+```py
+>>> A.x, B.x, C.x
+(1, 1, 1)
+>>> B.x = 2
+>>> A.x, B.x, C.x
+(1, 2, 1)
+>>> A.x = 3
+>>> A.x, B.x, C.x # C.x thay đổi, nhưng B.x không thay đổi
+(3, 2, 3)
+>>> a = A()
+>>> a.x, A.x
+(3, 3)
+>>> a.x += 1
+>>> a.x, A.x
+(4, 3)
+```
+
+2\.
+```py
+class SomeClass:
+ some_var = 15
+ some_list = [5]
+ another_list = [5]
+ def __init__(self, x):
+ self.some_var = x + 1
+ self.some_list = self.some_list + [x]
+ self.another_list += [x]
+```
+
+**Kết quả:**
+
+```py
+>>> some_obj = SomeClass(420)
+>>> some_obj.some_list
+[5, 420]
+>>> some_obj.another_list
+[5, 420]
+>>> another_obj = SomeClass(111)
+>>> another_obj.some_list
+[5, 111]
+>>> another_obj.another_list
+[5, 420, 111]
+>>> another_obj.another_list is SomeClass.another_list
+True
+>>> another_obj.another_list is some_obj.another_list
+True
+```
+
+#### 💡 Giải thích:
+
+* Các biến thuộc về lớp và các biến thuộc về các hiện thực của lơp (class instances) được xử lý nội tại như là các từ điển của một đối tượng lớp. Nếu một biến không nằm trong từ điển của lớp hiện hành, nó sẽ được tìm trong các lớp cha.
+* Phép `+=` thay đổi đối tượng có thể biến đổi (mutable) tại chỗ mà khôn cần phải tạo một đối tượng mới. Vì vậy thay đổi thuộc tính cua một hiện thực ảnh hưởng tới thuộc tính của các hiện thực khác và thuộc tính lớp.
+---
+
+### ▶ Non-reflexive class method *
+
+
+
+```py
+class SomeClass:
+ def instance_method(self):
+ pass
+
+ @classmethod
+ def class_method(cls):
+ pass
+```
+
+**Kết quả:**
+
+```py
+>>> SomeClass.instance_method is SomeClass.instance_method
+True
+>>> SomeClass.class_method is SomeClass.class_method
+False
+>>> id(SomeClass.class_method) == id(SomeClass.class_method)
+True
+```
+
+#### 💡 Giải thích:
+
+- Lý do là vì `SomeClass.class_method is SomeClass.class_method` trả về `False` là bởi vì decorator `@classmethod`.
+
+ ```py
+ >>> SomeClass.instance_method
+
+ >>> SomeClass.class_method
+
+ ```
+
+ Mỗi lần truy cập tới `SomeClass.class_method` là lại có một phương thức được bọc mới sinh ra (new bound method)
+- `id(SomeClass.class_method) == id(SomeClass.class_method)` trả về `True` bởi vì quá trình cấp phát bộ nhớ cho `class_method` lần thứ hai xảy ra tại cung một ví trí với quá trình giải phóng bộ nhớ đầu tiên (Xem lại "Deep Down, we're all the same example" để có lời giải thích rõ hơn).
+---
+
+
+### ▶ yielding None
+
+```py
+some_iterable = ('a', 'b')
+
+def some_func(val):
+ return "something"
+```
+
+**Kết quả (<= 3.7.x):**
+
+```py
+>>> [x for x in some_iterable]
+['a', 'b']
+>>> [(yield x) for x in some_iterable]
+ at 0x7f70b0a4ad58>
+>>> list([(yield x) for x in some_iterable])
+['a', 'b']
+>>> list((yield x) for x in some_iterable)
+['a', None, 'b', None]
+>>> list(some_func((yield x)) for x in some_iterable)
+['a', 'something', 'b', 'something']
+```
+
+#### 💡 Giải thích:
+- Đây là một bug tồn tại khi CPython xử lý `yield` trong các generators và comprehensions.
+- Bạn có thể tham khảo thêm về lỗi này tại đây: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
+- Báo cáo về bug này: http://bugs.python.org/issue10544
+- Theo Python 3.8+ `yield` không được phép nằm bên trong list comprehension và nếu bạn làm như vậy sẽ tạo ra lỗi cú pháp `SyntaxError`.
+
+---
+
+
+### ▶ Yielding from... return! *
+
+1\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ yield from range(x)
+```
+
+**Kết quả (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Đáng lẽ phải hiển thị `"wtf"` chứ nhỉ? Có phải là do `yield from`? Cùng tìm hiểu thêm nào,
+
+2\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ for i in range(x):
+ yield i
+```
+
+**Kết quả:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Vẫn lại không in ra `"wtf"` .
+
+#### 💡 Giải thích:
+
++ Từ Python 3.3 trở đi, ta có thể sử dụng `return` với các giá trị bên trong các generators (Xem thêm [PEP380](https://www.python.org/dev/peps/pep-0380/)). Các [tài liệu chính thức](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) cũng nói như vậy,
+> "... `return expr` tron một generator tạo ra ngoại lệ `StopIteration(expr)` khi thoát ra từ generator."
+
++ Trong trường hợp `some_func(3)`, ngoại lệ `StopIteration` được khởi lên ngay từ đầu bởi vì câu lệnh `return`. Ngoại lệ `StopIteration` được tự động bắt lại trong dòng lệnh bao `list(...)` và trong vòng lặp `for`. Do đó, cả hai đoạn mã trên đều trả về một danh sách rỗng.
+
++ Để có được `["wtf"]` từ generator `some_func` bạn cần bắt ngoại lệ `StopIteration`,
+
+ ```py
+ try:
+ next(some_func(3))
+ except StopIteration as e:
+ some_string = e.value
+ ```
+
+ ```py
+ >>> some_string
+ ["wtf"]
+ ```
+
+---
+
+### ▶ Tính phản xạ của Nan *
+
+
+1\.
+
+```py
+a = float('inf')
+b = float('nan')
+c = float('-iNf') # Các strings này không phân biệt hoa hay thường
+d = float('nan')
+```
+
+**Kết quả:**
+
+```py
+>>> a
+inf
+>>> b
+nan
+>>> c
+-inf
+>>> float('some_other_string')
+ValueError: could not convert string to float: some_other_string (Lỗi giá trị: Không thể chuyển đổi từ string sang float)
+>>> a == -c # inf==inf
+True
+>>> None == None # None == None
+True
+>>> b == d # nhưng nan!=nan
+False
+>>> 50 / a
+0.0
+>>> a / a
+nan
+>>> 23 + b
+nan
+```
+
+2\.
+
+```py
+>>> x = float('nan')
+>>> y = x / x
+>>> y is y # định danh giống nhau (cùng trỏ về một đối tượng)
+True
+>>> y == y # Gía trị lại không bằng nhau
+False
+>>> [y] == [y] # Giá trị bằng nhau khi nằm ở trong một list
+True
+```
+
+
+
+#### 💡 Giải thích:
+
+- `'inf'` và `'nan'` là các strings đặc biệt (không phân biệt hoa thường), khi được chuyển đổi sang kiểu `float` sẽ tương ứng biểu diễn cho giá trị vô hạn "infinity" hay không phải là một số "not a number".
+
+- Theo chuẩn của IEEE thì ` NaN != NaN`, tuân theo quy tắc trên sẽ phá vỡ giả định về tính tương phản của một phần tử trong một tập trong Python ví dụ. nếu `x` là một phần tử của một tập `list`, các phép toán trên các phần tử của tập như là so sánh sẽ dựa trên giải định rằng `x == x`. Do giả định này nên định danh được so sánh đầu tiên (do nhanh hơn) khi so sánh hai phần tử, và các giá trị được so sánh chỉ khi các định danh không khớp. Ví dụ sau sẽ giúp bạn dễ hiểu hơn
+ ```py
+ >>> x = float('nan')
+ >>> x == x, [x] == [x]
+ (False, True)
+ >>> y = float('nan')
+ >>> y == y, [y] == [y]
+ (False, True)
+ >>> x == y, [x] == [y]
+ (False, False)
+ ```
+
+ Do các định danh của `x` và `y` khác nhau, do đó giá trị của chúng sẽ được so sánh, mà giá trị của chúng khác nhau trong ví dụ này; nên kết quả trả về là `False`. Cụ thể hơn, theo tiêu chuẩn của IEEE thì `x` f va `y` đểu có giá trị là `nan` khi được chuyển đổi qua float, ` NaN != NaN` nên `x != y`, nhưng khi đặt trong một list thì định danh sẽ đc so sánh trước nên `[x] == [y]`
+
+- Đọc thêm: [Reflexivity, and other pillars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+
+---
+
+### ▶ Mutating the immutable!
+
+
+
+Ví dụ dưới đây có vẻ tầm thường nếu bạn hiểu cách các tham chiếu (references) hoạt đông trong Python.
+```py
+some_tuple = ("A", "tuple", "with", "values")
+another_tuple = ([1, 2], [3, 4], [5, 6])
+```
+
+**Kết quả:**
+```py
+>>> some_tuple[2] = "change this"
+TypeError: 'tuple' object does not support item assignment (Lỗi về kiểu: đối tượng 'tuple' không hỗ trợ phép gán phần tử)
+>>> another_tuple[2].append(1000) # Dòng này không bị lỗi
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000])
+>>> another_tuple[2] += [99, 999]
+TypeError: 'tuple' object does not support item assignment (Lỗi về kiểu: đối tượng 'tuple' không hỗ trợ phép gán phần tử)
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000, 99, 999])
+```
+
+Tôi đã nghĩ rằng các tuples thì bất biến (immutable) ...
+#### 💡 Giải thích:
+
+* Trích từ https://docs.python.org/2/reference/datamodel.html
+
+ > Các chuỗi bất biến
+ Một đối tượng kiểu chuỗi bất biến không thể thay đổi giá trị của nó sau khi được tạo. (Nếu đối tượng này chứa các tham chiếu tới các đối tượng khác, những đối tượng có thể thay đổi được; tuy thế, tập hợp các đối tượng được trỏ trực tiếp bởi một đối tượng bất biến không thể thay đổi .)
+
+* Toán tử `+=` thay đổi list tại chỗ. Phép gán phần tử không thực hiện được, nhưng khi ngoại lệ xảy ra, phần tử đã được thay đổi ngay tại chỗ.
+
+---
+
+### ▶ The disappearing variable from outer scope
+
+
+```py
+e = 7
+try:
+ raise Exception()
+except Exception as e:
+ pass
+```
+
+**Kết quả (Python 2.x):**
+```py
+>>> print(e)
+# Không in ra kết quả nào cả
+```
+
+**Kết quả (Python 3.x):**
+```py
+>>> print(e)
+NameError: name 'e' is not defined (Lỗi tên biến không được định nghĩa)
+```
+
+#### 💡 Giải thích:
+
+* Source: https://docs.python.org/3/reference/compound_stmts.html#except
+
+ Khi một ngoại lệ được gán sử dụng đích được định nghia bởi `as`, ngoại lệ này được dọn dẹp ở cuối câu `except`. Như vậy thì
+
+ ```py
+ except E as N:
+ foo
+ ```
+
+ sẽ được hiểu như sau
+
+ ```py
+ except E as N:
+ try:
+ foo
+ finally:
+ del N
+ ```
+
+
+ Điều này có nghĩa la ngoại lệ phải được gán cho một cái tên khác để ta có thể tìm thấy nó sau câu except. Các ngoại lệ được dọn dẹp bởi vì với truy lỗi (traceback) được gán cho chúng, chúng hình thành nên một vòng tham chiếu bên trong khung ngăn xếp (stack frame), giữ tất cả các biến cục bộ không bị xoá đi cho đến khi việc thu thập rác tiếp theo tiếp diễn.
+
+* Các câu này không được tính phạm vi trong Python. Mọi thư trong ví dụ nay đều nàm trong cùng một phạm vi, và biến `e` bị xoá đi bởi vì ngoại lệ `except`. Điều tương tự như vậy không đúng với các hàm có các nội phạm vi (inner-scopes) riêng biệt. Ví dụ sau sẽ cho ta thấy:
+
+ ```py
+ def f(x):
+ del(x)
+ print(x)
+
+ x = 5
+ y = [5, 4, 3]
+ ```
+
+ **Kết quả:**
+ ```py
+ >>>f(x)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>>f(y)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> x
+ 5
+ >>> y
+ [5, 4, 3]
+ ```
+
+* Trong Python 2.x, biến `e` được gán cho một hiện thực `Exception()`, khi bạn in ra biến này, nó không hiển thị gì cả
+
+ **Kết quả (Python 2.x):**
+ ```py
+ >>> e
+ Exception()
+ >>> print e
+ # Không in ra gì cả!
+ ```
+
+---
+
+
+### ▶ The mysterious key type conversion
+
+```py
+class SomeClass(str):
+ pass
+
+some_dict = {'s': 42}
+```
+
+**Kết quả:**
+```py
+>>> type(list(some_dict.keys())[0])
+str
+>>> s = SomeClass('s')
+>>> some_dict[s] = 40
+>>> some_dict # Giá trị mong đợi: Hai cặp khoá và giá trị khác nhau
+{'s': 40}
+>>> type(list(some_dict.keys())[0])
+str
+```
+
+#### 💡 Giải thích:
+
+* Cả đối tượng `s` và string `"s"` khi được băm (hash) sẽ cho ra cùng một giá trị ởi `SomeClass` thừa kế phương thức `__hash__` của lớp `str`.
+* `SomeClass("s") == "s"` bằng `True` bởi vì `SomeClass` cũng thừa kế phương thức `__eq__` từ lớp `str` .
+* Bởi vì cả hai đối tượng này khi băm cho ra cùng giá trị và bằng nhau nên chúng được biểu diễn bởi cùng một khoá trong từ điển.
+* Để có được kết quả như mong muốn với hai cặp giá khoá và giá trị khác nhau, chúng ta có thể định nghĩa phương thức `__eq__` trong `SomeClass`
+
+ ```py
+ class SomeClass(str):
+ def __eq__(self, other):
+ return (
+ type(self) is SomeClass
+ and type(other) is SomeClass
+ and super().__eq__(other)
+ )
+
+ # Khi chúng ta ta định nghĩa một phương thức __eq__ tuỳ chỉnh, Python tự động dừng việc thừa kế
+ # và chúng ta cũng cần định nghĩa phươn thức __hash__ ,
+ __hash__ = str.__hash__
+
+ some_dict = {'s':42}
+ ```
+
+ **Kết quả:**
+ ```py
+ >>> s = SomeClass('s')
+ >>> some_dict[s] = 40
+ >>> some_dict
+ {'s': 40, 's': 42}
+ >>> keys = list(some_dict.keys())
+ >>> type(keys[0]), type(keys[1])
+ (__main__.SomeClass, str)
+ ```
+
+---
+
+### ▶ Let's see if you can guess this?
+
+```py
+a, b = a[b] = {}, 5
+```
+
+**Kết quả:**
+```py
+>>> a
+{5: ({...}, 5)}
+```
+
+#### 💡 Giải thích:
+
+* Dựa trên [nguồn tham khảo ngôn ngữ Python](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), các câu lệnh gán sẽ có cách khai báo như sau
+ ```
+ (target_list "=")+ (expression_list | yield_expression)
+ ```
+ và
+Một câu lệnh gán đánh giá một danh sách biểu diễn(nhớ rằng đây có thể là một biểu diễn đơn lẻ hoặc một danh sách các biểu diễn được phân cách bởi dấu phẩy, đối với trường hợp phía sau thì sainh ra một tuple) và gán đối tượng kết quả đơn cho mỗi một danh sách mục tiêu, từ trái sang phải.
+
+
+* Toán tử `+` trong `(target_list "=")+` có nghĩa là có thể có **một hay nhiều** danh sách mục tiêu (target lists). Trong trường hợp này, các danh sách mục tiêu là `a, b` và `a[b]` (chú ý là danh sách biểu diễn chỉ có chính xác một, trong trường hợp của chúng ta là `{}, 5`)
+
+
+* Sau khi biểu diễn danh sách được đánh giá, giá trị của nó được giải nén thành các danh sách được giải nén thành các danh sách mục tiêu từ **trái sang phải**. Do đó, trong trường hợp của chúng ta, đầu tiên tuple `{}, 5` được giải nén ra `a, b` và chúng ta có `a = {}` và `b = 5`.
+
+* `a` được gán cho `{}`, đây là một đối tượng có thể thay đổi được giá trị (mutable object).
+
+* Danh sách mục tiêu thứ hai là `a[b]` (bạn có thể có thể nghĩ ta sẽ gặp một lỗi bởi vì cả `a` và `b` đều chưa được định nghĩa trong các câu lệnh trước đó. Nhưng nhớ rằng, chúng ta đã gán `a` bằng `{}` và `b` bằng `5`).
+
+* Bây giờ, chúng ta thiết lập khoá `5` trong từ điển với giá trị là tuple `({}, 5)` tạo ra một tham chiếu vòng tròn (`{...}` trong kết quả trỏ tới cùng một đối tượng mà `a` đã đang tham chiếu). Một ví dụ đơn giản hơn về tham chiếu vòng tròn là
+ ```py
+ >>> some_list = some_list[0] = [0]
+ >>> some_list
+ [[...]]
+ >>> some_list[0]
+ [[...]]
+ >>> some_list is some_list[0]
+ True
+ >>> some_list[0][0][0][0][0][0] == some_list
+ True
+ ```
+ Tương tự là trong ví dụ của chúng ta (`a[b][0]` là cùng đối tượng với `a`)
+
+* Tổng kết lại, bạn có thể chia ví dụ này ra
+ ```py
+ a, b = {}, 5
+ a[b] = a, b
+ ```
+ Và tham chiếu vòng có thể được biện hộ bởi một điều là `a[b][0]` là đối tượng giống `a`
+ ```py
+ >>> a[b][0] is a
+ True
+ ```
+
+---
+---
+
+## Section: Slippery Slopes
+
+### ▶ Modifying a dictionary while iterating over it
+
+```py
+x = {0: None}
+
+for i in x:
+ del x[i]
+ x[i+1] = None
+ print(i)
+```
+
+**Kết quả (Áp dụng cho các phiên bản Python 2.7- Python 3.5):**
+
+```
+0
+1
+2
+3
+4
+5
+6
+7
+```
+
+Vòng lặp chạy đúng *tám* lần rồi dừng lại
+
+#### 💡 Giải thích:
+
+* Việc lặp và chỉnh sửa một từ điển cùng một lúc không được hỗ trợ.
+* Có tám lần chạy bởi vì tại thời điểm dừng đó là lúc từ điển điều chỉnh kích thước để giữ thêm nhiều khoá hơn (chúng ta có tám phần từ xoá, do đó điều chỉnh kích thước là cần thiết). Đây thực sự là một chi tiết trong triển khai.
+* Cách các khoá bị xoá được xử lý và khi nao thì việc điều chỉnh kích thước diễn ra sẽ khác biệt đối với các phiên bản Python khác nhau
+* Do đó các phiên bản Python lớn hơn 2.7 và nhỏ hơn 3.5, số lượng cá khoá có thể giữ dao động từ 8 (nhưng khi bạn chạy thì con số này sẽ không thay đổi giữa các lần chạy). Bạn có thể xem thêm các thảo luận khác ở [đây](https://github.com/satwikkansal/wtfpython/issues/53) hoặc trên Stackoverflow tại [đây](https://stackoverflow.com/questions/44763802/bug-in-python-dict)
+* Từ phiên bản 3.7.6 trở đi, bạn sẽ gặp ngoại lệ `RuntimeError: dictionary keys changed during iteration` khi bạn cố gắng thử ví dụ trên.
+---
+
+### ▶ Stubborn `del` operation
+
+
+
+```py
+class SomeClass:
+ def __del__(self):
+ print("Deleted!")
+```
+
+**Kết quả:**
+1\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x # this should print "Deleted!"
+>>> del y
+Deleted!
+```
+
+
+Có thể bạn đoán được làm sao mà `__del__` không được gọi khi ta cố gắng xoá `x` trong lần đầu tiên. Hãy thử thêm
+2\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x
+>>> y # check if y exists Kiểm tra y có tồn tại
+<__main__.SomeClass instance at 0x7f98a1a67fc8>
+>>> del y # Như lần trước, đáng lẽ kết quả nên là in ra "Deleted!"
+>>> globals() # nhưng không, ta không có được kết quả như mong muốn. Cùng kiểm tra tất cả các biến toàn cục và xác nhận
+Deleted!
+{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}
+```
+
+Ok giờ thì nó đã được xoá :confused:
+
+#### 💡 Giải thích:
++ `del x` không gọi trực tiếp `x.__del__()`.
++ Khi `del x` được chạy, Python xoá tên `x` khỏi phạm vi hiện hành và giảm biến đếm tham chiếu của đối tượng đi 1. `__del__()` được gọi chỉ khi biến đếm này giảm xuống 0.
++ Tron đoạn mã thứ hai, `__del__()` không được gọi bởi vì câu lệnh trước đó (`>>> y`) tạo một tham chiếu khác tới cùng một đối tượng (cụ thể là, biến `_` trỏ tới giá trị kết quả của một biểu diễn không phải `None` tron REPL), do đó ngăn biến đếm tham chiếu giảm về 0 khi thực hiện `del y`
++ Gọi `globals` (thực ra thì thực hiện bất cứ thứ gì tạo ra kết quả không phải là `None`) làm cho `_` tham chiếu tới kết quả mới, bỏ đi tham chiếu hiện tồn tại. Bây giờ thì biến đếm tham chiếu giảm ve 0 và bạn có thể từ "Deleted!" được hiển thị.
+---
+
+### ▶ The out of scope variable
+
+```py
+a = 1
+def some_func():
+ return a
+
+def another_func():
+ a += 1
+ return a
+```
+
+**Kết quả:**
+```py
+>>> some_func()
+1
+>>> another_func()
+UnboundLocalError: local variable 'a' referenced before assignment (tham chiếu tới 'a' trước khi gán giá trị)
+```
+
+#### 💡 Giải thích:
+* Khi bạn gán giá trị cho một biến trong một phạm vi, thì biến này trở thành cục bộ cho phạm vi đó. Do đó `a` trở thành cục bộ đối với `another_func`, nhưng nó chưa được khởi tạo trong cùng phạm vi, nên ta gặp lỗi về tham chiếu phía trên.
+* Đọc [bài này](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) để học về cách hoạt động của các không gian tên (namespaces) và việc phân giải phạm vi trong Python.
+* Để thay đổi biên bên ngoài phạm vi `a` bên trong hàm `another_func`, sử dụng từ khoá `global`
+ ```py
+ def another_func()
+ global a
+ a += 1
+ return a
+ ```
+
+ **Kết quả:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+
+---
+
+### ▶ Deleting a list item while iterating
+
+```py
+list_1 = [1, 2, 3, 4]
+list_2 = [1, 2, 3, 4]
+list_3 = [1, 2, 3, 4]
+list_4 = [1, 2, 3, 4]
+
+for idx, item in enumerate(list_1):
+ del item
+
+for idx, item in enumerate(list_2):
+ list_2.remove(item)
+
+for idx, item in enumerate(list_3[:]):
+ list_3.remove(item)
+
+for idx, item in enumerate(list_4):
+ list_4.pop(idx)
+```
+
+**Kết quả:**
+```py
+>>> list_1
+[1, 2, 3, 4]
+>>> list_2
+[2, 4]
+>>> list_3
+[]
+>>> list_4
+[2, 4]
+```
+
+Vì sao lại có kết quả là `[2, 4]`?
+#### 💡 Giải thích:
+
+* Thay đổi đối tượng trong khi lặp không phải là một cách làm hay. Cách thực hiện đúng là lặp qua một bản sao của chính đối tượng đó như trường hợp sử dụng `list_3[:]`
+
+ ```py
+ >>> some_list = [1, 2, 3, 4]
+ >>> id(some_list)
+ 139798789457608
+ >>> id(some_list[:]) # Chú ý rằng Python tạo một đối tượng mới sinh ra từ việc cắt (slice) list.
+ 139798779601192
+ ```
+
+**Sự khác biệt giữa `del`, `remove`, và `pop`:**
+* `del var_name` chỉ loại bỏ sự có măt của `var_name` khỏi khô gian tên cục bộ và toàn cục (đó la lý do tại sao `list_1` không bị ảnh hưởng )
+* `remove` loại bỏ giá trị được khớp đầu tiên, không phải tại một chỉ số cụ thể, ngoại lệ `ValueError` sẽ xảy ra nếu giá trị muốn loại bỏ không tồn tại.
+* `pop` loại bỏ phần tử của danh sách ở mỗi chỉ số cụ thể và trả về phần từ đó, `pop` sẽ khởi lên `IndexError` nếu nó nhận một chỉ số không hợp lệ
+
+**Tại sao kết quả lại ra `[2, 4]`?**
+- Việc lặp qua danh sách được thực hiện theo từng chỉ số một, và khi chúng ta loại bỏ `1` khỏi `list_2` hay `list_4`, các danh sách này sẽ còn lại `[2, 3, 4]`. Các phần tử còn lại trong list được dịch chuyển sang trái, ví dụ như `2` sẽ có chỉ số là 0, và `3` có chỉ số là 1. Do lần lặp tiếp theo sẽ xử lý phần tử có chỉ số là 1 (`3`), nên phần tử tại chỉ số 0 (`2`) sẽ bị bỏ qua.
+
+* Xem thêm tại StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example
+* Và xem thêm ở đây để có các ví dụ liên quan tới các từ điển [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items).
+
+---
+
+
+### ▶ Lossy zip of iterators *
+
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three))
+[(0, 0), (1, 1), (2, 2)]
+# so far so good, let's zip the remaining
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Phần tử `3` trong `numbers` đâu?
+#### 💡 Giải thích:
+
+- Theo tài liệu của Python [docs](https://docs.python.org/3.3/library/functions.html#zip), triển khai gần nhất của hàm zip như sau,
+ ```py
+ def zip(*iterables):
+ sentinel = object()
+ iterators = [iter(it) for it in iterables]
+ while iterators:
+ result = []
+ for it in iterators:
+ elem = next(it, sentinel)
+ if elem is sentinel: return
+ result.append(elem)
+ yield tuple(result)
+ ```
+- Hàm này nhận vào một số tuỳ ý các đối tượng có thể lặp (iterable objects), thêm mỗi phần tử của các đối tượng này vào danh sách `result` thông qua việc gọi hàm `next` trên đối tượng này, và dưng lại khi đôi tượng này hết các phần tử để lặp
+- Chú ý là khi bất cứ đối tượng lặp nào cạn kiệt đối tượng lặp, các phần tử tồn tại trong danh sách `result` được bỏ qua. Đó là những gì xảy với `3` trong `numbers_iter`
+- Để thực hiện đúng, ta cần làm như sau
+ ```py
+ >>> numbers = list(range(7))
+ >>> numbers_iter = iter(numbers)
+ >>> list(zip(first_three, numbers_iter))
+ [(0, 0), (1, 1), (2, 2)]
+ >>> list(zip(remaining, numbers_iter))
+ [(3, 3), (4, 4), (5, 5), (6, 6)]
+ ```
+ Tham số đầu tiên của zip nên là đối tượng có số lượng các phần tử ít nhất.
+
+---
+
+### ▶ Loop variables leaking out!
+
+1\.
+```py
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Kết quả:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+Nhưng mà `x` chưa bao giờ được định nghĩa bên ngoài vòng lặp...
+2\.
+```py
+# Lần này khởi tạo x trước
+x = -1
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Kết quả:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+3\.
+
+**Kết quả (Python 2.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+4
+```
+
+**Kết quả (Python 3.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+1
+```
+
+#### 💡 Giải thích:
+
+- Trong Python, vòng lặp for sử dụng phạm vi mà chúng tồn tại bên trong và để biến lặp (loop-variable) đã được định nghĩa của chúng đằng sau. Điều này cũng áp dụng khi chúng ta định nghĩa rõ biến lặp trong không gian tên toàn cục trước đó. Trong trường hợp này vòng lặp sẽ gắn lại biến đã tồn tại.
+
+- Sự khác nhau giữa kết quả của trình thông dịch Python 2.x và Python 3.x liên quan tới ví dụ list comprehension có thể được giải thích bằng tài liệu [Những điều mới trong Python 3.0](https://docs.python.org/3/whatsnew/3.0.html):
+
+ > "List comprehensions không còn hỗ trợ dạng cú pháp `[... for var in item1, item2, ...]`. Hãy Sử dụng `[... for var in (item1, item2, ...)]`. Còn nữa, chú ý rằng list comprehensions có các ngữ nghĩa khác nhau: chúng khá gần với cú pháp đặc biệt của một biểu diễn generator bên trong hàm xây dựng `list()` , và cụ thể là, các biến điều khiển vòng lặp không còn bị rò rỉ (leaked) trong phạm vi xung quanh"
+
+---
+
+### ▶ Beware of default mutable arguments!
+
+
+```py
+def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+```
+
+**Kết quả:**
+```py
+>>> some_func()
+['some_string']
+>>> some_func()
+['some_string', 'some_string']
+>>> some_func([])
+['some_string']
+>>> some_func()
+['some_string', 'some_string', 'some_string']
+```
+
+#### 💡 Giải thích:
+
+- Các tham số mặc định có kiểu giá trị thay đổi được (mutable) của các hàm trong Python không thực sự được khởi tạo mỗi lần ta gọi hàm. Thay vào đó giá trị trị mới được gán cho chúng được sử dụng với vai trò giá trị mặc định. Khi ta truyền vào hàm `some_func` giá trị `[]`, giá trị mặc định của biến `default_arg` không được sử dụng, do đó hàm trả về kết quả như mong đợi
+
+ ```py
+ def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+ **Kết quả:**
+ ```py
+ >>> some_func.__defaults__ # Thuộc tính này sẽ cho ta thấy các giá trị mặc định của tham số truyền vào hàm
+ ([],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string'],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ >>> some_func([])
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ ```
+
+- Để tránh các bugs liên quan tới các tham số có thể thay đổi giá trị, ta có thể gán cho chúng giá trị mặc định là `None` và sau đó viết mã kiểm tra xem giá trị truyền vào hàm có tương ứng với tham số đó hay không. Ví dụ:
+
+ ```py
+ def some_func(default_arg=None):
+ if default_arg is None:
+ default_arg = []
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+---
+
+### ▶ Catching the Exceptions
+
+```py
+some_list = [1, 2, 3]
+try:
+ # Câu lệnh sau sẽ gây ra ngoại lệ ``IndexError``
+ print(some_list[4])
+except IndexError, ValueError:
+ print("Caught!")
+
+try:
+ # Câu lệnh sau sẽ gây ra ngoại lệ ``ValueError``
+ some_list.remove(4)
+except IndexError, ValueError:
+ print("Caught again!")
+```
+
+**Kết quả (Python 2.x):**
+```py
+Caught!
+
+ValueError: list.remove(x): x not in list
+```
+
+**Kết quả (Python 3.x):**
+```py
+ File "", line 3
+ except IndexError, ValueError:
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Giải thích
+
+* Để thêm nhiều ngoại lệ trên cùng một dòng except, bạn cần truyền vào một tuple với các ngoại lệ được liệt kê bên trong hai dấu ngoặc đơn. Ví dụ,
+ ```py
+ some_list = [1, 2, 3]
+ try:
+ # This should raise a ``ValueError``
+ some_list.remove(4)
+ except (IndexError, ValueError), e:
+ print("Caught again!")
+ print(e)
+ ```
+ **Kết quả (Python 2.x):**
+ ```
+ Caught again!
+ list.remove(x): x not in list
+ ```
+ **Kết quả (Python 3.x):**
+ ```py
+ File "", line 4
+ except (IndexError, ValueError), e:
+ ^
+ IndentationError: unindent does not match any outer indentation level
+ ```
+
+* Tách biệt ngoại lệ với biến dùng dấu phẩy đã khôn còn được áp dụng nữa và khi viết như vậy thi code sẽ không chạy trong Python 3; Cách làm đúng là sử dụng `as`. Ví dụ,
+ ```py
+ some_list = [1, 2, 3]
+ try:
+ some_list.remove(4)
+
+ except (IndexError, ValueError) as e:
+ print("Caught again!")
+ print(e)
+ ```
+ **Kết quả:**
+ ```
+ Caught again!
+ list.remove(x): x not in list
+ ```
+
+---
+
+### ▶ Same operands, different story!
+
+1\.
+```py
+a = [1, 2, 3, 4]
+b = a
+a = a + [5, 6, 7, 8]
+```
+
+**Kết quả:**
+```py
+>>> a
+[1, 2, 3, 4, 5, 6, 7, 8]
+>>> b
+[1, 2, 3, 4]
+```
+
+2\.
+```py
+a = [1, 2, 3, 4]
+b = a
+a += [5, 6, 7, 8]
+```
+
+**Kết quả:**
+```py
+>>> a
+[1, 2, 3, 4, 5, 6, 7, 8]
+>>> b
+[1, 2, 3, 4, 5, 6, 7, 8]
+```
+
+#### 💡 Giải thích:
+
+* `a += b` không phải luôn luôn cho ra kết quả giống như `a = a + b`. Các lơp *có thể* triển khai phép *`op=`* khác nhau.
+
+* Biểu diễn `a = a + [5,6,7,8]` sinh ra một danh sách mới và tham chiếu của `a` trỏ tới danh sách mới, và để cho `b` không đổi.
+* Biển diễn `a += [5,6,7,8]` thực sự tương đương vơi hàm "mở rộng" áp dụng cho danh sách ơ đó `a` và `b` vẫn trỏ về cùng một danh sách đã được thay đổi ngay tại chỗ.
+
+---
+
+### ▶ Name resolution ignoring class scope
+
+1\.
+```py
+x = 5
+class SomeClass:
+ x = 17
+ y = (x for i in range(10))
+```
+
+**Kết quả:**
+```py
+>>> list(SomeClass.y)[0]
+5
+```
+
+2\.
+```py
+x = 5
+class SomeClass:
+ x = 17
+ y = [x for i in range(10)]
+```
+
+**Kết quả (Python 2.x):**
+```py
+>>> SomeClass.y[0]
+17
+```
+
+**Kết quả (Python 3.x):**
+```py
+>>> SomeClass.y[0]
+5
+```
+
+#### 💡 Giải thích
+- Các phạm vi được lồng bên trong định nghĩa của lớp lờ đi các tên (biến) được khai báo ở mức lớp (biến gán với lớp)
+- Biễn diễn bộ sinh (generator) có phạm vi riêng của chúng
+- Bắt đầu từ Python 3.X, các list comprehensions cũng có phạm riêng của chúng
+
+---
+
+### ▶ Needles in a Haystack *
+
+
+
+Tôi chưa bao giờ gặp một lập trình viên Python kinh nghiệm nào mà chưa gặp phải một trong những tình huống éo le dưới đây
+1\.
+
+```py
+x, y = (0, 1) if True else None, None
+```
+
+**Kết qủa:**
+
+```py
+>>> x, y # Kết quả mong đợi (0, 1)
+((0, 1), None)
+```
+
+2\.
+
+```py
+t = ('one', 'two')
+for i in t:
+ print(i)
+
+t = ('one')
+for i in t:
+ print(i)
+
+t = ()
+print(t)
+```
+
+**Kết quả:**
+
+```py
+one
+two
+o
+n
+e
+tuple()
+```
+
+3\.
+
+```
+ten_words_list = [
+ "some",
+ "very",
+ "big",
+ "list",
+ "that"
+ "consists",
+ "of",
+ "exactly",
+ "ten",
+ "words"
+]
+```
+
+**Kết quả**
+
+```py
+>>> len(ten_words_list)
+9
+```
+
+4\. Not asserting strongly enough
+
+```py
+a = "python"
+b = "javascript"
+```
+
+**Kết quả:**
+
+```py
+# Gọi một câu lệnh assert với một thông điệp chỉ rõ lý do bị lỗi
+>>> assert(a == b, "Both languages are different")
+# Không thấy một ngoại lệ lỗi AssertionError
+```
+
+5\.
+
+```py
+some_list = [1, 2, 3]
+some_dict = {
+ "key_1": 1,
+ "key_2": 2,
+ "key_3": 3
+}
+
+some_list = some_list.append(4)
+some_dict = some_dict.update({"key_4": 4})
+```
+
+**Kết quả:**
+
+```py
+>>> print(some_list)
+None
+>>> print(some_dict)
+None
+```
+
+6\.
+
+```py
+def some_recursive_func(a):
+ if a[0] == 0:
+ return
+ a[0] -= 1
+ some_recursive_func(a)
+ return a
+
+def similar_recursive_func(a):
+ if a == 0:
+ return a
+ a -= 1
+ similar_recursive_func(a)
+ return a
+```
+
+**Kết quả:**
+
+```py
+>>> some_recursive_func([5, 0])
+[0, 0]
+>>> similar_recursive_func(5)
+4
+```
+
+#### 💡 Giải thích:
+
+* Trường hợp thứ nhất cách viết để có kết quả như mong đợi là `x, y = (0, 1) if True else (None, None)`.
+
+* Trong trường hợp thứ hai cách viết đúng phải là `t = ('one',)` hoặc `t = 'one',` (có thêm dấu phẩy phía sau) nếu không trình thông dịch sẽ xem `t` như là một `str` và lặp qua từng kí tự của string này.
+
+* `()` là một cặp kí hiệu đặc biệt định nghĩa một `tuple` rỗng.
+
+* Trong ví dụ thứ ba, bạn có thể để ý thấy thiếu một dấu phẩy đằng sau phần tử thứ 5 (`"that"`) của danh sách. Do đó, Python ngầm nối hai string liền kề,
+ ```py
+ >>> ten_words_list
+ ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
+ ```
+
+* Không có ngoại lệ `AssertionError` trong ví dụ thứ tư bởi vì thay vì kiểm tra tính đúng sai của biểu diễn `a == b`, chúng ta kiểm tra một tuple. Ví dụ dưới đây làm rõ hơn điều này,
+ ```py
+ >>> a = "python"
+ >>> b = "javascript"
+ >>> assert a == b
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError
+
+ >>> assert (a == b, "Values are not equal")
+ :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+ >>> assert a == b, "Values are not equal"
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError: Values are not equal
+ ```
+
+* Trong ví dụ thứ năm, hầu hết các phương thức thay đổi các phần tử của các đối tượng chuỗi (sequence) hay ánh xạ như `list.append`, `dict.update`,`list.sort`, và vân vân. thay đổi ngay tại chỗ (in-place) các đối tượng này và trả về `None`. Nguyên nhân sâu xa là nhằm tăng hiệu năng thông qua việc tránh tạo bản sao của đối tượng nếu hành động được thực hiện trên đối tượng mang tính "ngay tại chỗ" (Tham khảo thêm tại [đây](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+* Trường hợp cuối cùng dường như khá rõ rằng, đối tượng có thể thay đổi giá trị (như `list` ) có thể được thay đổi trong hàm, và việc gán biến này lại cho một đối tượng không thể thay đổi giá trị ()`a -= 1` không làm thay đổi giá trị.
+* Lưu ý đến những điều kể trên có thể giúp bạn tiết kiệm được nhiều thời gian cho việc tìm sửa lỗi trong các chương trình lớn.
+---
+
+
+### ▶ Splitsies *
+
+```py
+# thực hiện câu lệnh này
+>>> 'a'.split()
+['a']
+
+# cũng giống như
+>>> 'a'.split(' ')
+['a']
+
+# nhưng khi chạy
+>>> len(''.split())
+0
+
+# lại cho kết quả không giống nhau
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Giải thích:
+
+- Ta dường như thấy ngay là kí tự phân cách mặc định dùng cho split là một khoảng cách đơn (single space) `' '`, nhưng trong tài liệu [docs] (https://docs.python.org/2.7/library/stdtypes.html#str.split)
+ > Nếu kí tự phân cách không được chỉ định hoặc là `None`, một giải thuật chia tách khác được áp dụng: các khoảng trắng liên tục được xem như là một phân cách đơn, và kết quả sẽ chứa các strings khác rỗng tại phần đầu hoặc cuối nếu string có các khoảng trắng ở phần đầu và đuôi. Do vậy, phân tách một string rỗng hoặc một string chứa chỉ khoảng trắng với một phân tách None sẽ trả về `[]`.
+ > Nếu có kí tự phân cách, các dấu phân cách liên tục không được nhóm lại cùng nhau và được coi là để phân định các strings rỗng (ví dụ, `'1,,2'.split(',')` trả về `['1', '', '2']`). Phân tách một string rỗng với một kí tự phân tách chỉ định trả về `['']`.
+- Ví dụ dưới đây chỉ ra cách các khoảng trắng được xử lý,
+ ```py
+ >>> ' a '.split(' ')
+ ['', 'a', '']
+ >>> ' a '.split()
+ ['a']
+ >>> ''.split(' ')
+ ['']
+ ```
+
+---
+
+### ▶ Wild imports *
+
+
+
+```py
+# File: module.py
+
+def some_weird_name_func_():
+ print("works!")
+
+def _another_weird_name_func():
+ print("works!")
+
+```
+
+**Kết quả**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Giải thích:
+
+- Chúng ta được khuyên là tránh sử dụng các wildcard imports. Vì với chúng, các tên (ví dụ hàm) với dấu gạch chân phía trước sẽ không được import. Điều này gây ra lỗi trong lúc code chạy
+- Khi chúng ta dùng `from ... import a, b, c`, lỗi `NameError` sẽ khôn xảy ra nữa.
+ ```py
+ >>> from module import some_weird_name_func_, _another_weird_name_func
+ >>> _another_weird_name_func()
+ works!
+ ```
+- Nếu bạn thực sự muốn sử dụng wildcard imports, bạn se phải định nghĩa biến `__all__` trong module của bạn, biến này sẽ chưa một danh sách các đối tượng công cộng được import khi sử dụng wildcard imports.
+ ```py
+ __all__ = ['_another_weird_name_func']
+
+ def some_weird_name_func_():
+ print("works!")
+
+ def _another_weird_name_func():
+ print("works!")
+ ```
+ **Kết quả**
+
+ ```py
+ >>> _another_weird_name_func()
+ "works!"
+ >>> some_weird_name_func_()
+ Traceback (most recent call last):
+ File "", line 1, in
+ NameError: name 'some_weird_name_func_' is not defined (hàm "some_weird_name_func_" không được định nghĩa)
+ ```
+
+---
+
+### ▶ All sorted? *
+
+
+
+```py
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
+
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
+```
+
+#### 💡 Giải thích:
+
+- Phương thức `sorted` luôn luôn trả về một list, và trong Python so sánh giữa lists và tuples luôn luôn cho ra kết quả `False`.
+- ```py
+ >>> [] == tuple()
+ False
+ >>> x = 7, 8, 9
+ >>> type(x), type(sorted(x))
+ (tuple, list)
+ ```
+
+- Khác với `sorted`, phương thức `reversed` trả về một iterator. Tại sao? Bởi vì việc sắp xếp yêu cầu iterator có thể được thay đổi ngay tại chỗ (in-place) hoặc sử dụng một bộ chứa bổ sung (một list), trái lại việc đảo chiều (reversing) có thể hoạt động đơn giản là lặp từ chỉ số cuối về phần tử đầu
+- Do đó khi so sánh `sorted(y) == sorted(y)`, lời gọi đầu tiên `sorted()` sẽ tiêu thụ iterator `y`, và lời gọi tiếp theo sẽ trả về một list rỗng.
+
+ ```py
+ >>> x = 7, 8, 9
+ >>> y = reversed(x)
+ >>> sorted(y), sorted(y)
+ ([7, 8, 9], [])
+ ```
+
+---
+
+### ▶ Midnight time doesn't exist?
+
+```py
+from datetime import datetime
+
+midnight = datetime(2018, 1, 1, 0, 0)
+midnight_time = midnight.time()
+
+noon = datetime(2018, 1, 1, 12, 0)
+noon_time = noon.time()
+
+if midnight_time:
+ print("Time at midnight is", midnight_time)
+
+if noon_time:
+ print("Time at noon is", noon_time)
+```
+
+**Kết quả (< 3.5):**
+
+```py
+('Time at noon is', datetime.time(12, 0))
+```
+Thời gian nửa đêm không được hiển thị
+#### 💡 Giải thêm:
+
+Trước Python 3.5, giá trị luận lý cho đối tượng `datetime.time` được xem như là `False` nếu đối tượng này biểu diễn nửa đêm trong UTC. Code dễ sai khi sử dụng cú pháp `if obj:` để kiểm tra `obj` là null hay những giá trị tương tương với "rỗng".
+
+---
+---
+
+
+
+## Section: The Hidden treasures!
+
+Phần này bao gồm những điều ít được biết tới về Python, những điều hấp dẫn này hầu hết những người mới bắt đầu như tôi đều không biết
+
+### ▶ Okay Python, Can you make me fly?
+
+Hãy bắt đầu nào
+
+```py
+import antigravity
+```
+
+**Kết quả:**
+Sshh... Một bí mật lớn.
+
+#### 💡 Giải thích:
++ `antigravity` là một trong vài quả trứng phục sinh được tạo ra bởi các lập trình viên Python
++ `import antigravity` mở trang web [truyện hài XKCD ](http://xkcd.com/353/) trong một trình duyệt.
++ Còn nhiều hơn thế nữa. Có các **quả trứng phục sinh khác bên trong quả trứng phục sinh**. Nếu bạn xem đoạn [mã] (https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), có một hàm được định nghĩa để triển khai [Giải thuật geohashing của XKCD]
+
+---
+
+### ▶ `goto`, but why?
+
+
+```py
+from goto import goto, label
+for i in range(9):
+ for j in range(9):
+ for k in range(9):
+ print("I am trapped, please rescue!")
+ if k == 2:
+ goto .breakout # breaking out from a deeply nested loop
+label .breakout
+print("Freedom!")
+```
+
+**Kết quả (Python 2.3):**
+```py
+I am trapped, please rescue!
+I am trapped, please rescue!
+Freedom!
+```
+
+#### 💡 Giải thích:
+- Một phiên bản Python của `goto` được [công bố](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) trong ngày cá tháng tư năm 2004 như là một lời đùa.
+- Các phiên bản Python hiện hành không có module này.
+- Mặc dù triển khai `goto` chạy được, nhưng đừng sử dụng nó. [Lý do](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) tại sao Python không có `goto`.
+
+---
+
+### ▶ Brace yourself!
+
+Nếu bạn không thích sử dụng khoảng trắng để biểu thị các phạm vi, bạn có thể sử dụng phonng cách như trong ngôn ngữ C {} bằng cách import
+```py
+from __future__ import braces
+```
+
+**Kết quả:**
+```py
+ File "some_file.py", line 1
+ from __future__ import braces
+SyntaxError: not a chance
+```
+
+Các dấu ngoặc nhọn? Không được đâu! Nếu bạn nghĩ rằng điều gây thất vọng, sử dụng Java. Còn một điều ngạc nhiên nữa đây, bạn có thể tìm thấy ngoại lệ `SyntaxError` được khởi lên ở đâu trong module `__future__` hay không (https://github.com/python/cpython/blob/master/Lib/__future__.py)?
+
+#### 💡 Giải thích:
++ Module `__future__` thường được dùng để cung cấp các tính năng đến từ các phiên bản mới của Python. Tuy nhiên "tương lai" ("feature") trong hoàn cảnh này có vẻ hơi mỉa mai.
++ Có một quả trứng phục sinh liên quan đến tâm trạng của cộng đồng Python về vấn đề này.
++ Đoạn mã được tìm thấy [ở đây](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) trong file `future.c`.
++ Khi trình biên dịch Cpython gặp một [câu lệnh future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), Nó chạy đoạn mã tương ứng trong `future.c` trước khi thực hiện câu lệnh import thông thường.
+
+---
+
+### ▶ Let's meet Friendly Language Uncle For Life
+
+**Output (Python 3.x)**
+```py
+>>> from __future__ import barry_as_FLUFL
+>>> "Ruby" != "Python" # chả có gì phải nghi ngờ về câu lệnh so sánh này cả
+ File "some_file.py", line 1
+ "Ruby" != "Python"
+ ^
+SyntaxError: invalid syntax
+
+>>> "Ruby" <> "Python"
+True
+```
+
+Rồi! có thứ để xem.
+
+
+#### 💡 Giải thích:
+- Điều ta muốn tìm hiểu liên quan tới [PEP-401](https://www.python.org/dev/peps/pep-0401/), PEP này được xuất bản vào ngày một tháng tư năm 2009 (là gì thì bạn biết rồi đó).
+- Đoạn dưới đây được trích ra từ PEP-401
+
+ > Nhận ra rằng kí hiệu toán tử so sánh không bằng != trong Python 3.0 thấy gớm, gõ thật khó, FLUFL khôi phục lại kí hiệu hình kim cương <>.
+- Bạn nhiều thứ đáng xem trong PEP này; bạn có thể đọc chúng [ở đây]
+(https://www.python.org/dev/peps/pep-0401/).
+- Toán tử hình kim cương này hoạt động tốt trong môi trường tương tác, nhưng lại gây ra ngoại lệ `SyntaxError` khi chạy qua file python (hãy xem [vấn đề](https://github.com/satwikkansal/wtfpython/issues/94)). Tuy nhiên bạn có thể gói câu lệnh này vào trong hàm `eval` hoặc `compile` để chạy được.
+ ```py
+ from __future__ import barry_as_FLUFL
+ print(eval('"Ruby" <> "Python"'))
+ ```
+
+---
+
+### ▶ Even Python understands that love is complicated
+
+```py
+import this
+```
+
+Nào, **this** là gì thế? `this` là tình yêu :heart:
+
+**Kết quả:**
+```
+The Zen of Python, by Tim Peters
+
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it.
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than *right* now.
+If the implementation is hard to explain, it's a bad idea.
+If the implementation is easy to explain, it may be a good idea.
+Namespaces are one honking great idea -- let's do more of those!
+```
+
+`this` là Thiền của Python!
+
+```py
+>>> love = this
+>>> this is love
+True
+>>> love is True
+False
+>>> love is False
+False
+>>> love is not True or False
+True
+>>> love is not True or False; love is love # Tình yêu thật phức tạp
+True
+```
+
+#### 💡 Giải thích:
+* Module `this` trong Python là một quả trứng phục sinh cho Thiền của Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
+* Và nếu bạn thấy nó hứng thú, hãy xem mã triển khai của [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Hấp dẫn thay, **mã của Thiền lại vi phạm chính quy tắc thiền**
+* Nói về câu `love is not True or False; love is love`, mỉa mai thay câu nay tự thấy nó co nghĩa (nếu không, hay xnhinf cá ví dụ liên quan tới `is` và `is not`)
+---
+
+### ▶ Yes, it exists!
+
+** Khối `else` của các vòng lặp .** Dưới đây là một ví dụ điển hình:
+
+```py
+ def does_exists_num(l, to_find):
+ for num in l:
+ if num == to_find:
+ print("Exists!")
+ break
+ else:
+ print("Does not exist")
+```
+
+**Kết quả:**
+```py
+>>> some_list = [1, 2, 3, 4, 5]
+>>> does_exists_num(some_list, 4)
+Exists! (Tồn tại)
+>>> does_exists_num(some_list, -1)
+Does not exist (Không tồn tại)
+```
+
+**Khối `else` trong xử lý ngoại lệ.** Một ví dụ,
+
+```py
+try:
+ pass
+except:
+ print("Exception occurred!!!")
+else:
+ print("Try block executed successfully...")
+```
+
+**Kết quả:**
+```py
+Try block executed successfully...
+```
+
+#### 💡 Giải thích:
+- Khối `else` sau một vòng lặp được thực hiện chỉ khi trong quá trình lặp không có một `break` nào. Bạn có thể nghĩ nó như là một khối "không ngắt" ("nobreak")
+- Khối `else` sau một khối try còn được gọi la "khối hoàn tất" đó khi các câu lệnh trong khối này sẽ được thực thi khi khối try hoàn thành trọn vẹn công việc của mình.
+
+---
+### ▶ Ellipsis *
+
+```py
+def some_func():
+ Ellipsis
+```
+
+**Kết quả**
+```py
+>>> some_func()
+# No output, No Error
+
+>>> SomeRandomString
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Giải thích
+- Trong Python, `Ellipsis` là một đối tượng có sẵn, toàn cục tương đương với `...`.
+ ```py
+ >>> ...
+ Ellipsis
+ ```
+- Eliipsis có thể được sử dụng cho các mục đích sau
+ + Là một đối tượng "xí chỗ" cho mã chưa được viết (như câu lệnh `pass`)
+ + Trong cú pháp lát cắt (slicing syntax), nó được dùng để biểu diễn các lát cắt đầy đủ theo hướng còn lại
+ + In slicing syntax to represent the full slices in remaining direction
+ ```py
+ >>> import numpy as np
+ >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
+ array([
+ [
+ [0, 1],
+ [2, 3]
+ ],
+
+ [
+ [4, 5],
+ [6, 7]
+ ]
+ ])
+ ```
+ `three_dimensional_array` là một mảng của mảng của các mảng. Nào, chúng ta muốn in ra phần tử thứ hai (chỉ số `1`) của tất cả các mảng phía trong cùng, chugns ta có thể sử dụng Ellipsis để "chơi chiêu qua mặt" (bypass) tất cả các chiều (dimensions) phía trước đó.
+ ```py
+ >>> three_dimensional_array[:,:,1]
+ array([[1, 3],
+ [5, 7]])
+ >>> three_dimensional_array[..., 1] # using Ellipsis.
+ array([[1, 3],
+ [5, 7]])
+ ```
+ Chú ý rằng: cách trên có thể thực trên bất cứ mảng với số lượng chiều nào. Bạn có thể lựa trên lát cắt (slice) trước và chiều cuối cùng và lờ đi các chiều nằm ở giữa (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`)
+ + Trong [Gợi ý kiểu](https://docs.python.org/3/library/typing.html), Ellipsis được dùng để chỉ ra một phần của kiểu (như là `(Callable[..., int]` hay `Tuple[str, ...]`))
+ + Bạn có thể sử dụng Ellipsis như là một tham số hàm mặc định (trong những trường hợp bạn muốn phân biệt giữa hai tính huống "không có tham số được truyền vào") và "giá trị None được truyền vào"
+
+---
+
+### ▶ Inpinity
+
+Việc viết sai chính tả là chủ ý.
+**Kết quả (Python 3.x):**
+```py
+>>> infinity = float('infinity')
+>>> hash(infinity)
+314159
+>>> hash(float('-inf'))
+-314159
+```
+
+#### 💡 Giải thích:
+- Mã băm của vô cực là 10⁵ x π.
+- Thú vị là ở chỗ trong Python 3 mã băm của `float('-inf')` là "-10⁵ x π", trái lại trong Python là "-10⁵ x e"
+---
+
+### ▶ Let's mangle
+
+1\.
+```py
+class Yo(object):
+ def __init__(self):
+ self.__honey = True
+ self.bro = True
+```
+
+**Kết quả:**
+```py
+>>> Yo().bro
+True
+>>> Yo().__honey
+AttributeError: 'Yo' object has no attribute '__honey' (Đối tượng 'Yo' không có thuộc tính '__honey')
+>>> Yo()._Yo__honey
+True
+```
+
+2\.
+```py
+class Yo(object):
+ def __init__(self):
+ # Let's try something symmetrical this time
+ self.__honey__ = True
+ self.bro = True
+```
+
+**Kết quả:**
+```py
+>>> Yo().bro
+True
+
+>>> Yo()._Yo__honey__
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'Yo' object has no attribute '_Yo__honey__' (Đối tượng 'Yo' không có thuộc tính '_Yo__honey__')
+```
+
+Tại sao `Yo()._Yo__honey` lại gây ra lỗi?
+
+3\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+ def some_func(self):
+ return __variable # (biến này chưa được khởi tạo)
+```
+
+**Kết quả:**
+```py
+>>> A().__variable
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'A' object has no attribute '__variable' (Đối tượng 'A' không có thuộc tính '__variable')
+
+>>> A().some_func()
+'Some value'
+```
+
+
+#### 💡 Giải thích:
+
+* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) được sử dụng để tránh việc đụng độ về tên (names) giữa các không gian tên (namespaces).
+* Trong Python, trình thông dịch thay đổi (mangles) tên của các thành viên của một lớp mà bắt đầu với `__` (hai dấu gạch chân liền nhau hay còn gọi là "dunder") và các tên không thúc với nhiều hơn một dấu gạch chân bằng việc thêm vào `_TênCủaLớp` vào trước đó
+* Vì vậy, để truy cập vào thuộc tính `__honey` trong đoạn mã đầu tiên, bạn phải nối `_Yo` vào phía trước, để ngăn việc xung đột với thuộc tính có cùng tên trong lớp khác.
+* Nhưng tại sao trong đoạn mã thứ hai mặc dù đã dung tên đúng nhưng ta vẫn không truy cập được vào thuộc tính? Bởi vì cách thức mangling này không áp dụng đối với các tên biến kết thúc với hai dấu gạch chân.
+* Đoạn mã thứ ba cũng là kết quả của việc mangling. Tên `__variable` trong câu lệnh `return __variable` được chuyển thành `_A__variable`, và lại vô tình trùng với tên biến được khai báo phía bên ngoài
+* Còn nữa, nếu tên bị mangle nhiều hơn 255 kí tự, việc cắt gọn tên sẽ diên ra.
+
+---
+---
+
+## Section: Appearances are deceptive!
+
+### ▶ Skipping lines?
+
+**Kết quả:**
+```py
+>>> value = 11
+>>> valuе = 32
+>>> value
+11
+```
+
+Cái quái gì thế?
+
+**Chú ý:** Để làm ra kết quả như trên bạn chỉ cần sao chếp các câu lệnh và dán nó vào file hay shell.
+
+#### 💡 Giải thích
+
+Một vài kí tự không phải là kí tự phương tây trông giống như các kí tự trong bảng chữ cái tiếng Anh nhưng lại được diễn giải khác bởi trình thông idhcj
+```py
+>>> ord('е') # Kí tự cyrillic 'e' (Ye)
+1077
+>>> ord('e') # Kí tự latin 'e', được sử dụng trong tiếng Anh và trên các bàn phím chuẩn
+101
+>>> 'е' == 'e'
+False
+
+>>> value = 42 # latin e
+>>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here
+>>> value
+42
+```
+
+
+Hàm tích hợp sẵn `ord()` trả về mã Unicode của một kí tự [code point](https://en.wikipedia.org/wiki/Code_point), và bạn có thể thấy các mã khác nhau cho kí tự Cyrillic 'e' và kí tự Latin 'e' .
+
+---
+
+### ▶ Teleportation
+
+
+
+```py
+# Cài đặt thư viên numpy sử dụng `pip install numpy` trước
+import numpy as np
+
+def energy_send(x):
+ # Khởi tạo một mảng numpy
+ np.array([float(x)])
+
+def energy_receive():
+ # Trả về một mang numpy rỗng
+ return np.empty((), dtype=np.float).tolist()
+```
+
+**Kết quả:**
+```py
+>>> energy_send(123.456)
+>>> energy_receive()
+123.456
+```
+
+Có gì mới ở đây nào ?
+
+#### 💡 Giải thích:
+
+* Chú ý rằng mảng numpy được tạo trong hàm `energy_send` không có được trả vì, vì vậy không gian bộ nhớ được giải phóng.
+* `numpy.empty()` trả về phần bộ nhơ tự do tiếp theo mà không khởi tạo lại nó. Phân bộ nhớ nay lại vô tình trung với phần bộ nhớ trước đó được giải phóng (thường xảy ra, nhưng không phải là luôn luôn)
+
+---
+
+
+### ▶ Well, something is fishy...
+
+```py
+def square(x):
+ """
+ A simple function to calculate the square of a number by addition.
+ """
+ sum_so_far = 0
+ for counter in range(x):
+ sum_so_far = sum_so_far + x
+ return sum_so_far
+```
+
+**Kết quả (Python 2.x):**
+
+```py
+>>> square(10)
+10
+```
+
+Sao kết quả lại ra 100?
+
+**Chú ý:** Nếu bạn không thực hiện lại được ví dụ trên, chạy thử file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) thông qua shell.
+#### 💡 Explanation
+
+* **Đừng trộn lẫn tabs và các khoảng trắng (spaces)!** Kí tự nằm phía trước lệnh return là một "tab", và đoạn mã ở đâu đó trong code được thụt lùi theo bội số của "4 khoảng trắng"
+* This is how Python handles tabs:
+* Đây là cách Python xử lý tabs:
+ > Đầu tiên, tabs được thay thế (từ trái sang phải) bằng từ một tới tám khoảng trắng để cho tổng số lượng các kí tự (bao gồm cả kí tự thay thế) có giá trị là bội số của tám <...>
+* Do đó "tab" nằm ở dòng cuối của hàm `square` được thay thế bằng tám khoảng trắng, và nó đi vào nằm trong vòng lặp.
+* Python 3 sẽ văng ra một lỗi khi nó gặp phải các lỗi liên quan tới tabs và khoảng trắng.
+ **Kết quả (Python 3.x):**
+ ```py
+ TabError: inconsistent use of tabs and spaces in indentation
+ ```
+
+---
+---
+
+## Section: Miscellaneous
+
+
+### ▶ `+=` chạy nhanh hơn
+
+
+```py
+# Sử dụng "+" để cộng 3 strings:
+>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.25748300552368164
+# Sử dụng "+=" để cộng 3 strings:
+>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.012188911437988281
+```
+
+#### 💡 Giải thích:
++ `+=` nhanh hơn `+` khi nối nhiều hơn 2 strings bởi vì string đầu tiên (ví dụ, `s1` trong `s1 += s2 + s3`) không bị huỷ đi khi tạo ra chuỗi kết quả cuối cùng
+---
+
+### ▶ Let's make a giant string!
+
+```py
+def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s += "xyz"
+ assert len(s) == 3*iters
+
+def add_bytes_with_plus(iters):
+ s = b""
+ for i in range(iters):
+ s += b"xyz"
+ assert len(s) == 3*iters
+
+def add_string_with_format(iters):
+ fs = "{}"*iters
+ s = fs.format(*(["xyz"]*iters))
+ assert len(s) == 3*iters
+
+def add_string_with_join(iters):
+ l = []
+ for i in range(iters):
+ l.append("xyz")
+ s = "".join(l)
+ assert len(s) == 3*iters
+
+def convert_list_to_string(l, iters):
+ s = "".join(l)
+ assert len(s) == 3*iters
+```
+
+**Kết quả:**
+
+```py
+# Chạy các đoạn lệnh trong ipython shell sử dung %timeit để có kết quả dễ đọc hơn
+# Bạn cũng có thể sử dụng module timeit trong python shell bình thường, như ví dụ dưới đây
+# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())
+
+>>> NUM_ITERS = 1000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
+124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
+211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
+61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
+117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
+10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+Bây giờ tăng số vòng lặp lên 10 lần
+```py
+>>> NUM_ITERS = 10000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time
+1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # Quadratic increase
+6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # Linear increase
+645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # Linear increase
+1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # Linear increase
+86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+#### 💡 Giải thích
+- Bạn có thể đọc thêm về [timeit] (https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit). Module này được sử dụng để đo thời gian chạy của các đoạn code.
+- Đừng dùng `+` để sinh ra các strings dài. Trong Python, `str` không thể thay đổi được giá trị, do đó các strings phía bên trái và phải phải được chép vào string mới cho mỗi cặp ghép string. Nếu bạn nối strings có độ dài là 10, bạn sẽ chép + ((10+10)+10) + (((10+10)+10)+10) = 90 kí tự thay vì chỉ 40 kí tự. Sẽ tệ hơn nữa khi số lượng và kích thước của string tăng (như bạn có thể thấy ở hàm `add_bytes_with_plus` )
+- Do đó, bên nên dùng `.format.` hay `%` (mặc dù các cách sử dụng này sẽ chậm hơn `+` đối với các strings nhỏ )
+- Hay tốt hơn nữa, nếu bạn đã có sẵn những nội dung ở dạng một đối tượng có thể lặp, khi đó sử dụng `''.join(iterable_object)` sẽ nhanh hơn.
+- Không giống như `add_bytes_with_plus` với các tối ưu đến từ `+=` như đã thảo luận ở ví dụ trước đó, `add_string_with_plus` không cho thấy sự tăng cấp bậc hai về thời gian thưucj thi. Sử dụng `s = s + "x" + "y" + "z"` thay vì `s += "xyz"` sẽ làm tăng thời gian chạy lên hai lần..
+ ```py
+ def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s = s + "x" + "y" + "z"
+ assert len(s) == 3*iters
+
+ >>> %timeit -n100 add_string_with_plus(1000)
+ 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+ >>> %timeit -n100 add_string_with_plus(10000) # Quadratic increase in execution time
+ 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+ ```
+
+- Có nhiều cách để định dạng và tạo một string khổng lồ, trái ngược với điều trong [Zen of Python](https://www.python.org/dev/peps/pep-0020/), như sau
+ > Chỉ nên có một -- và tốt hơn là chỉ một -- cách rõ ràng để làm điều này.
+---
+
+
+### ▶ Minor Ones *
+
+* `join()` là một hàm dành cho string thay vì dành cho list. (nếu nhìn vào thì ta có thể thấy nó hơi ngược ngược)
+ **💡 Giải thích:** Nếu `join()` là một phương thức hoạt động với một string, khi đó nó cũng có thể làm việc được với bất cứ đối tượng có thể lặp khác (như list, tuple, iterators). Nếu nó là một phương thức hoạt động được trên list, thì nó phải được triển khai một cách tách biệt với mọi kiểu. Còn nữa, sẽ là không hợp lý để đặt một phương thức chỉ dành riêng cho string lên một đối tượng tổng quát `list`.
+
+* Các câu lệnh dưới đây nhìn có vẻ lạ, nhưng đúng về ngữ nghĩa:
+ + `[] = ()` vẫn đúng về mặt ngữ nghĩa (Giải nén một `tuple` rỗng sẽ tạo ra một `list` rỗng)
+ + `'a'[0][0][0][0][0]` cũng đúng về ngữ nghĩa bởi các strings là các [chuỗi](https://docs.python.org/3/glossary.html#term-sequence) (các đối tượng có thể lặp hỗ trợ truy cập và các phần tử nó chứa sử dụng các chỉ số số nguyên) trong Python.
+ + Cả `3 --0-- 5 == 8` và `--5 == 5` đều đúng về ngữ nghĩa và cho ra kết quả là `True`.
+
+* Với `a` là một số, `++a` và `--a` đều là các câu lệnh Python hợp lệ nhưng chúng không chạy giống như các câu lệnh tương tự trong các ngôn ngữ khác như C, C++, hay Java.
+ ```py
+ >>> a = 5
+ >>> a
+ 5
+ >>> ++a
+ 5
+ >>> --a
+ 5
+ ```
+
+ **💡 Giải thích:**
+ + Trong Python, không có phép `++`. Thực ra nó chỉ là hai phép tính `+`.
+ + `++a` được phân tích như `+(+a)` và được dịch ra là `a`. Tương tự là `--a`.
+ + [Bài đăng](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) trên StackOverflow thảo luận lý do tại sao không có các phép tính tăng và giảm trong Python.
+
+* Bạn phải biết về kí hiệu con hà mã trong Python. Nhưng bạn có bao giờ nghe tới *kí hiệu xâm lược không gian*?
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+ Nó được sử dụng như phép tính tăng, như với một ví dụ khác sau đây
+ ```py
+ >>> a +=+ 1
+ >>> a
+ >>> 44
+ ```
+ **💡 Giải thích:** Trò chơi khăm này xuất phát từ [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). Kí hiệu xâm lược không gian chỉ được định dạng khác đi là `a -= (-1)`. Tương tự với `a = a - (- 1)`. Tương tự với trường hợp `a += (+ 1)`.
+
+* Python có một tài liệu về phép [hàm ý đảo ngược](https://en.wikipedia.org/wiki/Converse_implication).
+
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 Giải thích:** Nếu bạn thay thế `False` và `True` bằng 0 và 1 và sau đó làm các phép toán, bảng chân trị tương đương với phép ám chỉ ngược. ([Nguồn](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+* Do chúng ta đang bàn về các phép tính, cũng có phép `@` dành cho việc nhân ma trận (đừng lo, đây là phép tính thực sự)
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 Giải thích:** Phép tính `@` được thêm vào Python 3.5 với sự chú ý dành cho cộng đồng khoa học. Bất cứ đối tượng nào cũng có thể ghi đè lên phương thức ma thuật (magic method) `__matmul__` để định nghĩa hành vi cho phép tính..
+
+* Từ Python 3.8 trở đi bạn có thể sử dụng cú pháp f-string như `f'{some_var=}` để debugging cho dễ. Ví dụ
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+* Python sử dụng 2 bytes cho lưu trữ biến cụ bộ trong các hàm. Về mặt lý thuyết, điều này có nghĩa là chỉ có 65536 biến có thể được định nghĩa trong một hàm. Tuy nhiên, Python có một giải pháp khéo léo, tích hợp sẵn để lưu nhiều hơn 2^16 tên biến. Đoạn code phía dưới cho ta thấy điều gì xảy ra trong stack khi có nhiều hơn 65536 biến cục bộ được định nghĩa (Cảnh báo: đoạn mã này in ra 2^18 dòng văn bản, hảy chuẩn bị!):
+
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+* Nhiều Python threads sẽ không chạy *Python code* đồng thời. ó vẻ tự nhiên khi sinh ra một số luồng và để nó chạy code Python của bạn đồng thời, nhưng bởi vì [Khoá trình thông dịch toàn cục](https://wiki.python.org/moin/GlobalInterpreterLock) trong Python, tất cả những gì bạn làm là làm cho các luồng của bạn thực thi trên cùng một core theo thứ tự. Các luồng Python rất tốt cho các tác vị liên quan tới IO, nhưng để đạt được việc xử lý song song trong Python cho các tác vụ gắn với CPY, bạn có thể sử dụng module [multiprocessing](https://docs.python.org/2/library/multiprocessing.html)
+
+ ```py
+ # File some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
+
+ Đoạn mã trên in ra `wtfpython` sau 3 seconds bởi vì tham số `end` bộ đệm kết quả được dọn sạch sau khi găp `\n` hoặc khi chương trình kết thúc thực thi. Bạn có thể bắt dọn sạch bộ đệm thông qua việc gửi vào tham số `flush=True`..
+
+* Cắt danh sách với các chỉ số nằm ngoài phạm vị sẽ không trả về lỗi
+*
+ ```py
+ >>> some_list = [1, 2, 3, 4, 5]
+ >>> some_list[111:]
+ []
+ ```
+* Cắt một đối tượng có thể lặp không phải lúc nào cũng tạo ra một đối tượng mới. Ví dụ,
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # False là bởi vì một đối tượng mới được tạo
+ False
+ >>> some_str is some_str[:] # True là bởi vì các strings không thể thay đổi giá trị, do vậy không tạo ra một đối tượng mới khi cắt.
+ True
+ ```
+
+* `int('١٢٣٤٥٦٧٨٩')` trả về `123456789` trong Python 3. Trong Python, các kí tự số thập phân bao gồm các kí tự số, và tất cả các kí tự có thể được dùng để tạo nên có số cơ số thập phân, ví dụ. U+0660, ARABIC-INDIC DIGIT ZERO. Đậy là [một câu chuyện hấp dân](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) liên quan
+
+* Bạn có thể ngăn cách các số đơn với dấu gạch chân (để đọc dễ hơn), từ Python 3 trở đi.
+
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+* `'abc'.count('') == 4`. Dưới đây là một cách triển khai gần tương tự với phương thức `count`, ví dụ này sẽ làm mọi thứ rõ ràng hơn
+ ```py
+ def count(s, sub):
+ result = 0
+ for i in range(len(s) + 1 - len(sub)):
+ result += (s[i:i + len(sub)] == sub)
+ return result
+ ```
+ Cư xử của hàm trên là do việc so khớp các chuỗi con (substring) rỗng với các lát cắt có độ dài bằng 0 trong string gốc.
+---
+---
+
+# Đóng góp
+
+Bạn có thể đóng góp cho wtfpython theo những cách dưới đây
+
+- Cho chúng tôi biết những ví dụ mới
+- Dịch wtfpython sang các ngôn gnuwx khác (Xem tại [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))
+- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc.
+- Sửa các lỗi phụ khác như các đoạn mã bị lỗi thời, các lỗi cú pháp, lỗi định dạng, vân vân.
+- Identifying gaps (things like inadequate explanation, redundant examples, etc.)
+- Tìm những thiếu sót (ví dụ như giải thích chưa cặn kẽ, các ví dụ không cần thiết, vân vân.)
+- Bất cứ đề xuất sáng tạo nào cũng làm cho wtfpython thú vị và hữu dụng hơn
+
+Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things.
+
+PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project.
+
+# Lời cám ơn
+
+Ý tưởng và thiết kế của wtfpython lấy cảm hứng từ dự án tuyệt vời của Denys Dovhan's [wtfjs](https://github.com/denysdovhan/wtfjs). Cùng với đó là sự hỗ trợ tuyệt vời của những người yêu Python, giúp cho wtfpython có được như ngày hôm nay.
+
+#### Một vài liên kết hay khác!
+* https://www.youtube.com/watch?v=sH4XF6pKKmk
+* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+* https://sopython.com/wiki/Common_Gotchas_In_Python
+* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+* https://www.python.org/doc/humor/
+* https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+* https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
+* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+* WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
+
+# 🎓 License
+
+[![WTFPL 2.0][license-image]][license-url]
+
+© [Satwik Kansal](https://satwikkansal.xyz)
+
+[license-url]: http://www.wtfpl.net
+[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
+
+## Chia sẻ cho bạn bè!
+
+Nếu bạn thích wtfpython, bạn có thể chia sẻ các liên kết dưới đây cho bạn bè,
+
+[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+
+## Bạn có cần bản pdf của wtf hay không?
+
+I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get them as soon as they are finished.
+
+Tôi nhận được một vài yêu cầu cho phiên bản pdf (và epub) của wtfpython. Nếu bạn muốn, bạn có thể thêm thông tin chi tiết của mình ở đây [here](https://satwikkansal.xyz/wtfpython-pdf/) để có phiên bản pdf sớm nhất.
+
+**That's all folks!** For upcoming content like this, you can add your email [here](https://www.satwikkansal.xyz/content-like-wtfpython/).
+
+*PS: On a sidenote, consider donating a dollar to [plant a tree](https://teamtrees.org/).*
diff --git a/docs/css/neoteroi-cards.css b/docs/css/neoteroi-cards.css
new file mode 100644
index 0000000..5a5152f
--- /dev/null
+++ b/docs/css/neoteroi-cards.css
@@ -0,0 +1,102 @@
+.nt-cards.nt-grid {
+ display: grid;
+ grid-auto-columns: 1fr;
+ gap: 0.5rem;
+ max-width: 100vw;
+ overflow-x: auto;
+ padding: 1px;
+}
+.nt-cards.nt-grid.cols-1 {
+ grid-template-columns: repeat(1, 1fr);
+}
+.nt-cards.nt-grid.cols-2 {
+ grid-template-columns: repeat(2, 1fr);
+}
+.nt-cards.nt-grid.cols-3 {
+ grid-template-columns: repeat(3, 1fr);
+}
+.nt-cards.nt-grid.cols-4 {
+ grid-template-columns: repeat(4, 1fr);
+}
+.nt-cards.nt-grid.cols-5 {
+ grid-template-columns: repeat(5, 1fr);
+}
+.nt-cards.nt-grid.cols-6 {
+ grid-template-columns: repeat(6, 1fr);
+}
+
+@media only screen and (max-width: 400px) {
+ .nt-cards.nt-grid {
+ grid-template-columns: repeat(1, 1fr) !important;
+ }
+}
+.nt-card {
+ box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14), 0 3px 1px -2px rgba(0, 0, 0, 0.2), 0 1px 5px 0 rgba(0, 0, 0, 0.12);
+}
+.nt-card:hover {
+ box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.24), 0 3px 1px -2px rgba(0, 0, 0, 0.3), 0 1px 5px 0 rgba(0, 0, 0, 0.22);
+}
+
+[data-md-color-scheme=slate] .nt-card {
+ box-shadow: 0 2px 2px 0 rgba(4, 40, 33, 0.14), 0 3px 1px -2px rgba(40, 86, 94, 0.47), 0 1px 5px 0 rgba(139, 252, 255, 0.64);
+}
+[data-md-color-scheme=slate] .nt-card:hover {
+ box-shadow: 0 2px 2px 0 rgba(0, 255, 206, 0.14), 0 3px 1px -2px rgba(33, 156, 177, 0.47), 0 1px 5px 0 rgba(96, 251, 255, 0.64);
+}
+
+.nt-card > a {
+ color: var(--md-default-fg-color);
+}
+
+.nt-card > a > div {
+ cursor: pointer;
+}
+
+.nt-card {
+ padding: 5px;
+ margin-bottom: 0.5rem;
+}
+
+.nt-card-title {
+ font-size: 1rem;
+ font-weight: bold;
+ margin: 4px 0 8px 0;
+ line-height: 22px;
+}
+
+.nt-card-content {
+ padding: 0.4rem 0.8rem 0.8rem 0.8rem;
+}
+
+.nt-card-text {
+ font-size: 14px;
+ padding: 0;
+ margin: 0;
+}
+
+.nt-card .nt-card-image {
+ text-align: center;
+ border-radius: 2px;
+ background-position: center center;
+ background-size: cover;
+ background-repeat: no-repeat;
+ min-height: 120px;
+}
+
+.nt-card .nt-card-image.tags img {
+ margin-top: 12px;
+}
+
+.nt-card .nt-card-image img {
+ height: 105px;
+ margin-top: 5px;
+}
+
+.nt-card a:hover,
+.nt-card a:focus {
+ color: var(--md-accent-fg-color);
+}
+
+.nt-card h2 {
+ margin: 0;
+}
diff --git a/docs/css/neoteroi-gantt.css b/docs/css/neoteroi-gantt.css
new file mode 100644
index 0000000..f93f202
--- /dev/null
+++ b/docs/css/neoteroi-gantt.css
@@ -0,0 +1,328 @@
+/**
+ * Extra CSS for the neoteroi.projects.gantt extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+:root {
+ --nt-scrollbar-color: #2751b0;
+ --nt-plan-actions-height: 24px;
+ --nt-units-background: #ff9800;
+ --nt-months-background: #2751b0;
+ --nt-plan-vertical-line-color: #a3a3a3ad;
+}
+
+.nt-pastello {
+ --nt-scrollbar-color: #9fb8f4;
+ --nt-units-background: #f5dc82;
+ --nt-months-background: #5b7fd1;
+}
+
+[data-md-color-scheme=slate] {
+ --nt-units-background: #003773;
+}
+[data-md-color-scheme=slate] .nt-pastello {
+ --nt-units-background: #3f4997;
+}
+
+.nt-plan-root {
+ min-height: 200px;
+ scrollbar-width: 20px;
+ scrollbar-color: var(--nt-scrollbar-color);
+ display: flex;
+}
+.nt-plan-root ::-webkit-scrollbar {
+ width: 20px;
+}
+.nt-plan-root ::-webkit-scrollbar-track {
+ box-shadow: inset 0 0 5px grey;
+ border-radius: 10px;
+}
+.nt-plan-root ::-webkit-scrollbar-thumb {
+ background: var(--nt-scrollbar-color);
+ border-radius: 10px;
+}
+.nt-plan-root .nt-plan {
+ flex: 80%;
+}
+.nt-plan-root.no-groups .nt-plan-periods {
+ padding-left: 0;
+}
+.nt-plan-root.no-groups .nt-plan-group-summary {
+ display: none;
+}
+.nt-plan-root .nt-timeline-dot.bigger {
+ top: -10px;
+}
+.nt-plan-root .nt-timeline-dot.bigger[title] {
+ cursor: help;
+}
+
+.nt-plan {
+ white-space: nowrap;
+ overflow-x: auto;
+ display: flex;
+}
+.nt-plan .ug-timeline-dot {
+ left: 368px;
+ top: -8px;
+ cursor: help;
+}
+
+.months {
+ display: flex;
+}
+
+.month {
+ flex: auto;
+ display: inline-block;
+ box-shadow: rgba(0, 0, 0, 0.2) 0px 3px 1px -2px, rgba(0, 0, 0, 0.14) 0px 2px 2px 0px, rgba(0, 0, 0, 0.12) 0px 1px 5px 0px inset;
+ background-color: var(--nt-months-background);
+ color: white;
+ text-transform: uppercase;
+ font-family: Roboto, Helvetica, Arial, sans-serif;
+ padding: 2px 5px;
+ font-size: 12px;
+ border: 1px solid #000;
+ width: 150px;
+ border-radius: 8px;
+}
+
+.nt-plan-group-activities {
+ flex: auto;
+ position: relative;
+}
+
+.nt-vline {
+ border-left: 1px dashed var(--nt-plan-vertical-line-color);
+ height: 100%;
+ left: 0;
+ position: absolute;
+ margin-left: -0.5px;
+ top: 0;
+ -webkit-transition: all 0.5s linear !important;
+ -moz-transition: all 0.5s linear !important;
+ -ms-transition: all 0.5s linear !important;
+ -o-transition: all 0.5s linear !important;
+ transition: all 0.5s linear !important;
+ z-index: -2;
+}
+
+.nt-plan-activity {
+ display: flex;
+ margin: 2px 0;
+ background-color: rgba(187, 187, 187, 0.2509803922);
+}
+
+.actions {
+ height: var(--nt-plan-actions-height);
+}
+
+.actions {
+ position: relative;
+}
+
+.period {
+ display: inline-block;
+ height: var(--nt-plan-actions-height);
+ width: 120px;
+ position: absolute;
+ left: 0px;
+ background: #1da1f2;
+ border-radius: 5px;
+ transition: all 0.5s;
+ cursor: help;
+ -webkit-transition: width 1s ease-in-out;
+ -moz-transition: width 1s ease-in-out;
+ -o-transition: width 1s ease-in-out;
+ transition: width 1s ease-in-out;
+}
+.period .nt-tooltip {
+ display: none;
+ top: 30px;
+ position: relative;
+ padding: 1rem;
+ text-align: center;
+ font-size: 12px;
+}
+.period:hover .nt-tooltip {
+ display: inline-block;
+}
+
+.period-0 {
+ left: 340px;
+ visibility: visible;
+ background-color: rgb(69, 97, 101);
+}
+
+.period-1 {
+ left: 40px;
+ visibility: visible;
+ background-color: green;
+}
+
+.period-2 {
+ left: 120px;
+ visibility: visible;
+ background-color: pink;
+ width: 80px;
+}
+
+.period-3 {
+ left: 190px;
+ visibility: visible;
+ background-color: darkred;
+ width: 150px;
+}
+
+.weeks > span,
+.days > span {
+ height: 25px;
+}
+
+.weeks > span {
+ display: inline-block;
+ margin: 0;
+ padding: 0;
+ font-weight: bold;
+}
+.weeks > span .week-text {
+ font-size: 10px;
+ position: absolute;
+ display: inline-block;
+ padding: 3px 4px;
+}
+
+.days {
+ z-index: -2;
+ position: relative;
+}
+
+.day-text {
+ font-size: 10px;
+ position: absolute;
+ display: inline-block;
+ padding: 3px 4px;
+}
+
+.period span {
+ font-size: 12px;
+ vertical-align: top;
+ margin-left: 4px;
+ color: black;
+ background: rgba(255, 255, 255, 0.6588235294);
+ border-radius: 6px;
+ padding: 0 4px;
+}
+
+.weeks,
+.days {
+ height: 20px;
+ display: flex;
+ box-sizing: content-box;
+}
+
+.months {
+ display: flex;
+}
+
+.week,
+.day {
+ height: 20px;
+ position: relative;
+ border: 1;
+ flex: auto;
+ border: 2px solid white;
+ border-radius: 4px;
+ background-color: var(--nt-units-background);
+ cursor: help;
+}
+
+.years {
+ display: flex;
+}
+
+.year {
+ text-align: center;
+ border-right: 1px solid var(--nt-plan-vertical-line-color);
+ font-weight: bold;
+}
+.year:first-child {
+ border-left: 1px solid var(--nt-plan-vertical-line-color);
+}
+.year:first-child:last-child {
+ width: 100%;
+}
+
+.quarters {
+ display: flex;
+}
+
+.quarter {
+ width: 12.5%;
+ text-align: center;
+ border-right: 1px solid var(--nt-plan-vertical-line-color);
+ font-weight: bold;
+}
+.quarter:first-child {
+ border-left: 1px solid var(--nt-plan-vertical-line-color);
+}
+
+.nt-plan-group {
+ margin: 20px 0;
+ position: relative;
+}
+
+.nt-plan-group {
+ display: flex;
+}
+
+.nt-plan-group-summary {
+ background: #2751b0;
+ width: 150px;
+ white-space: normal;
+ padding: 0.1rem 0.5rem;
+ border-radius: 5px;
+ color: #fff;
+ z-index: 3;
+}
+.nt-plan-group-summary p {
+ margin: 0;
+ padding: 0;
+ font-size: 0.6rem;
+ color: #fff;
+}
+
+.nt-plan-group-summary,
+.month,
+.period,
+.week,
+.day,
+.nt-tooltip {
+ border: 3px solid white;
+ box-shadow: 0 2px 3px -1px rgba(0, 0, 0, 0.2), 0 3px 3px 0 rgba(0, 0, 0, 0.14), 0 1px 5px 0 rgba(0, 0, 0, 0.12);
+}
+
+.nt-plan-periods {
+ padding-left: 150px;
+}
+
+.months {
+ z-index: 2;
+ position: relative;
+}
+
+.weeks {
+ position: relative;
+ top: -2px;
+ z-index: 0;
+}
+
+.month,
+.quarter,
+.year,
+.week,
+.day,
+.nt-tooltip {
+ font-family: Roboto, Helvetica, Arial, sans-serif;
+ box-sizing: border-box;
+}
diff --git a/docs/css/neoteroi-mkdocs.css b/docs/css/neoteroi-mkdocs.css
new file mode 100644
index 0000000..ee7d53a
--- /dev/null
+++ b/docs/css/neoteroi-mkdocs.css
@@ -0,0 +1,1399 @@
+/**
+ * All CSS for the neoteroi.projects.gantt extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+:root {
+ --nt-color-0: #CD853F;
+ --nt-color-1: #B22222;
+ --nt-color-2: #000080;
+ --nt-color-3: #4B0082;
+ --nt-color-4: #3CB371;
+ --nt-color-5: #D2B48C;
+ --nt-color-6: #FF00FF;
+ --nt-color-7: #98FB98;
+ --nt-color-8: #FFEBCD;
+ --nt-color-9: #2E8B57;
+ --nt-color-10: #6A5ACD;
+ --nt-color-11: #48D1CC;
+ --nt-color-12: #FFA500;
+ --nt-color-13: #F4A460;
+ --nt-color-14: #A52A2A;
+ --nt-color-15: #FFE4C4;
+ --nt-color-16: #FF4500;
+ --nt-color-17: #AFEEEE;
+ --nt-color-18: #FA8072;
+ --nt-color-19: #2F4F4F;
+ --nt-color-20: #FFDAB9;
+ --nt-color-21: #BC8F8F;
+ --nt-color-22: #FFC0CB;
+ --nt-color-23: #00FA9A;
+ --nt-color-24: #F0FFF0;
+ --nt-color-25: #FFFACD;
+ --nt-color-26: #F5F5F5;
+ --nt-color-27: #FF6347;
+ --nt-color-28: #FFFFF0;
+ --nt-color-29: #7FFFD4;
+ --nt-color-30: #E9967A;
+ --nt-color-31: #7B68EE;
+ --nt-color-32: #FFF8DC;
+ --nt-color-33: #0000CD;
+ --nt-color-34: #D2691E;
+ --nt-color-35: #708090;
+ --nt-color-36: #5F9EA0;
+ --nt-color-37: #008080;
+ --nt-color-38: #008000;
+ --nt-color-39: #FFE4E1;
+ --nt-color-40: #FFFF00;
+ --nt-color-41: #FFFAF0;
+ --nt-color-42: #DCDCDC;
+ --nt-color-43: #ADFF2F;
+ --nt-color-44: #ADD8E6;
+ --nt-color-45: #8B008B;
+ --nt-color-46: #7FFF00;
+ --nt-color-47: #800000;
+ --nt-color-48: #20B2AA;
+ --nt-color-49: #556B2F;
+ --nt-color-50: #778899;
+ --nt-color-51: #E6E6FA;
+ --nt-color-52: #FFFAFA;
+ --nt-color-53: #FF7F50;
+ --nt-color-54: #FF0000;
+ --nt-color-55: #F5DEB3;
+ --nt-color-56: #008B8B;
+ --nt-color-57: #66CDAA;
+ --nt-color-58: #808000;
+ --nt-color-59: #FAF0E6;
+ --nt-color-60: #00BFFF;
+ --nt-color-61: #C71585;
+ --nt-color-62: #00FFFF;
+ --nt-color-63: #8B4513;
+ --nt-color-64: #F0F8FF;
+ --nt-color-65: #FAEBD7;
+ --nt-color-66: #8B0000;
+ --nt-color-67: #4682B4;
+ --nt-color-68: #F0E68C;
+ --nt-color-69: #BDB76B;
+ --nt-color-70: #A0522D;
+ --nt-color-71: #FAFAD2;
+ --nt-color-72: #FFD700;
+ --nt-color-73: #DEB887;
+ --nt-color-74: #E0FFFF;
+ --nt-color-75: #8A2BE2;
+ --nt-color-76: #32CD32;
+ --nt-color-77: #87CEFA;
+ --nt-color-78: #00CED1;
+ --nt-color-79: #696969;
+ --nt-color-80: #DDA0DD;
+ --nt-color-81: #EE82EE;
+ --nt-color-82: #FFB6C1;
+ --nt-color-83: #8FBC8F;
+ --nt-color-84: #D8BFD8;
+ --nt-color-85: #9400D3;
+ --nt-color-86: #A9A9A9;
+ --nt-color-87: #FFFFE0;
+ --nt-color-88: #FFF5EE;
+ --nt-color-89: #FFF0F5;
+ --nt-color-90: #FFDEAD;
+ --nt-color-91: #800080;
+ --nt-color-92: #B0E0E6;
+ --nt-color-93: #9932CC;
+ --nt-color-94: #DAA520;
+ --nt-color-95: #F0FFFF;
+ --nt-color-96: #40E0D0;
+ --nt-color-97: #00FF7F;
+ --nt-color-98: #006400;
+ --nt-color-99: #808080;
+ --nt-color-100: #87CEEB;
+ --nt-color-101: #0000FF;
+ --nt-color-102: #6495ED;
+ --nt-color-103: #FDF5E6;
+ --nt-color-104: #B8860B;
+ --nt-color-105: #BA55D3;
+ --nt-color-106: #C0C0C0;
+ --nt-color-107: #000000;
+ --nt-color-108: #F08080;
+ --nt-color-109: #B0C4DE;
+ --nt-color-110: #00008B;
+ --nt-color-111: #6B8E23;
+ --nt-color-112: #FFE4B5;
+ --nt-color-113: #FFA07A;
+ --nt-color-114: #9ACD32;
+ --nt-color-115: #FFFFFF;
+ --nt-color-116: #F5F5DC;
+ --nt-color-117: #90EE90;
+ --nt-color-118: #1E90FF;
+ --nt-color-119: #7CFC00;
+ --nt-color-120: #FF69B4;
+ --nt-color-121: #F8F8FF;
+ --nt-color-122: #F5FFFA;
+ --nt-color-123: #00FF00;
+ --nt-color-124: #D3D3D3;
+ --nt-color-125: #DB7093;
+ --nt-color-126: #DA70D6;
+ --nt-color-127: #FF1493;
+ --nt-color-128: #228B22;
+ --nt-color-129: #FFEFD5;
+ --nt-color-130: #4169E1;
+ --nt-color-131: #191970;
+ --nt-color-132: #9370DB;
+ --nt-color-133: #483D8B;
+ --nt-color-134: #FF8C00;
+ --nt-color-135: #EEE8AA;
+ --nt-color-136: #CD5C5C;
+ --nt-color-137: #DC143C;
+}
+
+:root {
+ --nt-group-0-main: #000000;
+ --nt-group-0-dark: #FFFFFF;
+ --nt-group-0-light: #000000;
+ --nt-group-0-main-bg: #F44336;
+ --nt-group-0-dark-bg: #BA000D;
+ --nt-group-0-light-bg: #FF7961;
+ --nt-group-1-main: #000000;
+ --nt-group-1-dark: #FFFFFF;
+ --nt-group-1-light: #000000;
+ --nt-group-1-main-bg: #E91E63;
+ --nt-group-1-dark-bg: #B0003A;
+ --nt-group-1-light-bg: #FF6090;
+ --nt-group-2-main: #FFFFFF;
+ --nt-group-2-dark: #FFFFFF;
+ --nt-group-2-light: #000000;
+ --nt-group-2-main-bg: #9C27B0;
+ --nt-group-2-dark-bg: #6A0080;
+ --nt-group-2-light-bg: #D05CE3;
+ --nt-group-3-main: #FFFFFF;
+ --nt-group-3-dark: #FFFFFF;
+ --nt-group-3-light: #000000;
+ --nt-group-3-main-bg: #673AB7;
+ --nt-group-3-dark-bg: #320B86;
+ --nt-group-3-light-bg: #9A67EA;
+ --nt-group-4-main: #FFFFFF;
+ --nt-group-4-dark: #FFFFFF;
+ --nt-group-4-light: #000000;
+ --nt-group-4-main-bg: #3F51B5;
+ --nt-group-4-dark-bg: #002984;
+ --nt-group-4-light-bg: #757DE8;
+ --nt-group-5-main: #000000;
+ --nt-group-5-dark: #FFFFFF;
+ --nt-group-5-light: #000000;
+ --nt-group-5-main-bg: #2196F3;
+ --nt-group-5-dark-bg: #0069C0;
+ --nt-group-5-light-bg: #6EC6FF;
+ --nt-group-6-main: #000000;
+ --nt-group-6-dark: #FFFFFF;
+ --nt-group-6-light: #000000;
+ --nt-group-6-main-bg: #03A9F4;
+ --nt-group-6-dark-bg: #007AC1;
+ --nt-group-6-light-bg: #67DAFF;
+ --nt-group-7-main: #000000;
+ --nt-group-7-dark: #000000;
+ --nt-group-7-light: #000000;
+ --nt-group-7-main-bg: #00BCD4;
+ --nt-group-7-dark-bg: #008BA3;
+ --nt-group-7-light-bg: #62EFFF;
+ --nt-group-8-main: #000000;
+ --nt-group-8-dark: #FFFFFF;
+ --nt-group-8-light: #000000;
+ --nt-group-8-main-bg: #009688;
+ --nt-group-8-dark-bg: #00675B;
+ --nt-group-8-light-bg: #52C7B8;
+ --nt-group-9-main: #000000;
+ --nt-group-9-dark: #FFFFFF;
+ --nt-group-9-light: #000000;
+ --nt-group-9-main-bg: #4CAF50;
+ --nt-group-9-dark-bg: #087F23;
+ --nt-group-9-light-bg: #80E27E;
+ --nt-group-10-main: #000000;
+ --nt-group-10-dark: #000000;
+ --nt-group-10-light: #000000;
+ --nt-group-10-main-bg: #8BC34A;
+ --nt-group-10-dark-bg: #5A9216;
+ --nt-group-10-light-bg: #BEF67A;
+ --nt-group-11-main: #000000;
+ --nt-group-11-dark: #000000;
+ --nt-group-11-light: #000000;
+ --nt-group-11-main-bg: #CDDC39;
+ --nt-group-11-dark-bg: #99AA00;
+ --nt-group-11-light-bg: #FFFF6E;
+ --nt-group-12-main: #000000;
+ --nt-group-12-dark: #000000;
+ --nt-group-12-light: #000000;
+ --nt-group-12-main-bg: #FFEB3B;
+ --nt-group-12-dark-bg: #C8B900;
+ --nt-group-12-light-bg: #FFFF72;
+ --nt-group-13-main: #000000;
+ --nt-group-13-dark: #000000;
+ --nt-group-13-light: #000000;
+ --nt-group-13-main-bg: #FFC107;
+ --nt-group-13-dark-bg: #C79100;
+ --nt-group-13-light-bg: #FFF350;
+ --nt-group-14-main: #000000;
+ --nt-group-14-dark: #000000;
+ --nt-group-14-light: #000000;
+ --nt-group-14-main-bg: #FF9800;
+ --nt-group-14-dark-bg: #C66900;
+ --nt-group-14-light-bg: #FFC947;
+ --nt-group-15-main: #000000;
+ --nt-group-15-dark: #FFFFFF;
+ --nt-group-15-light: #000000;
+ --nt-group-15-main-bg: #FF5722;
+ --nt-group-15-dark-bg: #C41C00;
+ --nt-group-15-light-bg: #FF8A50;
+ --nt-group-16-main: #FFFFFF;
+ --nt-group-16-dark: #FFFFFF;
+ --nt-group-16-light: #000000;
+ --nt-group-16-main-bg: #795548;
+ --nt-group-16-dark-bg: #4B2C20;
+ --nt-group-16-light-bg: #A98274;
+ --nt-group-17-main: #000000;
+ --nt-group-17-dark: #FFFFFF;
+ --nt-group-17-light: #000000;
+ --nt-group-17-main-bg: #9E9E9E;
+ --nt-group-17-dark-bg: #707070;
+ --nt-group-17-light-bg: #CFCFCF;
+ --nt-group-18-main: #000000;
+ --nt-group-18-dark: #FFFFFF;
+ --nt-group-18-light: #000000;
+ --nt-group-18-main-bg: #607D8B;
+ --nt-group-18-dark-bg: #34515E;
+ --nt-group-18-light-bg: #8EACBB;
+}
+
+.nt-pastello {
+ --nt-group-0-main: #000000;
+ --nt-group-0-dark: #000000;
+ --nt-group-0-light: #000000;
+ --nt-group-0-main-bg: #EF9A9A;
+ --nt-group-0-dark-bg: #BA6B6C;
+ --nt-group-0-light-bg: #FFCCCB;
+ --nt-group-1-main: #000000;
+ --nt-group-1-dark: #000000;
+ --nt-group-1-light: #000000;
+ --nt-group-1-main-bg: #F48FB1;
+ --nt-group-1-dark-bg: #BF5F82;
+ --nt-group-1-light-bg: #FFC1E3;
+ --nt-group-2-main: #000000;
+ --nt-group-2-dark: #000000;
+ --nt-group-2-light: #000000;
+ --nt-group-2-main-bg: #CE93D8;
+ --nt-group-2-dark-bg: #9C64A6;
+ --nt-group-2-light-bg: #FFC4FF;
+ --nt-group-3-main: #000000;
+ --nt-group-3-dark: #000000;
+ --nt-group-3-light: #000000;
+ --nt-group-3-main-bg: #B39DDB;
+ --nt-group-3-dark-bg: #836FA9;
+ --nt-group-3-light-bg: #E6CEFF;
+ --nt-group-4-main: #000000;
+ --nt-group-4-dark: #000000;
+ --nt-group-4-light: #000000;
+ --nt-group-4-main-bg: #9FA8DA;
+ --nt-group-4-dark-bg: #6F79A8;
+ --nt-group-4-light-bg: #D1D9FF;
+ --nt-group-5-main: #000000;
+ --nt-group-5-dark: #000000;
+ --nt-group-5-light: #000000;
+ --nt-group-5-main-bg: #90CAF9;
+ --nt-group-5-dark-bg: #5D99C6;
+ --nt-group-5-light-bg: #C3FDFF;
+ --nt-group-6-main: #000000;
+ --nt-group-6-dark: #000000;
+ --nt-group-6-light: #000000;
+ --nt-group-6-main-bg: #81D4FA;
+ --nt-group-6-dark-bg: #4BA3C7;
+ --nt-group-6-light-bg: #B6FFFF;
+ --nt-group-7-main: #000000;
+ --nt-group-7-dark: #000000;
+ --nt-group-7-light: #000000;
+ --nt-group-7-main-bg: #80DEEA;
+ --nt-group-7-dark-bg: #4BACB8;
+ --nt-group-7-light-bg: #B4FFFF;
+ --nt-group-8-main: #000000;
+ --nt-group-8-dark: #000000;
+ --nt-group-8-light: #000000;
+ --nt-group-8-main-bg: #80CBC4;
+ --nt-group-8-dark-bg: #4F9A94;
+ --nt-group-8-light-bg: #B2FEF7;
+ --nt-group-9-main: #000000;
+ --nt-group-9-dark: #000000;
+ --nt-group-9-light: #000000;
+ --nt-group-9-main-bg: #A5D6A7;
+ --nt-group-9-dark-bg: #75A478;
+ --nt-group-9-light-bg: #D7FFD9;
+ --nt-group-10-main: #000000;
+ --nt-group-10-dark: #000000;
+ --nt-group-10-light: #000000;
+ --nt-group-10-main-bg: #C5E1A5;
+ --nt-group-10-dark-bg: #94AF76;
+ --nt-group-10-light-bg: #F8FFD7;
+ --nt-group-11-main: #000000;
+ --nt-group-11-dark: #000000;
+ --nt-group-11-light: #000000;
+ --nt-group-11-main-bg: #E6EE9C;
+ --nt-group-11-dark-bg: #B3BC6D;
+ --nt-group-11-light-bg: #FFFFCE;
+ --nt-group-12-main: #000000;
+ --nt-group-12-dark: #000000;
+ --nt-group-12-light: #000000;
+ --nt-group-12-main-bg: #FFF59D;
+ --nt-group-12-dark-bg: #CBC26D;
+ --nt-group-12-light-bg: #FFFFCF;
+ --nt-group-13-main: #000000;
+ --nt-group-13-dark: #000000;
+ --nt-group-13-light: #000000;
+ --nt-group-13-main-bg: #FFE082;
+ --nt-group-13-dark-bg: #CAAE53;
+ --nt-group-13-light-bg: #FFFFB3;
+ --nt-group-14-main: #000000;
+ --nt-group-14-dark: #000000;
+ --nt-group-14-light: #000000;
+ --nt-group-14-main-bg: #FFCC80;
+ --nt-group-14-dark-bg: #CA9B52;
+ --nt-group-14-light-bg: #FFFFB0;
+ --nt-group-15-main: #000000;
+ --nt-group-15-dark: #000000;
+ --nt-group-15-light: #000000;
+ --nt-group-15-main-bg: #FFAB91;
+ --nt-group-15-dark-bg: #C97B63;
+ --nt-group-15-light-bg: #FFDDC1;
+ --nt-group-16-main: #000000;
+ --nt-group-16-dark: #000000;
+ --nt-group-16-light: #000000;
+ --nt-group-16-main-bg: #BCAAA4;
+ --nt-group-16-dark-bg: #8C7B75;
+ --nt-group-16-light-bg: #EFDCD5;
+ --nt-group-17-main: #000000;
+ --nt-group-17-dark: #000000;
+ --nt-group-17-light: #000000;
+ --nt-group-17-main-bg: #EEEEEE;
+ --nt-group-17-dark-bg: #BCBCBC;
+ --nt-group-17-light-bg: #FFFFFF;
+ --nt-group-18-main: #000000;
+ --nt-group-18-dark: #000000;
+ --nt-group-18-light: #000000;
+ --nt-group-18-main-bg: #B0BEC5;
+ --nt-group-18-dark-bg: #808E95;
+ --nt-group-18-light-bg: #E2F1F8;
+}
+
+.nt-group-0 .nt-plan-group-summary,
+.nt-group-0 .nt-timeline-dot {
+ color: var(--nt-group-0-dark);
+ background-color: var(--nt-group-0-dark-bg);
+}
+.nt-group-0 .period {
+ color: var(--nt-group-0-main);
+ background-color: var(--nt-group-0-main-bg);
+}
+
+.nt-group-1 .nt-plan-group-summary,
+.nt-group-1 .nt-timeline-dot {
+ color: var(--nt-group-1-dark);
+ background-color: var(--nt-group-1-dark-bg);
+}
+.nt-group-1 .period {
+ color: var(--nt-group-1-main);
+ background-color: var(--nt-group-1-main-bg);
+}
+
+.nt-group-2 .nt-plan-group-summary,
+.nt-group-2 .nt-timeline-dot {
+ color: var(--nt-group-2-dark);
+ background-color: var(--nt-group-2-dark-bg);
+}
+.nt-group-2 .period {
+ color: var(--nt-group-2-main);
+ background-color: var(--nt-group-2-main-bg);
+}
+
+.nt-group-3 .nt-plan-group-summary,
+.nt-group-3 .nt-timeline-dot {
+ color: var(--nt-group-3-dark);
+ background-color: var(--nt-group-3-dark-bg);
+}
+.nt-group-3 .period {
+ color: var(--nt-group-3-main);
+ background-color: var(--nt-group-3-main-bg);
+}
+
+.nt-group-4 .nt-plan-group-summary,
+.nt-group-4 .nt-timeline-dot {
+ color: var(--nt-group-4-dark);
+ background-color: var(--nt-group-4-dark-bg);
+}
+.nt-group-4 .period {
+ color: var(--nt-group-4-main);
+ background-color: var(--nt-group-4-main-bg);
+}
+
+.nt-group-5 .nt-plan-group-summary,
+.nt-group-5 .nt-timeline-dot {
+ color: var(--nt-group-5-dark);
+ background-color: var(--nt-group-5-dark-bg);
+}
+.nt-group-5 .period {
+ color: var(--nt-group-5-main);
+ background-color: var(--nt-group-5-main-bg);
+}
+
+.nt-group-6 .nt-plan-group-summary,
+.nt-group-6 .nt-timeline-dot {
+ color: var(--nt-group-6-dark);
+ background-color: var(--nt-group-6-dark-bg);
+}
+.nt-group-6 .period {
+ color: var(--nt-group-6-main);
+ background-color: var(--nt-group-6-main-bg);
+}
+
+.nt-group-7 .nt-plan-group-summary,
+.nt-group-7 .nt-timeline-dot {
+ color: var(--nt-group-7-dark);
+ background-color: var(--nt-group-7-dark-bg);
+}
+.nt-group-7 .period {
+ color: var(--nt-group-7-main);
+ background-color: var(--nt-group-7-main-bg);
+}
+
+.nt-group-8 .nt-plan-group-summary,
+.nt-group-8 .nt-timeline-dot {
+ color: var(--nt-group-8-dark);
+ background-color: var(--nt-group-8-dark-bg);
+}
+.nt-group-8 .period {
+ color: var(--nt-group-8-main);
+ background-color: var(--nt-group-8-main-bg);
+}
+
+.nt-group-9 .nt-plan-group-summary,
+.nt-group-9 .nt-timeline-dot {
+ color: var(--nt-group-9-dark);
+ background-color: var(--nt-group-9-dark-bg);
+}
+.nt-group-9 .period {
+ color: var(--nt-group-9-main);
+ background-color: var(--nt-group-9-main-bg);
+}
+
+.nt-group-10 .nt-plan-group-summary,
+.nt-group-10 .nt-timeline-dot {
+ color: var(--nt-group-10-dark);
+ background-color: var(--nt-group-10-dark-bg);
+}
+.nt-group-10 .period {
+ color: var(--nt-group-10-main);
+ background-color: var(--nt-group-10-main-bg);
+}
+
+.nt-group-11 .nt-plan-group-summary,
+.nt-group-11 .nt-timeline-dot {
+ color: var(--nt-group-11-dark);
+ background-color: var(--nt-group-11-dark-bg);
+}
+.nt-group-11 .period {
+ color: var(--nt-group-11-main);
+ background-color: var(--nt-group-11-main-bg);
+}
+
+.nt-group-12 .nt-plan-group-summary,
+.nt-group-12 .nt-timeline-dot {
+ color: var(--nt-group-12-dark);
+ background-color: var(--nt-group-12-dark-bg);
+}
+.nt-group-12 .period {
+ color: var(--nt-group-12-main);
+ background-color: var(--nt-group-12-main-bg);
+}
+
+.nt-group-13 .nt-plan-group-summary,
+.nt-group-13 .nt-timeline-dot {
+ color: var(--nt-group-13-dark);
+ background-color: var(--nt-group-13-dark-bg);
+}
+.nt-group-13 .period {
+ color: var(--nt-group-13-main);
+ background-color: var(--nt-group-13-main-bg);
+}
+
+.nt-group-14 .nt-plan-group-summary,
+.nt-group-14 .nt-timeline-dot {
+ color: var(--nt-group-14-dark);
+ background-color: var(--nt-group-14-dark-bg);
+}
+.nt-group-14 .period {
+ color: var(--nt-group-14-main);
+ background-color: var(--nt-group-14-main-bg);
+}
+
+.nt-group-15 .nt-plan-group-summary,
+.nt-group-15 .nt-timeline-dot {
+ color: var(--nt-group-15-dark);
+ background-color: var(--nt-group-15-dark-bg);
+}
+.nt-group-15 .period {
+ color: var(--nt-group-15-main);
+ background-color: var(--nt-group-15-main-bg);
+}
+
+.nt-group-16 .nt-plan-group-summary,
+.nt-group-16 .nt-timeline-dot {
+ color: var(--nt-group-16-dark);
+ background-color: var(--nt-group-16-dark-bg);
+}
+.nt-group-16 .period {
+ color: var(--nt-group-16-main);
+ background-color: var(--nt-group-16-main-bg);
+}
+
+.nt-group-17 .nt-plan-group-summary,
+.nt-group-17 .nt-timeline-dot {
+ color: var(--nt-group-17-dark);
+ background-color: var(--nt-group-17-dark-bg);
+}
+.nt-group-17 .period {
+ color: var(--nt-group-17-main);
+ background-color: var(--nt-group-17-main-bg);
+}
+
+.nt-group-18 .nt-plan-group-summary,
+.nt-group-18 .nt-timeline-dot {
+ color: var(--nt-group-18-dark);
+ background-color: var(--nt-group-18-dark-bg);
+}
+.nt-group-18 .period {
+ color: var(--nt-group-18-main);
+ background-color: var(--nt-group-18-main-bg);
+}
+
+/**
+ * Extra CSS file for MkDocs and the neoteroi.timeline extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+.nt-error {
+ border: 2px dashed darkred;
+ padding: 0 1rem;
+ background: #faf9ba;
+ color: darkred;
+}
+
+.nt-timeline {
+ margin-top: 30px;
+}
+.nt-timeline .nt-timeline-title {
+ font-size: 1.1rem;
+ margin-top: 0;
+}
+.nt-timeline .nt-timeline-sub-title {
+ margin-top: 0;
+}
+.nt-timeline .nt-timeline-content {
+ font-size: 0.8rem;
+ border-bottom: 2px dashed #ccc;
+ padding-bottom: 1.2rem;
+}
+.nt-timeline.horizontal .nt-timeline-items {
+ flex-direction: row;
+ overflow-x: scroll;
+}
+.nt-timeline.horizontal .nt-timeline-items > div {
+ min-width: 400px;
+ margin-right: 50px;
+}
+.nt-timeline.horizontal.reverse .nt-timeline-items {
+ flex-direction: row-reverse;
+}
+.nt-timeline.horizontal.center .nt-timeline-before {
+ background-image: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%);
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ background-position: 0 center;
+}
+.nt-timeline.horizontal.center .nt-timeline-after {
+ background-image: linear-gradient(180deg, rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%);
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ background-position: 0 center;
+}
+.nt-timeline.horizontal.center .nt-timeline-items {
+ background-image: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%);
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ background-position: 0 center;
+}
+.nt-timeline.horizontal .nt-timeline-dot {
+ left: 50%;
+}
+.nt-timeline.horizontal .nt-timeline-dot:not(.bigger) {
+ top: calc(50% - 4px);
+}
+.nt-timeline.horizontal .nt-timeline-dot.bigger {
+ top: calc(50% - 15px);
+}
+.nt-timeline.vertical .nt-timeline-items {
+ flex-direction: column;
+}
+.nt-timeline.vertical.reverse .nt-timeline-items {
+ flex-direction: column-reverse;
+}
+.nt-timeline.vertical.center .nt-timeline-before {
+ background: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%;
+}
+.nt-timeline.vertical.center .nt-timeline-after {
+ background: linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat center/2px 100%;
+}
+.nt-timeline.vertical.center .nt-timeline-items {
+ background: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%;
+}
+.nt-timeline.vertical.center .nt-timeline-dot {
+ left: calc(50% - 10px);
+}
+.nt-timeline.vertical.center .nt-timeline-dot:not(.bigger) {
+ top: 10px;
+}
+.nt-timeline.vertical.center .nt-timeline-dot.bigger {
+ left: calc(50% - 20px);
+}
+.nt-timeline.vertical.left {
+ padding-left: 100px;
+}
+.nt-timeline.vertical.left .nt-timeline-item {
+ padding-left: 70px;
+}
+.nt-timeline.vertical.left .nt-timeline-sub-title {
+ left: -100px;
+ width: 100px;
+}
+.nt-timeline.vertical.left .nt-timeline-before {
+ background: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%;
+}
+.nt-timeline.vertical.left .nt-timeline-after {
+ background: linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat 30px/2px 100%;
+}
+.nt-timeline.vertical.left .nt-timeline-items {
+ background: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%;
+}
+.nt-timeline.vertical.left .nt-timeline-dot {
+ left: 21px;
+ top: 8px;
+}
+.nt-timeline.vertical.left .nt-timeline-dot.bigger {
+ top: 0px;
+ left: 10px;
+}
+.nt-timeline.vertical.right {
+ padding-right: 100px;
+}
+.nt-timeline.vertical.right .nt-timeline-sub-title {
+ right: -100px;
+ text-align: left;
+ width: 100px;
+}
+.nt-timeline.vertical.right .nt-timeline-item {
+ padding-right: 70px;
+}
+.nt-timeline.vertical.right .nt-timeline-before {
+ background: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%;
+}
+.nt-timeline.vertical.right .nt-timeline-after {
+ background: linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat calc(100% - 30px)/2px 100%;
+}
+.nt-timeline.vertical.right .nt-timeline-items {
+ background: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%;
+}
+.nt-timeline.vertical.right .nt-timeline-dot {
+ right: 21px;
+ top: 8px;
+}
+.nt-timeline.vertical.right .nt-timeline-dot.bigger {
+ top: 10px;
+ right: 10px;
+}
+
+.nt-timeline-items {
+ display: flex;
+ position: relative;
+}
+.nt-timeline-items > div {
+ min-height: 100px;
+ padding-top: 2px;
+ padding-bottom: 20px;
+}
+
+.nt-timeline-before {
+ content: "";
+ height: 15px;
+}
+
+.nt-timeline-after {
+ content: "";
+ height: 60px;
+ margin-bottom: 20px;
+}
+
+.nt-timeline-sub-title {
+ position: absolute;
+ width: 50%;
+ top: 4px;
+ font-size: 18px;
+ color: var(--nt-color-50);
+}
+
+[data-md-color-scheme=slate] .nt-timeline-sub-title {
+ color: var(--nt-color-51);
+}
+
+.nt-timeline-item {
+ position: relative;
+}
+
+.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item {
+ padding-left: calc(50% + 40px);
+}
+.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title {
+ left: 0;
+ padding-right: 40px;
+ text-align: right;
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) {
+ padding-left: calc(50% + 40px);
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title {
+ left: 0;
+ padding-right: 40px;
+ text-align: right;
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) {
+ text-align: right;
+ padding-right: calc(50% + 40px);
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title {
+ right: 0;
+ padding-left: 40px;
+ text-align: left;
+}
+
+.nt-timeline-dot {
+ position: relative;
+ width: 20px;
+ height: 20px;
+ border-radius: 100%;
+ background-color: #fc5b5b;
+ position: absolute;
+ top: 0px;
+ z-index: 2;
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ box-shadow: 0 2px 1px -1px rgba(0, 0, 0, 0.2), 0 1px 1px 0 rgba(0, 0, 0, 0.14), 0 1px 3px 0 rgba(0, 0, 0, 0.12);
+ border: 3px solid white;
+}
+.nt-timeline-dot:not(.bigger) .icon {
+ font-size: 10px;
+}
+.nt-timeline-dot.bigger {
+ width: 40px;
+ height: 40px;
+ padding: 3px;
+}
+.nt-timeline-dot .icon {
+ color: white;
+}
+
+/* Fix for webkit (Chrome, Safari) */
+@supports not (-moz-appearance: none) {
+ /*
+ This fix is necessary, for some reason, to render the timeline properly
+ inside `details` elements used by pymdownx. Firefox doesn't need this fix,
+ it renders elements properly.
+ */
+ details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title,
+details .nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title {
+ left: -40px;
+ }
+ details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title {
+ right: -40px;
+ }
+ details .nt-timeline.vertical.center .nt-timeline-dot {
+ left: calc(50% - 12px);
+ }
+ details .nt-timeline-dot.bigger {
+ font-size: 1rem !important;
+ }
+}
+/* default colors */
+.nt-timeline-item:nth-child(0) .nt-timeline-dot {
+ background-color: var(--nt-color-0);
+}
+
+.nt-timeline-item:nth-child(1) .nt-timeline-dot {
+ background-color: var(--nt-color-1);
+}
+
+.nt-timeline-item:nth-child(2) .nt-timeline-dot {
+ background-color: var(--nt-color-2);
+}
+
+.nt-timeline-item:nth-child(3) .nt-timeline-dot {
+ background-color: var(--nt-color-3);
+}
+
+.nt-timeline-item:nth-child(4) .nt-timeline-dot {
+ background-color: var(--nt-color-4);
+}
+
+.nt-timeline-item:nth-child(5) .nt-timeline-dot {
+ background-color: var(--nt-color-5);
+}
+
+.nt-timeline-item:nth-child(6) .nt-timeline-dot {
+ background-color: var(--nt-color-6);
+}
+
+.nt-timeline-item:nth-child(7) .nt-timeline-dot {
+ background-color: var(--nt-color-7);
+}
+
+.nt-timeline-item:nth-child(8) .nt-timeline-dot {
+ background-color: var(--nt-color-8);
+}
+
+.nt-timeline-item:nth-child(9) .nt-timeline-dot {
+ background-color: var(--nt-color-9);
+}
+
+.nt-timeline-item:nth-child(10) .nt-timeline-dot {
+ background-color: var(--nt-color-10);
+}
+
+.nt-timeline-item:nth-child(11) .nt-timeline-dot {
+ background-color: var(--nt-color-11);
+}
+
+.nt-timeline-item:nth-child(12) .nt-timeline-dot {
+ background-color: var(--nt-color-12);
+}
+
+.nt-timeline-item:nth-child(13) .nt-timeline-dot {
+ background-color: var(--nt-color-13);
+}
+
+.nt-timeline-item:nth-child(14) .nt-timeline-dot {
+ background-color: var(--nt-color-14);
+}
+
+.nt-timeline-item:nth-child(15) .nt-timeline-dot {
+ background-color: var(--nt-color-15);
+}
+
+.nt-timeline-item:nth-child(16) .nt-timeline-dot {
+ background-color: var(--nt-color-16);
+}
+
+.nt-timeline-item:nth-child(17) .nt-timeline-dot {
+ background-color: var(--nt-color-17);
+}
+
+.nt-timeline-item:nth-child(18) .nt-timeline-dot {
+ background-color: var(--nt-color-18);
+}
+
+.nt-timeline-item:nth-child(19) .nt-timeline-dot {
+ background-color: var(--nt-color-19);
+}
+
+.nt-timeline-item:nth-child(20) .nt-timeline-dot {
+ background-color: var(--nt-color-20);
+}
+
+/**
+ * Extra CSS for the neoteroi.projects.gantt extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+:root {
+ --nt-scrollbar-color: #2751b0;
+ --nt-plan-actions-height: 24px;
+ --nt-units-background: #ff9800;
+ --nt-months-background: #2751b0;
+ --nt-plan-vertical-line-color: #a3a3a3ad;
+}
+
+.nt-pastello {
+ --nt-scrollbar-color: #9fb8f4;
+ --nt-units-background: #f5dc82;
+ --nt-months-background: #5b7fd1;
+}
+
+[data-md-color-scheme=slate] {
+ --nt-units-background: #003773;
+}
+[data-md-color-scheme=slate] .nt-pastello {
+ --nt-units-background: #3f4997;
+}
+
+.nt-plan-root {
+ min-height: 200px;
+ scrollbar-width: 20px;
+ scrollbar-color: var(--nt-scrollbar-color);
+ display: flex;
+}
+.nt-plan-root ::-webkit-scrollbar {
+ width: 20px;
+}
+.nt-plan-root ::-webkit-scrollbar-track {
+ box-shadow: inset 0 0 5px grey;
+ border-radius: 10px;
+}
+.nt-plan-root ::-webkit-scrollbar-thumb {
+ background: var(--nt-scrollbar-color);
+ border-radius: 10px;
+}
+.nt-plan-root .nt-plan {
+ flex: 80%;
+}
+.nt-plan-root.no-groups .nt-plan-periods {
+ padding-left: 0;
+}
+.nt-plan-root.no-groups .nt-plan-group-summary {
+ display: none;
+}
+.nt-plan-root .nt-timeline-dot.bigger {
+ top: -10px;
+}
+.nt-plan-root .nt-timeline-dot.bigger[title] {
+ cursor: help;
+}
+
+.nt-plan {
+ white-space: nowrap;
+ overflow-x: auto;
+ display: flex;
+}
+.nt-plan .ug-timeline-dot {
+ left: 368px;
+ top: -8px;
+ cursor: help;
+}
+
+.months {
+ display: flex;
+}
+
+.month {
+ flex: auto;
+ display: inline-block;
+ box-shadow: rgba(0, 0, 0, 0.2) 0px 3px 1px -2px, rgba(0, 0, 0, 0.14) 0px 2px 2px 0px, rgba(0, 0, 0, 0.12) 0px 1px 5px 0px inset;
+ background-color: var(--nt-months-background);
+ color: white;
+ text-transform: uppercase;
+ font-family: Roboto, Helvetica, Arial, sans-serif;
+ padding: 2px 5px;
+ font-size: 12px;
+ border: 1px solid #000;
+ width: 150px;
+ border-radius: 8px;
+}
+
+.nt-plan-group-activities {
+ flex: auto;
+ position: relative;
+}
+
+.nt-vline {
+ border-left: 1px dashed var(--nt-plan-vertical-line-color);
+ height: 100%;
+ left: 0;
+ position: absolute;
+ margin-left: -0.5px;
+ top: 0;
+ -webkit-transition: all 0.5s linear !important;
+ -moz-transition: all 0.5s linear !important;
+ -ms-transition: all 0.5s linear !important;
+ -o-transition: all 0.5s linear !important;
+ transition: all 0.5s linear !important;
+ z-index: -2;
+}
+
+.nt-plan-activity {
+ display: flex;
+ margin: 2px 0;
+ background-color: rgba(187, 187, 187, 0.2509803922);
+}
+
+.actions {
+ height: var(--nt-plan-actions-height);
+}
+
+.actions {
+ position: relative;
+}
+
+.period {
+ display: inline-block;
+ height: var(--nt-plan-actions-height);
+ width: 120px;
+ position: absolute;
+ left: 0px;
+ background: #1da1f2;
+ border-radius: 5px;
+ transition: all 0.5s;
+ cursor: help;
+ -webkit-transition: width 1s ease-in-out;
+ -moz-transition: width 1s ease-in-out;
+ -o-transition: width 1s ease-in-out;
+ transition: width 1s ease-in-out;
+}
+.period .nt-tooltip {
+ display: none;
+ top: 30px;
+ position: relative;
+ padding: 1rem;
+ text-align: center;
+ font-size: 12px;
+}
+.period:hover .nt-tooltip {
+ display: inline-block;
+}
+
+.period-0 {
+ left: 340px;
+ visibility: visible;
+ background-color: rgb(69, 97, 101);
+}
+
+.period-1 {
+ left: 40px;
+ visibility: visible;
+ background-color: green;
+}
+
+.period-2 {
+ left: 120px;
+ visibility: visible;
+ background-color: pink;
+ width: 80px;
+}
+
+.period-3 {
+ left: 190px;
+ visibility: visible;
+ background-color: darkred;
+ width: 150px;
+}
+
+.weeks > span,
+.days > span {
+ height: 25px;
+}
+
+.weeks > span {
+ display: inline-block;
+ margin: 0;
+ padding: 0;
+ font-weight: bold;
+}
+.weeks > span .week-text {
+ font-size: 10px;
+ position: absolute;
+ display: inline-block;
+ padding: 3px 4px;
+}
+
+.days {
+ z-index: -2;
+ position: relative;
+}
+
+.day-text {
+ font-size: 10px;
+ position: absolute;
+ display: inline-block;
+ padding: 3px 4px;
+}
+
+.period span {
+ font-size: 12px;
+ vertical-align: top;
+ margin-left: 4px;
+ color: black;
+ background: rgba(255, 255, 255, 0.6588235294);
+ border-radius: 6px;
+ padding: 0 4px;
+}
+
+.weeks,
+.days {
+ height: 20px;
+ display: flex;
+ box-sizing: content-box;
+}
+
+.months {
+ display: flex;
+}
+
+.week,
+.day {
+ height: 20px;
+ position: relative;
+ border: 1;
+ flex: auto;
+ border: 2px solid white;
+ border-radius: 4px;
+ background-color: var(--nt-units-background);
+ cursor: help;
+}
+
+.years {
+ display: flex;
+}
+
+.year {
+ text-align: center;
+ border-right: 1px solid var(--nt-plan-vertical-line-color);
+ font-weight: bold;
+}
+.year:first-child {
+ border-left: 1px solid var(--nt-plan-vertical-line-color);
+}
+.year:first-child:last-child {
+ width: 100%;
+}
+
+.quarters {
+ display: flex;
+}
+
+.quarter {
+ width: 12.5%;
+ text-align: center;
+ border-right: 1px solid var(--nt-plan-vertical-line-color);
+ font-weight: bold;
+}
+.quarter:first-child {
+ border-left: 1px solid var(--nt-plan-vertical-line-color);
+}
+
+.nt-plan-group {
+ margin: 20px 0;
+ position: relative;
+}
+
+.nt-plan-group {
+ display: flex;
+}
+
+.nt-plan-group-summary {
+ background: #2751b0;
+ width: 150px;
+ white-space: normal;
+ padding: 0.1rem 0.5rem;
+ border-radius: 5px;
+ color: #fff;
+ z-index: 3;
+}
+.nt-plan-group-summary p {
+ margin: 0;
+ padding: 0;
+ font-size: 0.6rem;
+ color: #fff;
+}
+
+.nt-plan-group-summary,
+.month,
+.period,
+.week,
+.day,
+.nt-tooltip {
+ border: 3px solid white;
+ box-shadow: 0 2px 3px -1px rgba(0, 0, 0, 0.2), 0 3px 3px 0 rgba(0, 0, 0, 0.14), 0 1px 5px 0 rgba(0, 0, 0, 0.12);
+}
+
+.nt-plan-periods {
+ padding-left: 150px;
+}
+
+.months {
+ z-index: 2;
+ position: relative;
+}
+
+.weeks {
+ position: relative;
+ top: -2px;
+ z-index: 0;
+}
+
+.month,
+.quarter,
+.year,
+.week,
+.day,
+.nt-tooltip {
+ font-family: Roboto, Helvetica, Arial, sans-serif;
+ box-sizing: border-box;
+}
+
+.nt-cards.nt-grid {
+ display: grid;
+ grid-auto-columns: 1fr;
+ gap: 0.5rem;
+ max-width: 100vw;
+ overflow-x: auto;
+ padding: 1px;
+}
+.nt-cards.nt-grid.cols-1 {
+ grid-template-columns: repeat(1, 1fr);
+}
+.nt-cards.nt-grid.cols-2 {
+ grid-template-columns: repeat(2, 1fr);
+}
+.nt-cards.nt-grid.cols-3 {
+ grid-template-columns: repeat(3, 1fr);
+}
+.nt-cards.nt-grid.cols-4 {
+ grid-template-columns: repeat(4, 1fr);
+}
+.nt-cards.nt-grid.cols-5 {
+ grid-template-columns: repeat(5, 1fr);
+}
+.nt-cards.nt-grid.cols-6 {
+ grid-template-columns: repeat(6, 1fr);
+}
+
+@media only screen and (max-width: 400px) {
+ .nt-cards.nt-grid {
+ grid-template-columns: repeat(1, 1fr) !important;
+ }
+}
+.nt-card {
+ box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.14), 0 3px 1px -2px rgba(0, 0, 0, 0.2), 0 1px 5px 0 rgba(0, 0, 0, 0.12);
+}
+.nt-card:hover {
+ box-shadow: 0 2px 2px 0 rgba(0, 0, 0, 0.24), 0 3px 1px -2px rgba(0, 0, 0, 0.3), 0 1px 5px 0 rgba(0, 0, 0, 0.22);
+}
+
+[data-md-color-scheme=slate] .nt-card {
+ box-shadow: 0 2px 2px 0 rgba(4, 40, 33, 0.14), 0 3px 1px -2px rgba(40, 86, 94, 0.47), 0 1px 5px 0 rgba(139, 252, 255, 0.64);
+}
+[data-md-color-scheme=slate] .nt-card:hover {
+ box-shadow: 0 2px 2px 0 rgba(0, 255, 206, 0.14), 0 3px 1px -2px rgba(33, 156, 177, 0.47), 0 1px 5px 0 rgba(96, 251, 255, 0.64);
+}
+
+.nt-card > a {
+ color: var(--md-default-fg-color);
+}
+
+.nt-card > a > div {
+ cursor: pointer;
+}
+
+.nt-card {
+ padding: 5px;
+ margin-bottom: 0.5rem;
+}
+
+.nt-card-title {
+ font-size: 1rem;
+ font-weight: bold;
+ margin: 4px 0 8px 0;
+ line-height: 22px;
+}
+
+.nt-card-content {
+ padding: 0.4rem 0.8rem 0.8rem 0.8rem;
+}
+
+.nt-card-text {
+ font-size: 14px;
+ padding: 0;
+ margin: 0;
+}
+
+.nt-card .nt-card-image {
+ text-align: center;
+ border-radius: 2px;
+ background-position: center center;
+ background-size: cover;
+ background-repeat: no-repeat;
+ min-height: 120px;
+}
+
+.nt-card .nt-card-image.tags img {
+ margin-top: 12px;
+}
+
+.nt-card .nt-card-image img {
+ height: 105px;
+ margin-top: 5px;
+}
+
+.nt-card a:hover,
+.nt-card a:focus {
+ color: var(--md-accent-fg-color);
+}
+
+.nt-card h2 {
+ margin: 0;
+}
+
+/**
+ * Extra CSS file recommended for MkDocs and neoteroi.spantable extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+.span-table-wrapper table {
+ border-collapse: collapse;
+ margin-bottom: 2rem;
+ border-radius: 0.1rem;
+}
+
+.span-table td,
+.span-table th {
+ padding: 0.2rem;
+ background-color: var(--md-default-bg-color);
+ font-size: 0.64rem;
+ max-width: 100%;
+ overflow: auto;
+ touch-action: auto;
+ border-top: 0.05rem solid var(--md-typeset-table-color);
+ padding: 0.9375em 1.25em;
+ vertical-align: top;
+}
+
+.span-table tr:first-child td {
+ font-weight: 700;
+ min-width: 5rem;
+ padding: 0.9375em 1.25em;
+ vertical-align: top;
+}
+
+.span-table td:first-child {
+ border-left: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table td:last-child {
+ border-right: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table tr:last-child {
+ border-bottom: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table [colspan],
+.span-table [rowspan] {
+ font-weight: bold;
+ border: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table tr:not(:first-child):hover td:not([colspan]):not([rowspan]),
+.span-table td[colspan]:hover,
+.span-table td[rowspan]:hover {
+ background-color: rgba(0, 0, 0, 0.035);
+ box-shadow: 0 0.05rem 0 var(--md-default-bg-color) inset;
+ transition: background-color 125ms;
+}
diff --git a/docs/css/neoteroi-mkdocs.min.css b/docs/css/neoteroi-mkdocs.min.css
new file mode 100644
index 0000000..ea55c67
--- /dev/null
+++ b/docs/css/neoteroi-mkdocs.min.css
@@ -0,0 +1 @@
+:root{--nt-color-0: #CD853F;--nt-color-1: #B22222;--nt-color-2: #000080;--nt-color-3: #4B0082;--nt-color-4: #3CB371;--nt-color-5: #D2B48C;--nt-color-6: #FF00FF;--nt-color-7: #98FB98;--nt-color-8: #FFEBCD;--nt-color-9: #2E8B57;--nt-color-10: #6A5ACD;--nt-color-11: #48D1CC;--nt-color-12: #FFA500;--nt-color-13: #F4A460;--nt-color-14: #A52A2A;--nt-color-15: #FFE4C4;--nt-color-16: #FF4500;--nt-color-17: #AFEEEE;--nt-color-18: #FA8072;--nt-color-19: #2F4F4F;--nt-color-20: #FFDAB9;--nt-color-21: #BC8F8F;--nt-color-22: #FFC0CB;--nt-color-23: #00FA9A;--nt-color-24: #F0FFF0;--nt-color-25: #FFFACD;--nt-color-26: #F5F5F5;--nt-color-27: #FF6347;--nt-color-28: #FFFFF0;--nt-color-29: #7FFFD4;--nt-color-30: #E9967A;--nt-color-31: #7B68EE;--nt-color-32: #FFF8DC;--nt-color-33: #0000CD;--nt-color-34: #D2691E;--nt-color-35: #708090;--nt-color-36: #5F9EA0;--nt-color-37: #008080;--nt-color-38: #008000;--nt-color-39: #FFE4E1;--nt-color-40: #FFFF00;--nt-color-41: #FFFAF0;--nt-color-42: #DCDCDC;--nt-color-43: #ADFF2F;--nt-color-44: #ADD8E6;--nt-color-45: #8B008B;--nt-color-46: #7FFF00;--nt-color-47: #800000;--nt-color-48: #20B2AA;--nt-color-49: #556B2F;--nt-color-50: #778899;--nt-color-51: #E6E6FA;--nt-color-52: #FFFAFA;--nt-color-53: #FF7F50;--nt-color-54: #FF0000;--nt-color-55: #F5DEB3;--nt-color-56: #008B8B;--nt-color-57: #66CDAA;--nt-color-58: #808000;--nt-color-59: #FAF0E6;--nt-color-60: #00BFFF;--nt-color-61: #C71585;--nt-color-62: #00FFFF;--nt-color-63: #8B4513;--nt-color-64: #F0F8FF;--nt-color-65: #FAEBD7;--nt-color-66: #8B0000;--nt-color-67: #4682B4;--nt-color-68: #F0E68C;--nt-color-69: #BDB76B;--nt-color-70: #A0522D;--nt-color-71: #FAFAD2;--nt-color-72: #FFD700;--nt-color-73: #DEB887;--nt-color-74: #E0FFFF;--nt-color-75: #8A2BE2;--nt-color-76: #32CD32;--nt-color-77: #87CEFA;--nt-color-78: #00CED1;--nt-color-79: #696969;--nt-color-80: #DDA0DD;--nt-color-81: #EE82EE;--nt-color-82: #FFB6C1;--nt-color-83: #8FBC8F;--nt-color-84: #D8BFD8;--nt-color-85: #9400D3;--nt-color-86: #A9A9A9;--nt-color-87: #FFFFE0;--nt-color-88: #FFF5EE;--nt-color-89: #FFF0F5;--nt-color-90: #FFDEAD;--nt-color-91: #800080;--nt-color-92: #B0E0E6;--nt-color-93: #9932CC;--nt-color-94: #DAA520;--nt-color-95: #F0FFFF;--nt-color-96: #40E0D0;--nt-color-97: #00FF7F;--nt-color-98: #006400;--nt-color-99: #808080;--nt-color-100: #87CEEB;--nt-color-101: #0000FF;--nt-color-102: #6495ED;--nt-color-103: #FDF5E6;--nt-color-104: #B8860B;--nt-color-105: #BA55D3;--nt-color-106: #C0C0C0;--nt-color-107: #000000;--nt-color-108: #F08080;--nt-color-109: #B0C4DE;--nt-color-110: #00008B;--nt-color-111: #6B8E23;--nt-color-112: #FFE4B5;--nt-color-113: #FFA07A;--nt-color-114: #9ACD32;--nt-color-115: #FFFFFF;--nt-color-116: #F5F5DC;--nt-color-117: #90EE90;--nt-color-118: #1E90FF;--nt-color-119: #7CFC00;--nt-color-120: #FF69B4;--nt-color-121: #F8F8FF;--nt-color-122: #F5FFFA;--nt-color-123: #00FF00;--nt-color-124: #D3D3D3;--nt-color-125: #DB7093;--nt-color-126: #DA70D6;--nt-color-127: #FF1493;--nt-color-128: #228B22;--nt-color-129: #FFEFD5;--nt-color-130: #4169E1;--nt-color-131: #191970;--nt-color-132: #9370DB;--nt-color-133: #483D8B;--nt-color-134: #FF8C00;--nt-color-135: #EEE8AA;--nt-color-136: #CD5C5C;--nt-color-137: #DC143C}:root{--nt-group-0-main: #000000;--nt-group-0-dark: #FFFFFF;--nt-group-0-light: #000000;--nt-group-0-main-bg: #F44336;--nt-group-0-dark-bg: #BA000D;--nt-group-0-light-bg: #FF7961;--nt-group-1-main: #000000;--nt-group-1-dark: #FFFFFF;--nt-group-1-light: #000000;--nt-group-1-main-bg: #E91E63;--nt-group-1-dark-bg: #B0003A;--nt-group-1-light-bg: #FF6090;--nt-group-2-main: #FFFFFF;--nt-group-2-dark: #FFFFFF;--nt-group-2-light: #000000;--nt-group-2-main-bg: #9C27B0;--nt-group-2-dark-bg: #6A0080;--nt-group-2-light-bg: #D05CE3;--nt-group-3-main: #FFFFFF;--nt-group-3-dark: #FFFFFF;--nt-group-3-light: #000000;--nt-group-3-main-bg: #673AB7;--nt-group-3-dark-bg: #320B86;--nt-group-3-light-bg: #9A67EA;--nt-group-4-main: #FFFFFF;--nt-group-4-dark: #FFFFFF;--nt-group-4-light: #000000;--nt-group-4-main-bg: #3F51B5;--nt-group-4-dark-bg: #002984;--nt-group-4-light-bg: #757DE8;--nt-group-5-main: #000000;--nt-group-5-dark: #FFFFFF;--nt-group-5-light: #000000;--nt-group-5-main-bg: #2196F3;--nt-group-5-dark-bg: #0069C0;--nt-group-5-light-bg: #6EC6FF;--nt-group-6-main: #000000;--nt-group-6-dark: #FFFFFF;--nt-group-6-light: #000000;--nt-group-6-main-bg: #03A9F4;--nt-group-6-dark-bg: #007AC1;--nt-group-6-light-bg: #67DAFF;--nt-group-7-main: #000000;--nt-group-7-dark: #000000;--nt-group-7-light: #000000;--nt-group-7-main-bg: #00BCD4;--nt-group-7-dark-bg: #008BA3;--nt-group-7-light-bg: #62EFFF;--nt-group-8-main: #000000;--nt-group-8-dark: #FFFFFF;--nt-group-8-light: #000000;--nt-group-8-main-bg: #009688;--nt-group-8-dark-bg: #00675B;--nt-group-8-light-bg: #52C7B8;--nt-group-9-main: #000000;--nt-group-9-dark: #FFFFFF;--nt-group-9-light: #000000;--nt-group-9-main-bg: #4CAF50;--nt-group-9-dark-bg: #087F23;--nt-group-9-light-bg: #80E27E;--nt-group-10-main: #000000;--nt-group-10-dark: #000000;--nt-group-10-light: #000000;--nt-group-10-main-bg: #8BC34A;--nt-group-10-dark-bg: #5A9216;--nt-group-10-light-bg: #BEF67A;--nt-group-11-main: #000000;--nt-group-11-dark: #000000;--nt-group-11-light: #000000;--nt-group-11-main-bg: #CDDC39;--nt-group-11-dark-bg: #99AA00;--nt-group-11-light-bg: #FFFF6E;--nt-group-12-main: #000000;--nt-group-12-dark: #000000;--nt-group-12-light: #000000;--nt-group-12-main-bg: #FFEB3B;--nt-group-12-dark-bg: #C8B900;--nt-group-12-light-bg: #FFFF72;--nt-group-13-main: #000000;--nt-group-13-dark: #000000;--nt-group-13-light: #000000;--nt-group-13-main-bg: #FFC107;--nt-group-13-dark-bg: #C79100;--nt-group-13-light-bg: #FFF350;--nt-group-14-main: #000000;--nt-group-14-dark: #000000;--nt-group-14-light: #000000;--nt-group-14-main-bg: #FF9800;--nt-group-14-dark-bg: #C66900;--nt-group-14-light-bg: #FFC947;--nt-group-15-main: #000000;--nt-group-15-dark: #FFFFFF;--nt-group-15-light: #000000;--nt-group-15-main-bg: #FF5722;--nt-group-15-dark-bg: #C41C00;--nt-group-15-light-bg: #FF8A50;--nt-group-16-main: #FFFFFF;--nt-group-16-dark: #FFFFFF;--nt-group-16-light: #000000;--nt-group-16-main-bg: #795548;--nt-group-16-dark-bg: #4B2C20;--nt-group-16-light-bg: #A98274;--nt-group-17-main: #000000;--nt-group-17-dark: #FFFFFF;--nt-group-17-light: #000000;--nt-group-17-main-bg: #9E9E9E;--nt-group-17-dark-bg: #707070;--nt-group-17-light-bg: #CFCFCF;--nt-group-18-main: #000000;--nt-group-18-dark: #FFFFFF;--nt-group-18-light: #000000;--nt-group-18-main-bg: #607D8B;--nt-group-18-dark-bg: #34515E;--nt-group-18-light-bg: #8EACBB}.nt-pastello{--nt-group-0-main: #000000;--nt-group-0-dark: #000000;--nt-group-0-light: #000000;--nt-group-0-main-bg: #EF9A9A;--nt-group-0-dark-bg: #BA6B6C;--nt-group-0-light-bg: #FFCCCB;--nt-group-1-main: #000000;--nt-group-1-dark: #000000;--nt-group-1-light: #000000;--nt-group-1-main-bg: #F48FB1;--nt-group-1-dark-bg: #BF5F82;--nt-group-1-light-bg: #FFC1E3;--nt-group-2-main: #000000;--nt-group-2-dark: #000000;--nt-group-2-light: #000000;--nt-group-2-main-bg: #CE93D8;--nt-group-2-dark-bg: #9C64A6;--nt-group-2-light-bg: #FFC4FF;--nt-group-3-main: #000000;--nt-group-3-dark: #000000;--nt-group-3-light: #000000;--nt-group-3-main-bg: #B39DDB;--nt-group-3-dark-bg: #836FA9;--nt-group-3-light-bg: #E6CEFF;--nt-group-4-main: #000000;--nt-group-4-dark: #000000;--nt-group-4-light: #000000;--nt-group-4-main-bg: #9FA8DA;--nt-group-4-dark-bg: #6F79A8;--nt-group-4-light-bg: #D1D9FF;--nt-group-5-main: #000000;--nt-group-5-dark: #000000;--nt-group-5-light: #000000;--nt-group-5-main-bg: #90CAF9;--nt-group-5-dark-bg: #5D99C6;--nt-group-5-light-bg: #C3FDFF;--nt-group-6-main: #000000;--nt-group-6-dark: #000000;--nt-group-6-light: #000000;--nt-group-6-main-bg: #81D4FA;--nt-group-6-dark-bg: #4BA3C7;--nt-group-6-light-bg: #B6FFFF;--nt-group-7-main: #000000;--nt-group-7-dark: #000000;--nt-group-7-light: #000000;--nt-group-7-main-bg: #80DEEA;--nt-group-7-dark-bg: #4BACB8;--nt-group-7-light-bg: #B4FFFF;--nt-group-8-main: #000000;--nt-group-8-dark: #000000;--nt-group-8-light: #000000;--nt-group-8-main-bg: #80CBC4;--nt-group-8-dark-bg: #4F9A94;--nt-group-8-light-bg: #B2FEF7;--nt-group-9-main: #000000;--nt-group-9-dark: #000000;--nt-group-9-light: #000000;--nt-group-9-main-bg: #A5D6A7;--nt-group-9-dark-bg: #75A478;--nt-group-9-light-bg: #D7FFD9;--nt-group-10-main: #000000;--nt-group-10-dark: #000000;--nt-group-10-light: #000000;--nt-group-10-main-bg: #C5E1A5;--nt-group-10-dark-bg: #94AF76;--nt-group-10-light-bg: #F8FFD7;--nt-group-11-main: #000000;--nt-group-11-dark: #000000;--nt-group-11-light: #000000;--nt-group-11-main-bg: #E6EE9C;--nt-group-11-dark-bg: #B3BC6D;--nt-group-11-light-bg: #FFFFCE;--nt-group-12-main: #000000;--nt-group-12-dark: #000000;--nt-group-12-light: #000000;--nt-group-12-main-bg: #FFF59D;--nt-group-12-dark-bg: #CBC26D;--nt-group-12-light-bg: #FFFFCF;--nt-group-13-main: #000000;--nt-group-13-dark: #000000;--nt-group-13-light: #000000;--nt-group-13-main-bg: #FFE082;--nt-group-13-dark-bg: #CAAE53;--nt-group-13-light-bg: #FFFFB3;--nt-group-14-main: #000000;--nt-group-14-dark: #000000;--nt-group-14-light: #000000;--nt-group-14-main-bg: #FFCC80;--nt-group-14-dark-bg: #CA9B52;--nt-group-14-light-bg: #FFFFB0;--nt-group-15-main: #000000;--nt-group-15-dark: #000000;--nt-group-15-light: #000000;--nt-group-15-main-bg: #FFAB91;--nt-group-15-dark-bg: #C97B63;--nt-group-15-light-bg: #FFDDC1;--nt-group-16-main: #000000;--nt-group-16-dark: #000000;--nt-group-16-light: #000000;--nt-group-16-main-bg: #BCAAA4;--nt-group-16-dark-bg: #8C7B75;--nt-group-16-light-bg: #EFDCD5;--nt-group-17-main: #000000;--nt-group-17-dark: #000000;--nt-group-17-light: #000000;--nt-group-17-main-bg: #EEEEEE;--nt-group-17-dark-bg: #BCBCBC;--nt-group-17-light-bg: #FFFFFF;--nt-group-18-main: #000000;--nt-group-18-dark: #000000;--nt-group-18-light: #000000;--nt-group-18-main-bg: #B0BEC5;--nt-group-18-dark-bg: #808E95;--nt-group-18-light-bg: #E2F1F8}.nt-group-0 .nt-plan-group-summary,.nt-group-0 .nt-timeline-dot{color:var(--nt-group-0-dark);background-color:var(--nt-group-0-dark-bg)}.nt-group-0 .period{color:var(--nt-group-0-main);background-color:var(--nt-group-0-main-bg)}.nt-group-1 .nt-plan-group-summary,.nt-group-1 .nt-timeline-dot{color:var(--nt-group-1-dark);background-color:var(--nt-group-1-dark-bg)}.nt-group-1 .period{color:var(--nt-group-1-main);background-color:var(--nt-group-1-main-bg)}.nt-group-2 .nt-plan-group-summary,.nt-group-2 .nt-timeline-dot{color:var(--nt-group-2-dark);background-color:var(--nt-group-2-dark-bg)}.nt-group-2 .period{color:var(--nt-group-2-main);background-color:var(--nt-group-2-main-bg)}.nt-group-3 .nt-plan-group-summary,.nt-group-3 .nt-timeline-dot{color:var(--nt-group-3-dark);background-color:var(--nt-group-3-dark-bg)}.nt-group-3 .period{color:var(--nt-group-3-main);background-color:var(--nt-group-3-main-bg)}.nt-group-4 .nt-plan-group-summary,.nt-group-4 .nt-timeline-dot{color:var(--nt-group-4-dark);background-color:var(--nt-group-4-dark-bg)}.nt-group-4 .period{color:var(--nt-group-4-main);background-color:var(--nt-group-4-main-bg)}.nt-group-5 .nt-plan-group-summary,.nt-group-5 .nt-timeline-dot{color:var(--nt-group-5-dark);background-color:var(--nt-group-5-dark-bg)}.nt-group-5 .period{color:var(--nt-group-5-main);background-color:var(--nt-group-5-main-bg)}.nt-group-6 .nt-plan-group-summary,.nt-group-6 .nt-timeline-dot{color:var(--nt-group-6-dark);background-color:var(--nt-group-6-dark-bg)}.nt-group-6 .period{color:var(--nt-group-6-main);background-color:var(--nt-group-6-main-bg)}.nt-group-7 .nt-plan-group-summary,.nt-group-7 .nt-timeline-dot{color:var(--nt-group-7-dark);background-color:var(--nt-group-7-dark-bg)}.nt-group-7 .period{color:var(--nt-group-7-main);background-color:var(--nt-group-7-main-bg)}.nt-group-8 .nt-plan-group-summary,.nt-group-8 .nt-timeline-dot{color:var(--nt-group-8-dark);background-color:var(--nt-group-8-dark-bg)}.nt-group-8 .period{color:var(--nt-group-8-main);background-color:var(--nt-group-8-main-bg)}.nt-group-9 .nt-plan-group-summary,.nt-group-9 .nt-timeline-dot{color:var(--nt-group-9-dark);background-color:var(--nt-group-9-dark-bg)}.nt-group-9 .period{color:var(--nt-group-9-main);background-color:var(--nt-group-9-main-bg)}.nt-group-10 .nt-plan-group-summary,.nt-group-10 .nt-timeline-dot{color:var(--nt-group-10-dark);background-color:var(--nt-group-10-dark-bg)}.nt-group-10 .period{color:var(--nt-group-10-main);background-color:var(--nt-group-10-main-bg)}.nt-group-11 .nt-plan-group-summary,.nt-group-11 .nt-timeline-dot{color:var(--nt-group-11-dark);background-color:var(--nt-group-11-dark-bg)}.nt-group-11 .period{color:var(--nt-group-11-main);background-color:var(--nt-group-11-main-bg)}.nt-group-12 .nt-plan-group-summary,.nt-group-12 .nt-timeline-dot{color:var(--nt-group-12-dark);background-color:var(--nt-group-12-dark-bg)}.nt-group-12 .period{color:var(--nt-group-12-main);background-color:var(--nt-group-12-main-bg)}.nt-group-13 .nt-plan-group-summary,.nt-group-13 .nt-timeline-dot{color:var(--nt-group-13-dark);background-color:var(--nt-group-13-dark-bg)}.nt-group-13 .period{color:var(--nt-group-13-main);background-color:var(--nt-group-13-main-bg)}.nt-group-14 .nt-plan-group-summary,.nt-group-14 .nt-timeline-dot{color:var(--nt-group-14-dark);background-color:var(--nt-group-14-dark-bg)}.nt-group-14 .period{color:var(--nt-group-14-main);background-color:var(--nt-group-14-main-bg)}.nt-group-15 .nt-plan-group-summary,.nt-group-15 .nt-timeline-dot{color:var(--nt-group-15-dark);background-color:var(--nt-group-15-dark-bg)}.nt-group-15 .period{color:var(--nt-group-15-main);background-color:var(--nt-group-15-main-bg)}.nt-group-16 .nt-plan-group-summary,.nt-group-16 .nt-timeline-dot{color:var(--nt-group-16-dark);background-color:var(--nt-group-16-dark-bg)}.nt-group-16 .period{color:var(--nt-group-16-main);background-color:var(--nt-group-16-main-bg)}.nt-group-17 .nt-plan-group-summary,.nt-group-17 .nt-timeline-dot{color:var(--nt-group-17-dark);background-color:var(--nt-group-17-dark-bg)}.nt-group-17 .period{color:var(--nt-group-17-main);background-color:var(--nt-group-17-main-bg)}.nt-group-18 .nt-plan-group-summary,.nt-group-18 .nt-timeline-dot{color:var(--nt-group-18-dark);background-color:var(--nt-group-18-dark-bg)}.nt-group-18 .period{color:var(--nt-group-18-main);background-color:var(--nt-group-18-main-bg)}.nt-error{border:2px dashed darkred;padding:0 1rem;background:#faf9ba;color:darkred}.nt-timeline{margin-top:30px}.nt-timeline .nt-timeline-title{font-size:1.1rem;margin-top:0}.nt-timeline .nt-timeline-sub-title{margin-top:0}.nt-timeline .nt-timeline-content{font-size:.8rem;border-bottom:2px dashed #ccc;padding-bottom:1.2rem}.nt-timeline.horizontal .nt-timeline-items{flex-direction:row;overflow-x:scroll}.nt-timeline.horizontal .nt-timeline-items>div{min-width:400px;margin-right:50px}.nt-timeline.horizontal.reverse .nt-timeline-items{flex-direction:row-reverse}.nt-timeline.horizontal.center .nt-timeline-before{background-image:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal.center .nt-timeline-after{background-image:linear-gradient(180deg, rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal.center .nt-timeline-items{background-image:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal .nt-timeline-dot{left:50%}.nt-timeline.horizontal .nt-timeline-dot:not(.bigger){top:calc(50% - 4px)}.nt-timeline.horizontal .nt-timeline-dot.bigger{top:calc(50% - 15px)}.nt-timeline.vertical .nt-timeline-items{flex-direction:column}.nt-timeline.vertical.reverse .nt-timeline-items{flex-direction:column-reverse}.nt-timeline.vertical.center .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-dot{left:calc(50% - 10px)}.nt-timeline.vertical.center .nt-timeline-dot:not(.bigger){top:10px}.nt-timeline.vertical.center .nt-timeline-dot.bigger{left:calc(50% - 20px)}.nt-timeline.vertical.left{padding-left:100px}.nt-timeline.vertical.left .nt-timeline-item{padding-left:70px}.nt-timeline.vertical.left .nt-timeline-sub-title{left:-100px;width:100px}.nt-timeline.vertical.left .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-dot{left:21px;top:8px}.nt-timeline.vertical.left .nt-timeline-dot.bigger{top:0px;left:10px}.nt-timeline.vertical.right{padding-right:100px}.nt-timeline.vertical.right .nt-timeline-sub-title{right:-100px;text-align:left;width:100px}.nt-timeline.vertical.right .nt-timeline-item{padding-right:70px}.nt-timeline.vertical.right .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-dot{right:21px;top:8px}.nt-timeline.vertical.right .nt-timeline-dot.bigger{top:10px;right:10px}.nt-timeline-items{display:flex;position:relative}.nt-timeline-items>div{min-height:100px;padding-top:2px;padding-bottom:20px}.nt-timeline-before{content:"";height:15px}.nt-timeline-after{content:"";height:60px;margin-bottom:20px}.nt-timeline-sub-title{position:absolute;width:50%;top:4px;font-size:18px;color:var(--nt-color-50)}[data-md-color-scheme=slate] .nt-timeline-sub-title{color:var(--nt-color-51)}.nt-timeline-item{position:relative}.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item{padding-left:calc(50% + 40px)}.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title{left:0;padding-right:40px;text-align:right}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd){padding-left:calc(50% + 40px)}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title{left:0;padding-right:40px;text-align:right}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even){text-align:right;padding-right:calc(50% + 40px)}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title{right:0;padding-left:40px;text-align:left}.nt-timeline-dot{position:relative;width:20px;height:20px;border-radius:100%;background-color:#fc5b5b;position:absolute;top:0px;z-index:2;display:flex;justify-content:center;align-items:center;box-shadow:0 2px 1px -1px rgba(0,0,0,.2),0 1px 1px 0 rgba(0,0,0,.14),0 1px 3px 0 rgba(0,0,0,.12);border:3px solid #fff}.nt-timeline-dot:not(.bigger) .icon{font-size:10px}.nt-timeline-dot.bigger{width:40px;height:40px;padding:3px}.nt-timeline-dot .icon{color:#fff}@supports not (-moz-appearance: none){details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title,details .nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title{left:-40px}details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title{right:-40px}details .nt-timeline.vertical.center .nt-timeline-dot{left:calc(50% - 12px)}details .nt-timeline-dot.bigger{font-size:1rem !important}}.nt-timeline-item:nth-child(0) .nt-timeline-dot{background-color:var(--nt-color-0)}.nt-timeline-item:nth-child(1) .nt-timeline-dot{background-color:var(--nt-color-1)}.nt-timeline-item:nth-child(2) .nt-timeline-dot{background-color:var(--nt-color-2)}.nt-timeline-item:nth-child(3) .nt-timeline-dot{background-color:var(--nt-color-3)}.nt-timeline-item:nth-child(4) .nt-timeline-dot{background-color:var(--nt-color-4)}.nt-timeline-item:nth-child(5) .nt-timeline-dot{background-color:var(--nt-color-5)}.nt-timeline-item:nth-child(6) .nt-timeline-dot{background-color:var(--nt-color-6)}.nt-timeline-item:nth-child(7) .nt-timeline-dot{background-color:var(--nt-color-7)}.nt-timeline-item:nth-child(8) .nt-timeline-dot{background-color:var(--nt-color-8)}.nt-timeline-item:nth-child(9) .nt-timeline-dot{background-color:var(--nt-color-9)}.nt-timeline-item:nth-child(10) .nt-timeline-dot{background-color:var(--nt-color-10)}.nt-timeline-item:nth-child(11) .nt-timeline-dot{background-color:var(--nt-color-11)}.nt-timeline-item:nth-child(12) .nt-timeline-dot{background-color:var(--nt-color-12)}.nt-timeline-item:nth-child(13) .nt-timeline-dot{background-color:var(--nt-color-13)}.nt-timeline-item:nth-child(14) .nt-timeline-dot{background-color:var(--nt-color-14)}.nt-timeline-item:nth-child(15) .nt-timeline-dot{background-color:var(--nt-color-15)}.nt-timeline-item:nth-child(16) .nt-timeline-dot{background-color:var(--nt-color-16)}.nt-timeline-item:nth-child(17) .nt-timeline-dot{background-color:var(--nt-color-17)}.nt-timeline-item:nth-child(18) .nt-timeline-dot{background-color:var(--nt-color-18)}.nt-timeline-item:nth-child(19) .nt-timeline-dot{background-color:var(--nt-color-19)}.nt-timeline-item:nth-child(20) .nt-timeline-dot{background-color:var(--nt-color-20)}:root{--nt-scrollbar-color: #2751b0;--nt-plan-actions-height: 24px;--nt-units-background: #ff9800;--nt-months-background: #2751b0;--nt-plan-vertical-line-color: #a3a3a3ad}.nt-pastello{--nt-scrollbar-color: #9fb8f4;--nt-units-background: #f5dc82;--nt-months-background: #5b7fd1}[data-md-color-scheme=slate]{--nt-units-background: #003773}[data-md-color-scheme=slate] .nt-pastello{--nt-units-background: #3f4997}.nt-plan-root{min-height:200px;scrollbar-width:20px;scrollbar-color:var(--nt-scrollbar-color);display:flex}.nt-plan-root ::-webkit-scrollbar{width:20px}.nt-plan-root ::-webkit-scrollbar-track{box-shadow:inset 0 0 5px gray;border-radius:10px}.nt-plan-root ::-webkit-scrollbar-thumb{background:var(--nt-scrollbar-color);border-radius:10px}.nt-plan-root .nt-plan{flex:80%}.nt-plan-root.no-groups .nt-plan-periods{padding-left:0}.nt-plan-root.no-groups .nt-plan-group-summary{display:none}.nt-plan-root .nt-timeline-dot.bigger{top:-10px}.nt-plan-root .nt-timeline-dot.bigger[title]{cursor:help}.nt-plan{white-space:nowrap;overflow-x:auto;display:flex}.nt-plan .ug-timeline-dot{left:368px;top:-8px;cursor:help}.months{display:flex}.month{flex:auto;display:inline-block;box-shadow:rgba(0,0,0,.2) 0px 3px 1px -2px,rgba(0,0,0,.14) 0px 2px 2px 0px,rgba(0,0,0,.12) 0px 1px 5px 0px inset;background-color:var(--nt-months-background);color:#fff;text-transform:uppercase;font-family:Roboto,Helvetica,Arial,sans-serif;padding:2px 5px;font-size:12px;border:1px solid #000;width:150px;border-radius:8px}.nt-plan-group-activities{flex:auto;position:relative}.nt-vline{border-left:1px dashed var(--nt-plan-vertical-line-color);height:100%;left:0;position:absolute;margin-left:-0.5px;top:0;-webkit-transition:all .5s linear !important;-moz-transition:all .5s linear !important;-ms-transition:all .5s linear !important;-o-transition:all .5s linear !important;transition:all .5s linear !important;z-index:-2}.nt-plan-activity{display:flex;margin:2px 0;background-color:rgba(187,187,187,.2509803922)}.actions{height:var(--nt-plan-actions-height)}.actions{position:relative}.period{display:inline-block;height:var(--nt-plan-actions-height);width:120px;position:absolute;left:0px;background:#1da1f2;border-radius:5px;transition:all .5s;cursor:help;-webkit-transition:width 1s ease-in-out;-moz-transition:width 1s ease-in-out;-o-transition:width 1s ease-in-out;transition:width 1s ease-in-out}.period .nt-tooltip{display:none;top:30px;position:relative;padding:1rem;text-align:center;font-size:12px}.period:hover .nt-tooltip{display:inline-block}.period-0{left:340px;visibility:visible;background-color:#456165}.period-1{left:40px;visibility:visible;background-color:green}.period-2{left:120px;visibility:visible;background-color:pink;width:80px}.period-3{left:190px;visibility:visible;background-color:darkred;width:150px}.weeks>span,.days>span{height:25px}.weeks>span{display:inline-block;margin:0;padding:0;font-weight:bold}.weeks>span .week-text{font-size:10px;position:absolute;display:inline-block;padding:3px 4px}.days{z-index:-2;position:relative}.day-text{font-size:10px;position:absolute;display:inline-block;padding:3px 4px}.period span{font-size:12px;vertical-align:top;margin-left:4px;color:#000;background:rgba(255,255,255,.6588235294);border-radius:6px;padding:0 4px}.weeks,.days{height:20px;display:flex;box-sizing:content-box}.months{display:flex}.week,.day{height:20px;position:relative;border:1;flex:auto;border:2px solid #fff;border-radius:4px;background-color:var(--nt-units-background);cursor:help}.years{display:flex}.year{text-align:center;border-right:1px solid var(--nt-plan-vertical-line-color);font-weight:bold}.year:first-child{border-left:1px solid var(--nt-plan-vertical-line-color)}.year:first-child:last-child{width:100%}.quarters{display:flex}.quarter{width:12.5%;text-align:center;border-right:1px solid var(--nt-plan-vertical-line-color);font-weight:bold}.quarter:first-child{border-left:1px solid var(--nt-plan-vertical-line-color)}.nt-plan-group{margin:20px 0;position:relative}.nt-plan-group{display:flex}.nt-plan-group-summary{background:#2751b0;width:150px;white-space:normal;padding:.1rem .5rem;border-radius:5px;color:#fff;z-index:3}.nt-plan-group-summary p{margin:0;padding:0;font-size:.6rem;color:#fff}.nt-plan-group-summary,.month,.period,.week,.day,.nt-tooltip{border:3px solid #fff;box-shadow:0 2px 3px -1px rgba(0,0,0,.2),0 3px 3px 0 rgba(0,0,0,.14),0 1px 5px 0 rgba(0,0,0,.12)}.nt-plan-periods{padding-left:150px}.months{z-index:2;position:relative}.weeks{position:relative;top:-2px;z-index:0}.month,.quarter,.year,.week,.day,.nt-tooltip{font-family:Roboto,Helvetica,Arial,sans-serif;box-sizing:border-box}.nt-cards.nt-grid{display:grid;grid-auto-columns:1fr;gap:.5rem;max-width:100vw;overflow-x:auto;padding:1px}.nt-cards.nt-grid.cols-1{grid-template-columns:repeat(1, 1fr)}.nt-cards.nt-grid.cols-2{grid-template-columns:repeat(2, 1fr)}.nt-cards.nt-grid.cols-3{grid-template-columns:repeat(3, 1fr)}.nt-cards.nt-grid.cols-4{grid-template-columns:repeat(4, 1fr)}.nt-cards.nt-grid.cols-5{grid-template-columns:repeat(5, 1fr)}.nt-cards.nt-grid.cols-6{grid-template-columns:repeat(6, 1fr)}@media only screen and (max-width: 400px){.nt-cards.nt-grid{grid-template-columns:repeat(1, 1fr) !important}}.nt-card{box-shadow:0 2px 2px 0 rgba(0,0,0,.14),0 3px 1px -2px rgba(0,0,0,.2),0 1px 5px 0 rgba(0,0,0,.12)}.nt-card:hover{box-shadow:0 2px 2px 0 rgba(0,0,0,.24),0 3px 1px -2px rgba(0,0,0,.3),0 1px 5px 0 rgba(0,0,0,.22)}[data-md-color-scheme=slate] .nt-card{box-shadow:0 2px 2px 0 rgba(4,40,33,.14),0 3px 1px -2px rgba(40,86,94,.47),0 1px 5px 0 rgba(139,252,255,.64)}[data-md-color-scheme=slate] .nt-card:hover{box-shadow:0 2px 2px 0 rgba(0,255,206,.14),0 3px 1px -2px rgba(33,156,177,.47),0 1px 5px 0 rgba(96,251,255,.64)}.nt-card>a{color:var(--md-default-fg-color)}.nt-card>a>div{cursor:pointer}.nt-card{padding:5px;margin-bottom:.5rem}.nt-card-title{font-size:1rem;font-weight:bold;margin:4px 0 8px 0;line-height:22px}.nt-card-content{padding:.4rem .8rem .8rem .8rem}.nt-card-text{font-size:14px;padding:0;margin:0}.nt-card .nt-card-image{text-align:center;border-radius:2px;background-position:center center;background-size:cover;background-repeat:no-repeat;min-height:120px}.nt-card .nt-card-image.tags img{margin-top:12px}.nt-card .nt-card-image img{height:105px;margin-top:5px}.nt-card a:hover,.nt-card a:focus{color:var(--md-accent-fg-color)}.nt-card h2{margin:0}.span-table-wrapper table{border-collapse:collapse;margin-bottom:2rem;border-radius:.1rem}.span-table td,.span-table th{padding:.2rem;background-color:var(--md-default-bg-color);font-size:.64rem;max-width:100%;overflow:auto;touch-action:auto;border-top:.05rem solid var(--md-typeset-table-color);padding:.9375em 1.25em;vertical-align:top}.span-table tr:first-child td{font-weight:700;min-width:5rem;padding:.9375em 1.25em;vertical-align:top}.span-table td:first-child{border-left:.05rem solid var(--md-typeset-table-color)}.span-table td:last-child{border-right:.05rem solid var(--md-typeset-table-color)}.span-table tr:last-child{border-bottom:.05rem solid var(--md-typeset-table-color)}.span-table [colspan],.span-table [rowspan]{font-weight:bold;border:.05rem solid var(--md-typeset-table-color)}.span-table tr:not(:first-child):hover td:not([colspan]):not([rowspan]),.span-table td[colspan]:hover,.span-table td[rowspan]:hover{background-color:rgba(0,0,0,.035);box-shadow:0 .05rem 0 var(--md-default-bg-color) inset;transition:background-color 125ms}
diff --git a/docs/css/neoteroi-spantable.css b/docs/css/neoteroi-spantable.css
new file mode 100644
index 0000000..be069a8
--- /dev/null
+++ b/docs/css/neoteroi-spantable.css
@@ -0,0 +1,56 @@
+/**
+ * Extra CSS file recommended for MkDocs and neoteroi.spantable extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+.span-table-wrapper table {
+ border-collapse: collapse;
+ margin-bottom: 2rem;
+ border-radius: 0.1rem;
+}
+
+.span-table td,
+.span-table th {
+ padding: 0.2rem;
+ background-color: var(--md-default-bg-color);
+ font-size: 0.64rem;
+ max-width: 100%;
+ overflow: auto;
+ touch-action: auto;
+ border-top: 0.05rem solid var(--md-typeset-table-color);
+ padding: 0.9375em 1.25em;
+ vertical-align: top;
+}
+
+.span-table tr:first-child td {
+ font-weight: 700;
+ min-width: 5rem;
+ padding: 0.9375em 1.25em;
+ vertical-align: top;
+}
+
+.span-table td:first-child {
+ border-left: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table td:last-child {
+ border-right: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table tr:last-child {
+ border-bottom: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table [colspan],
+.span-table [rowspan] {
+ font-weight: bold;
+ border: 0.05rem solid var(--md-typeset-table-color);
+}
+
+.span-table tr:not(:first-child):hover td:not([colspan]):not([rowspan]),
+.span-table td[colspan]:hover,
+.span-table td[rowspan]:hover {
+ background-color: rgba(0, 0, 0, 0.035);
+ box-shadow: 0 0.05rem 0 var(--md-default-bg-color) inset;
+ transition: background-color 125ms;
+}
diff --git a/docs/css/neoteroi-timeline.css b/docs/css/neoteroi-timeline.css
new file mode 100644
index 0000000..488a37d
--- /dev/null
+++ b/docs/css/neoteroi-timeline.css
@@ -0,0 +1,341 @@
+/**
+ * Extra CSS file for MkDocs and the neoteroi.timeline extension.
+ *
+ * https://github.com/Neoteroi/mkdocs-plugins
+**/
+.nt-error {
+ border: 2px dashed darkred;
+ padding: 0 1rem;
+ background: #faf9ba;
+ color: darkred;
+}
+
+.nt-timeline {
+ margin-top: 30px;
+}
+.nt-timeline .nt-timeline-title {
+ font-size: 1.1rem;
+ margin-top: 0;
+}
+.nt-timeline .nt-timeline-sub-title {
+ margin-top: 0;
+}
+.nt-timeline .nt-timeline-content {
+ font-size: 0.8rem;
+ border-bottom: 2px dashed #ccc;
+ padding-bottom: 1.2rem;
+}
+.nt-timeline.horizontal .nt-timeline-items {
+ flex-direction: row;
+ overflow-x: scroll;
+}
+.nt-timeline.horizontal .nt-timeline-items > div {
+ min-width: 400px;
+ margin-right: 50px;
+}
+.nt-timeline.horizontal.reverse .nt-timeline-items {
+ flex-direction: row-reverse;
+}
+.nt-timeline.horizontal.center .nt-timeline-before {
+ background-image: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%);
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ background-position: 0 center;
+}
+.nt-timeline.horizontal.center .nt-timeline-after {
+ background-image: linear-gradient(180deg, rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%);
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ background-position: 0 center;
+}
+.nt-timeline.horizontal.center .nt-timeline-items {
+ background-image: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%);
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ background-position: 0 center;
+}
+.nt-timeline.horizontal .nt-timeline-dot {
+ left: 50%;
+}
+.nt-timeline.horizontal .nt-timeline-dot:not(.bigger) {
+ top: calc(50% - 4px);
+}
+.nt-timeline.horizontal .nt-timeline-dot.bigger {
+ top: calc(50% - 15px);
+}
+.nt-timeline.vertical .nt-timeline-items {
+ flex-direction: column;
+}
+.nt-timeline.vertical.reverse .nt-timeline-items {
+ flex-direction: column-reverse;
+}
+.nt-timeline.vertical.center .nt-timeline-before {
+ background: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%;
+}
+.nt-timeline.vertical.center .nt-timeline-after {
+ background: linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat center/2px 100%;
+}
+.nt-timeline.vertical.center .nt-timeline-items {
+ background: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%;
+}
+.nt-timeline.vertical.center .nt-timeline-dot {
+ left: calc(50% - 10px);
+}
+.nt-timeline.vertical.center .nt-timeline-dot:not(.bigger) {
+ top: 10px;
+}
+.nt-timeline.vertical.center .nt-timeline-dot.bigger {
+ left: calc(50% - 20px);
+}
+.nt-timeline.vertical.left {
+ padding-left: 100px;
+}
+.nt-timeline.vertical.left .nt-timeline-item {
+ padding-left: 70px;
+}
+.nt-timeline.vertical.left .nt-timeline-sub-title {
+ left: -100px;
+ width: 100px;
+}
+.nt-timeline.vertical.left .nt-timeline-before {
+ background: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%;
+}
+.nt-timeline.vertical.left .nt-timeline-after {
+ background: linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat 30px/2px 100%;
+}
+.nt-timeline.vertical.left .nt-timeline-items {
+ background: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%;
+}
+.nt-timeline.vertical.left .nt-timeline-dot {
+ left: 21px;
+ top: 8px;
+}
+.nt-timeline.vertical.left .nt-timeline-dot.bigger {
+ top: 0px;
+ left: 10px;
+}
+.nt-timeline.vertical.right {
+ padding-right: 100px;
+}
+.nt-timeline.vertical.right .nt-timeline-sub-title {
+ right: -100px;
+ text-align: left;
+ width: 100px;
+}
+.nt-timeline.vertical.right .nt-timeline-item {
+ padding-right: 70px;
+}
+.nt-timeline.vertical.right .nt-timeline-before {
+ background: linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%;
+}
+.nt-timeline.vertical.right .nt-timeline-after {
+ background: linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat calc(100% - 30px)/2px 100%;
+}
+.nt-timeline.vertical.right .nt-timeline-items {
+ background: radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%;
+}
+.nt-timeline.vertical.right .nt-timeline-dot {
+ right: 21px;
+ top: 8px;
+}
+.nt-timeline.vertical.right .nt-timeline-dot.bigger {
+ top: 10px;
+ right: 10px;
+}
+
+.nt-timeline-items {
+ display: flex;
+ position: relative;
+}
+.nt-timeline-items > div {
+ min-height: 100px;
+ padding-top: 2px;
+ padding-bottom: 20px;
+}
+
+.nt-timeline-before {
+ content: "";
+ height: 15px;
+}
+
+.nt-timeline-after {
+ content: "";
+ height: 60px;
+ margin-bottom: 20px;
+}
+
+.nt-timeline-sub-title {
+ position: absolute;
+ width: 50%;
+ top: 4px;
+ font-size: 18px;
+ color: var(--nt-color-50);
+}
+
+[data-md-color-scheme=slate] .nt-timeline-sub-title {
+ color: var(--nt-color-51);
+}
+
+.nt-timeline-item {
+ position: relative;
+}
+
+.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item {
+ padding-left: calc(50% + 40px);
+}
+.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title {
+ left: 0;
+ padding-right: 40px;
+ text-align: right;
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) {
+ padding-left: calc(50% + 40px);
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title {
+ left: 0;
+ padding-right: 40px;
+ text-align: right;
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) {
+ text-align: right;
+ padding-right: calc(50% + 40px);
+}
+.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title {
+ right: 0;
+ padding-left: 40px;
+ text-align: left;
+}
+
+.nt-timeline-dot {
+ position: relative;
+ width: 20px;
+ height: 20px;
+ border-radius: 100%;
+ background-color: #fc5b5b;
+ position: absolute;
+ top: 0px;
+ z-index: 2;
+ display: flex;
+ justify-content: center;
+ align-items: center;
+ box-shadow: 0 2px 1px -1px rgba(0, 0, 0, 0.2), 0 1px 1px 0 rgba(0, 0, 0, 0.14), 0 1px 3px 0 rgba(0, 0, 0, 0.12);
+ border: 3px solid white;
+}
+.nt-timeline-dot:not(.bigger) .icon {
+ font-size: 10px;
+}
+.nt-timeline-dot.bigger {
+ width: 40px;
+ height: 40px;
+ padding: 3px;
+}
+.nt-timeline-dot .icon {
+ color: white;
+}
+
+/* Fix for webkit (Chrome, Safari) */
+@supports not (-moz-appearance: none) {
+ /*
+ This fix is necessary, for some reason, to render the timeline properly
+ inside `details` elements used by pymdownx. Firefox doesn't need this fix,
+ it renders elements properly.
+ */
+ details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title,
+details .nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title {
+ left: -40px;
+ }
+ details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title {
+ right: -40px;
+ }
+ details .nt-timeline.vertical.center .nt-timeline-dot {
+ left: calc(50% - 12px);
+ }
+ details .nt-timeline-dot.bigger {
+ font-size: 1rem !important;
+ }
+}
+/* default colors */
+.nt-timeline-item:nth-child(0) .nt-timeline-dot {
+ background-color: var(--nt-color-0);
+}
+
+.nt-timeline-item:nth-child(1) .nt-timeline-dot {
+ background-color: var(--nt-color-1);
+}
+
+.nt-timeline-item:nth-child(2) .nt-timeline-dot {
+ background-color: var(--nt-color-2);
+}
+
+.nt-timeline-item:nth-child(3) .nt-timeline-dot {
+ background-color: var(--nt-color-3);
+}
+
+.nt-timeline-item:nth-child(4) .nt-timeline-dot {
+ background-color: var(--nt-color-4);
+}
+
+.nt-timeline-item:nth-child(5) .nt-timeline-dot {
+ background-color: var(--nt-color-5);
+}
+
+.nt-timeline-item:nth-child(6) .nt-timeline-dot {
+ background-color: var(--nt-color-6);
+}
+
+.nt-timeline-item:nth-child(7) .nt-timeline-dot {
+ background-color: var(--nt-color-7);
+}
+
+.nt-timeline-item:nth-child(8) .nt-timeline-dot {
+ background-color: var(--nt-color-8);
+}
+
+.nt-timeline-item:nth-child(9) .nt-timeline-dot {
+ background-color: var(--nt-color-9);
+}
+
+.nt-timeline-item:nth-child(10) .nt-timeline-dot {
+ background-color: var(--nt-color-10);
+}
+
+.nt-timeline-item:nth-child(11) .nt-timeline-dot {
+ background-color: var(--nt-color-11);
+}
+
+.nt-timeline-item:nth-child(12) .nt-timeline-dot {
+ background-color: var(--nt-color-12);
+}
+
+.nt-timeline-item:nth-child(13) .nt-timeline-dot {
+ background-color: var(--nt-color-13);
+}
+
+.nt-timeline-item:nth-child(14) .nt-timeline-dot {
+ background-color: var(--nt-color-14);
+}
+
+.nt-timeline-item:nth-child(15) .nt-timeline-dot {
+ background-color: var(--nt-color-15);
+}
+
+.nt-timeline-item:nth-child(16) .nt-timeline-dot {
+ background-color: var(--nt-color-16);
+}
+
+.nt-timeline-item:nth-child(17) .nt-timeline-dot {
+ background-color: var(--nt-color-17);
+}
+
+.nt-timeline-item:nth-child(18) .nt-timeline-dot {
+ background-color: var(--nt-color-18);
+}
+
+.nt-timeline-item:nth-child(19) .nt-timeline-dot {
+ background-color: var(--nt-color-19);
+}
+
+.nt-timeline-item:nth-child(20) .nt-timeline-dot {
+ background-color: var(--nt-color-20);
+}
+
diff --git a/docs/images/cli.png b/docs/images/cli.png
new file mode 100644
index 0000000..7872dd5
Binary files /dev/null and b/docs/images/cli.png differ
diff --git a/docs/images/jupyter.png b/docs/images/jupyter.png
new file mode 100644
index 0000000..c6a19aa
Binary files /dev/null and b/docs/images/jupyter.png differ
diff --git a/docs/images/logo-dark.png b/docs/images/logo-dark.png
new file mode 100644
index 0000000..9d7791f
Binary files /dev/null and b/docs/images/logo-dark.png differ
diff --git a/docs/images/logo.png b/docs/images/logo.png
new file mode 100644
index 0000000..014a63a
Binary files /dev/null and b/docs/images/logo.png differ
diff --git a/docs/images/string-intern/string_intern.png b/docs/images/string-intern/string_intern.png
new file mode 100644
index 0000000..6511978
Binary files /dev/null and b/docs/images/string-intern/string_intern.png differ
diff --git a/docs/images/tic-tac-toe/after_board_initialized.png b/docs/images/tic-tac-toe/after_board_initialized.png
new file mode 100644
index 0000000..616747f
Binary files /dev/null and b/docs/images/tic-tac-toe/after_board_initialized.png differ
diff --git a/docs/images/tic-tac-toe/after_row_initialized.png b/docs/images/tic-tac-toe/after_row_initialized.png
new file mode 100644
index 0000000..520d700
Binary files /dev/null and b/docs/images/tic-tac-toe/after_row_initialized.png differ
diff --git a/docs/images/usa.png b/docs/images/usa.png
new file mode 100644
index 0000000..fa68dcb
Binary files /dev/null and b/docs/images/usa.png differ
diff --git a/docs/images/website.png b/docs/images/website.png
new file mode 100644
index 0000000..3785138
Binary files /dev/null and b/docs/images/website.png differ
diff --git a/docs/images/world.png b/docs/images/world.png
new file mode 100644
index 0000000..78e031f
Binary files /dev/null and b/docs/images/world.png differ
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000..551290d
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,43 @@
+---
+hide:
+ - navigation
+ - toc
+---
+
+
+What the f*ck Python! 😱
+Exploring and understanding Python through surprising snippets.
+
+## Sections
+
+
+::cards:: cols=5
+
+- title: English
+ content: Original language
+ image: images/usa.png
+ url: usa
+
+- title: Translations
+ content: Other languages
+ image: images/world.png
+ url: cn
+
+- title: Website
+ content: Interactive Website
+ image: images/website.png
+ url: https://wtfpython-interactive.vercel.app/
+
+- title: Notebook
+ content: Interactive Notebook
+ image: images/jupyter.png
+ url: https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb
+
+- title: CLI
+ content: Installation
+ image: images/cli.png
+ url: https://pypi.org/project/wtfpython/
+
+::/cards::
+
+
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000..02d11d8
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,91 @@
+# Copyright (c) 2016-2022 Martin Donath
+
+# Project information
+site_name: What the f*ck Python!
+site_url: https://github.com/satwikkansal/wtfpython
+site_author: Francisco Alfaro
+site_description:
+
+# Repository
+repo_name: satwikkansal/wtfpython
+repo_url: https://github.com/satwikkansal/wtfpython
+edit_uri: ''
+
+# Markdown extensions
+markdown_extensions:
+ - pymdownx.superfences
+ - pymdownx.tabbed:
+ alternate_style: true
+ - neoteroi.cards
+ - neoteroi.timeline
+ - neoteroi.projects
+ - admonition
+ - pymdownx.details
+
+extra_css:
+ - css/neoteroi-mkdocs.css
+
+# Theme
+theme:
+ name: material
+ language: es
+ logo: https://www.svgrepo.com/show/405305/face-screaming-in-fear.svg
+ favicon: https://www.svgrepo.com/show/405305/face-screaming-in-fear.svg
+ palette:
+ - media: '(prefers-color-scheme: light)'
+ scheme: default
+ primary: deep purple
+ accent: deep purple
+ toggle:
+ icon: material/lightbulb
+ name: Switch to dark mode
+ - media: '(prefers-color-scheme: dark)'
+ scheme: slate
+ primary: deep purple
+ accent: deep purple
+ toggle:
+ icon: material/lightbulb-outline
+ name: Switch to light mode
+ features:
+ - search.suggest
+ - search.highlight
+ - content.tabs.link
+ - navigation.indexes
+ - content.tooltips
+ - navigation.path
+ - content.code.annotate
+ - content.code.copy
+ - content.code.select
+ - navigation.tabs
+
+# Customization
+extra:
+ social:
+ - icon: fontawesome/brands/github
+ link: https://github.com/satwikkansal
+ - icon: fontawesome/brands/twitter
+ link: https://twitter.com/satwikkansal
+ - icon: fontawesome/solid/globe
+ link: https://satwikkansal.xyz/
+
+# Plugins
+plugins:
+ - search
+
+# Extra javascript
+extra_javascript:
+ - javascripts/mathjax.js
+ - https://polyfill.io/v3/polyfill.min.js?features=es6
+ - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
+
+#TOC
+nav:
+ - 🏠 Home: index.md
+ - 🐍 Original: USA.md
+ - 🌎 World:
+ - Chinese: CN.md
+ - Vietnamese: VI.md
+ - Korean: KO.md
+ - Russian: RU.md
+ - German: GE.md
+
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..c64c949
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,13 @@
+[tool.poetry]
+name = "docs"
+version = "0.1.0"
+description = "mkdocs - courses"
+authors = ["Francisco Alfaro "]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+mkdocs-material = "*"
+neoteroi-mkdocs = "*"
+mkdocs-jupyter = "*"
+
+- 当在同一行将 `a` 和 `b` 的值设置为 `"wtf!"` 的时候, Python 解释器会创建一个新对象, 然后同时引用第二个变量(译: 仅适用于3.7以下, 详细情况请看[这里](https://github.com/leisurelicht/wtfpython-cn/issues/13)). 如果你在不同的行上进行赋值操作, 它就不会“知道”已经有一个 `wtf！` 对象 (因为 `"wtf!"` 不是按照上面提到的方式被隐式驻留的). 它是一种编译器优化, 特别适用于交互式环境.
+- 常量折叠(constant folding) 是 Python 中的一种 [窥孔优化(peephole optimization)](https://en.wikipedia.org/wiki/Peephole_optimization) 技术. 这意味着在编译时表达式 `'a'*20` 会被替换为 `'aaaaaaaaaaaaaaaaaaaa'` 以减少运行时的时钟周期. 只有长度小于 20 的字符串才会发生常量折叠. (为啥? 想象一下由于表达式 `'a'*10**10` 而生成的 `.pyc` 文件的大小). 相关的源码实现在[这里](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288).
+- 如果你是使用 3.7 版本中运行上述示例代码, 会发现部分代码的运行结果与注释说明相同. 这是因为在 3.7 版本中, 常量折叠已经从窥孔优化器迁移至新的 AST 优化器, 后者可以以更高的一致性来执行优化. (由 Eugene Toder 和 INADA Naoki 在 [bpo-29469](https://bugs.python.org/issue29469) 和 [bpo-11549](https://bugs.python.org/issue11549) 中贡献.)
+- (译: 但是在最新的 3.8 版本中, 结果又变回去了. 虽然 3.8 版本和 3.7 版本一样, 都是使用 AST 优化器. 目前不确定官方对 3.8 版本的 AST 做了什么调整.)
+
+
+---
+
+### > Be careful with chained operations/小心链式操作
+
+```py
+>>> (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 and b op2 c and ... y opN z.
+
+虽然上面的例子似乎很愚蠢, 但是像 `a == b == c` 或 `0 <= x <= 100` 就很棒了.
+
+* `False is False is False` 相当于 `(False is False) and (False is False)`
+* `True is False == False` 相当于 `(True is False) and (False == False)`, 由于语句的第一部分 (`True is False`) 等于 `False`, 因此整个表达式的结果为 `False`.
+* `1 > 0 < 1` 相当于 `(1 > 0) and (0 < 1)`, 所以最终结果为 `True`.
+* 表达式 `(1 > 0) < 1` 相当于 `True < 1` 且
+ ```py
+ >>> int(True)
+ 1
+ >>> True + 1 # 与这个例子无关，只是娱乐一下
+ 2
+ ```
+ 所以, `1 < 1` 等于 `False`
+
+
+---
+
+### > How not to use `is` operator/为什么不使用 `is` 操作符
+
+
+下面是一个在互联网上非常有名的例子.
+
+1\.
+
+```py
+>>> a = 256
+>>> b = 256
+>>> a is b
+True
+
+>>> a = 257
+>>> b = 257
+>>> a is b
+False
+```
+
+2\.
+
+```py
+>>> a = []
+>>> b = []
+>>> a is b
+False
+
+>>> a = tuple()
+>>> b = tuple()
+>>> a is b
+True
+```
+
+3\.
+**Output**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+True
+```
+
+**Output (Python 3.7.x specifically)**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+False
+```
+
+#### 💡 说明:
+
+**`is` 和 `==` 的区别**
+
+* `is` 运算符检查两个运算对象是否引用自同一对象 (即, 它检查两个运算对象是否相同).
+* `==` 运算符比较两个运算对象的值是否相等.
+* 因此 `is` 代表引用相同, `==` 代表值相等. 下面的例子可以很好的说明这点,
+ ```py
+ >>> [] == []
+ True
+ >>> [] is [] # 这两个空列表位于不同的内存地址.
+ False
+ ```
+
+**`256` 是一个已经存在的对象, 而 `257` 不是**
+
+当你启动Python 的时候, 数值为 `-5` 到 `256` 的对象就已经被分配好了. 这些数字因为经常被使用, 所以会被提前准备好.
+
+Python 通过这种创建小整数池的方式来避免小整数频繁的申请和销毁内存空间.
+
+引用自 https://docs.python.org/3/c-api/long.html
+> 当前的实现为-5到256之间的所有整数保留一个整数对象数组, 当你创建了一个该范围内的整数时, 你只需要返回现有对象的引用. 所以改变1的值是有可能的. 我怀疑这种行为在Python中是未定义行为. :-)
+
+```py
+>>> 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` 在同一行中使用相同的值初始化时，会指向同一个对象.**
+
+```py
+>>> 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` 文件中尝试这个例子, 则不会看到相同的行为, 因为文件是一次性编译的。这种优化不仅限于整数，它也适用于其他不可变数据类型，例如字符串（查看示例“微妙的字符串”）和浮点数，
+
+ ```py
+ >>> a, b = 257.0, 257.0
+ >>> a is b
+ True
+ ```
+
+* 为什么这不适用于 Python 3.7？ 大概是因为此类编译器优化是特定于实现的（即可能随版本、操作系统等而变化）。我仍在试图弄清楚导致问题的具体实现更改，您可以查看此 [问题](https://github.com/satwikkansal/wtfpython/issues/100) 以获取更新。
+
+
+---
+
+### > Hash brownies/是时候来点蛋糕了!
+* hash brownie指一种含有大麻成分的蛋糕, 所以这里是句双关
+* 这里保留原作者对于标题的翻译
+
+
+
+1\.
+```py
+some_dict = {}
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
+some_dict[5] = "Python"
+```
+
+**Output:**
+
+```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?
+
+
+#### 💡 说明
+
+
+* 这个 StackOverflow的 [回答](https://stackoverflow.com/a/32211042/4354153) 漂亮地解释了这背后的基本原理.
+
+* 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.0` 的字典中找到 `5` 的？ Python 只需要花费常数时间，而无需使用哈希函数遍历每一项。当 Python 在 dict 中查找键 `foo` 时，它首先计算 `hash(foo)`（以常数时间运行）。因为在 Python 中，要求相等的对象具有相同的哈希值（此处为[文档](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)）造成的，这也会降低哈希运算的性能。）
+
+
+---
+
+### > Deep down, we're all the same./本质上,我们都一样. *
+
+```py
+class WTF:
+ pass
+```
+
+**Output:**
+```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值是相同的.
+* 综上, 对象的id值仅仅在对象的生命周期内唯一. 在对象被销毁之后, 或被创建之前, 其他对象可以具有相同的id值.
+* 那为什么 `is` 操作的结果为 `False` 呢? 让我们看看这段代码.
+ ```py
+ class WTF(object):
+ def __init__(self): print("I")
+ def __del__(self): print("D")
+ ```
+
+ **Output:**
+ ```py
+ >>> WTF() is WTF()
+ I
+ I
+ D
+ D
+ False
+ >>> id(WTF()) == id(WTF())
+ I
+ D
+ I
+ D
+ True
+ ```
+ 正如你所看到的, 对象销毁的顺序是造成所有不同之处的原因.
+
+
+---
+
+### > Disorder within order/有序中潜藏着无序 *
+
+
+```py
+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):
+ """
+ 实现了 __hash__ 魔法方法的dict类
+ """
+ __hash__ = lambda self: 0
+
+class OrderedDictWithHash(OrderedDict):
+ """
+ 实现了 __hash__ 魔法方法的OrderedDict类
+ """
+ __hash__ = lambda self: 0
+```
+
+**Output**
+```py
+>>> dictionary == ordered_dict # 如果 a == b
+True
+>>> dictionary == another_ordered_dict # 且 b == c
+True
+>>> ordered_dict == another_ordered_dict # 那么为什么 c == a 不成立??
+False
+
+# 众所周知，set数据结构储存不重复元素，
+# 让我们生成以上字典的 set 数据类型，看看会发生什么……
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "