diff --git a/.gitignore b/.gitignore
index 057dcb0..7a88626 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,9 +2,6 @@
node_modules
npm-debug.log
-wtfpython-pypi/build/
-wtfpython-pypi/dist/
-wtfpython-pypi/wtfpython.egg-info
# Python-specific byte-compiled files should be ignored
__pycache__/
@@ -16,3 +13,8 @@ irrelevant/.ipynb_checkpoints/
irrelevant/.python-version
.idea/
+.vscode/
+
+# Virtual envitonments
+venv/
+.venv/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f774370..dd9049d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -40,3 +40,24 @@ Few things that you can consider while writing an example,
- Try to be consistent with the namings and the values you use with the variables. For instance, most variable names in the project are along the lines of `some_string`, `some_list`, `some_dict`, etc. You'd see a lot of `x`s for single letter variable names, and `"wtf"` as values for strings. There's no strictly enforced scheme in the project as such, but you can take a glance at other examples to get a gist.
- Try to be as creative as possible to add that element of "surprise" in the setting up part of an example. Sometimes this may mean writing a snippet a sane programmer would never write.
- Also, feel free to add your name to the [contributors list](/CONTRIBUTORS.md).
+
+**Some FAQs**
+
+ What is is this after every snippet title (###) in the README: ? Should it be added manually or can it be ignored when creating new snippets?
+
+That's a random UUID, it is used to keep identify the examples across multiple translations of the project. As a contributor, you don't have to worry about behind the scenes of how it is used, you just have to add a new random UUID to new examples in that format.
+
+ Where should new snippets be added? Top/bottom of the section, doesn't ?
+
+There are multiple things that are considered to decide the order (the dependency on the other examples, difficulty level, category, etc). I'd suggest simply adding the new example at the bottom of a section you find more fitting (or just add it to the Miscellaneous section). Its order will be taken care of in future revisions.
+
+ What's the difference between the sections (the first two feel very similar)?
+
+The section "Strain your brain" contains more contrived examples that you may not really encounter in real life, whereas the section "Slippery Slopes" contains examples that have the potential to be encountered more frequently while programming.
+
+ Before the table of contents it says that markdown-toc -i README.md --maxdepth 3 was used to create it. The pip package markdown-toc does not contain either -i or --maxdepth flags. Which package is meant, or what version of that package?
+ Should the new table of contents entry for the snippet be created with the above command or created manually (in case the above command does more than only add the entry)?
+
+We use the [markdown-toc](https://www.npmjs.com/package/markdown-toc) npm package to generate ToC. It has some issues with special characters though (I'm not sure if it's fixed yet). More often than not, I just end up inserting the toc link manually at the right place. The tool is handy when I have to big reordering, otherwise just updating toc manually is more convenient imo.
+
+If you have any questions feel free to ask on [this issue](https://github.com/satwikkansal/wtfpython/issues/269) (thanks to [@LiquidFun](https://github.com/LiquidFun) for starting it).
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 659a382..40526d9 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -18,11 +18,13 @@ Following are the wonderful people (in no specific order) who have contributed t
| leisurelicht | [leisurelicht](https://github.com/leisurelicht) | [#112](https://github.com/satwikkansal/wtfpython/issues/112) |
| mishaturnbull | [mishaturnbull](https://github.com/mishaturnbull) | [#108](https://github.com/satwikkansal/wtfpython/issues/108) |
| MuseBoy | [MuseBoy](https://github.com/MuseBoy) | [#101](https://github.com/satwikkansal/wtfpython/issues/101) |
-| Ghost account | N/A | [#96](https://github.com/satwikkansal/wtfpython/issues/96)
+| Ghost account | N/A | [#96](https://github.com/satwikkansal/wtfpython/issues/96) |
| koddo | [koddo](https://github.com/koddo) | [#80](https://github.com/satwikkansal/wtfpython/issues/80), [#73](https://github.com/satwikkansal/wtfpython/issues/73) |
| jab | [jab](https://github.com/jab) | [#77](https://github.com/satwikkansal/wtfpython/issues/77) |
| Jongy | [Jongy](https://github.com/Jongy) | [#208](https://github.com/satwikkansal/wtfpython/issues/208), [#210](https://github.com/satwikkansal/wtfpython/issues/210), [#233](https://github.com/satwikkansal/wtfpython/issues/233) |
| Diptangsu Goswami | [diptangsu](https://github.com/diptangsu) | [#193](https://github.com/satwikkansal/wtfpython/issues/193) |
+| Charles | [charles-l](https://github.com/charles-l) | [#245](https://github.com/satwikkansal/wtfpython/issues/245) |
+| LiquidFun | [LiquidFun](https://github.com/LiquidFun) | [#267](https://github.com/satwikkansal/wtfpython/issues/267) |
---
@@ -32,7 +34,8 @@ Following are the wonderful people (in no specific order) who have contributed t
|-------------|--------|--------|
| leisurelicht | [leisurelicht](https://github.com/leisurelicht) | [Chinese](https://github.com/leisurelicht/wtfpython-cn) |
| vuduclyunitn | [vuduclyunitn](https://github.com/vuduclyunitn) | [Vietnamese](https://github.com/vuduclyunitn/wtfptyhon-vi) |
-
+| José De Freitas | [JoseDeFreitas](https://github.com/JoseDeFreitas) | [Spanish](https://github.com/JoseDeFreitas/wtfpython-es) |
+| Vadim Nifadev | [nifadyev](https://github.com/nifadyev) | [Russian](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) |
Thank you all for your time and making wtfpython more awesome! :smile:
diff --git a/README.md b/README.md
index f12c475..61df081 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,17 @@
-
+
+
+
+
+
+
+
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) | [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](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
+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/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [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)
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.
@@ -41,7 +48,7 @@ So, here we go...
+ [▶ 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)
+ + [▶ 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)
@@ -59,6 +66,7 @@ So, here we go...
+ [▶ 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)
@@ -70,6 +78,7 @@ So, here we go...
+ [▶ 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-)
@@ -141,7 +150,7 @@ All the examples are structured like below:
# Usage
-A nice way to get the most out of these examples, in my opinion, is to read them chronologically, and for every example:
+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.
@@ -149,11 +158,6 @@ A nice way to get the most out of these examples, in my opinion, is to read them
- 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
@@ -207,7 +211,7 @@ SyntaxError: invalid syntax
(6, 9)
>>> (a, b = 16, 19) # Oops
File "", line 1
- (a, b = 6, 9)
+ (a, b = 16, 19)
^
SyntaxError: invalid syntax
@@ -349,7 +353,14 @@ Makes sense, right?
* 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.
@@ -383,15 +394,15 @@ False
#### 💡 Explanation:
-As per https://docs.python.org/3/reference/expressions.html#membership-test-operations
+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`.
+* `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)
@@ -448,7 +459,7 @@ True
```py
>>> a, b = 257, 257
->> a is b
+>>> a is b
False
```
@@ -618,7 +629,7 @@ True
* 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 evaluated to `False`? Let's see with this snippet.
+* But why did the `is` operator evaluate to `False`? Let's see with this snippet.
```py
class WTF(object):
def __init__(self): print("I")
@@ -916,9 +927,9 @@ array_4 = [400, 500, 600]
- 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 binded 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 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(g)` 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)
+- 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.
@@ -972,11 +983,23 @@ We didn't assign three `"X"`s, did we?
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).
@@ -989,10 +1012,9 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
---
-### ▶ The sticky output function
+### ▶ Schrödinger's variable *
-1\.
```py
funcs = []
@@ -1006,17 +1028,17 @@ for x in range(7):
funcs_results = [func() for func in funcs]
```
-**Output:**
-
+**Output (Python version):**
```py
>>> results
[0, 1, 2, 3, 4, 5, 6]
>>> funcs_results
[6, 6, 6, 6, 6, 6, 6]
```
-Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.
-2\.
+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)]
@@ -1024,27 +1046,45 @@ Even when the values of `x` were different in every iteration prior to appending
[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]
```
-#### 💡 Explanation
+#### 💡 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`:
-- 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. So all of the functions use the latest value assigned to the variable for computation.
+```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
-within the function's scope.
+* 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)
- ```
+```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]
- ```
+**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())
+```
---
@@ -1102,7 +1142,7 @@ False
**Output:**
```py
->>> from collections import Hashable
+>>> from collections.abc import Hashable
>>> issubclass(list, object)
True
>>> issubclass(object, Hashable)
@@ -1177,7 +1217,7 @@ True
True
```
-Accessing` classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`.
+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
@@ -1256,8 +1296,8 @@ Why's this True-False alteration?
```
- `all([])` returns `True` since the iterable is empty.
-- `all([[]])` returns `False` because `not []` is `True` is equivalent to `not False` as the list inside the iterable is empty.
-- `all([[[]]])` and higher recursive variants are always `True` since `not [[]]`, `not [[[]]]`, and so on are equivalent to `not True`.
+- `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.
---
@@ -1324,7 +1364,7 @@ True
```py
>>> r'wt\"f' == 'wt\\"f'
True
- >>> print(repr(r'wt\"f')
+ >>> print(repr(r'wt\"f'))
'wt\\"f'
>>> print("\n")
@@ -1823,9 +1863,9 @@ NameError: name 'e' is not defined
**Output:**
```py
- >>>f(x)
+ >>> f(x)
UnboundLocalError: local variable 'x' referenced before assignment
- >>>f(y)
+ >>> f(y)
UnboundLocalError: local variable 'x' referenced before assignment
>>> x
5
@@ -1957,9 +1997,45 @@ a, b = a[b] = {}, 5
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
@@ -2118,7 +2194,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
>>> another_func()
2
```
-* The keywords `global` and `nonlocal` tell the python interpreter to not delcare new variables and look them up in the corresponding outer scopes.
+* 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.
---
@@ -2515,6 +2591,56 @@ class SomeClass:
---
+### ▶ 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 *
@@ -2685,7 +2811,7 @@ def similar_recursive_func(a):
* 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 reassignation of an immutable (`a -= 1`) is not an alteration of the value.
+* 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.
@@ -3097,7 +3223,7 @@ Ellipsis
>>> ...
Ellipsis
```
-- Eliipsis can be used for several purposes,
+- 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
@@ -3542,7 +3668,7 @@ What makes those dictionaries become bloated? And why are newly created objects
+ 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 be 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.
++ 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__`!
@@ -3554,7 +3680,7 @@ What makes those dictionaries become bloated? And why are newly created objects
* 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.
+ + `'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.
@@ -3717,7 +3843,6 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
* 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/).
@@ -3738,7 +3863,7 @@ If you like wtfpython, you can use these quick links to share it with your frien
## 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.
+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://www.satwikkansal.xyz/content-like-wtfpython/).
+**That's all folks!** For upcoming content like this, you can add your email [here](https://form.jotform.com/221593598380062).
diff --git a/images/expanding-brain-meme.jpg b/images/expanding-brain-meme.jpg
deleted file mode 100644
index 9437c2f..0000000
Binary files a/images/expanding-brain-meme.jpg and /dev/null differ
diff --git a/images/logo.png b/images/logo.png
deleted file mode 100644
index 014a63a..0000000
Binary files a/images/logo.png and /dev/null differ
diff --git a/images/logo.svg b/images/logo.svg
new file mode 100755
index 0000000..6ec5eda
--- /dev/null
+++ b/images/logo.svg
@@ -0,0 +1,38 @@
+
+
+
diff --git a/images/logo_dark_theme.svg b/images/logo_dark_theme.svg
new file mode 100755
index 0000000..f89e797
--- /dev/null
+++ b/images/logo_dark_theme.svg
@@ -0,0 +1,38 @@
+
+
+
diff --git a/images/string-intern/string_intern.png b/images/string-intern/string_intern.png
deleted file mode 100644
index 6511978..0000000
Binary files a/images/string-intern/string_intern.png and /dev/null differ
diff --git a/images/string-intern/string_interning.svg b/images/string-intern/string_interning.svg
new file mode 100755
index 0000000..0572a9e
--- /dev/null
+++ b/images/string-intern/string_interning.svg
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/images/string-intern/string_interning_dark_theme.svg b/images/string-intern/string_interning_dark_theme.svg
new file mode 100755
index 0000000..69c32e4
--- /dev/null
+++ b/images/string-intern/string_interning_dark_theme.svg
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/images/tic-tac-toe.png b/images/tic-tac-toe.png
deleted file mode 100644
index 9c25117..0000000
Binary files a/images/tic-tac-toe.png and /dev/null differ
diff --git a/images/tic-tac-toe/after_board_initialized.png b/images/tic-tac-toe/after_board_initialized.png
deleted file mode 100644
index 616747f..0000000
Binary files a/images/tic-tac-toe/after_board_initialized.png and /dev/null differ
diff --git a/images/tic-tac-toe/after_board_initialized.svg b/images/tic-tac-toe/after_board_initialized.svg
new file mode 100755
index 0000000..02b1dad
--- /dev/null
+++ b/images/tic-tac-toe/after_board_initialized.svg
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/images/tic-tac-toe/after_board_initialized_dark_theme.svg b/images/tic-tac-toe/after_board_initialized_dark_theme.svg
new file mode 100755
index 0000000..3218ad0
--- /dev/null
+++ b/images/tic-tac-toe/after_board_initialized_dark_theme.svg
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/images/tic-tac-toe/after_row_initialized.png b/images/tic-tac-toe/after_row_initialized.png
deleted file mode 100644
index 520d700..0000000
Binary files a/images/tic-tac-toe/after_row_initialized.png and /dev/null differ
diff --git a/images/tic-tac-toe/after_row_initialized.svg b/images/tic-tac-toe/after_row_initialized.svg
new file mode 100755
index 0000000..92eb02c
--- /dev/null
+++ b/images/tic-tac-toe/after_row_initialized.svg
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/images/tic-tac-toe/after_row_initialized_dark_theme.svg b/images/tic-tac-toe/after_row_initialized_dark_theme.svg
new file mode 100755
index 0000000..2404958
--- /dev/null
+++ b/images/tic-tac-toe/after_row_initialized_dark_theme.svg
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/irrelevant/notebook_generator.py b/irrelevant/notebook_generator.py
index d275530..50e86d2 100644
--- a/irrelevant/notebook_generator.py
+++ b/irrelevant/notebook_generator.py
@@ -55,6 +55,12 @@ That being said, most of the examples do work as expected. If you face any troub
def generate_code_block(statements, output):
+ """
+ Generates a code block that executes the given statements.
+
+ :param statements: The list of statements to execute.
+ :type statements: list(str)
+ """
global sequence_num
result = {
"type": "code",
@@ -67,6 +73,9 @@ def generate_code_block(statements, output):
def generate_markdown_block(lines):
+ """
+ Generates a markdown block from a list of lines.
+ """
global sequence_num
result = {
"type": "markdown",
@@ -85,6 +94,12 @@ def is_interactive_statement(line):
def parse_example_parts(lines, title, current_line):
+ """
+ Parse the given lines and return a dictionary with two keys:
+ build_up, which contains all the text before an H4 (explanation) is encountered,
+ and
+ explanation, which contains all the text after build_up until --- or another H3 is encountered.
+ """
parts = {
"build_up": [],
"explanation": []
@@ -191,6 +206,14 @@ def remove_from_beginning(tokens, line):
def inspect_and_sanitize_code_lines(lines):
+ """
+ Remove lines from the beginning of a code block that are not statements.
+
+ :param lines: A list of strings, each representing a line in the code block.
+ :returns is_print_present, sanitized_lines: A boolean indicating whether print was present in the original code and a list of strings representing
+ sanitized lines. The latter may be an empty list if all input lines were removed as comments or whitespace (and thus did not contain any statements).
+ This function does not remove blank lines at the end of `lines`.
+ """
tokens_to_remove = STATEMENT_PREFIXES
result = []
is_print_present = False
@@ -203,6 +226,23 @@ def inspect_and_sanitize_code_lines(lines):
def convert_to_cells(cell_contents, read_only):
+ """
+ Converts a list of dictionaries containing markdown and code cells into a Jupyter notebook.
+
+ :param cell_contents: A list of dictionaries, each
+ dictionary representing either a markdown or code cell. Each dictionary should have the following keys: "type", which is either "markdown" or "code",
+ and "value". The value for type = 'markdown' is the content as string, whereas the value for type = 'code' is another dictionary with two keys,
+ statements and output. The statements key contains all lines in between ```py\n``` (including) until ```\n```, while output contains all lines after
+ ```.output py\n```.
+ :type cell_contents: List[Dict]
+
+ :param read_only (optional): If True then only print outputs are included in converted
+ cells. Default False
+ :type read_only (optional): bool
+
+ :returns A Jupyter notebook containing all cells from input parameter `cell_contents`.
+ Each converted cell has metadata attribute collapsed set to true if it's code-cell otherwise None if it's markdow-cell.
+ """
cells = []
for stuff in cell_contents:
if stuff["type"] == "markdown":
@@ -269,6 +309,9 @@ def convert_to_cells(cell_contents, read_only):
def convert_to_notebook(pre_examples_content, parsed_json, post_examples_content):
+ """
+ Convert a JSON file containing the examples to a Jupyter Notebook.
+ """
result = {
"cells": [],
"metadata": {},
diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb
index de1cba2..c0f3d66 100644
--- a/irrelevant/wtf.ipynb
+++ b/irrelevant/wtf.ipynb
@@ -4,13 +4,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "
\n",
+ "\n",
"
What the f*ck Python! \ud83d\ude31
\n",
"
Exploring and understanding Python through surprising snippets.
\n",
"\n",
- "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [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].)\n",
+ "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Ti\u1ebfng Vi\u1ec7t](https://github.com/vuduclyunitn/wtfptyhon-vi) | [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].)\n",
"\n",
- "Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/3.0/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)\n",
+ "Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb)\n",
"\n",
"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.\n",
"\n",
@@ -20,7 +20,7 @@
"\n",
"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:\n",
"\n",
- "PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).\n",
+ "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). \n",
"\n",
"So, here we go...\n",
"\n",
@@ -68,18 +68,9 @@
"- Read the output snippets and,\n",
" + Check if the outputs are the same as you'd expect.\n",
" + Make sure if you know the exact reason behind the output being the way it is.\n",
- " - 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)).\n",
+ " - 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)).\n",
" - If yes, give a gentle pat on your back, and you may skip to the next example.\n",
"\n",
- "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n",
- "```sh\n",
- "$ pip install wtfpython -U\n",
- "$ wtfpython\n",
- "```\n",
- "---\n",
- "\n",
- "# \ud83d\udc40 Examples\n",
- "\n",
"\n\n## Hosted notebook instructions\n\nThis is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, \n- they either require a version of Python that's not supported in the hosted runtime.\n- or they can't be reproduced in the notebook envrinonment.\n\nThe expected outputs are already present in collapsed cells following the code cells. The Google colab provides Python2 (2.7) and Python3 (3.6, default) runtimes. You can switch among these for Python2 specific examples. For examples specific to other minor versions, you can simply refer to collapsed outputs (it's not possible to control the minor version in hosted notebooks as of now). You can check the active version using\n\n```py\n>>> import sys\n>>> sys.version\n# Prints out Python version here.\n```\n\nThat being said, most of the examples do work as expected. If you face any trouble, feel free to consult the original content on wtfpython and create an issue in the repo. Have fun!\n\n---\n"
]
},
@@ -353,13 +344,13 @@
"+ After being \"interned,\" many variables may reference the same string object in memory (saving memory thereby).\n",
"+ 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:\n",
" * All length 0 and length 1 strings are interned.\n",
- " * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)\n",
+ " * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f'])` will not be interned)\n",
" * 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)\n",
- " \n",
- "+ 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).\n",
+ "\n",
+ "+ 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).\n",
"+ 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`\n",
- "+ 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 20. (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.\n",
- "+ 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 third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n",
+ "+ 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.\n",
+ "+ 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). \n",
"\n"
]
},
@@ -367,262 +358,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### \u25b6 Hash brownies\n",
- "1\\.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict = {}\n",
- "some_dict[5.5] = \"JavaScript\"\n",
- "some_dict[5.0] = \"Ruby\"\n",
- "some_dict[5] = \"Python\"\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"JavaScript\"\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[5.5]\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"Python\"\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[5.0] # \"Python\" destroyed the existence of \"Ruby\"?\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"Python\"\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[5] \n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "complex\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "complex_five = 5 + 0j\n",
- "type(complex_five)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"Python\"\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[complex_five]\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "So, why is Python all over the place?\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation\n",
- "\n",
- "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n",
- "* Immutable objects with the same value always have the same hash in Python.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " 5 == 5.0 == 5 + 0j\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " hash(5) == hash(5.0) == hash(5 + 0j)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- " **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n",
- "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n",
- "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Deep down, we're all the same.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "class WTF:\n",
- " pass\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n"
+ "### \u25b6 Be careful with chained operations\n"
]
},
{
@@ -644,7 +380,7 @@
}
],
"source": [
- "WTF() == WTF() # two different instances can't be equal\n"
+ "(False == False) in [False] # makes sense\n"
]
},
{
@@ -666,7 +402,75 @@
}
],
"source": [
- "WTF() is WTF() # identities are also different\n"
+ "False == (False in [False]) # makes sense\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "False == False in [False] # now what?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "True is False == False\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "False is False is False\n"
]
},
{
@@ -688,7 +492,7 @@
}
],
"source": [
- "hash(WTF()) == hash(WTF()) # hashes _should_ be different as well\n"
+ "1 > 0 < 1\n"
]
},
{
@@ -701,7 +505,7 @@
{
"data": {
"text/plain": [
- "True\n"
+ "False\n"
]
},
"output_type": "execute_result",
@@ -710,7 +514,29 @@
}
],
"source": [
- "id(WTF()) == id(WTF())\n"
+ "(1 > 0) < 1\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "1 > (0 < 1)\n"
]
},
{
@@ -726,40 +552,16 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"\n",
- "* 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.\n",
- "* 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.\n",
- "* 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.\n",
- "* But why did the `is` operator evaluated to `False`? Let's see with this snippet.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " class WTF(object):\n",
- " def __init__(self): print(\"I\")\n",
- " def __del__(self): print(\"D\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
+ "As per https://docs.python.org/3/reference/expressions.html#membership-test-operations\n",
"\n",
- " **Output:**\n"
+ "> 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.\n",
+ "\n",
+ "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`.\n",
+ "\n",
+ "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n",
+ "* `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`.\n",
+ "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n",
+ "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"
]
},
{
@@ -772,11 +574,7 @@
{
"data": {
"text/plain": [
- " I\n",
- " I\n",
- " D\n",
- " D\n",
- " False\n"
+ " 1\n"
]
},
"output_type": "execute_result",
@@ -785,7 +583,7 @@
}
],
"source": [
- " WTF() is WTF()\n"
+ " int(True)\n"
]
},
{
@@ -798,11 +596,7 @@
{
"data": {
"text/plain": [
- " I\n",
- " D\n",
- " I\n",
- " D\n",
- " True\n"
+ " 2\n"
]
},
"output_type": "execute_result",
@@ -811,989 +605,14 @@
}
],
"source": [
- " id(WTF()) == id(WTF())\n"
+ " True + 1 #not relevant for this example, but just for fun\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- " As you may observe, the order in which the objects are destroyed is what made all the difference here.\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Disorder within order *\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "from collections import OrderedDict\n",
- "\n",
- "dictionary = dict()\n",
- "dictionary[1] = 'a'; dictionary[2] = 'b';\n",
- "\n",
- "ordered_dict = OrderedDict()\n",
- "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n",
- "\n",
- "another_ordered_dict = OrderedDict()\n",
- "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n",
- "\n",
- "class DictWithHash(dict):\n",
- " \"\"\"\n",
- " A dict that also implements __hash__ magic.\n",
- " \"\"\"\n",
- " __hash__ = lambda self: 0\n",
- "\n",
- "class OrderedDictWithHash(OrderedDict):\n",
- " \"\"\"\n",
- " An OrderedDict that also implements __hash__ magic.\n",
- " \"\"\"\n",
- " __hash__ = lambda self: 0\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output**\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "dictionary == ordered_dict # If a == b\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "dictionary == another_ordered_dict # and b == c\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n",
- "\n",
- "# We all know that a set consists of only unique elements,\n",
- "# let's try making a set of these dictionaries and see what happens...\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "ordered_dict == another_ordered_dict # the why isn't c == a ??\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "Traceback (most recent call last):\n",
- " File \"\", line 1, in \n",
- "TypeError: unhashable type: 'dict'\n",
- "\n",
- "# Makes sense since dict don't have __hash__ implemented, let's use\n",
- "# our wrapper classes.\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "len({dictionary, ordered_dict, another_ordered_dict})\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "1\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "dictionary = DictWithHash()\n",
- "dictionary[1] = 'a'; dictionary[2] = 'b';\n",
- "ordered_dict = OrderedDictWithHash()\n",
- "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n",
- "another_ordered_dict = OrderedDictWithHash()\n",
- "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n",
- "len({dictionary, ordered_dict, another_ordered_dict})\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "2\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "What is going on here?\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation:\n",
- "\n",
- "- 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)\n",
- " \n",
- " > 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.\n",
- "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n",
- "- 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,\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " some_set = set()\n",
- " some_set.add(dictionary) # these are the mapping objects from the snippets above\n",
- " ordered_dict in some_set\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " 1\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " some_set.add(ordered_dict)\n",
- " len(some_set)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " another_ordered_dict in some_set\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " 1\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " some_set.add(another_ordered_dict)\n",
- " len(some_set)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " another_set = set()\n",
- " another_set.add(ordered_dict)\n",
- " another_ordered_dict in another_set\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " 2\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " another_set.add(another_ordered_dict)\n",
- " len(another_set)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " dictionary in another_set\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " 2\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " another_set.add(another_ordered_dict)\n",
- " len(another_set)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- " 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`.\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Keep trying... *\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "def some_func():\n",
- " try:\n",
- " return 'from_try'\n",
- " finally:\n",
- " return 'from_finally'\n",
- "\n",
- "def another_func(): \n",
- " for _ in range(3):\n",
- " try:\n",
- " continue\n",
- " finally:\n",
- " print(\"Finally!\")\n",
- "\n",
- "def one_more_func(): # A gotcha!\n",
- " try:\n",
- " for i in range(3):\n",
- " try:\n",
- " 1 / i\n",
- " except ZeroDivisionError:\n",
- " # Let's throw it here and handle it outside for loop\n",
- " raise ZeroDivisionError(\"A trivial divide by zero error\")\n",
- " finally:\n",
- " print(\"Iteration\", i)\n",
- " break\n",
- " except ZeroDivisionError as e:\n",
- " print(\"Zero division error occurred\", e)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "'from_finally'\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_func()\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "Finally!\n",
- "Finally!\n",
- "Finally!\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "another_func()\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "Traceback (most recent call last):\n",
- " File \"\", line 1, in \n",
- "ZeroDivisionError: division by zero\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "1 / 0\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "Iteration 0\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "one_more_func()\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation:\n",
- "\n",
- "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n",
- "- 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.\n",
- "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 For what?\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_string = \"wtf\"\n",
- "some_dict = {}\n",
- "for i, some_dict[i] in enumerate(some_string):\n",
- " i = 10\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{0: 'w', 1: 't', 2: 'f'}\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict # An indexed dict appears.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation:\n",
- "\n",
- "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n",
- " ```\n",
- " for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n",
- " ```\n",
- " Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n",
- " An interesting example that illustrates this:\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " for i in range(4):\n",
- " print(i)\n",
- " i = 10\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- " **Output:**\n",
- " ```\n",
- " 0\n",
- " 1\n",
- " 2\n",
- " 3\n",
- " ```\n",
- "\n",
- " Did you expect the loop to run just once?\n",
- "\n",
- " **\ud83d\udca1 Explanation:**\n",
- "\n",
- " - 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)` this case) is unpacked and assigned the target list variables (`i` in this case).\n",
- "\n",
- "* 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:\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " i, some_dict[i] = (0, 'w')\n",
- " i, some_dict[i] = (1, 't')\n",
- " i, some_dict[i] = (2, 'f')\n",
- " some_dict\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Evaluation time discrepancy\n",
- "1\\.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "array = [1, 8, 15]\n",
- "# A typical generator expression\n",
- "gen = (x for x in array if array.count(x) > 0)\n",
- "array = [2, 8, 22]\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "collapsed": true
- },
- "execution_count": null,
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[8]\n"
- ]
- }
- ],
- "source": [
- "print(list(gen)) # Where did the other values go?\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "2\\.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "array_1 = [1,2,3,4]\n",
- "gen_1 = (x for x in array_1)\n",
- "array_1 = [1,2,3,4,5]\n",
- "\n",
- "array_2 = [1,2,3,4]\n",
- "gen_2 = (x for x in array_2)\n",
- "array_2[:] = [1,2,3,4,5]\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n"
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "collapsed": true
- },
- "execution_count": null,
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1, 2, 3, 4]\n",
- "\n"
- ]
- }
- ],
- "source": [
- "print(list(gen_1))\n"
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "collapsed": true
- },
- "execution_count": null,
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1, 2, 3, 4, 5]\n"
- ]
- }
- ],
- "source": [
- "print(list(gen_2))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "3\\.\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "array_3 = [1, 2, 3]\n",
- "array_4 = [10, 20, 30]\n",
- "gen = (i + j for i in array_3 for j in array_4)\n",
- "\n",
- "array_3 = [4, 5, 6]\n",
- "array_4 = [400, 500, 600]\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n"
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "collapsed": true
- },
- "execution_count": null,
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[401, 501, 601, 402, 502, 602, 403, 503, 603]\n"
- ]
- }
- ],
- "source": [
- "print(list(gen))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation\n",
- "\n",
- "- 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.\n",
- "- 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`.\n",
- "- 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.\n",
- "- In the first case, `array_1` is binded 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).\n",
- "- 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]`).\n",
- "- Okay, going by the logic discussed so far, shouldn't be the value of `list(g)` 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)\n",
- " \n",
- " > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.\n",
+ " So, `1 < 1` evaluates to `False`\n",
"\n"
]
},
@@ -2322,6 +1141,1588 @@
"\n"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Hash brownies\n",
+ "1\\.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict = {}\n",
+ "some_dict[5.5] = \"JavaScript\"\n",
+ "some_dict[5.0] = \"Ruby\"\n",
+ "some_dict[5] = \"Python\"\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"JavaScript\"\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict[5.5]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Python\"\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict[5.0] # \"Python\" destroyed the existence of \"Ruby\"?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Python\"\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict[5] \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "complex\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "complex_five = 5 + 0j\n",
+ "type(complex_five)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Python\"\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict[complex_five]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "So, why is Python all over the place?\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "* 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`):\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " 5 == 5.0 == 5 + 0j\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " 5 is not 5.0 is not 5 + 0j\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_dict = {}\n",
+ " some_dict[5.0] = \"Ruby\"\n",
+ " 5.0 in some_dict\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " (5 in some_dict) and (5 + 0j in some_dict)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* 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.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " {5.0: 'Ruby'}\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_dict\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " {5.0: 'Python'}\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_dict[5] = \"Python\"\n",
+ " some_dict\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* 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.\n",
+ "\n",
+ "* 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.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " 5 == 5.0 == 5 + 0j\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " hash(5) == hash(5.0) == hash(5 + 0j)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " **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.)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Deep down, we're all the same.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "class WTF:\n",
+ " pass\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "WTF() == WTF() # two different instances can't be equal\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "WTF() is WTF() # identities are also different\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "hash(WTF()) == hash(WTF()) # hashes _should_ be different as well\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(WTF()) == id(WTF())\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* 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.\n",
+ "* 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.\n",
+ "* 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.\n",
+ "* But why did the `is` operator evaluated to `False`? Let's see with this snippet.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " class WTF(object):\n",
+ " def __init__(self): print(\"I\")\n",
+ " def __del__(self): print(\"D\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " **Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " I\n",
+ " I\n",
+ " D\n",
+ " D\n",
+ " False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " WTF() is WTF()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " I\n",
+ " D\n",
+ " I\n",
+ " D\n",
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " id(WTF()) == id(WTF())\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " As you may observe, the order in which the objects are destroyed is what made all the difference here.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Disorder within order *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "from collections import OrderedDict\n",
+ "\n",
+ "dictionary = dict()\n",
+ "dictionary[1] = 'a'; dictionary[2] = 'b';\n",
+ "\n",
+ "ordered_dict = OrderedDict()\n",
+ "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n",
+ "\n",
+ "another_ordered_dict = OrderedDict()\n",
+ "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n",
+ "\n",
+ "class DictWithHash(dict):\n",
+ " \"\"\"\n",
+ " A dict that also implements __hash__ magic.\n",
+ " \"\"\"\n",
+ " __hash__ = lambda self: 0\n",
+ "\n",
+ "class OrderedDictWithHash(OrderedDict):\n",
+ " \"\"\"\n",
+ " An OrderedDict that also implements __hash__ magic.\n",
+ " \"\"\"\n",
+ " __hash__ = lambda self: 0\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "dictionary == ordered_dict # If a == b\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "dictionary == another_ordered_dict # and b == c\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n",
+ "\n",
+ "# We all know that a set consists of only unique elements,\n",
+ "# let's try making a set of these dictionaries and see what happens...\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "ordered_dict == another_ordered_dict # then why isn't c == a ??\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ "TypeError: unhashable type: 'dict'\n",
+ "\n",
+ "# Makes sense since dict don't have __hash__ implemented, let's use\n",
+ "# our wrapper classes.\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "len({dictionary, ordered_dict, another_ordered_dict})\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "dictionary = DictWithHash()\n",
+ "dictionary[1] = 'a'; dictionary[2] = 'b';\n",
+ "ordered_dict = OrderedDictWithHash()\n",
+ "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n",
+ "another_ordered_dict = OrderedDictWithHash()\n",
+ "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n",
+ "len({dictionary, ordered_dict, another_ordered_dict})\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "What is going on here?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- 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)\n",
+ " \n",
+ " > 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.\n",
+ "- The reason for this equality in behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n",
+ "- 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,\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_set = set()\n",
+ " some_set.add(dictionary) # these are the mapping objects from the snippets above\n",
+ " ordered_dict in some_set\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 1\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_set.add(ordered_dict)\n",
+ " len(some_set)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " another_ordered_dict in some_set\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 1\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_set.add(another_ordered_dict)\n",
+ " len(some_set)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " another_set = set()\n",
+ " another_set.add(ordered_dict)\n",
+ " another_ordered_dict in another_set\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 2\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " another_set.add(another_ordered_dict)\n",
+ " len(another_set)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " True\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " dictionary in another_set\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 2\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " another_set.add(another_ordered_dict)\n",
+ " len(another_set)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " 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`.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Keep trying... *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "def some_func():\n",
+ " try:\n",
+ " return 'from_try'\n",
+ " finally:\n",
+ " return 'from_finally'\n",
+ "\n",
+ "def another_func(): \n",
+ " for _ in range(3):\n",
+ " try:\n",
+ " continue\n",
+ " finally:\n",
+ " print(\"Finally!\")\n",
+ "\n",
+ "def one_more_func(): # A gotcha!\n",
+ " try:\n",
+ " for i in range(3):\n",
+ " try:\n",
+ " 1 / i\n",
+ " except ZeroDivisionError:\n",
+ " # Let's throw it here and handle it outside for loop\n",
+ " raise ZeroDivisionError(\"A trivial divide by zero error\")\n",
+ " finally:\n",
+ " print(\"Iteration\", i)\n",
+ " break\n",
+ " except ZeroDivisionError as e:\n",
+ " print(\"Zero division error occurred\", e)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'from_finally'\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_func()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Finally!\n",
+ "Finally!\n",
+ "Finally!\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "another_func()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ "ZeroDivisionError: division by zero\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "1 / 0\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Iteration 0\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "one_more_func()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n",
+ "- 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.\n",
+ "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 For what?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_string = \"wtf\"\n",
+ "some_dict = {}\n",
+ "for i, some_dict[i] in enumerate(some_string):\n",
+ " i = 10\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{0: 'w', 1: 't', 2: 'f'}\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict # An indexed dict appears.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n",
+ " ```\n",
+ " for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n",
+ " ```\n",
+ " Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n",
+ " An interesting example that illustrates this:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " for i in range(4):\n",
+ " print(i)\n",
+ " i = 10\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " **Output:**\n",
+ " ```\n",
+ " 0\n",
+ " 1\n",
+ " 2\n",
+ " 3\n",
+ " ```\n",
+ "\n",
+ " Did you expect the loop to run just once?\n",
+ "\n",
+ " **\ud83d\udca1 Explanation:**\n",
+ "\n",
+ " - 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).\n",
+ "\n",
+ "* 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:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " i, some_dict[i] = (0, 'w')\n",
+ " i, some_dict[i] = (1, 't')\n",
+ " i, some_dict[i] = (2, 'f')\n",
+ " some_dict\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Evaluation time discrepancy\n",
+ "1\\.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "array = [1, 8, 15]\n",
+ "# A typical generator expression\n",
+ "gen = (x for x in array if array.count(x) > 0)\n",
+ "array = [2, 8, 22]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[8]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(list(gen)) # Where did the other values go?\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "2\\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "array_1 = [1,2,3,4]\n",
+ "gen_1 = (x for x in array_1)\n",
+ "array_1 = [1,2,3,4,5]\n",
+ "\n",
+ "array_2 = [1,2,3,4]\n",
+ "gen_2 = (x for x in array_2)\n",
+ "array_2[:] = [1,2,3,4,5]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4]\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(list(gen_1))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 5]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(list(gen_2))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "3\\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "array_3 = [1, 2, 3]\n",
+ "array_4 = [10, 20, 30]\n",
+ "gen = (i + j for i in array_3 for j in array_4)\n",
+ "\n",
+ "array_3 = [4, 5, 6]\n",
+ "array_4 = [400, 500, 600]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[401, 501, 601, 402, 502, 602, 403, 503, 603]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(list(gen))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "- 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.\n",
+ "- 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`.\n",
+ "- 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.\n",
+ "- In the first case, `array_1` is binded 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).\n",
+ "- 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]`).\n",
+ "- Okay, going by the logic discussed so far, shouldn't be the value of `list(g)` 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)\n",
+ " \n",
+ " > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.\n",
+ "\n"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -2387,7 +2788,8 @@
"#### \ud83d\udca1 Explanation\n",
"\n",
"- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated.\n",
- "- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise.\n",
+ "- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise. \n",
+ "- 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`.\n",
"\n"
]
},
@@ -2536,11 +2938,11 @@
"\n",
"When we initialize `row` variable, this visualization explains what happens in the memory\n",
"\n",
- "\n",
+ "\n",
"\n",
"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`)\n",
"\n",
- "\n",
+ "\n",
"\n",
"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).\n",
"\n"
@@ -2581,9 +2983,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### \u25b6 The sticky output function\n",
- "1\\.\n",
- "\n"
+ "### \u25b6 Schr\u00f6dinger's variable *\n"
]
},
{
@@ -2619,8 +3019,7 @@
"metadata": {},
"source": [
"\n",
- "**Output:**\n",
- "\n"
+ "**Output (Python version):**\n"
]
},
{
@@ -2671,9 +3070,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n",
"\n",
- "2\\.\n",
+ "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.\n",
+ "\n",
+ "2.\n",
"\n"
]
},
@@ -2711,11 +3111,70 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### \ud83d\udca1 Explanation\n",
+ "#### \ud83d\udca1 Explanation:\n",
+ "* 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:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "import inspect\n",
+ "inspect.getclosurevals(funcs[0])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Since `x` is a global value, we can change the value that the `funcs` will lookup and return by updating `x`:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[42, 42, 42, 42, 42, 42, 42]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "x = 42\n",
+ "[func() for func in funcs]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"\n",
- "- 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. So all of the functions use the latest value assigned to the variable for computation.\n",
- "\n",
- "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n",
+ "* 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.\n",
"\n"
]
},
@@ -2736,11 +3195,11 @@
}
],
"source": [
- " funcs = []\n",
- " for x in range(7):\n",
- " def some_func(x=x):\n",
- " return x\n",
- " funcs.append(some_func)\n"
+ "funcs = []\n",
+ "for x in range(7):\n",
+ " def some_func(x=x):\n",
+ " return x\n",
+ " funcs.append(some_func)\n"
]
},
{
@@ -2748,7 +3207,8 @@
"metadata": {},
"source": [
"\n",
- " **Output:**\n"
+ "**Output:**\n",
+ "\n"
]
},
{
@@ -2761,7 +3221,7 @@
{
"data": {
"text/plain": [
- " [0, 1, 2, 3, 4, 5, 6]\n"
+ "[0, 1, 2, 3, 4, 5, 6]\n"
]
},
"output_type": "execute_result",
@@ -2770,8 +3230,39 @@
}
],
"source": [
- " funcs_results = [func() for func in funcs]\n",
- " funcs_results\n"
+ "funcs_results = [func() for func in funcs]\n",
+ "funcs_results\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "It is not longer using the `x` in the global scope:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "inspect.getclosurevars(funcs[0])\n"
]
},
{
@@ -3129,6 +3620,481 @@
"\n"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Methods equality and identity\n",
+ "1.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "class SomeClass:\n",
+ " def method(self):\n",
+ " pass\n",
+ "\n",
+ " @classmethod\n",
+ " def classm(cls):\n",
+ " pass\n",
+ "\n",
+ " @staticmethod\n",
+ " def staticm():\n",
+ " pass\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.method is SomeClass.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.classm is SomeClass.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.classm == SomeClass.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.staticm is SomeClass.staticm)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens\n",
+ "with instances of `SomeClass`:\n",
+ "\n",
+ "2.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1 = SomeClass()\n",
+ "o2 = SomeClass()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.method == o2.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.method == o1.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.method is o1.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.classm is o1.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.classm == o1.classm == o2.classm == SomeClass.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Accessing` classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "* Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an\n",
+ "attribute, the descriptor is invoked, creating a method object which \"binds\" the function with the object owning the\n",
+ "attribute. If called, the method calls the function, implicitly passing the bound object as the first argument\n",
+ "(this is how we get `self` as the first argument, despite not passing it explicitly).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1.method\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is\n",
+ "never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so\n",
+ "`SomeClass.method is SomeClass.method` is truthy.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "SomeClass.method\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create\n",
+ "a method object which binds the *class* (type) of the object, instead of the object itself.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1.classm\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they\n",
+ "bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "SomeClass.classm\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* A method object compares equal when both the functions are equal, and the bound objects are the same. So\n",
+ "`o1.method == o1.method` is truthy, although not the same object in memory.\n",
+ "* `staticmethod` transforms functions into a \"no-op\" descriptor, which returns the function as-is. No method\n",
+ "objects are ever created, so comparison with `is` is truthy.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1.staticm\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "SomeClass.staticm\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* Having to create new \"method\" objects every time Python calls instance methods and having to modify the arguments\n",
+ "every time in order to insert `self` affected performance badly.\n",
+ "CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods\n",
+ "without creating the temporary method objects. This is used only when the accessed function is actually called, so the\n",
+ "snippets here are not affected, and still generate methods :)\n",
+ "\n"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -3491,7 +4457,7 @@
}
],
"source": [
- " 'wt\\\"f'\n"
+ " \"wt\\\"f\"\n"
]
},
{
@@ -3578,7 +4544,7 @@
{
"data": {
"text/plain": [
- " '\\\\\\\\n'\n"
+ " '\\\\n'\n"
]
},
"output_type": "execute_result",
@@ -3786,7 +4752,7 @@
"metadata": {},
"source": [
"#### \ud83d\udca1 Explanation:\n",
- "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n",
+ "+ Python supports implicit [string literal concatenation](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Example,\n",
" ```\n",
" >>> print(\"wtf\" \"python\")\n",
" wtfpython\n",
@@ -4539,186 +5505,6 @@
"\n"
]
},
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Non-reflexive class method *\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "class SomeClass:\n",
- " def instance_method(self):\n",
- " pass\n",
- " \n",
- " @classmethod\n",
- " def class_method(cls):\n",
- " pass\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "SomeClass.instance_method is SomeClass.instance_method\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "SomeClass.class_method is SomeClass.class_method\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "id(SomeClass.class_method) == id(SomeClass.class_method)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation:\n",
- "\n",
- "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " \n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " SomeClass.instance_method\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " \n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " SomeClass.class_method\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- " A new bound method every time `SomeClass.class_method` is accessed.\n",
- "\n",
- "- `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n",
- "\n"
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -4882,7 +5668,7 @@
"#### \ud83d\udca1 Explanation:\n",
"- This is a bug in CPython's handling of `yield` in generators and comprehensions.\n",
"- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions\n",
- "- Related bug report: http://bugs.python.org/issue10544\n",
+ "- Related bug report: https://bugs.python.org/issue10544\n",
"- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.\n",
"\n"
]
@@ -5682,12 +6468,13 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"\n",
- "* Quoting from https://docs.python.org/2/reference/datamodel.html\n",
+ "* Quoting from https://docs.python.org/3/reference/datamodel.html\n",
"\n",
" > Immutable sequences\n",
" 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.)\n",
"\n",
"* `+=` 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.\n",
+ "* 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).\n",
"\n"
]
},
@@ -6291,7 +7078,7 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"\n",
- "* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form\n",
+ "* According to [Python language reference](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), assignment statements have the form\n",
" ```\n",
" (target_list \"=\")+ (expression_list | yield_expression)\n",
" ```\n",
@@ -6529,7 +7316,7 @@
"* 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.\n",
"* How deleted keys are handled and when the resize occurs might be different for different Python implementations.\n",
"* 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.\n",
- "* Python 3.8 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n",
+ "* Python 3.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n",
"\n"
]
},
@@ -6537,7 +7324,8 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### \u25b6 The out of scope variable\n"
+ "### \u25b6 The out of scope variable\n",
+ "1\\.\n"
]
},
{
@@ -6566,6 +7354,45 @@
" return a\n"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "2\\.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "def some_closure_func():\n",
+ " a = 1\n",
+ " def some_inner_func():\n",
+ " return a\n",
+ " return some_inner_func()\n",
+ "\n",
+ "def another_closure_func():\n",
+ " a = 1\n",
+ " def another_inner_func():\n",
+ " a += 1\n",
+ " return a\n",
+ " return another_inner_func()\n"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -6606,7 +7433,8 @@
{
"data": {
"text/plain": [
- "UnboundLocalError: local variable 'a' referenced before assignment\n"
+ "UnboundLocalError: local variable 'a' referenced before assignment\n",
+ "\n"
]
},
"output_type": "execute_result",
@@ -6618,6 +7446,50 @@
"another_func()\n"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_closure_func()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "UnboundLocalError: local variable 'a' referenced before assignment\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "another_closure_func()\n"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -6630,9 +7502,8 @@
"metadata": {},
"source": [
"#### \ud83d\udca1 Explanation:\n",
- "* 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.\n",
- "* Read [this](http://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.\n",
- "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n"
+ "* 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.\n",
+ "* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword.\n"
]
},
{
@@ -6692,6 +7563,72 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "* 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. \n",
+ "* 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.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " def another_func():\n",
+ " a = 1\n",
+ " def another_inner_func():\n",
+ " nonlocal a\n",
+ " a += 1\n",
+ " return a\n",
+ " return another_inner_func()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " **Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 2\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " another_func()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* The keywords `global` and `nonlocal` tell the python interpreter to not delcare new variables and look them up in the corresponding outer scopes.\n",
+ "* 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.\n",
"\n"
]
},
@@ -7064,7 +8001,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "- So the function takes in arbitrary number of itreable 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. \n",
+ "- 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. \n",
"- 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`.\n",
"- The correct way to do the above using `zip` would be,\n"
]
@@ -7648,7 +8585,7 @@
],
"source": [
" def some_func(default_arg=None):\n",
- " if not default_arg:\n",
+ " if default_arg is None:\n",
" default_arg = []\n",
" default_arg.append(\"some_string\")\n",
" return default_arg\n"
@@ -8068,268 +9005,6 @@
"\n"
]
},
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Be careful with chained operations\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "(False == False) in [False] # makes sense\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "False == (False in [False]) # makes sense\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "False == False in [False] # now what?\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "True is False == False\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "False is False is False\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "1 > 0 < 1\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "(1 > 0) < 1\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "1 > (0 < 1)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation:\n",
- "\n",
- "As per https://docs.python.org/2/reference/expressions.html#not-in\n",
- "\n",
- "> 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.\n",
- "\n",
- "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`.\n",
- "\n",
- "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n",
- "* `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`.\n",
- "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n",
- "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " 1\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " int(True)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " 2\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " True + 1 #not relevant for this example, but just for fun\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- " So, `1 < 1` evaluates to `False`\n",
- "\n"
- ]
- },
{
"cell_type": "markdown",
"metadata": {},
@@ -8853,17 +9528,17 @@
"source": [
"def some_recursive_func(a):\n",
" if a[0] == 0:\n",
- " return \n",
+ " return\n",
" a[0] -= 1\n",
" some_recursive_func(a)\n",
" return a\n",
"\n",
"def similar_recursive_func(a):\n",
- " if a == 0:\n",
- " return a\n",
- " a -= 1\n",
- " similar_recursive_func(a)\n",
- " return a\n"
+ " if a == 0:\n",
+ " return a\n",
+ " a -= 1\n",
+ " similar_recursive_func(a)\n",
+ " return a\n"
]
},
{
@@ -9035,7 +9710,7 @@
"text/plain": [
" Traceback (most recent call last):\n",
" File \"\", line 1, in \n",
- " AssertionError: Values aren not equal\n"
+ " AssertionError: Values are not equal\n"
]
},
"output_type": "execute_result",
@@ -9052,9 +9727,9 @@
"metadata": {},
"source": [
"\n",
- "* 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](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n",
+ "* 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)).\n",
"\n",
- "* Last one should be fairly obvious, passing mutable object (like `list` ) results in a call by reference, whereas an immutable object (like `int`) results in a call by value.\n",
+ "* Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignation of an immutable (`a -= 1`) is not an alteration of the value.\n",
"\n",
"* Being aware of these nitpicks can save you hours of debugging effort in the long run. \n",
"\n"
@@ -9174,7 +9849,7 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"\n",
- "- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)\n",
+ "- 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)\n",
" > 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 `[]`.\n",
" > 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 `['']`.\n",
"- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,\n"
@@ -9520,7 +10195,7 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"+ `antigravity` module is one of the few easter eggs released by Python developers.\n",
- "+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python.\n",
+ "+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python.\n",
"+ 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/).\n",
"\n"
]
@@ -10707,6 +11382,31 @@
"**Output:**\n"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ "AttributeError: 'A' object has no attribute '__variable'\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "A().__variable\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -10726,10 +11426,6 @@
}
],
"source": [
- "Traceback (most recent call last):\n",
- " File \"\", line 1, in \n",
- "AttributeError: 'A' object has no attribute '__variable'\n",
- "\n",
"A().some_func()\n"
]
},
@@ -10933,7 +11629,7 @@
}
],
"source": [
- "# `pip install nump` first.\n",
+ "# `pip install numpy` first.\n",
"import numpy as np\n",
"\n",
"def energy_send(x):\n",
@@ -11562,6 +12258,441 @@
"\n"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Slowing down `dict` lookups *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict = {str(i): 1 for i in range(1_000_000)}\n",
+ "another_dict = {str(i): 1 for i in range(1_000_000)}\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "28.6 ns \u00b1 0.115 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit some_dict['5']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "37.2 ns \u00b1 0.265 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_dict[1] = 1\n",
+ "%timeit some_dict['5']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "28.5 ns \u00b1 0.142 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit another_dict['5']\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ "KeyError: 1\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "another_dict[1] # Trying to access a key that doesn't exist\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "38.5 ns \u00b1 0.0913 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit another_dict['5']\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Why are same lookups becoming slower?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "+ 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.\n",
+ "+ 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.\n",
+ "+ The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function.\n",
+ "+ 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.\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Bloating instance `dict`s *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "import sys\n",
+ "\n",
+ "class SomeClass:\n",
+ " def __init__(self):\n",
+ " self.some_attr1 = 1\n",
+ " self.some_attr2 = 2\n",
+ " self.some_attr3 = 3\n",
+ " self.some_attr4 = 4\n",
+ "\n",
+ "\n",
+ "def dict_size(o):\n",
+ " return sys.getsizeof(o.__dict__)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:** (Python 3.8, other Python 3 versions may vary a little)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "104\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1 = SomeClass()\n",
+ "o2 = SomeClass()\n",
+ "dict_size(o1)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "104\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "dict_size(o2)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "232\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "del o1.some_attr1\n",
+ "o3 = SomeClass()\n",
+ "dict_size(o3)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "232\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "dict_size(o1)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Let's try again... In a new interpreter:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "104 # as expected\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1 = SomeClass()\n",
+ "o2 = SomeClass()\n",
+ "dict_size(o1)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "360\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1.some_attr5 = 5\n",
+ "o1.some_attr6 = 6\n",
+ "dict_size(o1)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "272\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "dict_size(o2)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "232\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o3 = SomeClass()\n",
+ "dict_size(o3)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "What makes those dictionaries become bloated? And why are newly created objects bloated as well?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "+ 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.\n",
+ "+ This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken.\n",
+ "+ 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.\n",
+ "+ Additionaly, if the dictionary keys have be 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.\n",
+ "+ 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__`!\n",
+ "\n",
+ "\n"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -11636,7 +12767,7 @@
" ```py\n",
" >>> some_string = \"wtfpython\"\n",
" >>> f'{some_string=}'\n",
- " \"string='wtfpython'\"\n",
+ " \"some_string='wtfpython'\"\n",
" ``` \n",
"\n",
"* 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!):\n",
@@ -11653,7 +12784,7 @@
" print(dis.dis(f))\n",
" ```\n",
" \n",
- "* 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/2/library/multiprocessing.html) module.\n",
+ "* 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.\n",
"\n",
"* Sometimes, the `print` method might not print values immediately. For example,\n",
"\n",
@@ -11665,7 +12796,7 @@
" time.sleep(3)\n",
" ```\n",
"\n",
- " This will print the `wtfpython` after 10 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.\n",
+ " 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.\n",
"\n",
"* List slicing with out of the bounds indices throws no errors\n",
" ```py\n",
@@ -11684,7 +12815,7 @@
" True\n",
" ```\n",
"\n",
- "* `int('\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669')` 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](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n",
+ "* `int('\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669')` 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.\n",
"\n",
"* You can separate numeric literals with underscores (for better readability) from Python 3 onwards.\n",
"\n",
@@ -11706,8 +12837,6 @@
" return result\n",
" ```\n",
" The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.\n",
- "\n",
- "**That's all folks!**\n",
"\n"
]
},
@@ -11760,6 +12889,17 @@
"source": [
"```py\n",
">>> (a := \"wtf_walrus\") # This works though\n",
+ "```\n",
+ "```py\n",
+ "'wtf_walrus'\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
">>> a\n",
"```\n",
"```py\n",
@@ -11798,6 +12938,17 @@
"source": [
"```py\n",
">>> (a := 6, 9)\n",
+ "```\n",
+ "```py\n",
+ "(6, 9)\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
">>> a\n",
"```\n",
"```py\n",
@@ -11954,7 +13105,7 @@
"\n",
"- As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. \n",
"\n",
- "- 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, \n",
+ "- 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, \n",
"\n",
" - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6')\n",
"\n"
@@ -12055,7 +13206,7 @@
"metadata": {},
"source": [
"\n",
- "Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twists to the example.\n",
+ "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.\n",
"\n",
"2\\.\n"
]
@@ -12104,9 +13255,9 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"+ `del x` doesn\u2019t directly call `x.__del__()`.\n",
- "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x\u2019s reference count reaches zero.\n",
- "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n",
- "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n",
+ "+ 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.\n",
+ "+ 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.\n",
+ "+ 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!).\n",
"\n"
]
},
@@ -12184,7 +13335,7 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"\n",
- "- 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 get imported. This may lead to errors during runtime.\n",
+ "- 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.\n",
"- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred.\n"
]
},
@@ -12298,6 +13449,7 @@
"* https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator\n",
"* https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65\n",
"* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues\n",
+ "* 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/).\n",
"\n",
"# \ud83c\udf93 License\n",
"\n",
@@ -12314,4 +13466,4 @@
"metadata": {},
"nbformat": 4,
"nbformat_minor": 2
-}
\ No newline at end of file
+}
diff --git a/translations/ru-russian/CONTRIBUTING.md b/translations/ru-russian/CONTRIBUTING.md
new file mode 100644
index 0000000..a542814
--- /dev/null
+++ b/translations/ru-russian/CONTRIBUTING.md
@@ -0,0 +1,63 @@
+Приветствуются все виды изменений. Не стесняйтесь предлагать броские и смешные названия для существующих примеров. Цель - сделать эту коллекцию как можно более интересной для чтения. Вот несколько способов, с помощью которых вы можете внести свой вклад,
+
+- Если вы заинтересованы в переводе проекта на другой язык (некоторые люди уже делали это в прошлом), пожалуйста, не стесняйтесь открыть тему и дайте мне знать, если вам нужна какая-либо помощь.
+- Если изменения, которые вы предлагаете, значительны, то создание issue перед внесением изменений будет оценено по достоинству. Если вы хотите поработать над issue (это очень рекомендуется), выразите свою заинтересованность и вы будете назначены исполнителем.
+- Если вы добавляете новый пример, настоятельно рекомендуется создать issue, чтобы обсудить ее перед отправкой изменений. Для добавления нового примера вы можете использовать следующий шаблон:
+
+
+### ▶ Какое-то причудливое название. *
+* в конце названия означает, что пример был добавлен недавно.
+
+```py
+# Подготовка кода.
+# Подготовка к волшебству...
+```
+
+**Вывод (версия Python):**
+```py
+>>> triggering_statement
+Вероятно, неожиданный вывод
+
+```
+(Необязательно): Одна строка, описывающая неожиданный вывод.
+
+#### 💡 Объяснение:
+* Краткое объяснение того, что происходит и почему это происходит.
+ ```py
+ Подготовка примеров для пояснения (при необходимости)
+ ```
+
+ **Вывод:**
+ ```py
+ >>> trigger # пример, облегчающий понимание магии
+ # обоснованный вывод
+ ```
+
+
+Несколько моментов, которые стоит учитывать при написании примера,
+
+- Если вы решили отправить новый пример без создания issue и обсуждения, пожалуйста, проверьте проект, чтобы убедиться, что в нем уже нет похожих примеров.
+- Старайтесь быть последовательными в именах и значениях, которые вы используете для переменных. Например, большинство имен переменных в проекте имеют вид `some_string`, `some_list`, `some_dict` и т.д. Вы увидите много `x` для однобуквенных имен переменных, и `"wtf"` в качестве значений для строк. В проекте нет строгой схемы, как таковой, но вы можете взглянуть на другие примеры, чтобы понять суть.
+- Старайтесь быть как можно более креативными, чтобы добавить элемент "сюрприза" во время подготовки примеров. Иногда это может означать написание фрагмента, который здравомыслящий программист никогда бы не написал.
+- Также не стесняйтесь добавлять свое имя в список [контрибьюторов](/CONTRIBUTORS.md).
+
+**Некоторые часто задаваемые вопросы**
+
+ Что это такое после каждого заголовка сниппета (###) в README: ? Нужно ли его добавлять вручную или можно игнорировать при создании новых сниппетов?
+
+Это случайный UUID, он используется для идентификации примеров в нескольких переводах проекта. Как контрибьютор, вы не должны беспокоиться о том, как он используется, вы просто должны добавлять новый случайный UUID к новым примерам в этом формате.
+
+ Куда следует добавлять новые сниппеты? В начало/в конец раздела?
+
+При определении порядка учитывается множество факторов (зависимость от других примеров, уровень сложности, категория и т.д.). Я бы предложил просто добавить новый пример в конец раздела, который вы считаете более подходящим (или просто добавить его в раздел "Разное"). О его порядке можно будет позаботиться в будущих редакциях.
+
+ В чем разница между разделами (первые два очень похожи)?
+
+Раздел "Напрягите мозг" содержит более надуманные примеры, с которыми вы не столкнетесь в реальной жизни, в то время как раздел "Скользкие склоны" содержит примеры, с которыми можно чаще сталкиваться при программировании.
+
+ Перед оглавлением написано, что для его создания использовался markdown-toc -i README.md --maxdepth 3. Пакет pip markdown-toc не содержит ни флагов -i, ни --maxdepth. Какой пакет имеется в виду, или какая версия этого пакета?
+ Должна ли новая запись в оглавлении для фрагмента быть создана с помощью вышеуказанной команды или вручную (в случае, если вышеуказанная команда делает больше, чем просто добавляет запись)?
+
+Мы используем пакет [markdown-toc](https://www.npmjs.com/package/markdown-toc) npm для создания ToC (содержание). Однако у него есть некоторые проблемы со специальными символами (не уверен, что они уже исправлены). Чаще всего я просто вставляю ссылку toc вручную в нужное место. Инструмент удобен, когда мне нужно сделать большую перестановку, в остальных случаях просто обновлять toc вручную удобнее.
+
+Если у вас есть вопросы, не стесняйтесь спрашивать в [issue](https://github.com/satwikkansal/wtfpython/issues/269) (спасибо [@LiquidFun](https://github.com/LiquidFun) за ее создание).
diff --git a/translations/ru-russian/CONTRIBUTORS.md b/translations/ru-russian/CONTRIBUTORS.md
new file mode 100644
index 0000000..2599f8a
--- /dev/null
+++ b/translations/ru-russian/CONTRIBUTORS.md
@@ -0,0 +1,42 @@
+Ниже перечислены (без определенного порядка) замечательные люди, которые внесли вклад в развитие wtfpython.
+
+| Автор | Github | Issues |
+|-------------|--------|--------|
+| Lucas-C | [Lucas-C](https://github.com/Lucas-C) | [#36](https://github.com/satwikkansal/wtfpython/issues/36) |
+| MittalAshok | [MittalAshok](https://github.com/MittalAshok) | [#23](https://github.com/satwikkansal/wtfpython/issues/23) |
+| asottile | [asottile](https://github.com/asottile) | [#40](https://github.com/satwikkansal/wtfpython/issues/40) |
+| MostAwesomeDude | [MostAwesomeDude](https://github.com/MostAwesomeDude) | [#1](https://github.com/satwikkansal/wtfpython/issues/1) |
+| tukkek | [tukkek](https://github.com/tukkek) | [#11](https://github.com/satwikkansal/wtfpython/issues/11), [#26](https://github.com/satwikkansal/wtfpython/issues/26) |
+| PiaFraus | [PiaFraus](https://github.com/PiaFraus) | [#9](https://github.com/satwikkansal/wtfpython/issues/9) |
+| chris-rands | [chris-rands](https://github.com/chris-rands) | [#32](https://github.com/satwikkansal/wtfpython/issues/32) |
+| sohaibfarooqi | [sohaibfarooqi](https://github.com/sohaibfarooqi) | [#63](https://github.com/satwikkansal/wtfpython/issues/63) |
+| ipid | [ipid](https://github.com/ipid) | [#145](https://github.com/satwikkansal/wtfpython/issues/145) |
+| roshnet | [roshnet](https://github.com/roshnet) | [#140](https://github.com/satwikkansal/wtfpython/issues/140) |
+| daidai21 | [daidai21](https://github.com/daidai21) | [#137](https://github.com/satwikkansal/wtfpython/issues/137) |
+| scidam | [scidam](https://github.com/scidam) | [#136](https://github.com/satwikkansal/wtfpython/issues/136) |
+| pmjpawelec | [pmjpawelec](https://github.com/pmjpawelec) | [#121](https://github.com/satwikkansal/wtfpython/issues/121) |
+| leisurelicht | [leisurelicht](https://github.com/leisurelicht) | [#112](https://github.com/satwikkansal/wtfpython/issues/112) |
+| mishaturnbull | [mishaturnbull](https://github.com/mishaturnbull) | [#108](https://github.com/satwikkansal/wtfpython/issues/108) |
+| MuseBoy | [MuseBoy](https://github.com/MuseBoy) | [#101](https://github.com/satwikkansal/wtfpython/issues/101) |
+| Ghost account | N/A | [#96](https://github.com/satwikkansal/wtfpython/issues/96) |
+| koddo | [koddo](https://github.com/koddo) | [#80](https://github.com/satwikkansal/wtfpython/issues/80), [#73](https://github.com/satwikkansal/wtfpython/issues/73) |
+| jab | [jab](https://github.com/jab) | [#77](https://github.com/satwikkansal/wtfpython/issues/77) |
+| Jongy | [Jongy](https://github.com/Jongy) | [#208](https://github.com/satwikkansal/wtfpython/issues/208), [#210](https://github.com/satwikkansal/wtfpython/issues/210), [#233](https://github.com/satwikkansal/wtfpython/issues/233) |
+| Diptangsu Goswami | [diptangsu](https://github.com/diptangsu) | [#193](https://github.com/satwikkansal/wtfpython/issues/193) |
+| Charles | [charles-l](https://github.com/charles-l) | [#245](https://github.com/satwikkansal/wtfpython/issues/245) |
+| LiquidFun | [LiquidFun](https://github.com/LiquidFun) | [#267](https://github.com/satwikkansal/wtfpython/issues/267) |
+
+---
+
+**Переводчики**
+
+| Переводчик | Github | Язык |
+|-------------|--------|--------|
+| leisurelicht | [leisurelicht](https://github.com/leisurelicht) | [Chinese](https://github.com/leisurelicht/wtfpython-cn) |
+| vuduclyunitn | [vuduclyunitn](https://github.com/vuduclyunitn) | [Vietnamese](https://github.com/vuduclyunitn/wtfptyhon-vi) |
+| José De Freitas | [JoseDeFreitas](https://github.com/JoseDeFreitas) | [Spanish](https://github.com/JoseDeFreitas/wtfpython-es) |
+| Vadim Nifadev | [nifadyev](https://github.com/nifadyev) | [Russian](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) |
+
+Спасибо всем за ваше время и за то, что делаете wtfpython еще более потрясающим! :smile:
+
+PS: Этот список обновляется после каждого крупного релиза, если я забыл добавить сюда ваш вклад, пожалуйста, не стесняйтесь сделать Pull request.
diff --git a/translations/ru-russian/README.md b/translations/ru-russian/README.md
new file mode 100644
index 0000000..c80fe2a
--- /dev/null
+++ b/translations/ru-russian/README.md
@@ -0,0 +1,3965 @@
+
+
+
+
+
+
+
+
What the f*ck Python! 😱
+
Изучение и понимание Python с помощью удивительных примеров поведения.
+
+Переводы: [English Original](https://github.com/satwikkansal/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) | [Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [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].)
+
+Альтернативные способы: [Интерактивный сайт](https://wtfpython-interactive.vercel.app) | [Интерактивный Jupiter notebook](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb)
+
+Python, будучи прекрасно спроектированным высокоуровневым языком программирования, предоставляет множество возможностей для удобства программиста. Но иногда поведение Python кода могут показаться запутывающим на первый взгляд.
+
+**wtfpython** задуман как проект, пытающийся объяснить, что именно происходит под капотом неочевидных фрагментов кода и малоизвестных возможностей Python.
+
+Если вы опытный питонист, вы можете принять это как вызов и правильно объяснить WTF ситуации с первой попытки. Возможно, вы уже сталкивались с некоторыми из них раньше, и я смогу оживить ваши старые добрые воспоминания! 😅
+
+PS: Если вы уже читали **wtfpython** раньше, с изменениями можно ознакомиться [здесь](https://github.com/satwikkansal/wtfpython/releases/) (примеры, отмеченные звездочкой - это примеры, добавленные в последней основной редакции).
+
+Ну что ж, приступим...
+
+# Содержание
+- [Содержание](#содержание)
+- [Структура примера](#структура-примера)
+- [Применение](#применение)
+- [👀 Примеры](#-примеры)
+ - [Раздел: Напряги мозги!](#раздел-напряги-мозги)
+ - [▶ Первым делом!](#-первым-делом)
+ - [💡 Обьяснение](#-обьяснение)
+ - [▶ Строки иногда ведут себя непредсказуемо](#-строки-иногда-ведут-себя-непредсказуемо)
+ - [💡 Объяснение](#-объяснение)
+ - [▶ Осторожнее с цепочкой операций](#-осторожнее-с-цепочкой-операций)
+ - [💡 Объяснение:](#-объяснение-1)
+ - [▶ Как не надо использовать оператор `is`](#-как-не-надо-использовать-оператор-is)
+ - [💡 Объяснение:](#-объяснение-2)
+ - [▶ Мистическое хеширование](#-мистическое-хеширование)
+ - [💡 Объяснение](#-объяснение-3)
+ - [▶ В глубине души мы все одинаковы.](#-в-глубине-души-мы-все-одинаковы)
+ - [💡 Объяснение:](#-объяснение-4)
+ - [▶ Беспорядок внутри порядка \*](#-беспорядок-внутри-порядка-)
+ - [💡 Объяснение:](#-объяснение-5)
+ - [▶ Продолжай пытаться... \*](#-продолжай-пытаться-)
+ - [💡 Объяснение:](#-объяснение-6)
+ - [▶ Для чего?](#-для-чего)
+ - [💡 Объяснение:](#-объяснение-7)
+ - [▶ Расхождение во времени исполнения](#-расхождение-во-времени-исполнения)
+ - [💡 Объяснение](#-объяснение-8)
+ - [▶ `is not ...` не является `is (not ...)`](#-is-not--не-является-is-not-)
+ - [💡 Объяснение](#-объяснение-9)
+ - [▶ Крестики-нолики, где X побеждает с первой попытки!](#-крестики-нолики-где-x-побеждает-с-первой-попытки)
+ - [💡 Объяснение:](#-объяснение-10)
+ - [▶ Переменная Шредингера \*](#-переменная-шредингера-)
+ - [💡 Объяснение:](#-объяснение-11)
+ - [▶ Проблема курицы и яйца \*](#-проблема-курицы-и-яйца-)
+ - [💡 Объяснение](#-объяснение-12)
+ - [▶ Отношения между подклассами](#-отношения-между-подклассами)
+ - [💡 Объяснение](#-объяснение-13)
+ - [▶ Равенство и тождество методов](#-равенство-и-тождество-методов)
+ - [💡 Объяснение](#-объяснение-14)
+ - [▶ All-true-ation (непереводимая игра слов) \*](#-all-true-ation-непереводимая-игра-слов-)
+ - [💡 Объяснение:](#-объяснение-15)
+ - [💡 Объяснение:](#-объяснение-16)
+ - [▶ Строки и обратные слэши](#-строки-и-обратные-слэши)
+ - [💡 Объяснение](#-объяснение-17)
+ - [▶ Не узел! (англ. not knot!)](#-не-узел-англ-not-knot)
+ - [💡 Объяснение](#-объяснение-18)
+ - [▶ Строки, наполовину обернутые в тройные кавычки](#-строки-наполовину-обернутые-в-тройные-кавычки)
+ - [💡 Объяснение:](#-объяснение-19)
+ - [▶ Что не так с логическими значениями?](#-что-не-так-с-логическими-значениями)
+ - [💡 Объяснение:](#-объяснение-20)
+ - [▶ Атрибуты класса и экземпляра](#-атрибуты-класса-и-экземпляра)
+ - [💡 Объяснение:](#-объяснение-21)
+ - [▶ Возврат None из генератора](#-возврат-none-из-генератора)
+ - [💡 Объяснение:](#-объяснение-22)
+ - [▶ Yield from возвращает... \*](#-yield-from-возвращает-)
+ - [💡 Объяснение:](#-объяснение-23)
+ - [▶ Nan-рефлексивность \*](#-nan-рефлексивность-)
+ - [💡 Объяснение:](#-объяснение-24)
+ - [▶ Изменяем неизменяемое!](#-изменяем-неизменяемое)
+ - [💡 Объяснение:](#-объяснение-25)
+ - [▶ Исчезающая переменная из внешней области видимости](#-исчезающая-переменная-из-внешней-области-видимости)
+ - [💡 Объяснение:](#-объяснение-26)
+ - [▶ Загадочное преобразование типов ключей](#-загадочное-преобразование-типов-ключей)
+ - [💡 Объяснение:](#-объяснение-27)
+ - [▶ Посмотрим, сможете ли вы угадать что здесь?](#-посмотрим-сможете-ли-вы-угадать-что-здесь)
+ - [💡 Объяснение:](#-объяснение-28)
+ - [▶ Превышение предела целочисленного преобразования строк](#-превышение-предела-целочисленного-преобразования-строк)
+ - [💡 Объяснение:](#-объяснение-29)
+ - [Раздел: Скользкие склоны](#раздел-скользкие-склоны)
+ - [▶ Изменение словаря во время прохода по нему](#-изменение-словаря-во-время-прохода-по-нему)
+ - [💡 Объяснение:](#-объяснение-30)
+ - [▶ Упрямая операция `del`](#-упрямая-операция-del)
+ - [💡 Объяснение:](#-объяснение-31)
+ - [▶ Переменная за пределами видимости](#-переменная-за-пределами-видимости)
+ - [💡 Объяснение:](#-объяснение-32)
+ - [▶ Удаление элемента списка во время прохода по списку](#-удаление-элемента-списка-во-время-прохода-по-списку)
+ - [💡 Объяснение:](#-объяснение-33)
+ - [▶ Сжатие итераторов с потерями \*](#-сжатие-итераторов-с-потерями-)
+ - [💡 Объяснение:](#-объяснение-34)
+ - [▶ Утечка переменных внутри цикла](#-утечка-переменных-внутри-цикла)
+ - [💡 Объяснение:](#-объяснение-35)
+ - [▶ Остерегайтесь изменяемых аргументов по умолчанию!](#-остерегайтесь-изменяемых-аргументов-по-умолчанию)
+ - [💡 Объяснение:](#-объяснение-36)
+ - [▶ Ловля исключений](#-ловля-исключений)
+ - [💡 Объяснение](#-объяснение-37)
+ - [▶ Одни и те же операнды, разная история!](#-одни-и-те-же-операнды-разная-история)
+ - [💡 Объяснение:](#-объяснение-38)
+ - [▶ Разрешение имен игнорирует область видимости класса](#-разрешение-имен-игнорирует-область-видимости-класса)
+ - [💡 Объяснение](#-объяснение-39)
+ - [▶ Округляясь как банкир \*](#-округляясь-как-банкир-)
+ - [💡 Объяснение:](#-объяснение-40)
+ - [▶ Иголки в стоге сена \*](#-иголки-в-стоге-сена-)
+ - [💡 Объяснение:](#-объяснение-41)
+ - [▶ Сплиты (splitsies) \*](#-сплиты-splitsies-)
+ - [💡 Объяснение](#-объяснение-42)
+ - [▶ Подстановочное импортирование (wild imports) \*](#-подстановочное-импортирование-wild-imports-)
+ - [💡 Объяснение:](#-объяснение-43)
+ - [▶ Все ли отсортировано? \*](#-все-ли-отсортировано-)
+ - [💡 Объяснение:](#-объяснение-44)
+ - [▶ Полночи не существует?](#-полночи-не-существует)
+ - [💡 Объяснение:](#-объяснение-45)
+ - [Раздел: Скрытые сокровища!](#раздел-скрытые-сокровища)
+ - [▶ Python, можешь ли ты помочь взлететь?](#-python-можешь-ли-ты-помочь-взлететь)
+ - [💡 Объяснение:](#-объяснение-46)
+ - [▶ `goto`, но почему?](#-goto-но-почему)
+ - [💡 Объяснение:](#-объяснение-47)
+ - [▶ Держитесь!](#-держитесь)
+ - [💡 Объяснение:](#-объяснение-48)
+ - [▶ Давайте познакомимся с дружелюбным Дядей Барри](#-давайте-познакомимся-с-дружелюбным-дядей-барри)
+ - [💡 Объяснение:](#-объяснение-49)
+ - [▶ Даже Python понимает, что любовь - это сложно.](#-даже-python-понимает-что-любовь---это-сложно)
+ - [💡 Объяснение:](#-объяснение-50)
+ - [▶ Да, оно существует!](#-да-оно-существует)
+ - [💡 Объяснение:](#-объяснение-51)
+ - [▶ Многоточие \*](#-многоточие-)
+ - [💡 Объяснение](#-объяснение-52)
+ - [▶ Писконечность (Inpinity)](#-писконечность-inpinity)
+ - [💡 Объяснение:](#-объяснение-53)
+ - [▶ Давайте искажать](#-давайте-искажать)
+ - [💡 Объяснение:](#-объяснение-54)
+ - [Раздел: Внешность обманчива!](#раздел-внешность-обманчива)
+ - [▶ Пропускаем строки?](#-пропускаем-строки)
+ - [💡 Объяснение](#-объяснение-55)
+ - [▶ Телепортация](#-телепортация)
+ - [💡 Объяснение:](#-объяснение-56)
+ - [▶ Что-то не так...](#-что-то-не-так)
+ - [💡 Объяснение](#-объяснение-57)
+ - [Раздел: Разное](#раздел-разное)
+ - [▶ `+=` быстрее `+`](#--быстрее-)
+ - [💡 Объяснение:](#-объяснение-58)
+ - [▶ Сделаем гигантскую строку!](#-сделаем-гигантскую-строку)
+ - [💡 Объяснение](#-объяснение-59)
+ - [▶ Замедляем поиск по `dict` \*](#-замедляем-поиск-по-dict-)
+ - [💡 Объяснение:](#-объяснение-60)
+ - [▶ Раздуваем экземпляры словарей \*](#-раздуваем-экземпляры-словарей-)
+ - [💡 Объяснение:](#-объяснение-61)
+ - [▶ Минорное \*](#-минорное-)
+- [Вклад в проект](#вклад-в-проект)
+- [Благодарности](#благодарности)
+ - [Несколько хороших ссылок!](#несколько-хороших-ссылок)
+- [🎓 Лицензия](#-лицензия)
+ - [Удиви своих друзей!](#удиви-своих-друзей)
+ - [Нужна PDF версия?](#нужна-pdf-версия)
+
+# Структура примера
+
+Все примеры имеют следующую структуру:
+
+> ### ▶ Какой-то заголовок
+>
+> ```py
+> # Неочевидный фрагмент кода
+> # Подготовка к магии...
+> ```
+>
+> **Вывод (Python версия):**
+>
+> ```py
+> >>> triggering_statement
+> Неожиданные результаты
+> ```
+>
+> (Опционально): Краткое описание неожиданного результата
+>
+>
+> #### 💡 Объяснение
+>
+> * Краткое объяснение того, что происходит и почему это происходит.
+>
+> ```py
+> # Код
+> # Дополнительные примеры для дальнейшего разъяснения (если необходимо)
+> ```
+>
+> **Вывод (Python версия):**
+>
+> ```py
+> >>> trigger # какой-нибудь пример, позволяющий легко раскрыть магию
+> # обоснованный вывод
+> ```
+
+**Важно:** Все примеры протестированы на интерактивном интерпретаторе Python 3.5.2, и они должны работать для всех версий Python, если это явно не указано перед выводом.
+
+# Применение
+
+Хороший способ получить максимальную пользу от этих примеров - читать их последовательно, причем для каждого из них важно:
+
+- Внимательно изучить исходный код. Если вы опытный Python программист, то в большинстве случаев сможете предугадать, что произойдет дальше.
+- Прочитать фрагменты вывода и,
+ - Проверить, совпадают ли выходные данные с вашими ожиданиями.
+ - Убедиться, что вы знаете точную причину, по которой вывод получился именно таким.
+ - Если ответ отрицательный (что совершенно нормально), сделать глубокий вдох и прочитать объяснение (а если пример все еще непонятен, и создайте [issue](https://github.com/satwikkansal/wtfpython/issues/new)).
+ - Если "да", ощутите мощь своих познаний в Python и переходите к следующему примеру.
+
+# 👀 Примеры
+
+## Раздел: Напряги мозги!
+
+### ▶ Первым делом!
+
+
+
+
+По какой-то причине "моржовый оператор" (англ. 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") # А этот код работает
+'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 # Типичная распаковка
+>>> a, b
+(6, 9)
+>>> (a, b = 16, 19) # Упс
+ File "", line 1
+ (a, b = 16, 19)
+ ^
+SyntaxError: invalid syntax
+
+>>> (a, b := 16, 19) # На выводе получаем странный кортеж из 3 элементов
+(6, 16, 19)
+
+>>> a # Значение переменной остается неизменной?
+6
+
+>>> b
+16
+```
+
+#### 💡 Обьяснение
+
+**Быстрый разбор что такое "моржовый оператор"**
+
+"Моржовый оператор" (`:=`) был представлен в Python 3.8, может быть полезен в ситуациях, когда вы хотите присвоить значения переменным в выражении.
+
+```py
+def some_func():
+ # Предположим, что здесь выполняются требовательные к ресурсам вычисления
+ # time.sleep(1000)
+ return 5
+
+# Поэтому вместо,
+if some_func():
+ print(some_func()) # Плохая практика, поскольку вычисления происходят дважды.
+
+# Или
+a = some_func()
+if a:
+ print(a)
+
+# Можно лаконично написать
+if a := some_func():
+ print(a)
+```
+
+**Вывод (> 3.8):**
+
+```py
+5
+5
+5
+```
+
+Использование `:=` сэкономило одну строку кода и неявно предотвратило вызов `some_func` дважды.
+
+- "выражение присваивания", не обернутое в скобки, иначе говоря использование моржового оператора, ограничено на верхнем уровне, отсюда `SyntaxError` в выражении `a := "wtf_walrus"` в первом фрагменте. После оборачивания в скобки, `a` было присвоено значение, как и ожидалось.
+
+- В то же время оборачивание скобками выражения, содержащего оператор `=`, не допускается. Отсюда синтаксическая ошибка в `(a, b = 6, 9)`.
+
+- Синтаксис моржового оператора имеет вид `NAME:= expr`, где `NAME` - допустимый идентификатор, а `expr` - допустимое выражение. Следовательно, упаковка и распаковка итерируемых объектов не поддерживается, что означает,
+
+ - `(a := 6, 9)` эквивалентно `((a := 6), 9)` и в конечном итоге `(a, 9)` (где значение `a` равно `6`)
+
+ ```py
+ >>> (a := 6, 9) == ((a := 6), 9)
+ True
+ >>> x = (a := 696, 9)
+ >>> x
+ (696, 9)
+ >>> x[0] is a # Оба ссылаются на одну и ту же ячейку памяти
+ True
+ ```
+
+ - Аналогично, `(a, b := 16, 19)` эквивалентно `(a, (b := 16), 19)`, которое есть не что иное, как кортеж из 3 элементов.
+
+---
+
+### ▶ Строки иногда ведут себя непредсказуемо
+
+
+1\.
+
+```py
+>>> a = "some_string"
+>>> id(a)
+140420665652016
+>>> id("some" + "_" + "string") # Обратите внимание, оба идентификатора одинаковы
+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 # Актуально для версий Python, кроме 3.7.x
+True
+
+>>> a = "wtf!"; b = "wtf!"
+>>> a is b # Выражение вернет True или False в зависимости вызываемой среды (python shell / ipython / скрипт).
+False
+```
+
+```py
+# На этот раз в файле
+a = "wtf!"
+b = "wtf!"
+print(a is b)
+
+# Выводит True при запуске модуля
+```
+
+4\.
+
+**Output (< Python3.7 )**
+
+```py
+>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
+True
+>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
+False
+```
+
+Логично, правда?
+
+#### 💡 Объяснение
+
+- Поведение в первом и втором фрагментах связано с оптимизацией CPython (называемой интернированием строк ((англ. string interning))), которая пытается использовать существующие неизменяемые объекты в некоторых случаях вместо того, чтобы каждый раз создавать новый объект.
+- После "интернирования" многие переменные могут ссылаться на один и тот же строковый объект в памяти (тем самым экономя память).
+- В приведенных выше фрагментах строки неявно интернированы. Решение о том, когда неявно интернировать строку, зависит от реализации. Правила для интернирования строк следующие:
+ - Все строки длиной 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 (более подробное обсуждение смотрите [здесь](https://github.com/satwikkansal/wtfpython/issues/100)).
+- Единица компиляции в интерактивной среде IPython состоит из одного оператора, тогда как в случае модулей она состоит из всего модуля. `a, b = "wtf!", "wtf!"` - это одно утверждение, тогда как `a = "wtf!"; b = "wtf!"` - это два утверждения в одной строке. Это объясняет, почему тождества различны в `a = "wtf!"; b = "wtf!"`, но одинаковы при вызове в модуле.
+- Резкое изменение в выводе четвертого фрагмента связано с [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).
+
+---
+
+
+### ▶ Осторожнее с цепочкой операций
+
+```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 и 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)**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+False
+```
+
+#### 💡 Объяснение:
+
+**Разница между `is` и `==`**.
+
+* Оператор `is` проверяет, ссылаются ли оба операнда на один и тот же объект (т.е. проверяет, совпадают ли идентификаторы операндов или нет).
+* Оператор `==` сравнивает значения обоих операндов и проверяет, одинаковы ли они.
+* Таким образом, оператор `is` предназначен для равенства ссылок, а `==` - для равенства значений. Пример, чтобы прояснить ситуацию,
+ ```py
+ >>> class A: pass
+ >>> A() is A() # 2 пустых объекта в разных ячейках памяти
+ False
+ ```
+
+**`256` - существующий объект, а `257` - нет**.
+
+При запуске python числа от `-5` до `256` записываются в память. Эти числа используются часто, поэтому имеет смысл просто иметь их наготове.
+
+Перевод цитаты из [документации](https://docs.python.org/3/c-api/long.html)
+> Текущая реализация хранит массив целочисленных объектов для всех целых чисел от -5 до 256, когда вы создаете int в этом диапазоне, вы просто получаете обратно ссылку на существующий объект.
+
+```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) для получения обновлений.
+
+---
+
+
+### ▶ Мистическое хеширование
+
+1\.
+```py
+some_dict = {}
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
+some_dict[5] = "Python"
+```
+
+**Вывод:**
+
+```py
+>>> some_dict[5.5]
+"JavaScript"
+>>> some_dict[5.0] # "Python" уничтожил "Ruby"?
+"Python"
+>>> some_dict[5]
+"Python"
+
+>>> complex_five = 5 + 0j
+>>> type(complex_five)
+complex
+>>> some_dict[complex_five]
+"Python"
+```
+
+Так почему же Python повсюду?
+
+
+#### 💡 Объяснение
+
+* Уникальность ключей в словаре Python определяется *эквивалентностью*, а не тождеством. Поэтому, даже если `5`, `5.0` и `5 + 0j` являются различными объектами разных типов, поскольку они эквивалентны, они не могут находиться в одном и том же `dict` (или `set`). Как только вы вставите любой из них, попытка поиска по любому другому, но эквивалентному ключу будет успешной с исходным сопоставленным значением (а не завершится ошибкой `KeyError`):
+ ```py
+ >>> 5 == 5.0 == 5 + 0j
+ True
+ >>> 5 is not 5.0 is not 5 + 0j
+ True
+ >>> some_dict = {}
+ >>> some_dict[5.0] = "Ruby"
+ >>> 5.0 in some_dict
+ True
+ >>> (5 in some_dict) and (5 + 0j in some_dict)
+ True
+ ```
+* Это применимо и во время присваивания значения элементу. Поэтому, в выражении `some_dict[5] = "Python"` Python находит существующий элемент с эквивалентным ключом `5.0 -> "Ruby"`, перезаписывает его значение на место, а исходный ключ оставляет в покое.
+ ```py
+ >>> some_dict
+ {5.0: 'Ruby'}
+ >>> some_dict[5] = "Python"
+ >>> some_dict
+ {5.0: 'Python'}
+ ```
+* Итак, как мы можем обновить ключ до `5` (вместо `5.0`)? На самом деле мы не можем сделать это обновление на месте, но все же это возможно, нужно сначала удалить ключ (`del some_dict[5.0]`), а затем установить его (`some_dict[5]`), чтобы получить целое число `5` в качестве ключа вместо плавающего `5.0`, хотя это нужно в редких случаях.
+
+* Как Python нашел `5` в словаре, содержащем `5.0`? Python делает это за постоянное время без необходимости сканирования каждого элемента, используя хэш-функции. Когда Python ищет ключ `foo` в словаре, он сначала вычисляет `hash(foo)` (что выполняется в постоянном времени). Поскольку в Python требуется, чтобы объекты, которые одинаковы в сравнении, имели одинаковое хэш-значение (смотри [документацию](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() # разные экземпляры класса не могут быть равны
+False
+>>> WTF() is WTF() # идентификаторы также различаются
+False
+>>> hash(WTF()) == hash(WTF()) # хеши тоже должны отличаться
+True
+>>> id(WTF()) == id(WTF())
+True
+```
+#### 💡 Объяснение:
+
+* При вызове `id` Python создал объект класса `WTF` и передал его функции `id`. Функция `id` забирает свой `id` (расположение в памяти) и выбрасывает объект. Объект уничтожается.
+* Когда мы делаем это дважды подряд, Python выделяет ту же самую область памяти и для второго объекта. Поскольку (в CPython) `id` использует участок памяти в качестве идентификатора объекта, идентификатор двух объектов одинаков.
+* Таким образом, id объекта уникален только во время жизни объекта. После уничтожения объекта или до его создания, другой объект может иметь такой же id.
+* Но почему выражение с оператором `is` равно `False`? Давайте посмотрим с помощью этого фрагмента.
+ ```py
+ class WTF(object):
+ def __init__(self): print("I")
+ def __del__(self): print("D")
+ ```
+
+ **Вывод:**
+ ```py
+ >>> WTF() is WTF()
+ I
+ I
+ D
+ D
+ False
+ >>> id(WTF()) == id(WTF())
+ I
+ D
+ I
+ D
+ True
+ ```
+ Как вы можете заметить, все дело в порядке уничтожения объектов.
+
+---
+
+
+### ▶ Беспорядок внутри порядка *
+
+```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__.
+ """
+ __hash__ = lambda self: 0
+
+class OrderedDictWithHash(OrderedDict):
+ """
+ OrderedDict с реализованным методом __hash__.
+ """
+ __hash__ = lambda self: 0
+```
+
+**Вывод**
+```py
+>>> dictionary == ordered_dict # a == b
+True
+>>> dictionary == another_ordered_dict # b == c
+True
+>>> ordered_dict == another_ordered_dict # почему же c != a ??
+False
+
+# Мы все знаем, что множество состоит из уникальных элементов,
+# давайте попробуем составить множество из этих словарей и посмотрим, что получится...
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "", 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}) # изменим порядок элементов
+2
+```
+
+Что здесь происходит?
+
+#### 💡 Объяснение:
+
+- Переходное (интранзитивное) равенство между `dictionary`, `ordered_dict` и `another_ordered_dict` не выполняется из-за реализации магического метода `__eq__` в классе `OrderedDict`. Перевод цитаты из [документации](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) # используем объекты из фрагмента кода выше
+ >>> 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`.
+
+---
+
+
+### ▶ Продолжай пытаться... *
+
+```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(): # Попался!
+ try:
+ for i in range(3):
+ try:
+ 1 / i
+ except ZeroDivisionError:
+ # Вызовем исключение и обработаем его за пределами цикла
+ raise ZeroDivisionError("A trivial divide by zero error")
+ finally:
+ print("Iteration", i)
+ break
+ except ZeroDivisionError as e:
+ print("Zero division error occurred", e)
+```
+
+**Результат:**
+
+```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 # Словарь с индексами
+{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]
+# Типичный генератор
+gen = (x for x in array if array.count(x) > 0)
+array = [2, 8, 22]
+```
+
+**Вывод:**
+
+```py
+>>> print(list(gen)) # Куда подевались остальные значения?
+[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]
+```
+
+#### 💡 Объяснение
+
+- В выражении [генераторе](https://wiki.python.org/moin/Generators) условие `in` оценивается во время объявления, но условие `if` оценивается во время выполнения.
+- Перед выполнением кода, значение переменной `array` изменяется на список `[2, 8, 22]`, а поскольку из `1`, `8` и `15` только счетчик `8` больше `0`, генератор выдает только `8`.
+- Различия в выводе `g1` и `g2` во второй части связаны с тем, как переменным `array_1` и `array_2` присваиваются новые значения.
+ - В первом случае `array_1` привязывается к новому объекту `[1,2,3,4,5]`, а поскольку `in` выражение исполняется во время объявления, оно по-прежнему ссылается на старый объект `[1,2,3,4]` (который не уничтожается).
+ - Во втором случае присвоение среза `array_2` обновляет тот же старый объект `[1,2,3,4]` до `[1,2,3,4,5]`. Следовательно, и `g2`, и `array_2` по-прежнему имеют ссылку на один и тот же объект (который теперь обновлен до `[1,2,3,4,5]`).
+- Хорошо, следуя приведенной выше логике, не должно ли значение `list(gen)` в третьем фрагменте быть `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (потому что `array_3` и `array_4` будут вести себя так же, как `array_1`). Причина, по которой (только) значения `array_4` обновляются, объясняется в [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)
+
+ > Только крайнее for-выражение исполняется немедленно, остальные выражения откладываются до запуска генератора.
+
+---
+
+
+### ▶ `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
+# Инициализируем переменную row
+row = [""] * 3 #row i['', '', '']
+# Инициализируем игровую сетку
+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`)
+
+
+ 
+ 
+ 
+ ![\"\"](\"https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images/logo.png\"){kind=logo}
![\"wtfpython](\"https://raw.githubusercontent.com/satwikkansal/wtfpython/refs/heads/master/images/logo.svg\"){kind=logo}
\n",
"![\"Shows](\"https://raw.githubusercontent.com/satwikkansal/wtfpython/refs/heads/master/images/string-intern/string_interning.svg\")
\n",
+ "+ 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).\n",
"+ 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`\n",
- "+ 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 20. (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.\n",
- "+ 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 third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n",
+ "+ 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.\n",
+ "+ 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). \n",
"\n"
]
},
@@ -367,262 +358,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### \u25b6 Hash brownies\n",
- "1\\.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict = {}\n",
- "some_dict[5.5] = \"JavaScript\"\n",
- "some_dict[5.0] = \"Ruby\"\n",
- "some_dict[5] = \"Python\"\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n",
- "\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"JavaScript\"\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[5.5]\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"Python\"\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[5.0] # \"Python\" destroyed the existence of \"Ruby\"?\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"Python\"\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[5] \n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "complex\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "complex_five = 5 + 0j\n",
- "type(complex_five)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "\"Python\"\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "some_dict[complex_five]\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "So, why is Python all over the place?\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "#### \ud83d\udca1 Explanation\n",
- "\n",
- "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n",
- "* Immutable objects with the same value always have the same hash in Python.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " 5 == 5.0 == 5 + 0j\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- " True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " hash(5) == hash(5.0) == hash(5 + 0j)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- " **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n",
- "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n",
- "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Deep down, we're all the same.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "class WTF:\n",
- " pass\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output:**\n"
+ "### \u25b6 Be careful with chained operations\n"
]
},
{
@@ -644,7 +380,7 @@
}
],
"source": [
- "WTF() == WTF() # two different instances can't be equal\n"
+ "(False == False) in [False] # makes sense\n"
]
},
{
@@ -666,7 +402,75 @@
}
],
"source": [
- "WTF() is WTF() # identities are also different\n"
+ "False == (False in [False]) # makes sense\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "False == False in [False] # now what?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "True is False == False\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "False is False is False\n"
]
},
{
@@ -688,7 +492,7 @@
}
],
"source": [
- "hash(WTF()) == hash(WTF()) # hashes _should_ be different as well\n"
+ "1 > 0 < 1\n"
]
},
{
@@ -701,7 +505,7 @@
{
"data": {
"text/plain": [
- "True\n"
+ "False\n"
]
},
"output_type": "execute_result",
@@ -710,7 +514,29 @@
}
],
"source": [
- "id(WTF()) == id(WTF())\n"
+ "(1 > 0) < 1\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "1 > (0 < 1)\n"
]
},
{
@@ -726,40 +552,16 @@
"source": [
"#### \ud83d\udca1 Explanation:\n",
"\n",
- "* 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.\n",
- "* 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.\n",
- "* 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.\n",
- "* But why did the `is` operator evaluated to `False`? Let's see with this snippet.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- " class WTF(object):\n",
- " def __init__(self): print(\"I\")\n",
- " def __del__(self): print(\"D\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
+ "As per https://docs.python.org/3/reference/expressions.html#membership-test-operations\n",
"\n",
- " **Output:**\n"
+ "> 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.\n",
+ "\n",
+ "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`.\n",
+ "\n",
+ "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n",
+ "* `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`.\n",
+ "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n",
+ "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"
]
},
{
@@ -772,11 +574,7 @@
{
"data": {
"text/plain": [
- " I\n",
- " I\n",
- " D\n",
- " D\n",
- " False\n"
+ " 1\n"
]
},
"output_type": "execute_result",
@@ -785,7 +583,7 @@
}
],
"source": [
- " WTF() is WTF()\n"
+ " int(True)\n"
]
},
{
@@ -798,11 +596,7 @@
{
"data": {
"text/plain": [
- " I\n",
- " D\n",
- " I\n",
- " D\n",
- " True\n"
+ " 2\n"
]
},
"output_type": "execute_result",
@@ -811,989 +605,14 @@
}
],
"source": [
- " id(WTF()) == id(WTF())\n"
+ " True + 1 #not relevant for this example, but just for fun\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- " As you may observe, the order in which the objects are destroyed is what made all the difference here.\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### \u25b6 Disorder within order *\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": []
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "from collections import OrderedDict\n",
- "\n",
- "dictionary = dict()\n",
- "dictionary[1] = 'a'; dictionary[2] = 'b';\n",
- "\n",
- "ordered_dict = OrderedDict()\n",
- "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n",
- "\n",
- "another_ordered_dict = OrderedDict()\n",
- "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n",
- "\n",
- "class DictWithHash(dict):\n",
- " \"\"\"\n",
- " A dict that also implements __hash__ magic.\n",
- " \"\"\"\n",
- " __hash__ = lambda self: 0\n",
- "\n",
- "class OrderedDictWithHash(OrderedDict):\n",
- " \"\"\"\n",
- " An OrderedDict that also implements __hash__ magic.\n",
- " \"\"\"\n",
- " __hash__ = lambda self: 0\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "**Output**\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "dictionary == ordered_dict # If a == b\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "True\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "dictionary == another_ordered_dict # and b == c\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "False\n",
- "\n",
- "# We all know that a set consists of only unique elements,\n",
- "# let's try making a set of these dictionaries and see what happens...\n",
- "\n"
- ]
- },
- "output_type": "execute_result",
- "metadata": {},
- "execution_count": null
- }
- ],
- "source": [
- "ordered_dict == another_ordered_dict # the why isn't c == a ??\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "Traceback (most recent call last):\n",
- " File \"![\"Shows](\"https://raw.githubusercontent.com/satwikkansal/wtfpython/refs/heads/master/images/tic-tac-toe/after_row_initialized.svg\")
\n",
"\n",
"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`)\n",
"\n",
- "\n",
+ "![\"Shows](\"https://raw.githubusercontent.com/satwikkansal/wtfpython/refs/heads/master/images/tic-tac-toe/after_board_initialized.svg\")
\n",
"\n",
"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).\n",
"\n"
@@ -2581,9 +2983,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### \u25b6 The sticky output function\n",
- "1\\.\n",
- "\n"
+ "### \u25b6 Schr\u00f6dinger's variable *\n"
]
},
{
@@ -2619,8 +3019,7 @@
"metadata": {},
"source": [
"\n",
- "**Output:**\n",
- "\n"
+ "**Output (Python version):**\n"
]
},
{
@@ -2671,9 +3070,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n",
"\n",
- "2\\.\n",
+ "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.\n",
+ "\n",
+ "2.\n",
"\n"
]
},
@@ -2711,11 +3111,70 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### \ud83d\udca1 Explanation\n",
+ "#### \ud83d\udca1 Explanation:\n",
+ "* 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:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "import inspect\n",
+ "inspect.getclosurevals(funcs[0])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Since `x` is a global value, we can change the value that the `funcs` will lookup and return by updating `x`:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[42, 42, 42, 42, 42, 42, 42]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "x = 42\n",
+ "[func() for func in funcs]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"\n",
- "- 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. So all of the functions use the latest value assigned to the variable for computation.\n",
- "\n",
- "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n",
+ "* 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.\n",
"\n"
]
},
@@ -2736,11 +3195,11 @@
}
],
"source": [
- " funcs = []\n",
- " for x in range(7):\n",
- " def some_func(x=x):\n",
- " return x\n",
- " funcs.append(some_func)\n"
+ "funcs = []\n",
+ "for x in range(7):\n",
+ " def some_func(x=x):\n",
+ " return x\n",
+ " funcs.append(some_func)\n"
]
},
{
@@ -2748,7 +3207,8 @@
"metadata": {},
"source": [
"\n",
- " **Output:**\n"
+ "**Output:**\n",
+ "\n"
]
},
{
@@ -2761,7 +3221,7 @@
{
"data": {
"text/plain": [
- " [0, 1, 2, 3, 4, 5, 6]\n"
+ "[0, 1, 2, 3, 4, 5, 6]\n"
]
},
"output_type": "execute_result",
@@ -2770,8 +3230,39 @@
}
],
"source": [
- " funcs_results = [func() for func in funcs]\n",
- " funcs_results\n"
+ "funcs_results = [func() for func in funcs]\n",
+ "funcs_results\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "It is not longer using the `x` in the global scope:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "inspect.getclosurevars(funcs[0])\n"
]
},
{
@@ -3129,6 +3620,481 @@
"\n"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Methods equality and identity\n",
+ "1.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "class SomeClass:\n",
+ " def method(self):\n",
+ " pass\n",
+ "\n",
+ " @classmethod\n",
+ " def classm(cls):\n",
+ " pass\n",
+ "\n",
+ " @staticmethod\n",
+ " def staticm():\n",
+ " pass\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.method is SomeClass.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.classm is SomeClass.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.classm == SomeClass.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(SomeClass.staticm is SomeClass.staticm)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens\n",
+ "with instances of `SomeClass`:\n",
+ "\n",
+ "2.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "o1 = SomeClass()\n",
+ "o2 = SomeClass()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.method == o2.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.method == o1.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.method is o1.method)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.classm is o1.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.classm == o1.classm == o2.classm == SomeClass.classm)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Accessing` classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "* Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an\n",
+ "attribute, the descriptor is invoked, creating a method object which \"binds\" the function with the object owning the\n",
+ "attribute. If called, the method calls the function, implicitly passing the bound object as the first argument\n",
+ "(this is how we get `self` as the first argument, despite not passing it explicitly).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "
-+ 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 compiler optimization and specifically applies to the interactive environment.
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (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.
-
-
----
-
-### ▶ Time for some hash brownies!
-
-1\.
-```py
-some_dict = {}
-some_dict[5.5] = "Ruby"
-some_dict[5.0] = "JavaScript"
-some_dict[5] = "Python"
-```
-
-**Output:**
-```py
->>> some_dict[5.5]
-"Ruby"
->>> some_dict[5.0]
-"Python"
->>> some_dict[5]
-"Python"
-```
-
-"Python" destroyed the existence of "JavaScript"?
-
-#### 💡 Explanation
-
-* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.
-* Immutable objects with same value always have the same hash in Python.
- ```py
- >>> 5 == 5.0
- True
- >>> hash(5) == hash(5.0)
- True
- ```
- **Note:** Objects with different values may also have same hash (known as hash collision).
-* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
-* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
-
----
-
-### ▶ Return return everywhere!
-
-```py
-def some_func():
- try:
- return 'from_try'
- finally:
- return 'from_finally'
-```
-
-**Output:**
-```py
->>> some_func()
-'from_finally'
-```
-
-#### 💡 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.
-
----
-
-### ▶ 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, 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 evaluated 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.
-
----
-
-### ▶ For what?
-
-```py
-some_string = "wtf"
-some_dict = {}
-for i, some_dict[i] in enumerate(some_string):
- pass
-```
-
-**Output:**
-```py
->>> some_dict # An indexed dict is created.
-{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)` 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]
-g = (x for x in array if array.count(x) > 0)
-array = [2, 8, 22]
-```
-
-**Output:**
-```py
->>> print(list(g))
-[8]
-```
-
-2\.
-
-```py
-array_1 = [1,2,3,4]
-g1 = (x for x in array_1)
-array_1 = [1,2,3,4,5]
-
-array_2 = [1,2,3,4]
-g2 = (x for x in array_2)
-array_2[:] = [1,2,3,4,5]
-```
-
-**Output:**
-```py
->>> print(list(g1))
-[1,2,3,4]
-
->>> print(list(g2))
-[1,2,3,4,5]
-```
-
-#### 💡 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 binded 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]`).
-
----
-
-### ▶ `is` is not what it is!
-
-The following is a very famous example present all over the internet.
-
-```py
->>> a = 256
->>> b = 256
->>> a is b
-True
-
->>> a = 257
->>> b = 257
->>> a is b
-False
-
->>> a = 257; b = 257
->>> a is b
-True
-```
-
-#### 💡 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
- >>> [] == []
- True
- >>> [] is [] # These are two empty lists 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.
-
-**Both `a` and `b` refer to the same object when initialized with same value in the same line.**
-
-```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.
-
----
-
-### ▶ 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 3 "X"s or 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', '', ''], ['', '', ''], ['', '', '']]
-```
-
----
-
-### ▶ The sticky output function
-
-```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:**
-```py
->>> results
-[0, 1, 2, 3, 4, 5, 6]
->>> funcs_results
-[6, 6, 6, 6, 6, 6, 6]
-```
-Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.
-
-//OR
-
-```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. So all of the functions use the latest value assigned to the variable for computation.
-
-- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.
-
- ```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]
- ```
-
----
-
-### ▶ `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.
-
----
-
-### ▶ The surprising comma
-
-**Output:**
-```py
->>> def f(x, y,):
-... print(x, y)
-...
->>> def g(x=4, y=5,):
-... print(x, y)
-...
->>> def h(x, **kwargs,):
- File "