diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md
new file mode 100644
index 00000000..2cfa7778
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.md
@@ -0,0 +1,25 @@
+---
+name: Bug report
+about: Report a problem and provide necessary context
+title: 'Fix ...'
+labels: 'bug'
+
+---
+
+
+## What's wrong
+
+
+
+## How it should work?
+
+
+
+## Checklist before calling for maintainers
+
+* [ ] Have you checked to ensure there aren't other open [Issues](../issues) for the same problem?
+
diff --git a/.github/ISSUE_TEMPLATE/new_snippet.md b/.github/ISSUE_TEMPLATE/new_snippet.md
new file mode 100644
index 00000000..6bb19dc9
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/new_snippet.md
@@ -0,0 +1,23 @@
+---
+name: New snippet
+about: Suggest new gotcha and try to explain it
+title: 'New snippet: ...'
+labels: 'new snippets'
+---
+
+
+## Description
+
+## Snippet preview
+
+## Checklist before calling for maintainers
+
+* [ ] Have you checked to ensure there aren't other open [Issues](../issues) for the same update/change?
+* [ ] Have you checked that this snippet is not similar to any of the existing snippets?
+
+* [ ] Have you added an `Explanation` section? It shall include the reasons for changes and why you'd like us to include them
+
diff --git a/.github/ISSUE_TEMPLATE/translation.md b/.github/ISSUE_TEMPLATE/translation.md
new file mode 100644
index 00000000..37ea4c3a
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/translation.md
@@ -0,0 +1,13 @@
+---
+name: Translation
+about: Request a new traslation and start working on it (if possible)
+title: 'Translate to ...'
+labels: 'translations'
+
+---
+
+
+## Checklist before calling for maintainers
+
+* [ ] Have you checked to ensure there aren't other open [Issues](../issues) for the same translation?
+* [ ] Do you wish to make a translation by yourself?
diff --git a/.github/PULL_REQUEST_TEMPLATE/common.md b/.github/PULL_REQUEST_TEMPLATE/common.md
new file mode 100644
index 00000000..ab9f34ad
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE/common.md
@@ -0,0 +1,13 @@
+## #(issue number): Summarize your changes
+
+
+
+Closes # (issue number)
+
+## Checklist before requesting a review
+
+- [ ] Have you followed the guidelines in [CONTRIBUTING.md](../CONTRIBUTING.md)?
+- [ ] Have you performed a self-review?
+- [ ] Have you added yourself into [CONTRIBUTORS.md](../CONTRIBUTORS.md)?
+
diff --git a/.github/PULL_REQUEST_TEMPLATE/new_snippet.md b/.github/PULL_REQUEST_TEMPLATE/new_snippet.md
new file mode 100644
index 00000000..dab5816f
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE/new_snippet.md
@@ -0,0 +1,15 @@
+## #(issue number): Summarize your changes
+
+
+
+Closes # (issue number)
+
+## Checklist before requesting a review
+
+- [ ] Have you written simple and understandable explanation?
+- [ ] Have you added new snippet into `snippets/` with suitable name and number?
+- [ ] Have you updated Table of content? (later will be done by pre-commit)
+- [ ] Have you followed the guidelines in [CONTRIBUTING.md](../CONTRIBUTING.md)?
+- [ ] Have you performed a self-review?
+- [ ] Have you added yourself into [CONTRIBUTORS.md](../CONTRIBUTORS.md)?
diff --git a/.github/PULL_REQUEST_TEMPLATE/translation.md b/.github/PULL_REQUEST_TEMPLATE/translation.md
new file mode 100644
index 00000000..74f88005
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE/translation.md
@@ -0,0 +1,13 @@
+## #(issue number): Translate to ...
+
+
+
+Closes # (issue number)
+
+## Checklist before requesting a review
+
+- [ ] Have you fetched the latest `master` branch?
+- [ ] Have you translated all snippets?
+- [ ] Have you followed the guidelines in [CONTRIBUTING.md](../CONTRIBUTING.md)?
+- [ ] Have you performed a self-review?
+- [ ] Have you added yourself into [CONTRIBUTORS.md](../CONTRIBUTORS.md)?
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
new file mode 100644
index 00000000..8356b6f8
--- /dev/null
+++ b/.github/workflows/pr.yml
@@ -0,0 +1,28 @@
+on: [pull_request]
+
+permissions:
+ contents: read
+ pull-requests: read
+ checks: write
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ lint:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Write git diff to temp file
+ run: |
+ git fetch origin
+ git diff origin/${{ github.base_ref }} *.md translations/*/*.md \
+ | sed -n '/^+/p' | sed '/^+++/d' | sed 's/^+//' \
+ > ${{ runner.temp }}/diff.md
+ - name: Output diff
+ run: cat ${{ runner.temp }}/diff.md
+ - name: Check diff with markdownlint
+ uses: DavidAnson/markdownlint-cli2-action@v17
+ with:
+ globs: "${{ runner.temp }}/diff.md"
diff --git a/.gitignore b/.gitignore
index 523a028e..7a88626b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,20 @@
+.DS_Store
+
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__/
*.py[cod]
*$py.class
+
+irrelevant/.ipynb_checkpoints/
+
+irrelevant/.python-version
+
+.idea/
+.vscode/
+
+# Virtual envitonments
+venv/
+.venv/
diff --git a/.markdownlint.yaml b/.markdownlint.yaml
new file mode 100644
index 00000000..09e4e924
--- /dev/null
+++ b/.markdownlint.yaml
@@ -0,0 +1,17 @@
+MD013:
+ line_length: 120
+
+# no-duplicate-heading - Multiple headings with the same content (Ignore multiple `Explanation` headings)
+MD024: false
+
+# no-trailing-punctuation - Trailing punctuation in heading (Ignore exclamation marks in headings)
+MD026: false
+
+# no-inline-html : Inline HTML (HTML is used for centered and theme specific images)
+MD033: false
+
+# no-inline-html : Bare URL used (site should be attributed transparently, because otherwise we have to un-necesarily explain where the link directs)
+MD034: false
+
+# first-line-h1 : First line in a file should be a top-level heading (Ignore because diff file will never have valid heading)
+MD041: false
diff --git a/.npmignore b/.npmignore
deleted file mode 100644
index 9b7aaab0..00000000
--- a/.npmignore
+++ /dev/null
@@ -1 +0,0 @@
-irrelevant/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..8c241c39
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,7 @@
+default_language_version:
+ python: python3.12
+repos:
+- repo: https://github.com/DavidAnson/markdownlint-cli2
+ rev: v0.17.0
+ hooks:
+ - id: markdownlint-cli2
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..8d2ea6bb
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,3 @@
+language: python
+install: pip install flake8
+script: flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b003fbed..771ece8a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,12 +1,19 @@
-All kinds of patches are welcome. Feel free to even suggest some catchy and funny titles for the existing Examples. The goal is to make this collection as interesting to read as possible.
+# Contributing
-If you are interested in translating the project to another language (some people have done that in the past), please feel free to open up an issue or ping on the [gitter channel](https://gitter.im/wtfpython/Lobby) if you need any kind of help.
+## Getting Started
-If the changes you suggest are siginificant, filing an issue before submitting the actual patch will be appreciated. If you'd like to work on the issue (highly encouraged), you can mention that you're interested in working on it while creating the issue and get assigned to it.
+Contributions are made to this repo via Issues and Pull Requests (PRs). A few general guidelines that cover both:
-If you're adding a new example, please do create an issue to discuss it before submitting a patch.
+- Search for existing Issues and PRs before creating your own.
+- We work hard to makes sure issues are handled in a timely manner but, depending on the impact, it could take a while to investigate the root cause. A friendly ping in the comment thread to the submitter or a contributor can help draw attention if your issue is blocking.
-You can use the following template for adding a new example:
+## Issues
+
+All kinds of patches are welcome. Feel free to even suggest some catchy and funny titles for the existing Examples. The goal is to make this collection as interesting to read as possible. Here are a few ways through which you can contribute,
+
+- If you are interested in translating the project to another language, please feel free to open up an issue using `translation` template, and let me know if you need any kind of help.
+- If the changes you suggest are significant, filing an issue before submitting the actual patch will be appreciated. If you'd like to work on the issue (highly encouraged), you can mention that you're interested in working on it while creating the issue and get assigned to it.
+- If you're adding a new example, it is highly recommended to create an issue using `new_snippet` template to discuss it before submitting a patch. You can use the following template for adding a new example:
### ▶ Some fancy Title *
@@ -29,10 +36,30 @@ Probably unexpected output
```py
Setting up examples for clarification (if necessary)
```
- **Outupt:**
+ **Output:**
```py
>>> trigger # some example that makes it easy to unveil the magic
# some justified output
```
```
+
+## Pull requests
+
+- 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).
+
+## Common questions
+
+- 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 neither `-i` nor `--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)?
+ - `markdown-toc` will be replaced in the near future, follow the [issue](https://github.com/satwikkansal/wtfpython/issues/351) to check the progress.
+ - 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 58978539..40526d90 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,13 +1,42 @@
-I'm really greatful to all the contributors. Following are the wonderful people (in no specific order) who have contributed their examples to wtfpython.
+Following are the wonderful people (in no specific order) who have contributed their examples to wtfpython.
| Contributor | 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) |
-
-Thank you all for taking out time, and helping to make this project awesome! :smile:
+| 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) |
+
+---
+
+**Translations**
+
+| Translator | Github | Language |
+|-------------|--------|--------|
+| 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:
+
+PS: This list is updated after every major release, if I forgot to add your contribution here, please feel free to raise a Pull request.
diff --git a/README.md b/README.md
index 5ca25a3d..e4afe016 100644
--- a/README.md
+++ b/README.md
@@ -1,392 +1,458 @@
-
- What the f*ck Python! 🐍
- An interesting collection of surprising snippets and lesser-known Python features.
-
-[![WTFPL 2.0][license-image]][license-url]
-
-
-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 to a regular user at first sight.
-
-Here is a fun project to collect such tricky & counter-intuitive examples and lesser-known features in Python, attempting to discuss what exactly is happening under the hood!
-
-While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I think you'll find them interesting as well!
-
-If you're an experienced Python programmer, you can take it as a challenge to get most of them right in first attempt. You may be already familiar with some of these examples, and I might be able to revive sweet old memories of yours being bitten by these gotchas :sweat_smile:
-
-If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).
+
+
+
+
+
+
+
+What the f*ck Python! 😱
+Exploring and understanding Python through surprising snippets.
+
+Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) |
+[Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) |
+[Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) |
+[Korean 한국어](https://github.com/buttercrab/wtfpython-ko) |
+[Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) |
+[German Deutsch](https://github.com/BenSt099/wtfpython) |
+[Persian فارسی](https://github.com/satwikkansal/wtfpython/tree/master/translations/fa-farsi) |
+[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.
+
+Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets
+and lesser-known features in Python.
+
+While some of the examples you see below may not be WTFs in the truest sense,
+but they'll reveal some of the interesting parts of Python that you might be unaware of.
+I find it a nice way to learn the internals of a programming language, and I believe that you'll find it interesting too!
+
+If you're an experienced Python programmer, you can take it as a challenge to get most of them right in the first attempt
+You may have already experienced some of them before, and I might be able to revive sweet old memories of yours! :sweat_smile:
+
+PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/)
+(the examples marked with asterisk are the ones added in the latest major revision).
So, here we go...
# Table of Contents
-
-
+
+
- [Structure of the Examples](#structure-of-the-examples)
+ - [▶ Some fancy Title](#-some-fancy-title)
- [Usage](#usage)
- [👀 Examples](#-examples)
- [Section: Strain your brain!](#section-strain-your-brain)
- - [▶ Strings can be tricky sometimes *](#-strings-can-be-tricky-sometimes-)
- - [▶ Time for some hash brownies!](#-time-for-some-hash-brownies)
- - [▶ Return return everywhere!](#-return-return-everywhere)
- - [▶ Deep down, we're all the same. *](#-deep-down-were-all-the-same-)
+ - [▶ First things first! \*](#-first-things-first-)
+ - [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
+ - [▶ Be careful with chained operations](#-be-careful-with-chained-operations)
+ - [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
+ - [▶ Hash brownies](#-hash-brownies)
+ - [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)
+ - [▶ Disorder within order \*](#-disorder-within-order-)
+ - [▶ Keep trying... \*](#-keep-trying-)
- [▶ For what?](#-for-what)
- [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
- - [▶ `is` is not what it is!](#-is-is-not-what-it-is)
- - [▶ 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)
- [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+ - [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+ - [▶ Schrödinger's variable](#-schrödingers-variable-)
+ - [▶ The chicken-egg problem \*](#-the-chicken-egg-problem-)
+ - [▶ Subclass relationships](#-subclass-relationships)
+ - [▶ Methods equality and identity](#-methods-equality-and-identity)
+ - [▶ All-true-ation \*](#-all-true-ation-)
- [▶ The surprising comma](#-the-surprising-comma)
- - [▶ Backslashes at the end of string](#-backslashes-at-the-end-of-string)
+ - [▶ Strings and the backslashes](#-strings-and-the-backslashes)
- [▶ not knot!](#-not-knot)
- [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
- - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)
- [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)
- [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes)
- [▶ yielding None](#-yielding-none)
+ - [▶ Yielding from... return! \*](#-yielding-from-return-)
+ - [▶ Nan-reflexivity \*](#-nan-reflexivity-)
- [▶ Mutating the immutable!](#-mutating-the-immutable)
- [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)
- - [▶ When True is actually False](#-when-true-is-actually-false)
- - [▶ From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction)
- - [▶ Subclass relationships *](#-subclass-relationships-)
- - [▶ The mysterious key type conversion *](#-the-mysterious-key-type-conversion-)
+ - [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion)
- [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this)
- - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
- - [▶ Skipping lines?](#-skipping-lines)
- - [▶ Teleportation *](#-teleportation-)
- - [▶ Well, something is fishy...](#-well-something-is-fishy)
- - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines)
+ - [▶ 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` operator *](#-stubborn-del-operator-)
+ - [▶ Stubborn `del` operation](#-stubborn-del-operation)
+ - [▶ The out of scope variable](#-the-out-of-scope-variable)
- [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)
+ - [▶ Lossy zip of iterators \*](#-lossy-zip-of-iterators-)
- [▶ Loop variables leaking out!](#-loop-variables-leaking-out)
- [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)
- [▶ Catching the Exceptions](#-catching-the-exceptions)
- [▶ Same operands, different story!](#-same-operands-different-story)
- - [▶ The out of scope variable](#-the-out-of-scope-variable)
- - [▶ Be careful with chained operations](#-be-careful-with-chained-operations)
- [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope)
- - [▶ Needle in a Haystack](#-needle-in-a-haystack)
+ - [▶ Rounding like a banker \*](#-rounding-like-a-banker-)
+ - [▶ Needles in a Haystack \*](#-needles-in-a-haystack-)
+ - [▶ Splitsies \*](#-splitsies-)
+ - [▶ Wild imports \*](#-wild-imports-)
+ - [▶ All sorted? \*](#-all-sorted-)
+ - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)
- [Section: The Hidden treasures!](#section-the-hidden-treasures)
- - [▶ Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-)
- - [▶ `goto`, but why? *](#-goto-but-why-)
- - [▶ Brace yourself! *](#-brace-yourself-)
- - [▶ Let's meet Friendly Language Uncle For Life *](#-lets-meet-friendly-language-uncle-for-life-)
- - [▶ Even Python understands that love is complicated *](#-even-python-understands-that-love-is-complicated-)
+ - [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
+ - [▶ `goto`, but why?](#-goto-but-why)
+ - [▶ Brace yourself!](#-brace-yourself)
+ - [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
+ - [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
- [▶ Yes, it exists!](#-yes-it-exists)
- - [▶ Inpinity *](#-inpinity-)
- - [▶ Mangling time! *](#-mangling-time-)
- - [Section: Miscallaneous](#section-miscallaneous)
+ - [▶ Ellipsis \*](#-ellipsis-)
+ - [▶ Inpinity](#-inpinity)
+ - [▶ Let's mangle](#-lets-mangle)
+ - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
+ - [▶ Skipping lines?](#-skipping-lines)
+ - [▶ Teleportation](#-teleportation)
+ - [▶ Well, something is fishy...](#-well-something-is-fishy)
+ - [Section: Miscellaneous](#section-miscellaneous)
- [▶ `+=` is faster](#--is-faster)
- [▶ Let's make a giant string!](#-lets-make-a-giant-string)
- - [▶ Explicit typecast of strings](#-explicit-typecast-of-strings)
- - [▶ Minor Ones](#-minor-ones)
+ - [▶ Slowing down `dict` lookups \*](#-slowing-down-dict-lookups-)
+ - [▶ Bloating instance `dict`s \*](#-bloating-instance-dicts-)
+ - [▶ Minor Ones \*](#-minor-ones-)
- [Contributing](#contributing)
- [Acknowledgements](#acknowledgements)
- [🎓 License](#-license)
- - [Help](#help)
- - [Want to share wtfpython with friends?](#want-to-share-wtfpython-with-friends)
- - [Need a pdf version?](#need-a-pdf-version)
+ - [Surprise your friends as well!](#surprise-your-friends-as-well)
+ - [More content like this?](#more-content-like-this)
-
+
# Structure of the Examples
All the examples are structured like below:
-> ### ▶ Some fancy Title *
-> The asterisk at the end of the title indicates the example was not present in the first release and has been recently added.
->
+> ## Section: (if necessary)
+>
+> ### ▶ Some fancy Title
+>
> ```py
-> # Setting up the code.
+> # Set up the code.
> # Preparation for the magic...
> ```
->
-> **Output (Python version):**
+>
+> **Output (Python version(s)):**
+>
> ```py
> >>> triggering_statement
-> Probably unexpected output
+> Some unexpected output
> ```
+>
> (Optional): One line describing the unexpected output.
->
->
+>
> #### 💡 Explanation:
->
-> * Brief explanation of what's happening and why is it happening.
-> ```py
-> Setting up examples for clarification (if necessary)
-> ```
-> **Output:**
-> ```py
-> >>> trigger # some example that makes it easy to unveil the magic
-> # some justified output
-> ```
-
-**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified in the description.
+>
+> - Brief explanation of what's happening and why is it happening.
+>
+> ```py
+> # Set up code
+> # More examples for further clarification (if necessary)
+> ```
+>
+> **Output (Python version(s)):**
+>
+> ```py
+> >>> trigger # some example that makes it easy to unveil the magic
+> # some justified output
+> ```
+
+**Note:** All the examples are tested on Python 3.5.2 interactive interpreter,
+and they should work for all the Python versions unless explicitly specified before the output.
# Usage
-A nice way to get the most out of these examples, in my opinion, will be just to read the examples chronologically, and for every example:
-- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, most of the times you will successfully anticipate what's going to happen next.
+A nice way to get the most out of these examples, in my opinion, is to read them in sequential order, and for every example:
+
+- Carefully read the initial code for setting up the example.
+ If you're an experienced Python programmer, you'll successfully anticipate what's going to happen next most of the time.
- Read the output snippets and,
- + Check if the outputs are the same as you'd expect.
- + Make sure if you know the exact reason behind the output being the way it is.
- - If no, 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)).
+ - Check if the outputs are the same as you'd expect.
+ - Make sure if you know the exact reason behind the output being the way it is.
+ - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation
+ (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfpython/issues/new)).
- If yes, give a gentle pat on your back, and you may skip to the next example.
-PS: You can also read WTFpython at the command line. There's a pypi package and an npm package (supports colored formatting) for the same.
-
-To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython)
-```sh
-$ npm install -g wtfpython
-```
-
-Alternatively, to install the pypi package [`wtfpython`](https://pypi.python.org/pypi/wtfpython)
-```sh
-$ pip install wtfpython -U
-```
-
-Now, just run `wtfpython` at the command line which will open this collection in your selected `$PAGER`.
-
---
# 👀 Examples
-
## Section: Strain your brain!
-### ▶ Strings can be tricky sometimes *
+### ▶ First things first! \*
+
+
+
+For some reason, the Python 3.8's "Walrus" operator (`:=`) has become quite popular. Let's check it out,
1\.
-```py
->>> a = "some_string"
->>> id(a)
-140420665652016
->>> id("some" + "_" + "string") # Notice that both the ids are same.
-140420665652016
-```
-2\.
```py
->>> a = "wtf"
->>> b = "wtf"
->>> a is b
-True
+# Python version 3.8+
->>> a = "wtf!"
->>> b = "wtf!"
->>> a is b
-False
+>>> a = "wtf_walrus"
+>>> a
+'wtf_walrus'
->>> a, b = "wtf!", "wtf!"
->>> a is b
-True
+>>> a := "wtf_walrus"
+File "", line 1
+ a := "wtf_walrus"
+ ^
+SyntaxError: invalid syntax
+
+>>> (a := "wtf_walrus") # This works though
+'wtf_walrus'
+>>> a
+'wtf_walrus'
```
-3\.
+2 \.
+
```py
->>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
-True
->>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
-False
-```
+# Python version 3.8+
-Makes sense, right?
+>>> a = 6, 9
+>>> a
+(6, 9)
-#### 💡 Explanation:
-+ Such behavior is due to CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.
-+ After being interned, many variables may point to the same string object in memory (thereby saving memory).
-+ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some facts that can be used to guess if a string will be interned or not:
- * All length 0 and length 1 strings are interned.
- * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)
- * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`.
- ", line 1
+ (a, b = 16, 19)
+ ^
+SyntaxError: invalid syntax
-### ▶ Time for some hash brownies!
+>>> (a, b := 16, 19) # This prints out a weird 3-tuple
+(6, 16, 19)
-1\.
-```py
-some_dict = {}
-some_dict[5.5] = "Ruby"
-some_dict[5.0] = "JavaScript"
-some_dict[5] = "Python"
-```
+>>> a # a is still unchanged?
+6
-**Output:**
-```py
->>> some_dict[5.5]
-"Ruby"
->>> some_dict[5.0]
-"Python"
->>> some_dict[5]
-"Python"
+>>> b
+16
```
-"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 recongnizes `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!
+The Walrus operator (`:=`) was introduced in Python 3.8,
+it can be useful in situations where you'd want to assign values to variables within an expression.
```py
def some_func():
- try:
- return 'from_try'
- finally:
- return 'from_finally'
+ # Assume some expensive computation here
+ # time.sleep(1000)
+ return 5
+
+# So instead of,
+if some_func():
+ print(some_func()) # Which is bad practice since computation is happening twice
+
+# or
+a = some_func()
+if a:
+ print(a)
+
+# Now you can concisely write
+if a := some_func():
+ print(a)
```
-**Output:**
+**Output (> 3.8):**
+
```py
->>> some_func()
-'from_finally'
+5
+5
+5
```
-#### 💡 Explanation:
+This saved one line of code, and implicitly prevented invoking `some_func` twice.
-- 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.
+- Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level,
+ hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet.
+ Parenthesizing it worked as expected and assigned `a`.
+- As usual, parenthesizing of an expression containing `=` operator is not allowed.
+ Hence the syntax error in `(a, b = 6, 9)`.
+- The syntax of the Walrus operator is of the form `NAME:= expr`, where `NAME` is a valid identifier,
+ and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means,
+ - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9)` (where `a`'s value is 6')
+
+ ```py
+ >>> (a := 6, 9) == ((a := 6), 9)
+ True
+ >>> x = (a := 696, 9)
+ >>> x
+ (696, 9)
+ >>> x[0] is a # Both reference same memory location
+ True
+ ```
+
+ - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple.
---
-### ▶ Deep down, we're all the same. *
+### ▶ Strings can be tricky sometimes
-```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
+1\. Notice that both the ids are same.
+
+```python:snippets/2_tricky_strings.py -s 2 -e 3
+assert id("some_string") == id("some" + "_" + "string")
+assert id("some_string") == id("some_string")
```
-#### 💡 Explanation:
+2\. `True` because it is invoked in script. Might be `False` in `python shell` or `ipython`
-* 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 ")
- ```
+```python:snippets/2_tricky_strings.py -s 6 -e 12
+a = "wtf"
+b = "wtf"
+assert a is b
- **Output:**
- ```py
- >>> WTF() is WTF()
- I I D D
- >>> id(WTF()) == id(WTF())
- I D I D
- ```
- As you may observe, the order in which the objects are destroyed is what made all the difference here.
+a = "wtf!"
+b = "wtf!"
+assert a is b
+```
----
+3\. `True` because it is invoked in script. Might be `False` in `python shell` or `ipython`
-### ▶ For what?
+```python:snippets/2_tricky_strings.py -s 15 -e 19
+a, b = "wtf!", "wtf!"
+assert a is b
-```py
-some_string = "wtf"
-some_dict = {}
-for i, some_dict[i] in enumerate(some_string):
- pass
+a = "wtf!"; b = "wtf!"
+assert a is b
```
-**Output:**
+4\. **Disclaimer - snippet is not relevant in modern Python versions**
+
+**Output (< Python3.7 )**
+
```py
->>> some_dict # An indexed dict is created.
-{0: 'w', 1: 't', 2: 'f'}
+>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
+True
+>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
+False
```
-#### 💡 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
- ```
+Makes sense, right?
- **Output:**
- ```
- 0
- 1
- 2
- 3
- ```
+#### 💡 Explanation:
- Did you expect the loop to run just once?
+- The behavior in first and second snippets is due to a CPython optimization (called string interning)
+ that tries to use existing immutable objects in some cases rather than creating a new object every time.
+- After being "interned," many variables may reference the same string object in memory (saving memory thereby).
+- In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is
+ implementation-dependent. There are some rules that can be used to guess if a string will be interned or not:
+ - All length 0 and length 1 strings are interned.
+ - Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f'])` will not be interned)
+ - Strings that are not composed of ASCII letters, digits or underscores, are not interned.
+ This explains why `'wtf!'` was not interned due to `!`. CPython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
+
+
+
+
+
+
+
+
+- When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object,
+ then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that
+ there's already `"wtf!"` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above).
+ It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython
+ (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).
+- A compile unit in an interactive environment like IPython consists of a single statement,
+ whereas it consists of the entire module in case of modules. `a, b = "wtf!", "wtf!"` is single statement,
+ whereas `a = "wtf!"; b = "wtf!"` are two statements in a single line.
+ This explains why the identities are different in `a = "wtf!"; b = "wtf!"`,
+ and also explain why they are same when invoked in `some_file.py`
+- The abrupt change in the output of the fourth snippet is due to a
+ [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding.
+ This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save
+ a few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 21.
+ (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`).
+ [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
+- Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer
+ with some change in logic as well, so the fourth snippet doesn't work for Python 3.7.
+ You can read more about the change [here](https://bugs.python.org/issue11549).
- **💡 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).
+### ▶ Be careful with chained operations
-* 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
- ```
+
----
+```py
+>>> (False == False) in [False] # makes sense
+False
+>>> False == (False in [False]) # makes sense
+False
+>>> False == False in [False] # now what?
+True
-### ▶ Evaluation time discrepancy
+>>> True is False == False
+False
+>>> False is False is False
+True
-```py
-array = [1, 8, 15]
-g = (x for x in array if array.count(x) > 0)
-array = [2, 8, 22]
+>>> 1 > 0 < 1
+True
+>>> (1 > 0) < 1
+False
+>>> 1 > (0 < 1)
+False
```
-**Output:**
-```py
->>> print(list(g))
-[8]
-```
+#### 💡 Explanation:
-#### 💡 Explanation
+As per https://docs.python.org/3/reference/expressions.html#comparisons
-- 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`.
+> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators,
+ then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z,
+ except that each expression is evaluated at most once.
+
+While such behavior might seem silly to you in the above examples,
+it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.
+
+- `False is False is False` is equivalent to `(False is False) and (False is False)`
+- `True is False == False` is equivalent to `(True is False) and (False == False)`
+ and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.
+- `1 > 0 < 1` is equivalent to `(1 > 0) and (0 < 1)` which evaluates to `True`.
+- The expression `(1 > 0) < 1` is equivalent to `True < 1` and
+
+ ```py
+ >>> int(True)
+ 1
+ >>> True + 1 # not relevant for this example, but just for fun
+ 2
+ ```
+
+ So, `1 < 1` evaluates to `False`
---
-### ▶ `is` is not what it is!
+### ▶ How not to use `is` operator
+
+
The following is a very famous example present all over the internet.
+1\.
+
```py
>>> a = 256
>>> b = 256
@@ -397,23 +463,50 @@ True
>>> b = 257
>>> a is b
False
+```
+
+2\.
+
+```py
+>>> a = []
+>>> b = []
+>>> a is b
+False
+
+>>> a = tuple()
+>>> b = tuple()
+>>> a is b
+True
+```
+
+3\.
+**Output**
->>> a = 257; b = 257
+```py
+>>> a, b = 257, 257
>>> a is b
True
```
+**Output (Python 3.7.x specifically)**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+False
+```
+
#### 💡 Explanation:
**The difference between `is` and `==`**
-* `is` operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not).
-* `==` operator compares the values of both the operands and checks if they are the same.
-* So `is` is for reference equality and `==` is for value equality. An example to clear things up,
+- `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.
+ >>> class A: pass
+ >>> A() is A() # These are two empty objects at two different memory locations.
False
```
@@ -422,6 +515,7 @@ True
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
@@ -445,8 +539,12 @@ Quoting from https://docs.python.org/3/c-api/long.html
Here the interpreter isn't smart enough while executing `y = 257` to recognize that we've already created an integer of the value `257,` and so it goes on to create another object in the memory.
+Similar optimization applies to other **immutable** objects like empty tuples as well. Since lists are mutable, that's why `[] is []` will return `False` and `() is ()` will return `True`. This explains our second snippet. Let's move on to the third one,
+
**Both `a` and `b` refer to the same object when initialized with same value in the same line.**
+**Output**
+
```py
>>> a, b = 257, 257
>>> id(a)
@@ -461,21 +559,482 @@ Here the interpreter isn't smart enough while executing `y = 257` to recognize t
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.
+- When a and b are set to `257` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `257` as an object.
+
+- It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a `.py` file, you would not see the same behavior, because the file is compiled all at once. This optimization is not limited to integers, it works for other immutable data types like strings (check the "Strings are tricky example") and floats as well,
+
+ ```py
+ >>> a, b = 257.0, 257.0
+ >>> a is b
+ True
+ ```
+
+- Why didn't this work for Python 3.7? The abstract reason is because such compiler optimizations are implementation specific (i.e. may change with version, OS, etc). I'm still figuring out what exact implementation change cause the issue, you can check out this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for updates.
---
-### ▶ A tic-tac-toe where X wins in the first attempt!
+### ▶ Hash brownies
-```py
-# Let's initialize a row
-row = [""]*3 #row i['', '', '']
-# Let's make a board
-board = [row]*3
-```
+
+
+1\.
+
+```py
+some_dict = {}
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
+some_dict[5] = "Python"
+```
+
+**Output:**
+
+```py
+>>> some_dict[5.5]
+"JavaScript"
+>>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"?
+"Python"
+>>> some_dict[5]
+"Python"
+
+>>> complex_five = 5 + 0j
+>>> type(complex_five)
+complex
+>>> some_dict[complex_five]
+"Python"
+```
+
+So, why is Python all over the place?
+
+#### 💡 Explanation
+
+- Uniqueness of keys in a Python dictionary is by _equivalence_, not identity. So even though `5`, `5.0`, and `5 + 0j` are distinct objects of different types, since they're equal, they can't both be in the same `dict` (or `set`). As soon as you insert any one of them, attempting to look up any distinct but equivalent key will succeed with the original mapped value (rather than failing with a `KeyError`):
+
+ ```py
+ >>> 5 == 5.0 == 5 + 0j
+ True
+ >>> 5 is not 5.0 is not 5 + 0j
+ True
+ >>> some_dict = {}
+ >>> some_dict[5.0] = "Ruby"
+ >>> 5.0 in some_dict
+ True
+ >>> (5 in some_dict) and (5 + 0j in some_dict)
+ True
+ ```
+
+- This applies when setting an item as well. So when you do `some_dict[5] = "Python"`, Python finds the existing item with equivalent key `5.0 -> "Ruby"`, overwrites its value in place, and leaves the original key alone.
+
+ ```py
+ >>> some_dict
+ {5.0: 'Ruby'}
+ >>> some_dict[5] = "Python"
+ >>> some_dict
+ {5.0: 'Python'}
+ ```
+
+- So how can we update the key to `5` (instead of `5.0`)? We can't actually do this update in place, but what we can do is first delete the key (`del some_dict[5.0]`), and then set it (`some_dict[5]`) to get the integer `5` as the key instead of floating `5.0`, though this should be needed in rare cases.
+
+- How did Python find `5` in a dictionary containing `5.0`? Python does this in constant time without having to scan through every item by using hash functions. When Python looks up a key `foo` in a dict, it first computes `hash(foo)` (which runs in constant-time). Since in Python it is required that objects that compare equal also have the same hash value ([docs](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value.
+
+ ```py
+ >>> 5 == 5.0 == 5 + 0j
+ True
+ >>> hash(5) == hash(5.0) == hash(5 + 0j)
+ True
+ ```
+
+ **Note:** The inverse is not necessarily true: Objects with equal hash values may themselves be unequal. (This causes what's known as a [hash collision](), and degrades the constant-time performance that hashing usually provides.)
+
+---
+
+### ▶ Deep down, we're all the same.
+
+
+
+```py
+class WTF:
+ pass
+```
+
+**Output:**
+
+```py
+>>> WTF() == WTF() # two different instances can't be equal
+False
+>>> WTF() is WTF() # identities are also different
+False
+>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
+True
+>>> id(WTF()) == id(WTF())
+True
+```
+
+#### 💡 Explanation:
+
+- When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.
+- When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.
+- So, the object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
+- But why did the `is` operator evaluate to `False`? Let's see with this snippet.
+
+ ```py
+ class WTF(object):
+ def __init__(self): print("I")
+ def __del__(self): print("D")
+ ```
+
+ **Output:**
+
+ ```py
+ >>> WTF() is WTF()
+ I
+ I
+ D
+ D
+ False
+ >>> id(WTF()) == id(WTF())
+ I
+ D
+ I
+ D
+ True
+ ```
+
+ As you may observe, the order in which the objects are destroyed is what made all the difference here.
+
+---
+
+### ▶ Disorder within order \*
+
+
+
+```py
+from collections import OrderedDict
+
+dictionary = dict()
+dictionary[1] = 'a'; dictionary[2] = 'b';
+
+ordered_dict = OrderedDict()
+ordered_dict[1] = 'a'; ordered_dict[2] = 'b';
+
+another_ordered_dict = OrderedDict()
+another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';
+
+class DictWithHash(dict):
+ """
+ A dict that also implements __hash__ magic.
+ """
+ __hash__ = lambda self: 0
+
+class OrderedDictWithHash(OrderedDict):
+ """
+ An OrderedDict that also implements __hash__ magic.
+ """
+ __hash__ = lambda self: 0
+```
+
+**Output**
+
+```py
+>>> dictionary == ordered_dict # If a == b
+True
+>>> dictionary == another_ordered_dict # and b == c
+True
+>>> ordered_dict == another_ordered_dict # then why isn't c == a ??
+False
+
+# We all know that a set consists of only unique elements,
+# let's try making a set of these dictionaries and see what happens...
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "", line 1, in
+TypeError: unhashable type: 'dict'
+
+# Makes sense since dict don't have __hash__ implemented, let's use
+# our wrapper classes.
+>>> dictionary = DictWithHash()
+>>> dictionary[1] = 'a'; dictionary[2] = 'b';
+>>> ordered_dict = OrderedDictWithHash()
+>>> ordered_dict[1] = 'a'; ordered_dict[2] = 'b';
+>>> another_ordered_dict = OrderedDictWithHash()
+>>> another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+1
+>>> len({ordered_dict, another_ordered_dict, dictionary}) # changing the order
+2
+```
+
+What is going on here?
+
+#### 💡 Explanation:
+
+- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)
+
+ > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.
+
+- The reason for this equality in behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.
+- Okay, so why did changing the order affect the length of the generated `set` object? The answer is the lack of intransitive equality only. Since sets are "unordered" collections of unique elements, the order in which elements are inserted shouldn't matter. But in this case, it does matter. Let's break it down a bit,
+
+ ```py
+ >>> some_set = set()
+ >>> some_set.add(dictionary) # these are the mapping objects from the snippets above
+ >>> ordered_dict in some_set
+ True
+ >>> some_set.add(ordered_dict)
+ >>> len(some_set)
+ 1
+ >>> another_ordered_dict in some_set
+ True
+ >>> some_set.add(another_ordered_dict)
+ >>> len(some_set)
+ 1
+
+ >>> another_set = set()
+ >>> another_set.add(ordered_dict)
+ >>> another_ordered_dict in another_set
+ False
+ >>> another_set.add(another_ordered_dict)
+ >>> len(another_set)
+ 2
+ >>> dictionary in another_set
+ True
+ >>> another_set.add(another_ordered_dict)
+ >>> len(another_set)
+ 2
+ ```
+
+ So the inconsistency is due to `another_ordered_dict in another_set` being `False` because `ordered_dict` was already present in `another_set` and as observed before, `ordered_dict == another_ordered_dict` is `False`.
+
+---
+
+### ▶ Keep trying... \*
+
+
+
+```py
+def some_func():
+ try:
+ return 'from_try'
+ finally:
+ return 'from_finally'
+
+def another_func():
+ for _ in range(3):
+ try:
+ continue
+ finally:
+ print("Finally!")
+
+def one_more_func(): # A gotcha!
+ try:
+ for i in range(3):
+ try:
+ 1 / i
+ except ZeroDivisionError:
+ # Let's throw it here and handle it outside for loop
+ raise ZeroDivisionError("A trivial divide by zero error")
+ finally:
+ print("Iteration", i)
+ break
+ except ZeroDivisionError as e:
+ print("Zero division error occurred", e)
+```
+
+**Output:**
+
+```py
+>>> some_func()
+'from_finally'
+
+>>> another_func()
+Finally!
+Finally!
+Finally!
+
+>>> 1 / 0
+Traceback (most recent call last):
+ File "", line 1, in
+ZeroDivisionError: division by zero
+
+>>> one_more_func()
+Iteration 0
+
+```
+
+#### 💡 Explanation:
+
+- When a `return`, `break` or `continue` statement is executed in the `try` suite of a "try…finally" statement, the `finally` clause is also executed on the way out.
+- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.
+- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.
+
+---
+
+### ▶ For what?
+
+
+
+```py
+some_string = "wtf"
+some_dict = {}
+for i, some_dict[i] in enumerate(some_string):
+ i = 10
+```
+
+**Output:**
+
+```py
+>>> some_dict # An indexed dict appears.
+{0: 'w', 1: 't', 2: 'f'}
+```
+
+#### 💡 Explanation:
+
+- A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:
+
+ ```
+ for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+ ```
+
+ Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.
+ An interesting example that illustrates this:
+
+ ```py
+ for i in range(4):
+ print(i)
+ i = 10
+ ```
+
+ **Output:**
+
+ ```
+ 0
+ 1
+ 2
+ 3
+ ```
+
+ Did you expect the loop to run just once?
+
+ **💡 Explanation:**
+
+ - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` in this case) is unpacked and assigned the target list variables (`i` in this case).
+
+- The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:
+
+ ```py
+ >>> i, some_dict[i] = (0, 'w')
+ >>> i, some_dict[i] = (1, 't')
+ >>> i, some_dict[i] = (2, 'f')
+ >>> some_dict
+ ```
+
+---
+
+### ▶ Evaluation time discrepancy
+
+
+
+1\.
+
+```py
+array = [1, 8, 15]
+# A typical generator expression
+gen = (x for x in array if array.count(x) > 0)
+array = [2, 8, 22]
+```
+
+**Output:**
+
+```py
+>>> print(list(gen)) # Where did the other values go?
+[8]
+```
+
+2\.
+
+```py
+array_1 = [1,2,3,4]
+gen_1 = (x for x in array_1)
+array_1 = [1,2,3,4,5]
+
+array_2 = [1,2,3,4]
+gen_2 = (x for x in array_2)
+array_2[:] = [1,2,3,4,5]
+```
+
+**Output:**
+
+```py
+>>> print(list(gen_1))
+[1, 2, 3, 4]
+
+>>> print(list(gen_2))
+[1, 2, 3, 4, 5]
+```
+
+3\.
+
+```py
+array_3 = [1, 2, 3]
+array_4 = [10, 20, 30]
+gen = (i + j for i in array_3 for j in array_4)
+
+array_3 = [4, 5, 6]
+array_4 = [400, 500, 600]
+```
**Output:**
+
+```py
+>>> print(list(gen))
+[401, 501, 601, 402, 502, 602, 403, 503, 603]
+```
+
+#### 💡 Explanation
+
+- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.
+- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`.
+- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.
+- In the first case, `array_1` is bound to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
+- In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
+- Okay, going by the logic discussed so far, shouldn't be the value of `list(gen)` in the third snippet be `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (because `array_3` and `array_4` are going to behave just like `array_1`). The reason why (only) `array_4` values got updated is explained in [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)
+
+ > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
+
+---
+
+### ▶ `is not ...` is not `is (not ...)`
+
+
+
+```py
+>>> 'something' is not None
+True
+>>> 'something' is (not None)
+False
+```
+
+#### 💡 Explanation
+
+- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated.
+- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise.
+- In the example, `(not None)` evaluates to `True` since the value `None` is `False` in a boolean context, so the expression becomes `'something' is True`.
+
+---
+
+### ▶ A tic-tac-toe where X wins in the first attempt!
+
+
+
+```py
+# Let's initialize a row
+row = [""] * 3 #row i['', '', '']
+# Let's make a board
+board = [row] * 3
+```
+
+**Output:**
+
```py
>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
@@ -488,21 +1047,44 @@ board = [row]*3
[['X', '', ''], ['X', '', ''], ['X', '', '']]
```
-We didn't assign 3 "X"s or did we?
+We didn't assign three `"X"`s, did we?
#### 💡 Explanation:
When we initialize `row` variable, this visualization explains what happens in the memory
-
+
+
+
+
+
+
And when the `board` is initialized by multiplying the `row`, this is what happens inside the memory (each of the elements `board[0]`, `board[1]` and `board[2]` is a reference to the same list referred by `row`)
-
+
+
+
+
+
+
+
+We can avoid this scenario here by not using `row` variable to generate `board`. (Asked in [this](https://github.com/satwikkansal/wtfpython/issues/68) issue).
+
+```py
+>>> board = [['']*3 for _ in range(3)]
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['', '', ''], ['', '', '']]
+```
---
-### ▶ The sticky output function
+### ▶ Schrödinger's variable \*
+
+
```py
funcs = []
@@ -511,21 +1093,23 @@ for x in range(7):
def some_func():
return x
funcs.append(some_func)
- results.append(some_func())
+ results.append(some_func()) # note the function call here
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.
-//OR
+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)]
@@ -533,48 +1117,295 @@ 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:
+
+- When defining a function inside a loop that uses the loop variable in its body,
+ the loop function's closure is bound to the _variable_, not its _value_.
+ The function looks up `x` in the surrounding context, rather than using the value of `x` at the time
+ the function is created. So all of the functions use the latest value assigned to the variable for computation.
+ We can see that it's using the `x` from the surrounding context (i.e. _not_ a local variable) with:
+
+```py
+>>> import inspect
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())
+```
+
+Since `x` is a global value, we can change the value that the `funcs` will lookup and return by updating `x`:
+
+```py
+>>> x = 42
+>>> [func() for func in funcs]
+[42, 42, 42, 42, 42, 42, 42]
+```
+
+- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why does this work?** Because this will define the variable _inside_ the function's scope. It will no longer go to the surrounding (global) scope to look up the variables value but will create a local variable that stores the value of `x` at that point in time.
+
+```py
+funcs = []
+for x in range(7):
+ def some_func(x=x):
+ return x
+ funcs.append(some_func)
+```
+
+**Output:**
+
+```py
+>>> funcs_results = [func() for func in funcs]
+>>> funcs_results
+[0, 1, 2, 3, 4, 5, 6]
+```
+
+It is not longer using the `x` in the global scope:
+
+```py
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())
+```
+
+---
+
+### ▶ The chicken-egg problem \*
+
+
+
+1\.
+
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+So which is the "ultimate" base class? There's more to the confusion by the way,
+
+2\.
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
#### 💡 Explanation
-- 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.
+- `type` is a [metaclass](https://realpython.com/python-metaclasses/) in Python.
+- **Everything** is an `object` in Python, which includes classes as well as their objects (instances).
+- class `type` is the metaclass of class `object`, and every class (including `type`) has inherited directly or indirectly from `object`.
+- There is no real base class among `object` and `type`. The confusion in the above snippets is arising because we're thinking about these relationships (`issubclass` and `isinstance`) in terms of Python classes. The relationship between `object` and `type` can't be reproduced in pure python. To be more precise the following relationships can't be reproduced in pure Python,
+ - class A is an instance of class B, and class B is an instance of class A.
+ - class A is an instance of itself.
+- These relationships between `object` and `type` (both being instances of each other as well as themselves) exist in Python because of "cheating" at the implementation level.
-- 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)
- ```
+### ▶ Subclass relationships
- **Output:**
- ```py
- >>> funcs_results = [func() for func in funcs]
- >>> funcs_results
- [0, 1, 2, 3, 4, 5, 6]
- ```
+
+
+**Output:**
+
+```py
+>>> from collections.abc import Hashable
+>>> issubclass(list, object)
+True
+>>> issubclass(object, Hashable)
+True
+>>> issubclass(list, Hashable)
+False
+```
+
+The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`)
+
+#### 💡 Explanation:
+
+- Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass.
+- When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey "`__hash__`" method in `cls` or anything it inherits from.
+- Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation.
+- More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).
---
-### ▶ `is not ...` is not `is (not ...)`
+### ▶ Methods equality and identity
+
+
+
+1.
```py
->>> 'something' is not None
+class SomeClass:
+ def method(self):
+ pass
+
+ @classmethod
+ def classm(cls):
+ pass
+
+ @staticmethod
+ def staticm():
+ pass
+```
+
+**Output:**
+
+```py
+>>> print(SomeClass.method is SomeClass.method)
+True
+>>> print(SomeClass.classm is SomeClass.classm)
+False
+>>> print(SomeClass.classm == SomeClass.classm)
+True
+>>> print(SomeClass.staticm is SomeClass.staticm)
+True
+```
+
+Accessing `classm` twice, we get an equal object, but not the _same_ one? Let's see what happens
+with instances of `SomeClass`:
+
+2.
+
+```py
+o1 = SomeClass()
+o2 = SomeClass()
+```
+
+**Output:**
+
+```py
+>>> print(o1.method == o2.method)
+False
+>>> print(o1.method == o1.method)
+True
+>>> print(o1.method is o1.method)
+False
+>>> print(o1.classm is o1.classm)
+False
+>>> print(o1.classm == o1.classm == o2.classm == SomeClass.classm)
+True
+>>> print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)
+True
+```
+
+Accessing `classm` or `method` twice, creates equal but not _same_ objects for the same instance of `SomeClass`.
+
+#### 💡 Explanation
+
+- Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an
+ attribute, the descriptor is invoked, creating a method object which "binds" the function with the object owning the
+ attribute. If called, the method calls the function, implicitly passing the bound object as the first argument
+ (this is how we get `self` as the first argument, despite not passing it explicitly).
+
+```py
+>>> o1.method
+>
+```
+
+- Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is
+ never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so
+ `SomeClass.method is SomeClass.method` is truthy.
+
+```py
+>>> SomeClass.method
+
+```
+
+- `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create
+ a method object which binds the _class_ (type) of the object, instead of the object itself.
+
+```py
+>>> o1.classm
+>
+```
+
+- Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they
+ bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy.
+
+```py
+>>> SomeClass.classm
+>
+```
+
+- A method object compares equal when both the functions are equal, and the bound objects are the same. So
+ `o1.method == o1.method` is truthy, although not the same object in memory.
+- `staticmethod` transforms functions into a "no-op" descriptor, which returns the function as-is. No method
+ objects are ever created, so comparison with `is` is truthy.
+
+```py
+>>> o1.staticm
+
+>>> SomeClass.staticm
+
+```
+
+- Having to create new "method" objects every time Python calls instance methods and having to modify the arguments
+every time in order to insert `self` affected performance badly.
+CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods
+without creating the temporary method objects. This is used only when the accessed function is actually called, so the
+snippets here are not affected, and still generate methods :)
+
+### ▶ All-true-ation \*
+
+
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
True
->>> 'something' is (not None)
+>>> all([[]])
False
+>>> all([[[]]])
+True
```
-#### 💡 Explanation
+Why's this True-False alteration?
-- `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.
+#### 💡 Explanation:
+
+- The implementation of `all` function is equivalent to
+
+- ```py
+ def all(iterable):
+ for element in iterable:
+ if not element:
+ return False
+ return True
+ ```
+
+- `all([])` returns `True` since the iterable is empty.
+- `all([[]])` returns `False` because the passed array has one element, `[]`, and in python, an empty list is falsy.
+- `all([[[]]])` and higher recursive variants are always `True`. This is because the passed array's single element (`[[...]]`) is no longer empty, and lists with values are truthy.
---
### ▶ The surprising comma
-**Output:**
+
+
+**Output (< 3.6):**
+
```py
>>> def f(x, y,):
... print(x, y)
@@ -587,6 +1418,7 @@ False
def h(x, **kwargs,):
^
SyntaxError: invalid syntax
+
>>> def h(*args,):
File "", line 1
def h(*args,):
@@ -597,46 +1429,72 @@ SyntaxError: invalid syntax
#### 💡 Explanation:
- Trailing comma is not always legal in formal parameters list of a Python function.
-- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.
-- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python.
+- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.
+- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python.
---
-### ▶ Backslashes at the end of string
+### ▶ Strings and the backslashes
+
+
**Output:**
-```
->>> print("\\ C:\\")
-\ C:\
->>> print(r"\ C:")
-\ C:
->>> print(r"\ C:\")
- File "", line 1
- print(r"\ C:\")
- ^
+```py
+>>> print("\"")
+"
+
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "", line 1
+ print(r"\")
+ ^
SyntaxError: EOL while scanning string literal
+
+>>> r'\'' == "\\'"
+True
```
#### 💡 Explanation
-- In a raw string literal, as indicated by the prefix `r`, the backslash doesn't have the special meaning.
+- In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself).
+
```py
- >>> print(repr(r"wt\"f"))
+ >>> "wt\"f"
+ 'wt"f'
+ ```
+
+- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character.
+
+ ```py
+ >>> r'wt\"f' == 'wt\\"f'
+ True
+ >>> print(repr(r'wt\"f'))
'wt\\"f'
+
+ >>> print("\n")
+
+ >>> print(r"\\n")
+ '\\n'
```
-- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string.
+
+- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string.
---
### ▶ not knot!
+
+
```py
x = True
y = False
```
**Output:**
+
```py
>>> not x == y
True
@@ -649,16 +1507,19 @@ SyntaxError: invalid syntax
#### 💡 Explanation:
-* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.
-* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.
-* But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight.
-* The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`.
+- Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.
+- So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.
+- But `x == not y` raises a `SyntaxError` because it can be thought of being equivalent to `(x == not) y` and not `x == (not y)` which you might have expected at first sight.
+- The parser expected the `not` token to be a part of the `not in` operator (because both `==` and `not in` operators have the same precedence), but after not being able to find an `in` token following the `not` token, it raises a `SyntaxError`.
---
### ▶ Half triple-quoted strings
+
+
**Output:**
+
```py
>>> print('wtfpython''')
wtfpython
@@ -667,55 +1528,35 @@ wtfpython
>>> # The following statements raise `SyntaxError`
>>> # print('''wtfpython')
>>> # print("""wtfpython")
+ File "", line 1, in
+ AssertionError
+
+ >>> assert (a == b, "Values are not equal")
+ :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+ >>> assert a == b, "Values are not equal"
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError: Values are not equal
```
+- As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+
+- Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignment of an immutable (`a -= 1`) is not an alteration of the value.
+
+- Being aware of these nitpicks can save you hours of debugging effort in the long run.
+
---
-### ▶ Be careful with chained operations
+### ▶ Splitsies \*
+
+
```py
->>> (False == False) in [False] # makes sense
-False
->>> False == (False in [False]) # makes sense
-False
->>> False == False in [False] # now what?
-True
+>>> 'a'.split()
+['a']
->>> True is False == False
-False
->>> False is False is False
-True
+# is same as
+>>> 'a'.split(' ')
+['a']
->>> 1 > 0 < 1
-True
->>> (1 > 0) < 1
-False
->>> 1 > (0 < 1)
-False
+# but
+>>> len(''.split())
+0
+
+# isn't the same as
+>>> len(''.split(' '))
+1
```
#### 💡 Explanation:
-As per https://docs.python.org/2/reference/expressions.html#not-in
+- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split)
+ > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
+ > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
+- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
-> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.
-
-While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.
-
-* `False is False is False` is equivalent to `(False is False) and (False is False)`
-* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.
-* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.
-* The expression `(1 > 0) < 1` is equivalent to `True < 1` and
```py
- >>> int(True)
- 1
- >>> True + 1 #not relevant for this example, but just for fun
- 2
+ >>> ' a '.split(' ')
+ ['', 'a', '']
+ >>> ' a '.split()
+ ['a']
+ >>> ''.split(' ')
+ ['']
```
- So, `1 < 1` evaluates to `False`
---
-### ▶ Name resolution ignoring class scope
+### ▶ Wild imports \*
+
+
+
-1\.
```py
-x = 5
-class SomeClass:
- x = 17
- y = (x for i in range(10))
+# File: module.py
+
+def some_weird_name_func_():
+ print("works!")
+
+def _another_weird_name_func():
+ print("works!")
+
```
-**Output:**
+**Output**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Explanation:
+
+- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime.
+- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred.
+
+ ```py
+ >>> from module import some_weird_name_func_, _another_weird_name_func
+ >>> _another_weird_name_func()
+ works!
+ ```
+
+- If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports.
+
+ ```py
+ __all__ = ['_another_weird_name_func']
+
+ def some_weird_name_func_():
+ print("works!")
+
+ def _another_weird_name_func():
+ print("works!")
+ ```
+
+ **Output**
+
+ ```py
+ >>> _another_weird_name_func()
+ "works!"
+ >>> some_weird_name_func_()
+ Traceback (most recent call last):
+ File "", line 1, in
+ NameError: name 'some_weird_name_func_' is not defined
+ ```
+
+---
+
+### ▶ All sorted? \*
+
+
+
```py
->>> list(SomeClass.y)[0]
-5
-```
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
-2\.
-```py
-x = 5
-class SomeClass:
- x = 17
- y = [x for i in range(10)]
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
```
-**Output (Python 2.x):**
-```py
->>> SomeClass.y[0]
-17
-```
+#### 💡 Explanation:
-**Output (Python 3.x):**
-```py
->>> SomeClass.y[0]
-5
-```
+- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python.
-#### 💡 Explanation
-- Scopes nested inside class definition ignore names bound at the class level.
-- A generator expression has its own scope.
-- Starting from Python 3.X, list comprehensions also have their own scope.
+- ```py
+ >>> [] == tuple()
+ False
+ >>> x = 7, 8, 9
+ >>> type(x), type(sorted(x))
+ (tuple, list)
+ ```
----
+- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first.
-### ▶ Needle in a Haystack
+- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list.
-1\.
-```py
-x, y = (0, 1) if True else None, None
-```
+ ```py
+ >>> x = 7, 8, 9
+ >>> y = reversed(x)
+ >>> sorted(y), sorted(y)
+ ([7, 8, 9], [])
+ ```
-**Output:**
-```
->>> x, y # expected (0, 1)
-((0, 1), None)
-```
+---
+
+### ▶ Midnight time doesn't exist?
-Almost every Python programmer has faced a similar situation.
+
-2\.
```py
-t = ('one', 'two')
-for i in t:
- print(i)
+from datetime import datetime
-t = ('one')
-for i in t:
- print(i)
+midnight = datetime(2018, 1, 1, 0, 0)
+midnight_time = midnight.time()
-t = ()
-print(t)
+noon = datetime(2018, 1, 1, 12, 0)
+noon_time = noon.time()
+
+if midnight_time:
+ print("Time at midnight is", midnight_time)
+
+if noon_time:
+ print("Time at noon is", noon_time)
```
-**Output:**
+**Output (< 3.5):**
+
```py
-one
-two
-o
-n
-e
-tuple()
+('Time at noon is', datetime.time(12, 0))
```
+The midnight time is not printed.
+
#### 💡 Explanation:
-* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.
-* For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character.
-* `()` is a special token and denotes empty `tuple`.
----
+Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of "empty."
---
+---
## Section: The Hidden treasures!
-This section contains few of the lesser-known interesting things about Python that most beginners like me are unaware of (well, not anymore).
+This section contains a few lesser-known and interesting things about Python that most beginners like me are unaware of (well, not anymore).
+
+### ▶ Okay Python, Can you make me fly?
-### ▶ Okay Python, Can you make me fly? *
+
Well, here you go
@@ -1854,23 +3228,26 @@ import antigravity
```
**Output:**
-Sshh.. It's a super secret.
+Sshh... It's a super-secret.
#### 💡 Explanation:
-+ `antigravity` module is one of the few easter eggs released by Python developers.
-+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python.
-+ Well, there's more to it. There's **another easter egg inside the easter egg**. If 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/).
+
+- `antigravity` module is one of the few easter eggs released by Python developers.
+- `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python.
+- Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/).
---
-### ▶ `goto`, but why? *
+### ▶ `goto`, but why?
+
+
```py
from goto import goto, label
for i in range(9):
for j in range(9):
for k in range(9):
- print("I'm trapped, please rescue!")
+ print("I am trapped, please rescue!")
if k == 2:
goto .breakout # breaking out from a deeply nested loop
label .breakout
@@ -1878,20 +3255,24 @@ print("Freedom!")
```
**Output (Python 2.3):**
+
```py
-I'm trapped, please rescue!
-I'm trapped, please rescue!
+I am trapped, please rescue!
+I am trapped, please rescue!
Freedom!
```
#### 💡 Explanation:
+
- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004.
- Current versions of Python do not have this module.
- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python.
---
-### ▶ Brace yourself! *
+### ▶ Brace yourself!
+
+
If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing,
@@ -1900,23 +3281,30 @@ from __future__ import braces
```
**Output:**
+
```py
File "some_file.py", line 1
from __future__ import braces
SyntaxError: not a chance
```
-Braces? No way! If you think that's disappointing, use Java.
+Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)?
#### 💡 Explanation:
-+ The `__future__` module is normally used to provide features from future versions of Python. The "future" here is however ironic.
-+ This is an easter egg concerned with the community's feelings on this issue.
+
+- The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however, ironic.
+- This is an easter egg concerned with the community's feelings on this issue.
+- The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file.
+- When the CPython compiler encounters a [future statement](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), it first runs the appropriate code in `future.c` before treating it as a normal import statement.
---
-### ▶ Let's meet Friendly Language Uncle For Life *
+### ▶ Let's meet Friendly Language Uncle For Life
+
+
**Output (Python 3.x)**
+
```py
>>> from __future__ import barry_as_FLUFL
>>> "Ruby" != "Python" # there's no doubt about it
@@ -1932,14 +3320,25 @@ True
There we go.
#### 💡 Explanation:
+
- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means).
- Quoting from the PEP-401
- > Recognized that the != inequality operator in Python 3.0 was a horrible, finger pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.
+
+ > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.
+
- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/).
+- It works well in an interactive environment, but it will raise a `SyntaxError` when you run via python file (see this [issue](https://github.com/satwikkansal/wtfpython/issues/94)). However, you can wrap the statement inside an `eval` or `compile` to get it working,
+
+ ```py
+ from __future__ import barry_as_FLUFL
+ print(eval('"Ruby" <> "Python"'))
+ ```
---
-### ▶ Even Python understands that love is complicated *
+### ▶ Even Python understands that love is complicated
+
+
```py
import this
@@ -1948,6 +3347,7 @@ import this
Wait, what's **this**? `this` is love :heart:
**Output:**
+
```
The Zen of Python, by Tim Peters
@@ -1972,130 +3372,385 @@ If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
```
-It's the Zen of Python!
+It's the Zen of Python!
+
+```py
+>>> love = this
+>>> this is love
+True
+>>> love is True
+False
+>>> love is False
+False
+>>> love is not True or False
+True
+>>> love is not True or False; love is love # Love is complicated
+True
+```
+
+#### 💡 Explanation:
+
+- `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
+- And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, **the code for the Zen violates itself** (and that's probably the only place where this happens).
+- Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory (if not, please see the examples related to `is` and `is not` operators).
+
+---
+
+### ▶ Yes, it exists!
+
+
+
+**The `else` clause for loops.** One typical example might be:
+
+```py
+ def does_exists_num(l, to_find):
+ for num in l:
+ if num == to_find:
+ print("Exists!")
+ break
+ else:
+ print("Does not exist")
+```
+
+**Output:**
+
+```py
+>>> some_list = [1, 2, 3, 4, 5]
+>>> does_exists_num(some_list, 4)
+Exists!
+>>> does_exists_num(some_list, -1)
+Does not exist
+```
+
+**The `else` clause in exception handling.** An example,
+
+```py
+try:
+ pass
+except:
+ print("Exception occurred!!!")
+else:
+ print("Try block executed successfully...")
+```
+
+**Output:**
+
+```py
+Try block executed successfully...
+```
+
+#### 💡 Explanation:
+
+- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. You can think of it as a "nobreak" clause.
+- `else` clause after a try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
+
+---
+
+### ▶ Ellipsis \*
+
+
+
+```py
+def some_func():
+ Ellipsis
+```
+
+**Output**
+
+```py
+>>> some_func()
+# No output, No Error
+
+>>> SomeRandomString
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Explanation
+
+- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`.
+
+ ```py
+ >>> ...
+ Ellipsis
+ ```
+
+- Ellipsis can be used for several purposes,
+
+ - As a placeholder for code that hasn't been written yet (just like `pass` statement)
+ - In slicing syntax to represent the full slices in remaining direction
+
+ ```py
+ >>> import numpy as np
+ >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
+ array([
+ [
+ [0, 1],
+ [2, 3]
+ ],
+
+ [
+ [4, 5],
+ [6, 7]
+ ]
+ ])
+ ```
+
+ So our `three_dimensional_array` is an array of array of arrays. Let's say we want to print the second element (index `1`) of all the innermost arrays, we can use Ellipsis to bypass all the preceding dimensions
+
+ ```py
+ >>> three_dimensional_array[:,:,1]
+ array([[1, 3],
+ [5, 7]])
+ >>> three_dimensional_array[..., 1] # using Ellipsis.
+ array([[1, 3],
+ [5, 7]])
+ ```
+
+ Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`)
+
+ - In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`))
+ - You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the "no argument passed" and "None value passed" scenarios).
+
+---
+
+### ▶ Inpinity
+
+
+
+The spelling is intended. Please, don't submit a patch for this.
+
+**Output (Python 3.x):**
+
+```py
+>>> infinity = float('infinity')
+>>> hash(infinity)
+314159
+>>> hash(float('-inf'))
+-314159
+```
+
+#### 💡 Explanation:
+
+- Hash of infinity is 10⁵ x π.
+- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2.
+
+---
+
+### ▶ Let's mangle
+
+
+
+1\.
+
+```py
+class Yo(object):
+ def __init__(self):
+ self.__honey = True
+ self.bro = True
+```
+
+**Output:**
+
+```py
+>>> Yo().bro
+True
+>>> Yo().__honey
+AttributeError: 'Yo' object has no attribute '__honey'
+>>> Yo()._Yo__honey
+True
+```
+
+2\.
+
+```py
+class Yo(object):
+ def __init__(self):
+ # Let's try something symmetrical this time
+ self.__honey__ = True
+ self.bro = True
+```
+
+**Output:**
+
+```py
+>>> Yo().bro
+True
+
+>>> Yo()._Yo__honey__
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
+Why did `Yo()._Yo__honey` work?
+
+3\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+ def some_func(self):
+ return __variable # not initialized anywhere yet
+```
+
+**Output:**
```py
->>> love = this
->>> this is love
-True
->>> love is True
-False
->>> love is False
-False
->>> love is not True or False
-True
->>> love is not True or False; love is love # Love is complicated
-True
+>>> A().__variable
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> A().some_func()
+'Some value'
```
#### 💡 Explanation:
-* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
-* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, the code for the Zen violates itself (and that's probably the only place where this happens).
-* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory.
+- [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces.
+- In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore a.k.a "dunder") and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front.
+- So, to access `__honey` attribute in the first snippet, we had to append `_Yo` to the front, which would prevent conflicts with the same name attribute defined in any other class.
+- But then why didn't it work in the second snippet? Because name mangling excludes the names ending with double underscores.
+- The third snippet was also a consequence of name mangling. The name `__variable` in the statement `return __variable` was mangled to `_A__variable`, which also happens to be the name of the variable we declared in the outer scope.
+- Also, if the mangled name is longer than 255 characters, truncation will happen.
---
-### ▶ Yes, it exists!
+---
-**The `else` clause for loops.** One typical example might be:
+## Section: Appearances are deceptive!
-```py
- def does_exists_num(l, to_find):
- for num in l:
- if num == to_find:
- print("Exists!")
- break
- else:
- print("Does not exist")
-```
+### ▶ Skipping lines?
+
+
**Output:**
+
```py
->>> some_list = [1, 2, 3, 4, 5]
->>> does_exists_num(some_list, 4)
-Exists!
->>> does_exists_num(some_list, -1)
-Does not exist
+>>> value = 11
+>>> valuе = 32
+>>> value
+11
```
-**The `else` clause in exception handling.** An example,
+Wut?
-```py
-try:
- pass
-except:
- print("Exception occurred!!!")
-else:
- print("Try block executed successfully...")
-```
+**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.
+
+#### 💡 Explanation
+
+Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.
-**Output:**
```py
-Try block executed successfully...
+>>> ord('е') # cyrillic 'e' (Ye)
+1077
+>>> ord('e') # latin 'e', as used in English and typed using standard keyboard
+101
+>>> 'е' == 'e'
+False
+
+>>> value = 42 # latin e
+>>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here
+>>> value
+42
```
-#### 💡 Explanation:
-- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations.
-- `else` clause after try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
+The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.
---
-### ▶ Inpinity *
+### ▶ Teleportation
-The spelling is intended. Please, don't submit a patch for this.
+
-**Output (Python 3.x):**
```py
->>> infinity = float('infinity')
->>> hash(infinity)
-314159
->>> hash(float('-inf'))
--314159
+# `pip install numpy` first.
+import numpy as np
+
+def energy_send(x):
+ # Initializing a numpy array
+ np.array([float(x)])
+
+def energy_receive():
+ # Return an empty numpy array
+ return np.empty((), dtype=np.float).tolist()
+```
+
+**Output:**
+
+```py
+>>> energy_send(123.456)
+>>> energy_receive()
+123.456
```
+Where's the Nobel Prize?
+
#### 💡 Explanation:
-- Hash of infinity is 10⁵ x π.
-- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2.
+
+- Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate.
+- `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).
---
-### ▶ Mangling time! *
+### ▶ Well, something is fishy...
+
+
```py
-class Yo(object):
- def __init__(self):
- self.__honey = True
- self.bitch = True
+def square(x):
+ """
+ A simple function to calculate the square of a number by addition.
+ """
+ sum_so_far = 0
+ for counter in range(x):
+ sum_so_far = sum_so_far + x
+ return sum_so_far
```
-**Output:**
+**Output (Python 2.x):**
+
```py
->>> Yo().bitch
-True
->>> Yo().__honey
-AttributeError: 'Yo' object has no attribute '__honey'
->>> Yo()._Yo__honey
-True
+>>> square(10)
+10
```
-Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
+Shouldn't that be 100?
-#### 💡 Explanation:
+**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.
+
+#### 💡 Explanation
-* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces.
-* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore) and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front.
-* So, to access `__honey` attribute, we are required to append `_Yo` to the front which would prevent conflicts with the same name attribute defined in any other class.
+- **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.
+- This is how Python handles tabs:
----
+ > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
+
+- So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.
+- Python 3 is kind enough to throw an error for such cases automatically.
+
+ **Output (Python 3.x):**
+
+ ```py
+ TabError: inconsistent use of tabs and spaces in indentation
+ ```
---
-## Section: Miscallaneous
+---
+## Section: Miscellaneous
### ▶ `+=` is faster
+
+
```py
# using "+", three strings:
>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
@@ -2106,12 +3761,15 @@ Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
```
#### 💡 Explanation:
-+ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string.
+
+- `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string.
---
### ▶ Let's make a giant string!
+
+
```py
def add_string_with_plus(iters):
s = ""
@@ -2143,42 +3801,51 @@ def convert_list_to_string(l, iters):
```
**Output:**
+
```py
->>> timeit(add_string_with_plus(10000))
-1000 loops, best of 3: 972 µs per loop
->>> timeit(add_bytes_with_plus(10000))
-1000 loops, best of 3: 815 µs per loop
->>> timeit(add_string_with_format(10000))
-1000 loops, best of 3: 508 µs per loop
->>> timeit(add_string_with_join(10000))
-1000 loops, best of 3: 878 µs per loop
->>> l = ["xyz"]*10000
->>> timeit(convert_list_to_string(l, 10000))
-10000 loops, best of 3: 80 µs per loop
+# Executed in ipython shell using %timeit for better readability of results.
+# You can also use the timeit module in normal python shell/scriptm=, example usage below
+# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())
+
+>>> NUM_ITERS = 1000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
+124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
+211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
+61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
+117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
+10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
```
Let's increase the number of iterations by a factor of 10.
```py
->>> timeit(add_string_with_plus(100000)) # Linear increase in execution time
-100 loops, best of 3: 9.75 ms per loop
->>> timeit(add_bytes_with_plus(100000)) # Quadratic increase
-1000 loops, best of 3: 974 ms per loop
->>> timeit(add_string_with_format(100000)) # Linear increase
-100 loops, best of 3: 5.25 ms per loop
->>> timeit(add_string_with_join(100000)) # Linear increase
-100 loops, best of 3: 9.85 ms per loop
->>> l = ["xyz"]*100000
->>> timeit(convert_list_to_string(l, 100000)) # Linear increase
-1000 loops, best of 3: 723 µs per loop
+>>> NUM_ITERS = 10000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time
+1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # Quadratic increase
+6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # Linear increase
+645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # Linear increase
+1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # Linear increase
+86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
```
#### 💡 Explanation
-- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) from here. It is generally used to measure the execution time of snippets.
+
+- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) on these links. They are used to measure the execution time of code pieces.
- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function)
-- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for short strings).
+- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings).
- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster.
-- `add_string_with_plus` didn't show a quadratic increase in execution time unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic.
+- Unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example, `add_string_with_plus` didn't show a quadratic increase in execution time. Had the statement been `s = s + "x" + "y" + "z"` instead of `s += "xyz"`, the increase would have been quadratic.
+
```py
def add_string_with_plus(iters):
s = ""
@@ -2186,66 +3853,136 @@ Let's increase the number of iterations by a factor of 10.
s = s + "x" + "y" + "z"
assert len(s) == 3*iters
- >>> timeit(add_string_with_plus(10000))
- 100 loops, best of 3: 9.87 ms per loop
- >>> timeit(add_string_with_plus(100000)) # Quadratic increase in execution time
- 1 loops, best of 3: 1.09 s per loop
+ >>> %timeit -n100 add_string_with_plus(1000)
+ 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+ >>> %timeit -n100 add_string_with_plus(10000) # Quadratic increase in execution time
+ 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
```
+- So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which,
+
+ > There should be one-- and preferably only one --obvious way to do it.
+
---
-### ▶ Explicit typecast of strings
+### ▶ Slowing down `dict` lookups \*
+
+
```py
-a = float('inf')
-b = float('nan')
-c = float('-iNf') #These strings are case-insensitive
-d = float('nan')
+some_dict = {str(i): 1 for i in range(1_000_000)}
+another_dict = {str(i): 1 for i in range(1_000_000)}
```
**Output:**
+
```py
->>> a
-inf
->>> b
-nan
->>> c
--inf
->>> float('some_other_string')
-ValueError: could not convert string to float: some_other_string
->>> a == -c #inf==inf
-True
->>> None == None # None==None
-True
->>> b == d #but nan!=nan
-False
->>> 50/a
-0.0
->>> a/a
-nan
->>> 23 + b
-nan
+>>> %timeit some_dict['5']
+28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> some_dict[1] = 1
+>>> %timeit some_dict['5']
+37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+>>> %timeit another_dict['5']
+28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> another_dict[1] # Trying to access a key that doesn't exist
+Traceback (most recent call last):
+ File "", line 1, in
+KeyError: 1
+>>> %timeit another_dict['5']
+38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
```
+Why are same lookups becoming slower?
+
#### 💡 Explanation:
-`'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecasted to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
+- CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys.
+- The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method.
+- The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function.
+- This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect.
----
+### ▶ Bloating instance `dict`s \*
-### ▶ Minor Ones
+
-* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
-
- **💡 Explanation:**
- If `join()` is a method on a string then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API.
+```py
+import sys
+
+class SomeClass:
+ def __init__(self):
+ self.some_attr1 = 1
+ self.some_attr2 = 2
+ self.some_attr3 = 3
+ self.some_attr4 = 4
+
+
+def dict_size(o):
+ return sys.getsizeof(o.__dict__)
+
+```
+
+**Output:** (Python 3.8, other Python 3 versions may vary a little)
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104
+>>> dict_size(o2)
+104
+>>> del o1.some_attr1
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+>>> dict_size(o1)
+232
+```
+
+Let's try again... In a new interpreter:
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104 # as expected
+>>> o1.some_attr5 = 5
+>>> o1.some_attr6 = 6
+>>> dict_size(o1)
+360
+>>> dict_size(o2)
+272
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+```
+
+What makes those dictionaries become bloated? And why are newly created objects bloated as well?
+
+#### 💡 Explanation:
+
+- CPython is able to reuse the same "keys" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances.
+- This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken.
+- Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is "unshared", and key-sharing is disabled for all future instances of the same class.
+- Additionally, if the dictionary keys have been resized (because new keys are inserted), they are kept shared _only_ if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an "unshare"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys.
+- A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`!
+
+### ▶ Minor Ones \*
+
+
+
+- `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
-* Few weird looking but semantically correct statements:
- + `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`)
- + `'a'[0][0][0][0][0]` is also a semantically correct statement as strings are [sequences](https://docs.python.org/3/glossary.html#term-sequence)(iterables supporting element access using integer indices) in Python.
- + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`.
+ **💡 Explanation:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API.
+
+- Few weird looking but semantically correct statements:
+
+ - `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`)
+ - `'a'[0][0][0][0][0]` is also semantically correct, because Python doesn't have a character data type like other languages branched from C. So selecting a single character from a string returns a single-character string.
+ - `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`.
+
+- Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++, or Java.
-* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++ or Java.
```py
>>> a = 5
>>> a
@@ -2257,35 +3994,125 @@ nan
```
**💡 Explanation:**
- + There is no `++` operator in Python grammar. It is actually two `+` operators.
- + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified.
- + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python.
-* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!):
- ```py
- import dis
- exec("""
- def f():
- """ + """
- """.join(["X"+str(x)+"=" + str(x) for x in range(65539)]))
+ - There is no `++` operator in Python grammar. It is actually two `+` operators.
+ - `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified.
+ - This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python.
+
+- You must be aware of the Walrus operator in Python. But have you ever heard about _the space-invader operator_?
+
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+
+ It is used as an alternative incrementation operator, together with another one
+
+ ```py
+ >>> a +=+ 1
+ >>> a
+ >>> 44
+ ```
+
+ **💡 Explanation:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
+
+- Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator.
+
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+- Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real).
+
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
+
+- From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example,
+
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+- Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!):
+
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+- Multiple Python threads won't run your _Python code_ concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module.
+
+- Sometimes, the `print` method might not print values immediately. For example,
- f()
+ ```py
+ # File some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
- print(dis.dis(f))
- ```
+ 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.
-* 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.
+- List slicing with out of the bounds indices throws no errors
-* List slicing with out of the bounds indices throws no errors
```py
>>> some_list = [1, 2, 3, 4, 5]
>>> some_list[111:]
[]
```
-* `int('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.
+- Slicing an iterable not always creates a new object. For example,
+
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # False expected because a new object is created.
+ False
+ >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use.
+ True
+ ```
+
+- `int('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.
+
+- You can separate numeric literals with underscores (for better readability) from Python 3 onwards.
+
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+- `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
-* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
```py
def count(s, sub):
result = 0
@@ -2293,49 +4120,60 @@ nan
result += (s[i:i + len(sub)] == sub)
return result
```
+
The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.
---
+---
+
# Contributing
-All patches are Welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details.
+A few ways in which you can contribute to wtfpython,
+
+- Suggesting new examples
+- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))
+- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc.
+- Identifying gaps (things like inadequate explanation, redundant examples, etc.)
+- Any creative suggestions to make this project more fun and useful
-For discussions, you can either create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) or ping on the Gitter [channel](https://gitter.im/wtfpython/Lobby)
+Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things.
+
+PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project.
# Acknowledgements
-The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by the community gave it the shape it is in right now.
+The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now.
#### Some nice Links!
-* https://www.youtube.com/watch?v=sH4XF6pKKmk
-* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
-* https://sopython.com/wiki/Common_Gotchas_In_Python
-* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
-* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
-* https://www.python.org/doc/humor/
-* https://www.satwikkansal.xyz/archives/posts/python/My-Python-archives/
+
+- https://www.youtube.com/watch?v=sH4XF6pKKmk
+- https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+- https://sopython.com/wiki/Common_Gotchas_In_Python
+- https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+- https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+- https://www.python.org/doc/humor/
+- https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+- https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+- WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
# 🎓 License
-[![CC 4.0][license-image]][license-url]
+[![WTFPL 2.0][license-image]][license-url]
© [Satwik Kansal](https://satwikkansal.xyz)
[license-url]: http://www.wtfpl.net
[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
-## Help
-
-If you have any wtfs, ideas or suggestions, please share.
+## Surprise your friends as well!
-## Want to share wtfpython with friends?
+If you like wtfpython, you can use these quick links to share it with your friends,
-You can use these quick links for Twitter and Linkedin.
-
-[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&hastags=python,wtfpython) |
-[Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=An%20interesting%20collection%20of%20subtle%20and%20tricky%20Python%20snippets.)
+[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
## Need a pdf version?
-I've received a few requests for the pdf version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get the pdf as soon as it is 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://form.jotform.com/221593598380062).
diff --git a/images/logo.png b/images/logo.png
deleted file mode 100644
index 014a63a4..00000000
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 00000000..6ec5edab
--- /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 00000000..f89e7970
--- /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 6511978a..00000000
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 00000000..0572a9e3
--- /dev/null
+++ b/images/string-intern/string_interning.svg
@@ -0,0 +1,4 @@
+
+
+
+PyStringObject "wtf!" a PyStringObject "wtf!" b PyStringObject "wtf!" a b Text is not SVG - cannot display PyStringObject "wtf!" a PyStringObject "wtf!" b PyStringObject "wtf!" a b Text is not SVG - cannot display " " " " " " row board[0] board[1] board[2] Text is not SVG - cannot display " " " " " " row board[0] board[1] board[2] Text is not SVG - cannot display " " " " " " row Text is not SVG - cannot display " " " " " " row Text is not SVG - cannot display 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) | [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/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",
+ "Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python.\n",
+ "\n",
+ "While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I believe that you'll find it interesting too!\n",
+ "\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/) (the examples marked with asterisk are the ones added in the latest major revision). \n",
+ "\n",
+ "So, here we go...\n",
+ "\n",
+ "\n",
+ "# Structure of the Examples\n",
+ "\n",
+ "All the examples are structured like below:\n",
+ "\n",
+ "> ### \u25b6 Some fancy Title\n",
+ ">\n",
+ "> ```py\n",
+ "> # Set up the code.\n",
+ "> # Preparation for the magic...\n",
+ "> ```\n",
+ ">\n",
+ "> **Output (Python version(s)):**\n",
+ ">\n",
+ "> ```py\n",
+ "> >>> triggering_statement\n",
+ "> Some unexpected output\n",
+ "> ```\n",
+ "> (Optional): One line describing the unexpected output.\n",
+ ">\n",
+ ">\n",
+ "> #### \ud83d\udca1 Explanation:\n",
+ ">\n",
+ "> * Brief explanation of what's happening and why is it happening.\n",
+ "> ```py\n",
+ "> # Set up code\n",
+ "> # More examples for further clarification (if necessary)\n",
+ "> ```\n",
+ "> **Output (Python version(s)):**\n",
+ ">\n",
+ "> ```py\n",
+ "> >>> trigger # some example that makes it easy to unveil the magic\n",
+ "> # some justified output\n",
+ "> ```\n",
+ "\n",
+ "**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified before the output.\n",
+ "\n",
+ "# Usage\n",
+ "\n",
+ "A nice way to get the most out of these examples, in my opinion, is to read them chronologically, and for every example:\n",
+ "- 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.\n",
+ "- 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/issues/new)).\n",
+ " - If yes, give a gentle pat on your back, and you may skip to the next example.\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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Strings can be tricky sometimes\n",
+ "1\\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140420665652016\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a = \"some_string\"\n",
+ "id(a)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140420665652016\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(\"some\" + \"_\" + \"string\") # Notice that both the ids are same.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "2\\.\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": [
+ "a = \"wtf\"\n",
+ "b = \"wtf\"\n",
+ "a is b\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a = \"wtf!\"\n",
+ "b = \"wtf!\"\n",
+ "a is b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "3\\.\n",
+ "\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": [
+ "a, b = \"wtf!\", \"wtf!\"\n",
+ "a is b # All versions except 3.7.x\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": [
+ "a = \"wtf!\"; b = \"wtf!\"\n",
+ "a is b # This will print True or False depending on where you're invoking it (python shell / ipython / as a script)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": []
+ }
+ ],
+ "source": [
+ "# This time in file some_file.py\n",
+ "a = \"wtf!\"\n",
+ "b = \"wtf!\"\n",
+ "print(a is b)\n",
+ "\n",
+ "# prints True when the module is invoked!\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "4\\.\n",
+ "\n",
+ "**Output (< Python3.7 )**\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": [
+ "'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'\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": [
+ "'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Makes sense, right?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "+ The behavior in first and second snippets is due to a CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.\n",
+ "+ 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 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",
+ "\", 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": {},
+ "source": [
+ "### \u25b6 `is not ...` is not `is (not ...)`\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": [
+ "'something' is not None\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": [
+ "'something' is (not None)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \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",
+ "- 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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 A tic-tac-toe where X wins in the first attempt!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "# Let's initialize a row\n",
+ "row = [\"\"] * 3 #row i['', '', '']\n",
+ "# Let's make a board\n",
+ "board = [row] * 3\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\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": [
+ "board\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['', '', '']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "board[0]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "''\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "board[0][0]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[['X', '', ''], ['X', '', ''], ['X', '', '']]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "board[0][0] = \"X\"\n",
+ "board\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "We didn't assign three `\"X\"`s, did we?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "When we initialize `row` variable, this visualization explains what happens in the memory\n",
+ "\n",
+ ">\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": {},
+ "source": [
+ "### \u25b6 All-true-ation *\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": [
+ "all([True, True, True])\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "all([True, True, 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": [
+ "all([])\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": [
+ "all([[]])\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": [
+ "all([[[]]])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Why's this True-False alteration?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- The implementation of `all` function is equivalent to\n",
+ "\n",
+ "- ```py\n",
+ " def all(iterable):\n",
+ " for element in iterable:\n",
+ " if not element:\n",
+ " return False\n",
+ " return True\n",
+ " ```\n",
+ "\n",
+ "- `all([])` returns `True` since the iterable is empty. \n",
+ "- `all([[]])` returns `False` because `not []` is `True` is equivalent to `not False` as the list inside the iterable is empty.\n",
+ "- `all([[[]]])` and higher recursive variants are always `True` since `not [[]]`, `not [[[]]]`, and so on are equivalent to `not True`.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 The surprising comma\n",
+ "**Output (< 3.6):**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " File \"\", line 1\n",
+ " def h(x, **kwargs,):\n",
+ " ^\n",
+ "SyntaxError: invalid syntax\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "def f(x, y,):\n",
+ " print(x, y)\n",
+ "\n",
+ "def g(x=4, y=5,):\n",
+ " print(x, y)\n",
+ "\n",
+ "def h(x, **kwargs,):\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " File \"\", line 1\n",
+ " def h(*args,):\n",
+ " ^\n",
+ "SyntaxError: invalid syntax\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "def h(*args,):\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- Trailing comma is not always legal in formal parameters list of a Python function.\n",
+ "- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.\n",
+ "- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Strings and the backslashes\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\"\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"\\\"\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\\\"\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(r\"\\\"\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "File \"\", line 1\n",
+ " print(r\"\\\")\n",
+ " ^\n",
+ "SyntaxError: EOL while scanning string literal\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(r\"\\\")\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": [
+ "r'\\'' == \"\\\\'\"\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "- In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself).\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 'wt\"f'\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " \"wt\\\"f\"\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- In a raw string literal (as indicated by the prefix `r`), the backslashes pass themselves as is along with the behavior of escaping the following character.\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": [
+ " r'wt\\\"f' == 'wt\\\\\"f'\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 'wt\\\\\"f'\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " print(repr(r'wt\\\"f')\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " print(\"\\n\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " '\\\\n'\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " print(r\"\\\\n\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r\"\\\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 not knot!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "x = True\n",
+ "y = False\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": [
+ "not x == y\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " File \" at 0x7f70b0a4ad58>\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "[(yield x) for x in some_iterable]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'b']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list([(yield x) for x in some_iterable])\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', None, 'b', None]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list((yield x) for x in some_iterable)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a', 'something', 'b', 'something']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list(some_func((yield x)) for x in some_iterable)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \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: https://bugs.python.org/issue10544\n",
+ "- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Yielding from... return! *\n",
+ "1\\.\n",
+ "\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(x):\n",
+ " if x == 3:\n",
+ " return [\"wtf\"]\n",
+ " else:\n",
+ " yield from range(x)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (> 3.3):**\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": [
+ "list(some_func(3))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Where did the `\"wtf\"` go? Is it due to some special effect of `yield from`? Let's validate that,\n",
+ "\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": [
+ "def some_func(x):\n",
+ " if x == 3:\n",
+ " return [\"wtf\"]\n",
+ " else:\n",
+ " for i in range(x):\n",
+ " yield i\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\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": [
+ "list(some_func(3))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "The same result, this didn't work either.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "+ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that,\n",
+ "\n",
+ "> \"... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator.\"\n",
+ "\n",
+ "+ In the case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically caught inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.\n",
+ "\n",
+ "+ To get `[\"wtf\"]` from the generator `some_func` we need to catch the `StopIteration` exception,\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " try:\n",
+ " next(some_func(3))\n",
+ " except StopIteration as e:\n",
+ " some_string = e.value\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " [\"wtf\"]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_string\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Nan-reflexivity *\n",
+ "1\\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a = float('inf')\n",
+ "b = float('nan')\n",
+ "c = float('-iNf') # These strings are case-insensitive\n",
+ "d = float('nan')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "inf\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "b\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-inf\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "c\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ValueError: could not convert string to float: some_other_string\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "float('some_other_string')\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": [
+ "a == -c # inf==inf\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": [
+ "None == None # None == None\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": [
+ "b == d # but nan!=nan\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.0\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "50 / a\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a / a\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "nan\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "23 + b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "2\\.\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": [
+ "x = float('nan')\n",
+ "y = x / x\n",
+ "y is y # identity holds\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": [
+ "y == y # equality fails of y\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": [
+ "[y] == [y] # but the equality succeeds for the list containing y\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- `'inf'` and `'nan'` are special strings (case-insensitive), which, when explicitly typecast-ed to `float` type, are used to represent mathematical \"infinity\" and \"not a number\" respectively.\n",
+ "\n",
+ "- Since according to IEEE standards ` NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`. Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer,\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (False, True)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " x = float('nan')\n",
+ " x == x, [x] == [x]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (False, True)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " y = float('nan')\n",
+ " y == y, [y] == [y]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (False, False)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " x == y, [x] == [y]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " Since the identities of `x` and `y` are different, the values are considered, which are also different; hence the comparison returns `False` this time.\n",
+ "\n",
+ "- Interesting read: [Reflexivity, and other pillars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Mutating the immutable!\n",
+ "This might seem trivial if you know how references work in Python.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_tuple = (\"A\", \"tuple\", \"with\", \"values\")\n",
+ "another_tuple = ([1, 2], [3, 4], [5, 6])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "TypeError: 'tuple' object does not support item assignment\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_tuple[2] = \"change this\"\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "([1, 2], [3, 4], [5, 6, 1000])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "another_tuple[2].append(1000) #This throws no error\n",
+ "another_tuple\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "TypeError: 'tuple' object does not support item assignment\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "another_tuple[2] += [99, 999]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "([1, 2], [3, 4], [5, 6, 1000, 99, 999])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "another_tuple\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "But I thought tuples were immutable...\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 The disappearing variable from outer scope\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "e = 7\n",
+ "try:\n",
+ " raise Exception()\n",
+ "except Exception as e:\n",
+ " pass\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 2.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "# prints nothing\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(e)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 3.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "NameError: name 'e' is not defined\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(e)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* Source: https://docs.python.org/3/reference/compound_stmts.html#except\n",
+ "\n",
+ " When an exception has been assigned using `as` target, it is cleared at the end of the `except` clause. This is as if\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " except E as N:\n",
+ " foo\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " was translated into\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " except E as N:\n",
+ " try:\n",
+ " foo\n",
+ " finally:\n",
+ " del N\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.\n",
+ "\n",
+ "* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " def f(x):\n",
+ " del(x)\n",
+ " print(x)\n",
+ "\n",
+ " x = 5\n",
+ " y = [5, 4, 3]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " **Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 5\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " >>>f(x)\n",
+ " UnboundLocalError: local variable 'x' referenced before assignment\n",
+ " >>>f(y)\n",
+ " UnboundLocalError: local variable 'x' referenced before assignment\n",
+ " x\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " [5, 4, 3]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " y\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "* In Python 2.x, the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing.\n",
+ "\n",
+ " **Output (Python 2.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " Exception()\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " e\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " # Nothing is printed!\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " print e\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 The mysterious key type conversion\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(str):\n",
+ " pass\n",
+ "\n",
+ "some_dict = {'s': 42}\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "type(list(some_dict.keys())[0])\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'s': 40}\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "s = SomeClass('s')\n",
+ "some_dict[s] = 40\n",
+ "some_dict # expected: Two different keys-value pairs\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "str\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "type(list(some_dict.keys())[0])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* Both the object `s` and the string `\"s\"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class.\n",
+ "* `SomeClass(\"s\") == \"s\"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class.\n",
+ "* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary.\n",
+ "* For the desired behavior, we can redefine the `__eq__` method in `SomeClass`\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(str):\n",
+ " def __eq__(self, other):\n",
+ " return (\n",
+ " type(self) is SomeClass\n",
+ " and type(other) is SomeClass\n",
+ " and super().__eq__(other)\n",
+ " )\n",
+ "\n",
+ " # When we define a custom __eq__, Python stops automatically inheriting the\n",
+ " # __hash__ method, so we need to define it as well\n",
+ " __hash__ = str.__hash__\n",
+ "\n",
+ " some_dict = {'s':42}\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " **Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " {'s': 40, 's': 42}\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " s = SomeClass('s')\n",
+ " some_dict[s] = 40\n",
+ " some_dict\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (__main__.SomeClass, str)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " keys = list(some_dict.keys())\n",
+ " type(keys[0]), type(keys[1])\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Let's see if you can guess this?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a, b = a[b] = {}, 5\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{5: ({...}, 5)}\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\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",
+ " and\n",
+ " \n",
+ "> An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.\n",
+ "\n",
+ "* The `+` in `(target_list \"=\")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`).\n",
+ "\n",
+ "* After the expression list is evaluated, its value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`.\n",
+ "\n",
+ "* `a` is now assigned to `{}`, which is a mutable object.\n",
+ "\n",
+ "* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`).\n",
+ "\n",
+ "* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " [[...]]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_list = some_list[0] = [0]\n",
+ " some_list\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " [[...]]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_list[0]\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_list is some_list[0]\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_list[0][0][0][0][0][0] == some_list\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " Similar is the case in our example (`a[b][0]` is the same object as `a`)\n",
+ "\n",
+ "* So to sum it up, you can break the example down to\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " a, b = {}, 5\n",
+ " a[b] = a, b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a`\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": [
+ " a[b][0] is a\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Modifying a dictionary while iterating over it\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "x = {0: None}\n",
+ "\n",
+ "for i in x:\n",
+ " del x[i]\n",
+ " x[i+1] = None\n",
+ " print(i)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 2.7- Python 3.5):**\n",
+ "\n",
+ "```\n",
+ "0\n",
+ "1\n",
+ "2\n",
+ "3\n",
+ "4\n",
+ "5\n",
+ "6\n",
+ "7\n",
+ "```\n",
+ "\n",
+ "Yes, it runs for exactly **eight** times and stops.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* Iteration over a dictionary that you edit at the same time is not supported.\n",
+ "* 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.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 The out of scope variable\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": [
+ "a = 1\n",
+ "def some_func():\n",
+ " return a\n",
+ "\n",
+ "def another_func():\n",
+ " a += 1\n",
+ " 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": {},
+ "source": [
+ "\n",
+ "**Output:**\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_func()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "UnboundLocalError: local variable 'a' referenced before assignment\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": [
+ "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": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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",
+ "* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword.\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",
+ " global a\n",
+ " a += 1\n",
+ " return a\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": [
+ "* 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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Deleting a list item while iterating\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list_1 = [1, 2, 3, 4]\n",
+ "list_2 = [1, 2, 3, 4]\n",
+ "list_3 = [1, 2, 3, 4]\n",
+ "list_4 = [1, 2, 3, 4]\n",
+ "\n",
+ "for idx, item in enumerate(list_1):\n",
+ " del item\n",
+ "\n",
+ "for idx, item in enumerate(list_2):\n",
+ " list_2.remove(item)\n",
+ "\n",
+ "for idx, item in enumerate(list_3[:]):\n",
+ " list_3.remove(item)\n",
+ "\n",
+ "for idx, item in enumerate(list_4):\n",
+ " list_4.pop(idx)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[1, 2, 3, 4]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list_1\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[2, 4]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list_2\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list_3\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[2, 4]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list_4\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Can you guess why the output is `[2, 4]`?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 139798789457608\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_list = [1, 2, 3, 4]\n",
+ " id(some_list)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 139798779601192\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " id(some_list[:]) # Notice that python creates new object for sliced list.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Difference between `del`, `remove`, and `pop`:**\n",
+ "* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected).\n",
+ "* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found.\n",
+ "* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified.\n",
+ "\n",
+ "**Why the output is `[2, 4]`?**\n",
+ "- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence.\n",
+ "\n",
+ "* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example\n",
+ "* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Lossy zip of iterators *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 1, 2, 3, 4, 5, 6]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "numbers = list(range(7))\n",
+ "numbers\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "([0, 1, 2], [3, 4, 5, 6])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "first_three, remaining = numbers[:3], numbers[3:]\n",
+ "first_three, remaining\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[(0, 0), (1, 1), (2, 2)]\n",
+ "# so far so good, let's zip the remaining\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "numbers_iter = iter(numbers)\n",
+ "list(zip(numbers_iter, first_three)) \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[(4, 3), (5, 4), (6, 5)]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "list(zip(numbers_iter, remaining))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Where did element `3` go from the `numbers` list?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " def zip(*iterables):\n",
+ " sentinel = object()\n",
+ " iterators = [iter(it) for it in iterables]\n",
+ " while iterators:\n",
+ " result = []\n",
+ " for it in iterators:\n",
+ " elem = next(it, sentinel)\n",
+ " if elem is sentinel: return\n",
+ " result.append(elem)\n",
+ " yield tuple(result)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- 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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " [(0, 0), (1, 1), (2, 2)]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " numbers = list(range(7))\n",
+ " numbers_iter = iter(numbers)\n",
+ " list(zip(first_three, numbers_iter))\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " [(3, 3), (4, 4), (5, 5), (6, 6)]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " list(zip(remaining, numbers_iter))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " The first argument of zip should be the one with fewest elements.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Loop variables leaking out!\n",
+ "1\\.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": []
+ }
+ ],
+ "source": [
+ "for x in range(7):\n",
+ " if x == 6:\n",
+ " print(x, ': for x inside loop')\n",
+ "print(x, ': x in global')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "6 : for x inside loop\n",
+ "6 : x in global\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "But `x` was never defined outside the scope of for loop...\n",
+ "\n",
+ "2\\.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": []
+ }
+ ],
+ "source": [
+ "# This time let's initialize x first\n",
+ "x = -1\n",
+ "for x in range(7):\n",
+ " if x == 6:\n",
+ " print(x, ': for x inside loop')\n",
+ "print(x, ': x in global')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "6 : for x inside loop\n",
+ "6 : x in global\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "3\\.\n",
+ "\n",
+ "**Output (Python 2.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[0, 1, 2, 3, 4]\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = 1\n",
+ "print([x for x in range(5)])\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(x)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 3.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[0, 1, 2, 3, 4]\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = 1\n",
+ "print([x for x in range(5)])\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(x)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable.\n",
+ "\n",
+ "- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What\u2019s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog:\n",
+ "\n",
+ " > \"List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular, the loop control variables are no longer leaked into the surrounding scope.\"\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Beware of default mutable arguments!\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(default_arg=[]):\n",
+ " default_arg.append(\"some_string\")\n",
+ " return default_arg\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['some_string']\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": [
+ "['some_string', 'some_string']\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": [
+ "['some_string']\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": [
+ "['some_string', 'some_string', 'some_string']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_func()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected.\n",
+ "\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(default_arg=[]):\n",
+ " default_arg.append(\"some_string\")\n",
+ " return default_arg\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " **Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " ([],)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_func.__defaults__ #This will show the default argument values for the function\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (['some_string'],)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_func()\n",
+ " some_func.__defaults__\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (['some_string', 'some_string'],)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_func()\n",
+ " some_func.__defaults__\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " (['some_string', 'some_string'],)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " some_func([])\n",
+ " some_func.__defaults__\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example:\n",
+ "\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(default_arg=None):\n",
+ " if default_arg is None:\n",
+ " default_arg = []\n",
+ " default_arg.append(\"some_string\")\n",
+ " return default_arg\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Catching the Exceptions\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_list = [1, 2, 3]\n",
+ "try:\n",
+ " # This should raise an ``IndexError``\n",
+ " print(some_list[4])\n",
+ "except IndexError, ValueError:\n",
+ " print(\"Caught!\")\n",
+ "\n",
+ "try:\n",
+ " # This should raise a ``ValueError``\n",
+ " some_list.remove(4)\n",
+ "except IndexError, ValueError:\n",
+ " print(\"Caught again!\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 2.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "Caught!\n",
+ "\n",
+ "ValueError: list.remove(x): x not in list\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 3.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " File \"\", line 1, in \n",
+ " AssertionError\n",
+ " \n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " a = \"python\"\n",
+ " b = \"javascript\"\n",
+ " assert a == b\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n",
+ " \n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " assert (a == b, \"Values are not equal\")\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",
+ " AssertionError: Values are not equal\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " assert a == b, \"Values are not equal\"\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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](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, 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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Splitsies *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a']\n",
+ "\n",
+ "# is same as\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "'a'.split()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['a']\n",
+ "\n",
+ "# but\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "'a'.split(' ')\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0\n",
+ "\n",
+ "# isn't the same as\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "len(''.split())\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": [
+ "len(''.split(' '))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "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/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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " ['', 'a', '']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " ' a '.split(' ')\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " ['a']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " ' a '.split()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " ['']\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " ''.split(' ')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 All sorted? *\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": [
+ "x = 7, 8, 9\n",
+ "sorted(x) == x\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": [
+ "sorted(x) == sorted(x)\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": [
+ "y = reversed(x)\n",
+ "sorted(y) == sorted(y)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python. \n",
+ "\n",
+ "- ```py\n",
+ " >>> [] == tuple()\n",
+ " False\n",
+ " >>> x = 7, 8, 9\n",
+ " >>> type(x), type(sorted(x))\n",
+ " (tuple, list)\n",
+ " ```\n",
+ "\n",
+ "- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first.\n",
+ "\n",
+ "- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " ([7, 8, 9], [])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " x = 7, 8, 9\n",
+ " y = reversed(x)\n",
+ " sorted(y), sorted(y)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Midnight time doesn't exist?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "from datetime import datetime\n",
+ "\n",
+ "midnight = datetime(2018, 1, 1, 0, 0)\n",
+ "midnight_time = midnight.time()\n",
+ "\n",
+ "noon = datetime(2018, 1, 1, 12, 0)\n",
+ "noon_time = noon.time()\n",
+ "\n",
+ "if midnight_time:\n",
+ " print(\"Time at midnight is\", midnight_time)\n",
+ "\n",
+ "if noon_time:\n",
+ " print(\"Time at noon is\", noon_time)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (< 3.5):**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "('Time at noon is', datetime.time(12, 0))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The midnight time is not printed.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of \"empty.\"\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Okay Python, Can you make me fly?\n",
+ "Well, here you go\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "import antigravity\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "Sshh... It's a super-secret.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "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](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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 `goto`, but why?\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "collapsed": true
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": []
+ }
+ ],
+ "source": [
+ "from goto import goto, label\n",
+ "for i in range(9):\n",
+ " for j in range(9):\n",
+ " for k in range(9):\n",
+ " print(\"I am trapped, please rescue!\")\n",
+ " if k == 2:\n",
+ " goto .breakout # breaking out from a deeply nested loop\n",
+ "label .breakout\n",
+ "print(\"Freedom!\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 2.3):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "I am trapped, please rescue!\n",
+ "I am trapped, please rescue!\n",
+ "Freedom!\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004.\n",
+ "- Current versions of Python do not have this module.\n",
+ "- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Brace yourself!\n",
+ "If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing,\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "from __future__ import braces\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " File \"some_file.py\", line 1\n",
+ " from __future__ import braces\n",
+ "SyntaxError: not a chance\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "+ The `__future__` module is normally used to provide features from future versions of Python. The \"future\" in this specific context is however, ironic.\n",
+ "+ This is an easter egg concerned with the community's feelings on this issue.\n",
+ "+ The code is actually present [here](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) in `future.c` file.\n",
+ "+ When the CPython compiler encounters a [future statement](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), it first runs the appropriate code in `future.c` before treating it as a normal import statement.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Let's meet Friendly Language Uncle For Life\n",
+ "**Output (Python 3.x)**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " File \"some_file.py\", line 1\n",
+ " \"Ruby\" != \"Python\"\n",
+ " ^\n",
+ "SyntaxError: invalid syntax\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "from __future__ import barry_as_FLUFL\n",
+ "\"Ruby\" != \"Python\" # there's no doubt about it\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": [
+ "\"Ruby\" <> \"Python\"\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "There we go.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means).\n",
+ "- Quoting from the PEP-401\n",
+ " \n",
+ " > Recognized that the != inequality operator in Python 3.0 was a horrible, finger-pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.\n",
+ "- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/).\n",
+ "- It works well in an interactive environment, but it will raise a `SyntaxError` when you run via python file (see this [issue](https://github.com/satwikkansal/wtfpython/issues/94)). However, you can wrap the statement inside an `eval` or `compile` to get it working,\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " from __future__ import barry_as_FLUFL\n",
+ " print(eval('\"Ruby\" <> \"Python\"'))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Even Python understands that love is complicated\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "import this\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Wait, what's **this**? `this` is love :heart:\n",
+ "\n",
+ "**Output:**\n",
+ "```\n",
+ "The Zen of Python, by Tim Peters\n",
+ "\n",
+ "Beautiful is better than ugly.\n",
+ "Explicit is better than implicit.\n",
+ "Simple is better than complex.\n",
+ "Complex is better than complicated.\n",
+ "Flat is better than nested.\n",
+ "Sparse is better than dense.\n",
+ "Readability counts.\n",
+ "Special cases aren't special enough to break the rules.\n",
+ "Although practicality beats purity.\n",
+ "Errors should never pass silently.\n",
+ "Unless explicitly silenced.\n",
+ "In the face of ambiguity, refuse the temptation to guess.\n",
+ "There should be one-- and preferably only one --obvious way to do it.\n",
+ "Although that way may not be obvious at first unless you're Dutch.\n",
+ "Now is better than never.\n",
+ "Although never is often better than *right* now.\n",
+ "If the implementation is hard to explain, it's a bad idea.\n",
+ "If the implementation is easy to explain, it may be a good idea.\n",
+ "Namespaces are one honking great idea -- let's do more of those!\n",
+ "```\n",
+ "\n",
+ "It's the Zen of Python!\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": [
+ "love = this\n",
+ "this is love\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": [
+ "love is True\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": [
+ "love 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": [
+ "love is not True or 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": [
+ "love is not True or False; love is love # Love is complicated\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).\n",
+ "* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, **the code for the Zen violates itself** (and that's probably the only place where this happens).\n",
+ "* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory (if not, please see the examples related to `is` and `is not` operators).\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Yes, it exists!\n",
+ "**The `else` clause for loops.** One typical example might be:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " def does_exists_num(l, to_find):\n",
+ " for num in l:\n",
+ " if num == to_find:\n",
+ " print(\"Exists!\")\n",
+ " break\n",
+ " else:\n",
+ " print(\"Does not exist\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Exists!\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "some_list = [1, 2, 3, 4, 5]\n",
+ "does_exists_num(some_list, 4)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Does not exist\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "does_exists_num(some_list, -1)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**The `else` clause in exception handling.** An example,\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "try:\n",
+ " pass\n",
+ "except:\n",
+ " print(\"Exception occurred!!!\")\n",
+ "else:\n",
+ " print(\"Try block executed successfully...\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "Try block executed successfully...\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations. You can think of it as a \"nobreak\" clause.\n",
+ "- `else` clause after a try block is also called \"completion clause\" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Ellipsis *\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",
+ " Ellipsis\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "# No output, No Error\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": [
+ "Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ "NameError: name 'SomeRandomString' is not defined\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "SomeRandomString\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Ellipsis\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "Ellipsis\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " Ellipsis\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " ...\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- Eliipsis can be used for several purposes,\n",
+ " + As a placeholder for code that hasn't been written yet (just like `pass` statement)\n",
+ " + In slicing syntax to represent the full slices in remaining direction\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " array([\n",
+ " [\n",
+ " [0, 1],\n",
+ " [2, 3]\n",
+ " ],\n",
+ "\n",
+ " [\n",
+ " [4, 5],\n",
+ " [6, 7]\n",
+ " ]\n",
+ " ])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " import numpy as np\n",
+ " three_dimensional_array = np.arange(8).reshape(2, 2, 2)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " So our `three_dimensional_array` is an array of array of arrays. Let's say we want to print the second element (index `1`) of all the innermost arrays, we can use Ellipsis to bypass all the preceding dimensions\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " array([[1, 3],\n",
+ " [5, 7]])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " three_dimensional_array[:,:,1]\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " array([[1, 3],\n",
+ " [5, 7]])\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " three_dimensional_array[..., 1] # using Ellipsis.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " Note: this will work for any number of dimensions. You can even select slice in first and last dimension and ignore the middle ones this way (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`)\n",
+ " + In [type hinting](https://docs.python.org/3/library/typing.html) to indicate only a part of the type (like `(Callable[..., int]` or `Tuple[str, ...]`))\n",
+ " + You may also use Ellipsis as a default function argument (in the cases when you want to differentiate between the \"no argument passed\" and \"None value passed\" scenarios).\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Inpinity\n",
+ "The spelling is intended. Please, don't submit a patch for this.\n",
+ "\n",
+ "**Output (Python 3.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "314159\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "infinity = float('infinity')\n",
+ "hash(infinity)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-314159\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "hash(float('-inf'))\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "- Hash of infinity is 10\u2075 x \u03c0.\n",
+ "- Interestingly, the hash of `float('-inf')` is \"-10\u2075 x \u03c0\" in Python 3, whereas \"-10\u2075 x e\" in Python 2.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Let's mangle\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 Yo(object):\n",
+ " def __init__(self):\n",
+ " self.__honey = True\n",
+ " self.bro = True\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": [
+ "Yo().bro\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "AttributeError: 'Yo' object has no attribute '__honey'\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "Yo().__honey\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": [
+ "Yo()._Yo__honey\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": [
+ "class Yo(object):\n",
+ " def __init__(self):\n",
+ " # Let's try something symmetrical this time\n",
+ " self.__honey__ = True\n",
+ " self.bro = True\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\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": [
+ "Yo().bro\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: 'Yo' object has no attribute '_Yo__honey__'\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "Yo()._Yo__honey__\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Why did `Yo()._Yo__honey` work?\n",
+ "\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": [
+ "_A__variable = \"Some value\"\n",
+ "\n",
+ "class A(object):\n",
+ " def some_func(self):\n",
+ " return __variable # not initialized anywhere yet\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**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,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Some value'\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "A().some_func()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces.\n",
+ "* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore a.k.a \"dunder\") and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front.\n",
+ "* So, to access `__honey` attribute in the first snippet, we had to append `_Yo` to the front, which would prevent conflicts with the same name attribute defined in any other class.\n",
+ "* But then why didn't it work in the second snippet? Because name mangling excludes the names ending with double underscores.\n",
+ "* The third snippet was also a consequence of name mangling. The name `__variable` in the statement `return __variable` was mangled to `_A__variable`, which also happens to be the name of the variable we declared in the outer scope.\n",
+ "* Also, if the mangled name is longer than 255 characters, truncation will happen.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Skipping lines?\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "11\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "value = 11\n",
+ "valu\u0435 = 32\n",
+ "value\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Wut?\n",
+ "\n",
+ "**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1077\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "ord('\u0435') # cyrillic 'e' (Ye)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "101\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "ord('e') # latin 'e', as used in English and typed using standard keyboard\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "'\u0435' == 'e'\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "42\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "value = 42 # latin e\n",
+ "valu\u0435 = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here\n",
+ "value\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Teleportation\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "# `pip install numpy` first.\n",
+ "import numpy as np\n",
+ "\n",
+ "def energy_send(x):\n",
+ " # Initializing a numpy array\n",
+ " np.array([float(x)])\n",
+ "\n",
+ "def energy_receive():\n",
+ " # Return an empty numpy array\n",
+ " return np.empty((), dtype=np.float).tolist()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "123.456\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "energy_send(123.456)\n",
+ "energy_receive()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Where's the Nobel Prize?\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate.\n",
+ "* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Well, something is fishy...\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "def square(x):\n",
+ " \"\"\"\n",
+ " A simple function to calculate the square of a number by addition.\n",
+ " \"\"\"\n",
+ " sum_so_far = 0\n",
+ " for counter in range(x):\n",
+ " sum_so_far = sum_so_far + x\n",
+ " return sum_so_far\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 2.x):**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "square(10)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Shouldn't that be 100?\n",
+ "\n",
+ "**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "* **Don't mix tabs and spaces!** The character just preceding return is a \"tab\", and the code is indented by multiple of \"4 spaces\" elsewhere in the example.\n",
+ "* This is how Python handles tabs:\n",
+ " \n",
+ " > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>\n",
+ "* So the \"tab\" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.\n",
+ "* Python 3 is kind enough to throw an error for such cases automatically.\n",
+ "\n",
+ " **Output (Python 3.x):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " TabError: inconsistent use of tabs and spaces in indentation\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 `+=` is faster\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.25748300552368164\n",
+ "# using \"+=\", three strings:\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "# using \"+\", three strings:\n",
+ "timeit.timeit(\"s1 = s1 + s2 + s3\", setup=\"s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000\", number=100)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.012188911437988281\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "timeit.timeit(\"s1 += s2 + s3\", setup=\"s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000\", number=100)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "+ `+=` is faster than `+` for concatenating more than two strings because the first string (example, `s1` for `s1 += s2 + s3`) is not destroyed while calculating the complete string.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Let's make a giant string!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "def add_string_with_plus(iters):\n",
+ " s = \"\"\n",
+ " for i in range(iters):\n",
+ " s += \"xyz\"\n",
+ " assert len(s) == 3*iters\n",
+ "\n",
+ "def add_bytes_with_plus(iters):\n",
+ " s = b\"\"\n",
+ " for i in range(iters):\n",
+ " s += b\"xyz\"\n",
+ " assert len(s) == 3*iters\n",
+ "\n",
+ "def add_string_with_format(iters):\n",
+ " fs = \"{}\"*iters\n",
+ " s = fs.format(*([\"xyz\"]*iters))\n",
+ " assert len(s) == 3*iters\n",
+ "\n",
+ "def add_string_with_join(iters):\n",
+ " l = []\n",
+ " for i in range(iters):\n",
+ " l.append(\"xyz\")\n",
+ " s = \"\".join(l)\n",
+ " assert len(s) == 3*iters\n",
+ "\n",
+ "def convert_list_to_string(l, iters):\n",
+ " s = \"\".join(l)\n",
+ " assert len(s) == 3*iters\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "124 \u00b5s \u00b1 4.73 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "# Executed in ipython shell using %timeit for better readability of results.\n",
+ "# You can also use the timeit module in normal python shell/scriptm=, example usage below\n",
+ "# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())\n",
+ "\n",
+ "NUM_ITERS = 1000\n",
+ "%timeit -n1000 add_string_with_plus(NUM_ITERS)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "211 \u00b5s \u00b1 10.5 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit -n1000 add_bytes_with_plus(NUM_ITERS)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "61 \u00b5s \u00b1 2.18 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit -n1000 add_string_with_format(NUM_ITERS)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "117 \u00b5s \u00b1 3.21 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit -n1000 add_string_with_join(NUM_ITERS)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10.1 \u00b5s \u00b1 1.06 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "l = [\"xyz\"]*NUM_ITERS\n",
+ "%timeit -n1000 convert_list_to_string(l, NUM_ITERS)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Let's increase the number of iterations by a factor of 10.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.26 ms \u00b1 76.8 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "NUM_ITERS = 10000\n",
+ "%timeit -n1000 add_string_with_plus(NUM_ITERS) # Linear increase in execution time\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "6.82 ms \u00b1 134 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit -n1000 add_bytes_with_plus(NUM_ITERS) # Quadratic increase\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "645 \u00b5s \u00b1 24.5 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit -n1000 add_string_with_format(NUM_ITERS) # Linear increase\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.17 ms \u00b1 7.25 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "%timeit -n1000 add_string_with_join(NUM_ITERS) # Linear increase\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "86.3 \u00b5s \u00b1 2 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "l = [\"xyz\"]*NUM_ITERS\n",
+ "%timeit -n1000 convert_list_to_string(l, NUM_ITERS) # Linear increase\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) or [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) on these links. They are used to measure the execution time of code pieces.\n",
+ "- Don't use `+` for generating long strings \u2014 In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function)\n",
+ "- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings).\n",
+ "- Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster.\n",
+ "- Unlike `add_bytes_with_plus` because of the `+=` optimizations discussed in the previous example, `add_string_with_plus` didn't show a quadratic increase in execution time. Had the statement been `s = s + \"x\" + \"y\" + \"z\"` instead of `s += \"xyz\"`, the increase would have been quadratic.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 388 \u00b5s \u00b1 22.4 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " def add_string_with_plus(iters):\n",
+ " s = \"\"\n",
+ " for i in range(iters):\n",
+ " s = s + \"x\" + \"y\" + \"z\"\n",
+ " assert len(s) == 3*iters\n",
+ "\n",
+ " %timeit -n100 add_string_with_plus(1000)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " 9 ms \u00b1 298 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ " %timeit -n100 add_string_with_plus(10000) # Quadratic increase in execution time\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- So many ways to format and create a giant string are somewhat in contrast to the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), according to which,\n",
+ " \n",
+ " > There should be one-- and preferably only one --obvious way to do it.\n",
+ "\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": {},
+ "source": [
+ "### \u25b6 Minor Ones *\n",
+ "* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)\n",
+ "\n",
+ " **\ud83d\udca1 Explanation:** If `join()` is a method on a string, then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a generic `list` object API.\n",
+ " \n",
+ "* Few weird looking but semantically correct statements:\n",
+ " + `[] = ()` is a semantically correct statement (unpacking an empty `tuple` into an empty `list`)\n",
+ " + `'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.\n",
+ " + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`.\n",
+ "\n",
+ "* 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.\n",
+ " ```py\n",
+ " >>> a = 5\n",
+ " >>> a\n",
+ " 5\n",
+ " >>> ++a\n",
+ " 5\n",
+ " >>> --a\n",
+ " 5\n",
+ " ```\n",
+ "\n",
+ " **\ud83d\udca1 Explanation:**\n",
+ " + There is no `++` operator in Python grammar. It is actually two `+` operators.\n",
+ " + `++a` parses as `+(+a)` which translates to `a`. Similarly, the output of the statement `--a` can be justified.\n",
+ " + This StackOverflow [thread](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) discusses the rationale behind the absence of increment and decrement operators in Python.\n",
+ "\n",
+ "* You must be aware of the Walrus operator in Python. But have you ever heard about *the space-invader operator*?\n",
+ " ```py\n",
+ " >>> a = 42\n",
+ " >>> a -=- 1\n",
+ " >>> a\n",
+ " 43\n",
+ " ```\n",
+ " It is used as an alternative incrementation operator, together with another one\n",
+ " ```py\n",
+ " >>> a +=+ 1\n",
+ " >>> a\n",
+ " >>> 44\n",
+ " ```\n",
+ " **\ud83d\udca1 Explanation:** This prank comes from [Raymond Hettinger's tweet](https://twitter.com/raymondh/status/1131103570856632321?lang=en). The space invader operator is actually just a malformatted `a -= (-1)`. Which is equivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.\n",
+ " \n",
+ "* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator. \n",
+ " \n",
+ " ```py\n",
+ " >>> False ** False == True\n",
+ " True\n",
+ " >>> False ** True == False\n",
+ " True\n",
+ " >>> True ** False == True\n",
+ " True\n",
+ " >>> True ** True == True\n",
+ " True\n",
+ " ```\n",
+ "\n",
+ " **\ud83d\udca1 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to a converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))\n",
+ " \n",
+ "* Since we are talking operators, there's also `@` operator for matrix multiplication (don't worry, this time it's for real).\n",
+ "\n",
+ " ```py\n",
+ " >>> import numpy as np\n",
+ " >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])\n",
+ " 46\n",
+ " ```\n",
+ "\n",
+ " **\ud83d\udca1 Explanation:** The `@` operator was added in Python 3.5 keeping the scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.\n",
+ "\n",
+ "* From Python 3.8 onwards you can use a typical f-string syntax like `f'{some_var=}` for quick debugging. Example,\n",
+ " ```py\n",
+ " >>> some_string = \"wtfpython\"\n",
+ " >>> f'{some_string=}'\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",
+ " \n",
+ " ```py\n",
+ " import dis\n",
+ " exec(\"\"\"\n",
+ " def f():\n",
+ " \"\"\" + \"\"\"\n",
+ " \"\"\".join([\"X\" + str(x) + \"=\" + str(x) for x in range(65539)]))\n",
+ "\n",
+ " f()\n",
+ "\n",
+ " 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/3/library/multiprocessing.html) module.\n",
+ "\n",
+ "* Sometimes, the `print` method might not print values immediately. For example,\n",
+ "\n",
+ " ```py\n",
+ " # File some_file.py\n",
+ " import time\n",
+ " \n",
+ " print(\"wtfpython\", end=\"_\")\n",
+ " time.sleep(3)\n",
+ " ```\n",
+ "\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",
+ " >>> some_list = [1, 2, 3, 4, 5]\n",
+ " >>> some_list[111:]\n",
+ " []\n",
+ " ```\n",
+ "\n",
+ "* Slicing an iterable not always creates a new object. For example,\n",
+ " ```py\n",
+ " >>> some_str = \"wtfpython\"\n",
+ " >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']\n",
+ " >>> some_list is some_list[:] # False expected because a new object is created.\n",
+ " False\n",
+ " >>> some_str is some_str[:] # True because strings are immutable, so making a new object is of not much use.\n",
+ " 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](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",
+ " ```py\n",
+ " >>> six_million = 6_000_000\n",
+ " >>> six_million\n",
+ " 6000000\n",
+ " >>> hex_address = 0xF00D_CAFE\n",
+ " >>> hex_address\n",
+ " 4027435774\n",
+ " ```\n",
+ "\n",
+ "* `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear\n",
+ " ```py\n",
+ " def count(s, sub):\n",
+ " result = 0\n",
+ " for i in range(len(s) + 1 - len(sub)):\n",
+ " result += (s[i:i + len(sub)] == sub)\n",
+ " 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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 First things first! *\n",
+ "For some reason, the Python 3.8's \"Walrus\" operator (`:=`) has become quite popular. Let's check it out,\n",
+ "\n",
+ "1\\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ "# Python version 3.8+\n",
+ "\n",
+ ">>> a = \"wtf_walrus\"\n",
+ ">>> a\n",
+ "```\n",
+ "```py\n",
+ "'wtf_walrus'\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> a := \"wtf_walrus\"\n",
+ "```\n",
+ "```py\n",
+ "File \"\", line 1\n",
+ " a := \"wtf_walrus\"\n",
+ " ^\n",
+ "SyntaxError: invalid syntax\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "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",
+ "'wtf_walrus'\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "2 \\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ "# Python version 3.8+\n",
+ "\n",
+ ">>> a = 6, 9\n",
+ ">>> a\n",
+ "```\n",
+ "```py\n",
+ "(6, 9)\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "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",
+ "6\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> a, b = 6, 9 # Typical unpacking\n",
+ ">>> a, b\n",
+ "```\n",
+ "```py\n",
+ "(6, 9)\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> (a, b = 16, 19) # Oops\n",
+ "```\n",
+ "```py\n",
+ " File \"\", line 1\n",
+ " (a, b = 6, 9)\n",
+ " ^\n",
+ "SyntaxError: invalid syntax\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> (a, b := 16, 19) # This prints out a weird 3-tuple\n",
+ "```\n",
+ "```py\n",
+ "(6, 16, 19)\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> a # a is still unchanged?\n",
+ "```\n",
+ "```py\n",
+ "6\n",
+ "\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> b\n",
+ "```\n",
+ "```py\n",
+ "16\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "**Quick walrus operator refresher**\n",
+ "\n",
+ "The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situations where you'd want to assign values to variables within an expression.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ "def some_func():\n",
+ " # Assume some expensive computation here\n",
+ " # time.sleep(1000)\n",
+ " return 5\n",
+ "\n",
+ "# So instead of,\n",
+ "if some_func():\n",
+ " print(some_func()) # Which is bad practice since computation is happening twice\n",
+ "\n",
+ "# or\n",
+ "a = some_func()\n",
+ "if a:\n",
+ " print(a)\n",
+ "\n",
+ "# Now you can concisely write\n",
+ "if a := some_func():\n",
+ " print(a)\n",
+ "```\n",
+ "```py\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (> 3.8):**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ "5\n",
+ "5\n",
+ "5\n",
+ "```\n",
+ "```py\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "This saved one line of code, and implicitly prevented invoking `some_func` twice.\n",
+ "\n",
+ "- Unparenthesized \"assignment expression\" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := \"wtf_walrus\"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`. \n",
+ "\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",
+ "\n",
+ " - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6')\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " >>> (a := 6, 9) == ((a := 6), 9)\n",
+ "```\n",
+ "```py\n",
+ " True\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " >>> x = (a := 696, 9)\n",
+ " >>> x\n",
+ "```\n",
+ "```py\n",
+ " (696, 9)\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " >>> x[0] is a # Both reference same memory location\n",
+ "```\n",
+ "```py\n",
+ " True\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ " - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple. \n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Stubborn `del` operation\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ "class SomeClass:\n",
+ " def __del__(self):\n",
+ " print(\"Deleted!\")\n",
+ "```\n",
+ "```py\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "1\\.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> x = SomeClass()\n",
+ ">>> y = x\n",
+ ">>> del x # this should print \"Deleted!\"\n",
+ ">>> del y\n",
+ "```\n",
+ "```py\n",
+ "Deleted!\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> x = SomeClass()\n",
+ ">>> y = x\n",
+ ">>> del x\n",
+ ">>> y # check if y exists\n",
+ "```\n",
+ "```py\n",
+ "<__main__.SomeClass instance at 0x7f98a1a67fc8>\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> del y # Like previously, this should print \"Deleted!\"\n",
+ ">>> globals() # oh, it didn't. Let's check all our global variables and confirm\n",
+ "```\n",
+ "```py\n",
+ "Deleted!\n",
+ "{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Okay, now it's deleted :confused:\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "+ `del x` doesn\u2019t directly call `x.__del__()`.\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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Wild imports *\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ "# File: module.py\n",
+ "\n",
+ "def some_weird_name_func_():\n",
+ " print(\"works!\")\n",
+ "\n",
+ "def _another_weird_name_func():\n",
+ " print(\"works!\")\n",
+ "\n",
+ "```\n",
+ "```py\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> from module import *\n",
+ ">>> some_weird_name_func_()\n",
+ "```\n",
+ "```py\n",
+ "\"works!\"\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ ">>> _another_weird_name_func()\n",
+ "```\n",
+ "```py\n",
+ "Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ "NameError: name '_another_weird_name_func' is not defined\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "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 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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " >>> from module import some_weird_name_func_, _another_weird_name_func\n",
+ " >>> _another_weird_name_func()\n",
+ "```\n",
+ "```py\n",
+ " works!\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- If you really want to use wildcard imports, then you'd have to define the list `__all__` in your module that will contain a list of public objects that'll be available when we do wildcard imports.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " __all__ = ['_another_weird_name_func']\n",
+ "\n",
+ " def some_weird_name_func_():\n",
+ " print(\"works!\")\n",
+ "\n",
+ " def _another_weird_name_func():\n",
+ " print(\"works!\")\n",
+ "```\n",
+ "```py\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " **Output**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " >>> _another_weird_name_func()\n",
+ "```\n",
+ "```py\n",
+ " \"works!\"\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```py\n",
+ " >>> some_weird_name_func_()\n",
+ "```\n",
+ "```py\n",
+ " Traceback (most recent call last):\n",
+ " File \"\", line 1, in \n",
+ " NameError: name 'some_weird_name_func_' is not defined\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Contributing\n",
+ "\n",
+ "A few ways in which you can contribute to wtfpython,\n",
+ "\n",
+ "- Suggesting new examples\n",
+ "- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))\n",
+ "- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc.\n",
+ "- Identifying gaps (things like inadequate explanation, redundant examples, etc.)\n",
+ "- Any creative suggestions to make this project more fun and useful\n",
+ "\n",
+ "Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new) to discuss things.\n",
+ "\n",
+ "PS: Please don't reach out with backlinking requests, no links will be added unless they're highly relevant to the project.\n",
+ "\n",
+ "# Acknowledgements\n",
+ "\n",
+ "The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by Pythonistas gave it the shape it is in right now.\n",
+ "\n",
+ "#### Some nice Links!\n",
+ "* https://www.youtube.com/watch?v=sH4XF6pKKmk\n",
+ "* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python\n",
+ "* https://sopython.com/wiki/Common_Gotchas_In_Python\n",
+ "* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines\n",
+ "* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python\n",
+ "* https://www.python.org/doc/humor/\n",
+ "* 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",
+ "[![WTFPL 2.0][license-image]][license-url]\n",
+ "\n",
+ "© [Satwik Kansal](https://satwikkansal.xyz)\n",
+ "\n",
+ "[license-url]: http://www.wtfpl.net\n",
+ "[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square\n",
+ "\n"
+ ]
+ }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/noxfile.py b/noxfile.py
new file mode 100644
index 00000000..f693b854
--- /dev/null
+++ b/noxfile.py
@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+import nox
+
+
+if TYPE_CHECKING:
+ from nox.sessions import Session
+
+python_versions = ["3.9", "3.10", "3.11", "3.12", "3.13"]
+
+@nox.session(python=python_versions, reuse_venv=True)
+def tests(session: "Session") -> None:
+ _ = session.run("python", "snippets/2_tricky_strings.py")
diff --git a/package.json b/package.json
deleted file mode 100644
index f6170911..00000000
--- a/package.json
+++ /dev/null
@@ -1,41 +0,0 @@
-{
- "name": "wtfpython",
- "version": "2.1.0",
- "description": "A collection of surprising Python snippets and lesser known features.",
- "bin": "wtfpython",
- "scripts": {
- "postpublish": "git push origin master",
- "toc": "doctoc --github --title '# Table of Contents' --maxlevel 3 README.md"
- },
- "repository": {
- "type": "git",
- "url": "git+https://github.com/satwikkansal/wtfPython.git"
- },
- "keywords": [
- "python",
- "specification",
- "notes",
- "wtf",
- "learning",
- "guide",
- "handbook"
- ],
- "author": "Satwik Kansal (https://satwikkansal.xyz)",
- "license": "WTFPL 2.0",
- "bugs": {
- "url": "https://github.com/satwikkansal/wtfPython/issues"
- },
- "homepage": "https://github.com/satwikkansal/wtfPython#readme",
- "devDependencies": {
- "doctoc": "^1.3.0"
- },
- "dependencies": {
- "boxen": "^1.1.0",
- "chalk": "^1.1.1",
- "default-pager": "^1.1.0",
- "meow": "^3.7.0",
- "msee": "^0.3.3",
- "through2": "^2.0.2",
- "update-notifier": "^2.0.0"
- }
-}
diff --git a/poetry.lock b/poetry.lock
new file mode 100644
index 00000000..47b34986
--- /dev/null
+++ b/poetry.lock
@@ -0,0 +1,155 @@
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
+
+[[package]]
+name = "argcomplete"
+version = "3.5.1"
+description = "Bash tab completion for argparse"
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "argcomplete-3.5.1-py3-none-any.whl", hash = "sha256:1a1d148bdaa3e3b93454900163403df41448a248af01b6e849edc5ac08e6c363"},
+ {file = "argcomplete-3.5.1.tar.gz", hash = "sha256:eb1ee355aa2557bd3d0145de7b06b2a45b0ce461e1e7813f5d066039ab4177b4"},
+]
+
+[package.extras]
+test = ["coverage", "mypy", "pexpect", "ruff", "wheel"]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+description = "Cross-platform colored terminal text."
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+files = [
+ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
+ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
+]
+
+[[package]]
+name = "colorlog"
+version = "6.8.2"
+description = "Add colours to the output of Python's logging module."
+optional = false
+python-versions = ">=3.6"
+files = [
+ {file = "colorlog-6.8.2-py3-none-any.whl", hash = "sha256:4dcbb62368e2800cb3c5abd348da7e53f6c362dda502ec27c560b2e58a66bd33"},
+ {file = "colorlog-6.8.2.tar.gz", hash = "sha256:3e3e079a41feb5a1b64f978b5ea4f46040a94f11f0e8bbb8261e3dbbeca64d44"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+
+[package.extras]
+development = ["black", "flake8", "mypy", "pytest", "types-colorama"]
+
+[[package]]
+name = "distlib"
+version = "0.3.9"
+description = "Distribution utilities"
+optional = false
+python-versions = "*"
+files = [
+ {file = "distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87"},
+ {file = "distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403"},
+]
+
+[[package]]
+name = "filelock"
+version = "3.16.1"
+description = "A platform independent file lock."
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"},
+ {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"},
+]
+
+[package.extras]
+docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"]
+typing = ["typing-extensions (>=4.12.2)"]
+
+[[package]]
+name = "nox"
+version = "2024.10.9"
+description = "Flexible test automation."
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "nox-2024.10.9-py3-none-any.whl", hash = "sha256:1d36f309a0a2a853e9bccb76bbef6bb118ba92fa92674d15604ca99adeb29eab"},
+ {file = "nox-2024.10.9.tar.gz", hash = "sha256:7aa9dc8d1c27e9f45ab046ffd1c3b2c4f7c91755304769df231308849ebded95"},
+]
+
+[package.dependencies]
+argcomplete = ">=1.9.4,<4"
+colorlog = ">=2.6.1,<7"
+packaging = ">=20.9"
+tomli = {version = ">=1", markers = "python_version < \"3.11\""}
+virtualenv = ">=20.14.1"
+
+[package.extras]
+tox-to-nox = ["jinja2", "tox"]
+uv = ["uv (>=0.1.6)"]
+
+[[package]]
+name = "packaging"
+version = "24.1"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
+ {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.3.6"
+description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"},
+ {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"},
+]
+
+[package.extras]
+docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"]
+test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"]
+type = ["mypy (>=1.11.2)"]
+
+[[package]]
+name = "tomli"
+version = "2.0.2"
+description = "A lil' TOML parser"
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "tomli-2.0.2-py3-none-any.whl", hash = "sha256:2ebe24485c53d303f690b0ec092806a085f07af5a5aa1464f3931eec36caaa38"},
+ {file = "tomli-2.0.2.tar.gz", hash = "sha256:d46d457a85337051c36524bc5349dd91b1877838e2979ac5ced3e710ed8a60ed"},
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.27.0"
+description = "Virtual Python Environment builder"
+optional = false
+python-versions = ">=3.8"
+files = [
+ {file = "virtualenv-20.27.0-py3-none-any.whl", hash = "sha256:44a72c29cceb0ee08f300b314848c86e57bf8d1f13107a5e671fb9274138d655"},
+ {file = "virtualenv-20.27.0.tar.gz", hash = "sha256:2ca56a68ed615b8fe4326d11a0dca5dfbe8fd68510fb6c6349163bed3c15f2b2"},
+]
+
+[package.dependencies]
+distlib = ">=0.3.7,<1"
+filelock = ">=3.12.2,<4"
+platformdirs = ">=3.9.1,<5"
+
+[package.extras]
+docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
+test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.9"
+content-hash = "af91619c8e62e649ee538e51a248ef2fc1e4f4495e7748b3b551685aa47b404e"
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..a048fafe
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "wtfpython"
+version = "3.0.0"
+description = "What the f*ck Python!"
+authors = ["Satwik Kansal "]
+license = "WTFPL 2.0"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+nox = "^2024.10.9"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
diff --git a/snippets/2_tricky_strings.py b/snippets/2_tricky_strings.py
new file mode 100644
index 00000000..25320f27
--- /dev/null
+++ b/snippets/2_tricky_strings.py
@@ -0,0 +1,19 @@
+# 1
+assert id("some_string") == id("some" + "_" + "string")
+assert id("some_string") == id("some_string")
+
+# 2
+a = "wtf"
+b = "wtf"
+assert a is b
+
+a = "wtf!"
+b = "wtf!"
+assert a is b
+
+# 3
+a, b = "wtf!", "wtf!"
+assert a is b
+
+a = "wtf!"; b = "wtf!"
+assert a is b
diff --git a/wtfpython-pypi/wtf_python/__init__.py b/snippets/__init__.py
similarity index 100%
rename from wtfpython-pypi/wtf_python/__init__.py
rename to snippets/__init__.py
diff --git a/translations/fa-farsi/README.md b/translations/fa-farsi/README.md
new file mode 100644
index 00000000..cddeb0b7
--- /dev/null
+++ b/translations/fa-farsi/README.md
@@ -0,0 +1,4229 @@
+
+
+
+
+
+
+
+
+
+What the f*ck Python! 😱
+کاوش و درک پایتون از طریق تکههای کد شگفتانگیز.
+
+ترجمهها: [انگلیسی English](https://github.com/satwikkansal/wtfpython) | [چینی 中文](https://github.com/leisurelicht/wtfpython-cn) | [ویتنامی Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [اسپانیایی Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [کرهای 한국어](https://github.com/buttercrab/wtfpython-ko) | [روسی Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [آلمانی Deutsch](https://github.com/BenSt099/wtfpython) | [Persian فارسی](https://github.com/satwikkansal/wtfpython/tree/master/translations/fa-farsi) | [اضافه کردن ترجمه](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) | [دفترچه تعاملی](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb)
+
+پایتون، یه زبان زیبا طراحی شده، سطح بالا و مبتنی بر مفسره که قابلیتهای بسیاری برای راحتی ما برنامهنویسها فراهم میکنه.
+ولی گاهی اوقات قطعهکدهایی رو میبینیم که تو نگاه اول خروجیهاشون واضح نیست.
+
+این یه پروژه باحاله که سعی داریم توش توضیح بدیم که پشت پرده یه سری قطعهکدهای غیرشهودی و قابلیتهای کمتر شناخته شده پایتون
+چه خبره.
+
+درحالی که بعضی از مثالهایی که قراره تو این سند ببینید واقعا عجیب و غریب نیستند ولی بخشهای جالبی از پایتون رو ظاهر میکنند که
+ممکنه شما از وجودشون بیخبر باشید. به نظرم این شیوه جالبیه برای یادگیری جزئیات داخلی یه زبان برنامه نویسی و باور دارم که
+برای شما هم جالب خواهد بود.
+
+اگه شما یه پایتون کار سابقهدار هستید، میتونید از این فرصت به عنوان یه چالش برای خودتون استفاده کنید تا بیشتر مثالها رو
+تو تلاش اول حدس بزنید. ممکنه شما بعضی از این مثالها رو قبلا تجربه کرده باشید و من خاطراتشون رو در این سند براتون زنده
+کرده باشم! :sweat_smile:
+
+پ.ن: اگه شما قبلا این سند رو خوندید، میتونید تغییرات جدید رو در بخش انتشار (فعلا در [اینجا](https://github.com/satwikkansal/wtfpython/releases/)) مطالعه کنید
+(مثالهایی که کنارشون علامت ستاره دارند، در آخرین ویرایش اضافه شدهاند).
+
+پس، بزن بریم...
+
+# فهرست مطالب
+
+
+
+
+
+- [فهرست مطالب](#فهرست-مطالب)
+- [ساختار مثالها](#ساختار-مثالها)
+- [استفاده](#استفاده)
+- [👀 مثالها](#-مثالها)
+ - [بخش: ذهن خود را به چالش بکشید!](#بخش-ذهن-خود-را-به-چالش-بکشید)
+ - [◀ اول از همه! \*](#-اول-از-همه-)
+ - [💡 توضیح](#-توضیح)
+ - [◀ بعضی وقتها رشتهها میتوانند دردسرساز شوند](#-بعضی-وقتها-رشتهها-میتوانند-دردسرساز-شوند)
+ - [💡 توضیح:](#-توضیح-1)
+ - [◀ مراقب عملیاتهای زنجیرهای باشید](#-مراقب-عملیاتهای-زنجیرهای-باشید)
+ - [💡 توضیح:](#-توضیح-2)
+ - [◀ چطور از عملگر `is` استفاده نکنیم](#-چطور-از-عملگر-is-استفاده-نکنیم)
+ - [💡 توضیح:](#-توضیح-3)
+ - [◀ کلیدهای هش](#-کلیدهای-هش)
+ - [💡 توضیح](#-توضیح-4)
+ - [◀ در عمق وجود همه ما یکسان هستیم](#-در-عمق-وجود-همه-ما-یکسان-هستیم)
+ - [💡 توضیح:](#-توضیح-5)
+ - [◀ بینظمی در خود نظم \*](#-بینظمی-در-خود-نظم-)
+ - [💡 توضیح:](#-توضیح-6)
+ - [💡 توضیح:](#-توضیح-7)
+ - [◀ برای چی؟](#-برای-چی)
+ - [💡 توضیح:](#-توضیح-8)
+ - [◀ اختلاف زمانی در محاسبه](#-اختلاف-زمانی-در-محاسبه)
+ - [💡 توضیح](#-توضیح-9)
+ - [◀ هر گردی، گردو نیست](#-هر-گردی-گردو-نیست)
+ - [💡 توضیح](#-توضیح-10)
+ - [◀ یک بازی دوز که توش X همون اول برنده میشه!](#-یک-بازی-دوز-که-توش-x-همون-اول-برنده-میشه)
+ - [💡 توضیح:](#-توضیح-11)
+ - [◀ متغیر شرودینگر \*](#-متغیر-شرودینگر-)
+ - [💡 توضیح:](#-توضیح-12)
+ - [◀ اول مرغ بوده یا تخم مرغ؟ \*](#-اول-مرغ-بوده-یا-تخم-مرغ-)
+ - [💡 توضیح](#-توضیح-13)
+ - [◀ روابط بین زیرمجموعه کلاسها](#-روابط-بین-زیرمجموعه-کلاسها)
+ - [💡 توضیح:](#-توضیح-14)
+ - [◀ برابری و هویت متدها](#-برابری-و-هویت-متدها)
+ - [💡 توضیح](#-توضیح-15)
+ - [◀ آل-ترو-یشن \*](#-آل-ترو-یشن-)
+ - [💡 توضیحات:](#-توضیحات)
+ - [💡 توضیح:](#-توضیح-16)
+ - [◀ رشتهها و بکاسلشها](#-رشتهها-و-بکاسلشها)
+ - [💡 توضیح:](#-توضیح-17)
+ - [◀ گره نیست، نَه!](#-گره-نیست-نَه)
+ - [💡 توضیح:](#-توضیح-18)
+ - [◀ رشتههای نیمه سهنقلقولی](#-رشتههای-نیمه-سهنقلقولی)
+ - [💡 توضیح:](#-توضیح-19)
+ - [◀ مشکل بولین ها چیست؟](#-مشکل-بولین-ها-چیست)
+ - [💡 توضیح:](#-توضیح-20)
+ - [◀ متغیرهای کلاس و متغیرهای نمونه](#-متغیرهای-کلاس-و-متغیرهای-نمونه)
+ - [💡 توضیح:](#-توضیح-21)
+ - [◀ واگذار کردن None](#-واگذار-کردن-none)
+ - [💡 توضیح:](#-توضیح-22)
+ - [◀ بازگرداندن با استفاده از `yield from`!](#-بازگرداندن-با-استفاده-از-yield-from)
+ - [💡 توضیح:](#-توضیح-23)
+ - [◀ بازتابناپذیری \*](#-بازتابناپذیری-)
+ - [💡 توضیح:](#-توضیح-24)
+ - [◀ تغییر دادن اشیای تغییرناپذیر!](#-تغییر-دادن-اشیای-تغییرناپذیر)
+ - [💡 توضیح:](#-توضیح-25)
+ - [◀ متغیری که از اسکوپ بیرونی ناپدید میشود](#-متغیری-که-از-اسکوپ-بیرونی-ناپدید-میشود)
+ - [💡 توضیح:](#-توضیح-26)
+ - [◀ تبدیل اسرارآمیز نوع کلید](#-تبدیل-اسرارآمیز-نوع-کلید)
+ - [💡 توضیح:](#-توضیح-27)
+ - [◀ ببینیم میتوانید این را حدس بزنید؟](#-ببینیم-میتوانید-این-را-حدس-بزنید)
+ - [💡 توضیح:](#-توضیح-28)
+ - [◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر میرود](#-از-حد-مجاز-برای-تبدیل-رشته-به-عدد-صحیح-فراتر-میرود)
+ - [💡 توضیح:](#-توضیح-29)
+ - [بخش: شیبهای لغزنده](#بخش-شیبهای-لغزنده)
+ - [◀ تغییر یک دیکشنری هنگام پیمایش روی آن](#-تغییر-یک-دیکشنری-هنگام-پیمایش-روی-آن)
+ - [💡 توضیح:](#-توضیح-30)
+ - [◀ عملیات سرسختانهی `del`](#-عملیات-سرسختانهی-del)
+ - [💡 توضیح:](#-توضیح-31)
+ - [◀ متغیری که از حوزه خارج است](#-متغیری-که-از-حوزه-خارج-است)
+ - [💡 توضیح:](#-توضیح-32)
+ - [◀ حذف المانهای لیست در حین پیمایش](#-حذف-المانهای-لیست-در-حین-پیمایش)
+ - [💡 توضیح:](#-توضیح-33)
+ - [◀ زیپِ دارای اتلاف برای پیمایشگرها \*](#-زیپِ-دارای-اتلاف-برای-پیمایشگرها-)
+ - [💡 توضیح:](#-توضیح-34)
+ - [◀ نشت کردن متغیرهای حلقه!](#-نشت-کردن-متغیرهای-حلقه)
+ - [💡 توضیح:](#-توضیح-35)
+ - [◀ مراقب آرگومانهای تغییرپذیر پیشفرض باشید!](#-مراقب-آرگومانهای-تغییرپذیر-پیشفرض-باشید)
+ - [💡 توضیح:](#-توضیح-36)
+ - [◀ گرفتن استثناها (Exceptions)](#-گرفتن-استثناها-exceptions)
+ - [💡 توضیح](#-توضیح-37)
+ - [◀ عملوندهای یکسان، داستانی متفاوت!](#-عملوندهای-یکسان-داستانی-متفاوت)
+ - [💡 توضیح:](#-توضیح-38)
+ - [◀ تفکیک نامها با نادیده گرفتن حوزهی کلاس](#-تفکیک-نامها-با-نادیده-گرفتن-حوزهی-کلاس)
+ - [💡 توضیح](#-توضیح-39)
+ - [◀ گرد کردن به روش بانکدار \*](#-گرد-کردن-به-روش-بانکدار-)
+ - [💡 توضیح:](#-توضیح-40)
+ - [◀ سوزنهایی در انبار کاه \*](#-سوزنهایی-در-انبار-کاه-)
+ - [💡 توضیح:](#-توضیح-41)
+ - [◀ تقسیمها \*](#-تقسیمها-)
+ - [💡 توضیح:](#-توضیح-42)
+ - [◀ واردسازیهای عمومی \*](#-واردسازیهای-عمومی-)
+ - [💡 توضیح:](#-توضیح-43)
+ - [◀ همه چیز مرتب شده؟ \*](#-همه-چیز-مرتب-شده-)
+ - [💡 توضیح:](#-توضیح-44)
+ - [◀ زمان نیمهشب وجود ندارد؟](#-زمان-نیمهشب-وجود-ندارد)
+ - [💡 توضیح:](#-توضیح-45)
+ - [بخش: گنجینههای پنهان!](#بخش-گنجینههای-پنهان)
+ - [◀ خب پایتون، میتوانی کاری کنی پرواز کنم؟](#-خب-پایتون-میتوانی-کاری-کنی-پرواز-کنم)
+ - [💡 توضیح:](#-توضیح-46)
+ - [◀ `goto`، ولی چرا؟](#-goto-ولی-چرا)
+ - [💡 توضیح:](#-توضیح-47)
+ - [◀ خودتان را آماده کنید!](#-خودتان-را-آماده-کنید)
+ - [💡 توضیح:](#-توضیح-48)
+ - [◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم](#-بیایید-با-عمو-زبان-مهربان-برای-همیشه-آشنا-شویم)
+ - [💡 توضیح:](#-توضیح-49)
+ - [◀ حتی پایتون هم میداند که عشق پیچیده است](#-حتی-پایتون-هم-میداند-که-عشق-پیچیده-است)
+ - [💡 توضیح:](#-توضیح-50)
+ - [◀ بله، این واقعاً وجود دارد!](#-بله-این-واقعاً-وجود-دارد)
+ - [💡 توضیح:](#-توضیح-51)
+ - [◀ عملگر Ellipsis \*](#-عملگر-ellipsis-)
+ - [💡توضیح](#توضیح)
+ - [◀ بینهایت (`Inpinity`)](#-بینهایت-inpinity)
+ - [💡 توضیح:](#-توضیح-52)
+ - [◀ بیایید خرابکاری کنیم](#-بیایید-خرابکاری-کنیم)
+ - [💡 توضیح:](#-توضیح-53)
+ - [بخش: ظاهرها فریبندهاند!](#بخش-ظاهرها-فریبندهاند)
+ - [◀ خطوط را رد میکند؟](#-خطوط-را-رد-میکند)
+ - [💡 توضیح](#-توضیح-54)
+ - [◀ تلهپورت کردن](#-تلهپورت-کردن)
+ - [💡 توضیح:](#-توضیح-55)
+ - [◀ خب، یک جای کار مشکوک است...](#-خب-یک-جای-کار-مشکوک-است)
+ - [💡 توضیح](#-توضیح-56)
+ - [بخش: متفرقه](#بخش-متفرقه)
+ - [◀ `+=` سریعتر است](#--سریعتر-است)
+ - [💡 توضیح:](#-توضیح-57)
+ - [◀ بیایید یک رشتهی بزرگ بسازیم!](#-بیایید-یک-رشتهی-بزرگ-بسازیم)
+ - [💡 توضیح](#-توضیح-58)
+ - [◀ کُند کردن جستجوها در `dict` \*](#-کُند-کردن-جستجوها-در-dict-)
+ - [💡 توضیح:](#-توضیح-59)
+ - [◀ حجیم کردن دیکشنری نمونهها (`instance dicts`) \*](#-حجیم-کردن-دیکشنری-نمونهها-instance-dicts-)
+ - [💡 توضیح:](#-توضیح-60)
+ - [◀ موارد جزئی \*](#-موارد-جزئی-)
+- [مشارکت](#مشارکت)
+- [تقدیر و تشکر](#تقدیر-و-تشکر) - [چند لینک جالب!](#چند-لینک-جالب)
+- [🎓 مجوز](#-مجوز)
+ - [دوستانتان را هم شگفتزده کنید!](#دوستانتان-را-هم-شگفتزده-کنید)
+ - [آیا به یک نسخه pdf نیاز دارید؟](#آیا-به-یک-نسخه-pdf-نیاز-دارید)
+
+
+
+# ساختار مثالها
+
+همه مثالها به صورت زیر ساخته میشوند:
+
+> ### ◀ یه اسم خوشگل
+>
+> ```py
+> # راه اندازی کد
+> # آماده سازی برای جادو...
+> ```
+>
+> **خروجی (نسخه(های) پایتون):**
+>
+> ```py
+> >>> triggering_statement
+> یه خروجی غیرمنتظره
+> ```
+>
+> (دلخواه): توضیح یکخطی خروجی غیرمنتظره
+>
+> #### 💡 توضیح:
+>
+> - توضیح کوتاه درمورد اینکه چی داره اتفاق میافته و چرا.
+>
+> ```py
+> # راه اندازی کد
+> # مثالهای بیشتر برای شفاف سازی (در صورت نیاز)
+> ```
+>
+> **خروجی (نسخه(های) پایتون):**
+>
+> ```py
+> >>> trigger # یک مثال که رونمایی از جادو رو راحتتر میکنه
+> # یک خروجی توجیه شده و واضح
+> ```
+
+**توجه:** همه مثالها در برنامه مفسر تعاملی پایتون نسخه
+۳.۵.۲ آزمایش شدهاند و باید در همه نسخههای پایتون کار
+کنند مگراینکه به صورت جداگانه و به طور واضح نسخه مخصوص
+پایتون قبل از خروجی ذکر شده باشد.
+
+# استفاده
+
+یه راه خوب برای بیشتر بهره بردن، به نظرم، اینه که مثالها رو به ترتیب متوالی بخونید و برای هر مثال:
+
+- کد ابتدایی برای راه اندازی مثال رو با دقت بخونید. اگه شما یه پایتون کار سابقهدار باشید، با موفقیت بیشتر اوقات اتفاق بعدی رو پیشبینی میکنید.
+- قطعه خروجی رو بخونید و
+ - بررسی کنید که آیا خروجیها همونطور که انتظار دارید هستند.
+ - مطمئین بشید که دقیقا دلیل اینکه خروجی اون طوری هست رو میدونید.
+ - اگه نمیدونید (که کاملا عادیه و اصلا بد نیست)، یک نفس عمیق بکشید و توضیحات رو بخونید (و اگه نفهمیدید، داد بزنید! و [اینجا](https://github.com/emargi/wtfpython/issues/new) درموردش حرف بزنید).
+ - اگه میدونید، به افتخار خودتون یه دست محکم بزنید و برید سراغ مثال بعدی.
+
+---
+
+# 👀 مثالها
+
+## بخش: ذهن خود را به چالش بکشید!
+
+### ◀ اول از همه! \*
+
+
+
+
+به دلایلی، عملگر "Walrus" (`:=`) که در نسخه ۳.۸ پایتون معرفی شد، خیلی محبوب شده. بیاید بررسیش کنیم.
+
+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) # این یه تاپل ۳تایی چاپ میکنه رو صفحه
+(6, 16, 19)
+
+>>> a # هنوز تغییر نکرده؟
+6
+
+>>> b
+16
+```
+
+#### 💡 توضیح
+
+**مرور سریع بر عملگر Walrus**
+
+عملگر Walrus همونطور که اشاره شد، در نسخه ۳.۸ پایتون معرفی
+شد. این عملگر میتونه تو موقعیتهایی کاربردی باشه که شما میخواید داخل یه عبارت، مقادیری رو به متغیرها اختصاص بدید.
+
+```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)
+
+```
+
+**خروجی (+۳.۸):**
+
+```py
+5
+5
+5
+```
+
+این باعث میشه که یک خط کمتر کد بزنیم و از دوبار فراخوندن `some_func` جلوگیری کرد.
+
+- "عبارت اختصاصدادن مقدار" بدون پرانتز (نحوه استفاده عملگر Walrus)، در سطح بالا محدود است، `SyntaxError` در عبارت `a := "wtf_walrus"` در قطعهکد اول به همین دلیل است. قرار دادن آن داخل پرانتز، همانطور که میخواستیم کار کرد و مقدار را به `a` اختصاص داد.
+
+- به طور معمول، قرار دادن عبارتی که دارای `=` است داخل پرانتز مجاز نیست. به همین دلیل عبارت `(a, b = 6, 9)` به ما خطای سینتکس داد.
+
+- قائده استفاده از عملگر Walrus به صورت `NAME:= expr` است، به طوری که `NAME` یک شناسه صحیح و `expr` یک عبارت صحیح است. به همین دلیل باز و بسته کردن با تکرار (iterable) پشتیبانی نمیشوند. پس،
+
+ - عبارت `(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)` است که چیزی جز یک تاپل ۳تایی نیست.
+
+---
+
+### ◀ بعضی وقتها رشتهها میتوانند دردسرساز شوند
+
+
+
+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 # همهی نسخهها به جز 3.7.x
+True
+
+>>> a = "wtf!"; b = "wtf!"
+>>> a is b # ممکن است True یا False باشد بسته به جایی که آن را اجرا میکنید (python shell / ipython / بهصورت اسکریپت)
+False
+```
+
+```py
+# این بار در فایل some_file.py
+a = "wtf!"
+b = "wtf!"
+print(a is b)
+
+# موقع اجرای ماژول، True را چاپ میکند!
+```
+
+4\.
+
+**خروجی (< Python3.7 )**
+
+```py
+>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
+True
+>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
+False
+```
+
+منطقیه، نه؟
+
+#### 💡 توضیح:
+
+- در قطعهکد اول و دوم، رفتار کد به دلیل یک بهینه سازی در CPython است (به نام داوطلب سازی رشتهها) که باعث میشود از برخی مقادیر غیرقابل تغییر، به جای مقداردهی مجدد، دوباره استفاده شود.
+- بیشتر متغیرهایی که بهاین صورت جایگزین میشوند، در حافظه دستگاه به مقدار داوطلب خود اشاره میکنند (تا از حافظه کمتری استفاده شود)
+- در قطعهکدهای بالا، رشتهها بهصورت غیرمستقیم داوطلب میشوند. تصمیم اینکه رشتهها چه زمانی به صورت غیرمستقیم داوطلب شوند به نحوه پیادهسازی و مقداردهی آنها بستگی دارد. برخی قوانین وجود دارند تا بتوانیم داوطلب شدن یا نشدن یک رشته را حدس بزنیم:
+ - همه رشتهها با طول صفر یا یک داوطلب میشوند.
+ - رشتهها در زمان کامپایل داوطلب میشوند (`'wtf'` داوطلب میشود اما `''.join(['w', 't', 'f'])` داوطلب نمیشود)
+ - رشتههایی که از حروف ASCII ، اعداد صحیح و آندرلاین تشکیل نشدهباشند داوطلب نمیشود. به همین دلیل `'wtf!'` به خاطر وجود `'!'` داوطلب نشد. پیادهسازی این قانون در CPython در [اینجا](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19) قرار دارد.
+
+
+
+
+
+
+
+
+- زمانی که `"wtf!"` را در یک خط به `a` و `b` اختصاص میدهیم، مفسر پایتون شیء جدید میسازد و متغیر دوم را به آن ارجاع میدهد. اگر مقدار دهی در خطهای جدا از هم انجام شود، در واقع مفسر "خبر ندارد" که یک شیء مختص به `"wtf!"` از قبل در برنامه وجود دارد (زیرا `"wtf!"` به دلایلی که در بالا گفته شد، بهصورت غیرمستقیم داوطلب نمیشود). این بهینه سازی در زمان کامپایل انجام میشود. این بهینه سازی همچنین برای نسخه های (x).۳.۷ وجود ندارد (برای گفتوگوی بیشتر این [موضوع](https://github.com/satwikkansal/wtfpython/issues/100) را ببینید).
+- یک واحد کامپایل در یک محیط تعاملی مانند IPython از یک عبارت تشکیل میشود، در حالی که برای ماژولها شامل کل ماژول میشود. `a, b = "wtf!", "wtf!"` یک عبارت است. در حالی که `a = "wtf!"; b = "wtf!"` دو عبارت در یک خط است. به همین دلیل شناسهها در `a = "wtf!"; b = "wtf!"` متفاوتند و همینطور وقتی با مفسر پایتون داخل فایل `some_file.py` اجرا میشوند، شناسهها یکسانند.
+- تغییر ناگهانی در خروجی قطعهکد چهارم به دلیل [بهینهسازی پنجرهای](https://en.wikipedia.org/wiki/Peephole_optimization) است که تکنیکی معروف به جمع آوری ثابتها است. به همین خاطر عبارت `'a'*20` با `'aaaaaaaaaaaaaaaaaaaa'` در هنگام کامپایل جایگزین میشود تا کمی بار از دوش چرخهساعتی پردازنده کم شود. تکنیک جمع آوری ثابتها فقط مخصوص رشتههایی با طول کمتر از 21 است. (چرا؟ فرض کنید که فایل `.pyc` که توسط کامپایلر ساخته میشود چقدر بزرگ میشد اگر عبارت `'a'*10**10`). [این](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) هم کد پیادهسازی این تکنیک در CPython.
+- توجه: در پایتون ۳.۷، جمع آوری ثابتها از بهینهساز پنجرهای به بهینهساز AST جدید انتقال داده شد همراه با تغییراتی در منطق آن. پس چهارمین قطعهکد در پایتون نسخه ۳.۷ کار نمیکند. شما میتوانید در [اینجا](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 and b op2 c and ... y opN z است. فقط دقت کنید که هر عبارت یک بار ارزیابی میشود.
+
+شاید چنین رفتاری برای شما احمقانه به نظر بیاد ولی برای عملیاتهایی مثل `a == b == c` و `0 <= x <= 100` عالی عمل میکنه.
+
+- عبارت `False is False is False` معادل عبارت `(False is False) and (False is False)` است
+- عبارت `True is False == False` معادل عبارت `(True is False) and (False == False)` است و از آنجایی که قسمت اول این عبارت (`True is False`) پس از ارزیابی برابر با `False` میشود. پس کل عبارت معادل `False` میشود.
+- عبارت `1 > 0 < 1` معادل عبارت `(1 > 0) and (0 < 1)` است.
+- عبارت `(1 > 0) < 1` معادل عبارت `True < 1` است و :
+
+ ```py
+ >>> int(True)
+ 1
+ >>> True + 1 # مربوط به این بخش نیست ولی همینجوری گذاشتم
+ 2
+ ```
+
+ پس عبارت `True < 1` معادل عبارت `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
+```
+
+**خروجی (مخصوص نسخههای (x).۳.۷)**
+
+```py
+>>> a, b = 257, 257
+>>> a is b
+False
+```
+
+#### 💡 توضیح:
+
+**فرض بین عملگرهای `is` و `==`**
+
+- عملگر `is` بررسی میکنه که دو متغیر در حافظه دستگاه به یک شیء اشاره میکنند یا نه (یعنی شناسه متغیرها رو با هم تطبیق میده).
+- عملگر `==` مقدار متغیرها رو با هم مقایسه میکنه و یکسان بودنشون رو بررسی میکنه.
+- پس `is` برای معادل بودن متغیرها در حافظه دستگاه و `==` برای معادل بودن مقادیر استفاده میشه. یه مثال برای شفاف سازی بیشتر:
+
+ ```py
+ >>> class A: pass
+ >>> A() is A() # اینها دو شیء خالی هستند که در دو جای مختلف در حافظه قرار دارند.
+ False
+ ```
+
+**عدد `256` از قبل تو حافظه قرار داده شده ولی `257` نه؟**
+
+وقتی پایتون رو اجرا میکنید اعداد از `-5` تا `256` در حافظه ذخیره میشن. چون این اعداد خیلی پرکاربرد هستند پس منطقیه که اونها رو در حافظه دستگاه، آماده داشته باشیم.
+
+نقل قول از https://docs.python.org/3/c-api/long.html
+
+> در پیاده سازی فعلی یک آرایه از اشیاء عددی صحیح برای تمام اعداد صحیح بین `-5` تا `256` نگهداری میشود. وقتی شما یک عدد صحیح در این بازه به مقداردهی میکنید، فقط یک ارجاع به آن عدد که از قبل در حافظه ذخیره شده است دریافت میکنید. پس تغییر مقدار عدد 1 باید ممکن باشد. که در این مورد من به رفتار پایتون شک دارم تعریفنشده است. :-)
+
+```py
+>>> id(256)
+10922528
+>>> a = 256
+>>> b = 256
+>>> id(a)
+10922528
+>>> id(b)
+10922528
+>>> id(257)
+140084850247312
+>>> x = 257
+>>> y = 257
+>>> id(x)
+140084850247440
+>>> id(y)
+140084850247344
+```
+
+در اینجا مفسر وقتی عبارت `y = 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` مقداردهی میشن، مفسر پایتون یک شیء برای یکی از متغیرها در حافظه میسازه و متغیر دوم رو در حافظه به اون ارجاع میده. اگه این کار رو تو دو خط جدا از هم انجام بدید، درواقع مفسر پایتون از وجود مقدار `257` به عنوان یک شیء، "خبر نداره".
+
+- این یک بهینه سازی توسط کامپایلر هست و مخصوصا در محیط تعاملی به کار برده میشه. وقتی شما دو خط رو در یک مفسر زنده وارد میکنید، اونها به صورت جداگانه کامپایل میشن، به همین دلیل بهینه سازی به صورت جداگانه برای هرکدوم اعمال میشه. اگر بخواهید این مثال رو در یک فایل `.py` امتحان کنید، رفتار متفاوتی میبینید زیرا فایل به صورت کلی و یکجا کامپایل میشه. این بهینه سازی محدود به اعداد صحیح نیست و برای انواع دادههای غیرقابل تغییر دیگه مانند رشتهها (مثال "رشتهها میتوانند دردسرساز شوند" رو ببینید) و اعداد اعشاری هم اعمال میشه.
+
+ ```py
+ >>> a, b = 257.0, 257.0
+ >>> a is b
+ True
+ ```
+
+- چرا این برای پایتون ۳.۷ کار نکرد؟ دلیل انتزاعیش اینه که چنین بهینهسازیهای کامپایلری وابسته به پیادهسازی هستن (یعنی بسته به نسخه، و نوع سیستمعامل و چیزهای دیگه تغییر میکنن). من هنوز پیگیرم که بدونم که کدوم تغییر تو پیادهسازی باعث همچین مشکلاتی میشه، میتونید برای خبرهای بیشتر این [موضوع](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 همه جارو گرفت؟
+
+#### 💡 توضیح
+
+- تو دیکشنریهای پایتون چیزی که کلیدها رو یگانه میکنه مقدار کلیدهاست، نه شناسه اونها. پس با اینکه `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"` رو اجرا میکنید، پایتون دنبال کلیدی با مقدار یکسان میگرده که اینجا ما داریم `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` به عنوان کلید داخل دیکشنری داشته باشیم. درکل خیلی کم پیش میاد که بخوایم چنین کاری کنیم.
+
+- پایتون چطوری توی دیکشنری که کلید `5.0` رو داره، کلید `5` رو پیدا کرد؟ پایتون این کار رو توی زمان ثابتی توسط توابع هش انجام میده بدون اینکه مجبور باشه همه کلیدها رو بررسی کنه. وقتی پایتون دنبال کلیدی مثل `foo` داخل یه `dict` میگرده، اول مقدار `hash(foo)` رو محاسبه میکنه (که توی زمان ثابتی انجام میشه). از اونجایی که توی پایتون برای مقایسه برابری مقدار دو شیء لازمه که هش یکسانی هم داشته باشند ([مستندات](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
+ ```
+
+ **توجه:** برعکس این قضیه لزوما درست نیست. شیءهای میتونن هش های یکسانی داشته باشند ولی مقادیر نابرابری داشته باشند. (این باعث به وجود اومدن پدیدهای معروف [تصادف هش]() میشه)، در این صورت توابع هش عملکرد خودشون رو کندتر از حالت عادی انجام میدهند.
+
+---
+
+### ◀ در عمق وجود همه ما یکسان هستیم
+
+
+
+```py
+class WTF:
+ pass
+```
+
+**خروجی:**
+
+```py
+>>> WTF() == WTF() # دو نمونه متفاوت از یک کلاس نمیتونند برابر هم باشند
+False
+>>> WTF() is WTF() # شناسهها هم متفاوتند
+False
+>>> hash(WTF()) == hash(WTF()) # هشها هم _باید_ متفاوت باشند
+True
+>>> id(WTF()) == id(WTF())
+True
+```
+
+#### 💡 توضیح:
+
+- وقتی `id` صدا زده شد، پایتون یک شیء با کلاس `WTF` ساخت و اون رو به تابع `id` داد. تابع `id` شناسه این شیء رو میگیره (درواقع آدرس اون شیء در حافظه دستگاه) و شیء رو حذف میکنه.
+- وقتی این کار رو دو بار متوالی انجام بدیم، پایتون آدرس یکسانی رو به شیء دوم اختصاص میده. از اونجایی که (در CPython) تابع `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):
+ """
+ یک dict که تابع جادویی __hash__ هم توش پیاده شده.
+ """
+ __hash__ = lambda self: 0
+
+class OrderedDictWithHash(OrderedDict):
+ """
+ یک OrderedDict که تابع جادویی __hash__ هم توش پیاده شده.
+ """
+ __hash__ = lambda self: 0
+```
+
+**خروجی**
+
+```py
+>>> dictionary == ordered_dict # اگر مقدار اولی با دومی برابره
+True
+>>> dictionary == another_ordered_dict # و مقدار اولی با سومی برابره
+True
+>>> ordered_dict == another_ordered_dict # پس چرا مقدار دومی با سومی برابر نیست؟
+False
+
+# ما همهمون میدونیم که یک مجموعه فقط شامل عناصر منحصربهفرد و غیرتکراریه.
+# بیاید یک مجموعه از این دیکشنریها بسازیم ببینیم چه اتفاقی میافته...
+
+>>> len({dictionary, ordered_dict, another_ordered_dict})
+Traceback (most recent call last):
+ File "", line 1, in
+TypeError: unhashable type: 'dict'
+
+# منطقیه چون 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` و شیءهای قابل نگاشت دیگر به ترتیب اعضای آنها بستگی ندارد و مقایسه همانند دیکشنریهای عادی انجام میشود.
+- این رفتار باعث میشه که بتونیم `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 in 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" اجرا میشه، بخش `fianlly` هم هنگام خارج شدن اجرا میشه.
+- مقدار بازگشتی یک تابع از طریق آخرین عبارت `return` که داخل تابع اجرا میشه، مشخص میشه. از اونجایی که بخش `finally` همیشه اجرا میشه، عبارت `return` که داخل بخش `finally` هست آخرین عبارتیه که اجرا میشه.
+- نکته اینجاست که اگه بخش داخل بخش `finally` یک عبارت `return` یا `break` اجرا بشه، `exception` موقتی که ذخیره شده، رها میشه.
+
+---
+
+### ◀ برای چی؟
+
+
+
+```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` در [گرامر پایتون](https://docs.python.org/3/reference/grammar.html) این طور تعریف میشه:
+
+ ```bash
+ for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+ ```
+
+ به طوری که `exprlist` یک هدف برای مقداردهیه. این یعنی، معادل عبارت `{exprlist} = {next_value}` **برای هر شیء داخل `testlist` اجرا میشود**.
+ یک مثال جالب برای نشون دادن این تعریف:
+
+ ```py
+ for i in range(4):
+ print(i)
+ i = 10
+ ```
+
+ **خروجی:**
+
+ ```bash
+ 0
+ 1
+ 2
+ 3
+ ```
+
+ آیا انتظار داشتید که حلقه فقط یک بار اجرا بشه؟
+
+ **💡 توضیح:**
+
+ - عبارت مقداردهی `i = 10` به خاطر نحوه کار کردن حلقهها، هیچوقت باعث تغییر در تکرار حلقه نمیشه. قبل از شروع هر تکرار، مقدار بعدی که توسط شیء قابل تکرار (که در اینجا `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` در هنگام تعریف محاسبه میشه ولی عبارت شرطی در زمان اجرا محاسبه میشه.
+- پس قبل از زمان اجرا، `array` دوباره با لیست `[2, 8, 22]` مقداردهی میشه و از آنجایی که در مقدار جدید `array`، بین `1`، `8` و `15`، فقط تعداد `8` بزرگتر از `0` است، تولیدکننده فقط مقدار `8` رو برمیگردونه
+- تفاوت در مقدار `gen_1` و `gen_2` در بخش دوم به خاطر نحوه مقداردهی دوباره `array_1` و `array_2` است.
+- در مورد اول، متغیر `array_1` به شیء جدید `[1,2,3,4,5]` وصله و از اون جایی که عبارت بند `in` در هنگام تعریف محاسبه میشه، `array_1` داخل تولیدکننده هنوز به شیء قدیمی `[1,2,3,4]` (که هنوز حذف نشده)
+- در مورد دوم، مقداردهی برشی به `array_2` باعث بهروز شدن شیء قدیمی این متغیر از `[1,2,3,4]` به `[1,2,3,4,5]` میشه و هر دو متغیر `gen_2` و `array_2` به یک شیء اشاره میکنند که حالا بهروز شده.
+- خیلیخب، حالا طبق منطقی که تا الان گفتیم، نباید مقدار `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` بلافاصله محاسبه میشه و باقی عبارتها به تعویق انداخته میشن تا زمانی که تولیدکننده اجرا بشه.
+
+---
+
+### ◀ هر گردی، گردو نیست
+
+
+
+```py
+>>> 'something' is not None
+True
+>>> 'something' is (not None)
+False
+```
+
+#### 💡 توضیح
+
+- عملگر `is not` یک عملگر باینری واحده و رفتارش متفاوت تر از استفاده `is` و `not` به صورت جداگانهست.
+- عملگر `is not` مقدار `False` رو برمیگردونه اگر متغیرها در هردو سمت این عملگر به شیء یکسانی اشاره کنند و درغیر این صورت، مقدار `True` برمیگردونه
+- در مثال بالا، عبارت `(not None)` برابره با مقدار `True` از اونجایی که مقدار `None` در زمینه boolean به `False` تبدیل میشه. پس کل عبارت معادل عبارت `'something' is True` میشه.
+
+---
+
+### ◀ یک بازی دوز که توش X همون اول برنده میشه!
+
+
+
+```py
+
+# بیاید یک سطر تشکیل بدیم
+
+row = [""] * 3 #row i['', '', '']
+
+# حالا بیاید تخته بازی رو ایجاد کنیم
+
+board = [row] * 3
+
+```
+
+**خروجی:**
+
+```py
+>>> board
+[['', '', ''], ['', '', ''], ['', '', '']]
+>>> board[0]
+['', '', '']
+>>> board[0][0]
+''
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['X', '', ''], ['X', '', '']]
+```
+
+ما که سهتا `"X"` نذاشتیم. گذاشتیم مگه؟
+
+#### 💡 توضیح:
+
+وقتی متغیر `row` رو تشکیل میدیم، تصویر زیر نشون میده که چه اتفاقی در حافظه دستگاه میافته.
+
+
+
+
+
+
+
+
+و وقتی متغیر `board` رو با ضرب کردن متغیر `row` تشکیل میدیم، تصویر زیر به صورت کلی نشون میده که چه اتفاقی در حافظه میافته (هر کدوم از عناصر `board[0]`، `board[1]` و `board[2]` در حافظه به لیست یکسانی به نشانی `row` اشاره میکنند).
+
+
+
+
+
+
+
+
+ما میتونیم با استفاده نکردن از متغیر `row` برای تولید متغیر `board` از این سناریو پرهیز کنیم. (در [این](https://github.com/satwikkansal/wtfpython/issues/68) موضوع پرسیده شده).
+
+```py
+>>> board = [['']*3 for _ in range(3)]
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['', '', ''], ['', '', '']]
+```
+
+---
+
+### ◀ متغیر شرودینگر \*
+
+
+
+مثال اول:
+
+```py
+funcs = []
+results = []
+for x in range(7):
+ def some_func():
+ return x
+ funcs.append(some_func)
+ results.append(some_func()) # به فراخوانی تابع دقت کنید.
+
+funcs_results = [func() for func in funcs]
+```
+
+**خروجی:**
+
+```py
+>>> results
+[0, 1, 2, 3, 4, 5, 6]
+>>> funcs_results
+[6, 6, 6, 6, 6, 6, 6]
+```
+
+مقدار `x` در هر تکرار حلقه قبل از اضافه کردن `some_func` به لیست `funcs` متفاوت بود، ولی همه توابع در خارج از حلقه مقدار `6` رو برمیگردونند.
+
+مثال دوم:
+
+```py
+>>> powers_of_x = [lambda x: x**i for i in range(10)]
+>>> [f(2) for f in powers_of_x]
+[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]
+```
+
+#### 💡 توضیح:
+
+- وقتی یک تابع رو در داخل یک حلقه تعریف میکنیم که در بدنهاش از متغیر اون حلقه استفاده شده، بست این تابع به _متغیر_ وصله، نه _مقدار_ اون. تابع به جای اینکه از مقدار `x` در زمان تعریف تابع استفاده کنه، در زمینه اطرافش دنبال `x` میگرده. پس همه این توابع از آخرین مقداری که به متغیر `x` مقداردهی شده برای محاسباتشون استفاده میکنند. ما میتونیم ببینیم که این توابع از متغیر `x` که در زمینه اطرافشون (_نه_ از متغیر محلی) هست، استفاده میکنند، به این صورت:
+
+```py
+>>> import inspect
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())
+```
+
+از اونجایی که `x` یک متغیر سراسریه (گلوبال)، ما میتونیم مقداری که توابع داخل `funcs` دنبالشون میگردند و برمیگردونند رو با بهروز کردن `x` تغییر بدیم:
+
+```py
+>>> x = 42
+>>> [func() for func in funcs]
+[42, 42, 42, 42, 42, 42, 42]
+```
+
+- برای رسیدن به رفتار موردنظر شما میتونید متغیر حلقه رو به عنوان یک متغیر اسمدار به تابع بدید. **چرا در این صورت کار میکنه؟** چون اینجوری یک متغیر در دامنه خود تابع تعریف میشه. تابع دیگه دنبال مقدار `x` در دامنه اطراف (سراسری) نمیگرده ولی یک متغیر محلی برای ذخیره کردن مقدار `x` در اون لحظه میسازه.
+
+```py
+funcs = []
+for x in range(7):
+ def some_func(x=x):
+ return x
+ funcs.append(some_func)
+```
+
+**خروجی:**
+
+```py
+>>> funcs_results = [func() for func in funcs]
+>>> funcs_results
+[0, 1, 2, 3, 4, 5, 6]
+```
+
+دیگه از متغیر `x` در دامنه سراسری استفاده نمیکنه:
+
+```py
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())
+```
+
+---
+
+### ◀ اول مرغ بوده یا تخم مرغ؟ \*
+
+
+
+1\.
+
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+پس کدوم کلاس پایه "نهایی" هست؟ راستی سردرگمی بیشتری هم تو راهه.
+
+2\.
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+#### 💡 توضیح
+
+- در پایتون، `type` یک [متاکلاس](https://realpython.com/python-metaclasses/) است.
+- در پایتون **همه چیز** یک `object` است، که کلاسها و همچنین نمونههاشون (یا همان instance های کلاسها) هم شامل این موضوع میشن.
+- کلاس `type` یک متاکلاسه برای کلاس `object` و همه کلاسها (همچنین کلاس `type`) به صورت مستقیم یا غیرمستقیم از کلاس `object` ارث بری کرده است.
+- هیچ کلاس پایه واقعی بین کلاسهای `object` و `type` وجود نداره. سردرگمی که در قطعهکدهای بالا به وجود اومده، به خاطر اینه که ما به این روابط (یعنی `issubclass` و `isinstance`) از دیدگاه کلاسهای پایتون فکر میکنیم. رابطه بین `object` و `type` رو در پایتون خالص نمیشه بازتولید کرد. برای اینکه دقیقتر باشیم، رابطههای زیر در پایتون خالص نمیتونند بازتولید بشن.
+ - کلاس A یک نمونه از کلاس B، و کلاس B یک نمونه از کلاس A باشه.
+ - کلاس A یک نمونه از خودش باشه.
+- این روابط بین `object` و `type` (که هردو نمونه یکدیگه و همچنین خودشون باشند) به خاطر "تقلب" در مرحله پیادهسازی، وجود دارند.
+
+---
+
+### ◀ روابط بین زیرمجموعه کلاسها
+
+
+
+**خروجی:**
+
+```py
+>>> from collections.abc import Hashable
+>>> issubclass(list, object)
+True
+>>> issubclass(object, Hashable)
+True
+>>> issubclass(list, Hashable)
+False
+```
+
+ما انتظار داشتیم که روابط بین زیرکلاسها، انتقالی باشند، درسته؟ (یعنی اگه `A` زیرکلاس `B` باشه و `B` هم زیرکلاس `C` باشه، کلس `A` **باید** زیرکلاس `C` باشه)
+
+#### 💡 توضیح:
+
+- روابط بین زیرکلاسها در پایتون لزوما انتقالی نیستند. همه مجازند که تابع `__subclasscheck__` دلخواه خودشون رو در یک متاکلاس تعریف کنند.
+- وقتی عبارت `issubclass(cls, Hashable)` اجرا میشه، برنامه دنبال یک تابع "غیر نادرست" (یا non-Falsy) در `cls` یا هرچیزی که ازش ارثبری میکنه، میگرده.
+- از اونجایی که `object` قابل هش شدنه، ولی `list` اینطور نیست، رابطه انتقالی شکسته میشه.
+- توضیحات با جزئیات بیشتر [اینجا](https://www.naftaliharris.com/blog/python-subclass-intransitivity/) پیدا میشه.
+
+---
+
+### ◀ برابری و هویت متدها
+
+
+
+مثال اول
+
+```py
+class SomeClass:
+ def method(self):
+ pass
+
+ @classmethod
+ def classm(cls):
+ pass
+
+ @staticmethod
+ def staticm():
+ pass
+```
+
+**خروجی:**
+
+```py
+>>> print(SomeClass.method is SomeClass.method)
+True
+>>> print(SomeClass.classm is SomeClass.classm)
+False
+>>> print(SomeClass.classm == SomeClass.classm)
+True
+>>> print(SomeClass.staticm is SomeClass.staticm)
+True
+```
+
+با دوبار دسترسی به `classm`، یک شیء برابر دریافت میکنیم، اما _همان_ شیء نیست؟ بیایید ببینیم
+چه اتفاقی برای نمونههای `SomeClass` میافتد:
+
+مثال دوم
+
+```py
+o1 = SomeClass()
+o2 = SomeClass()
+```
+
+**خروجی:**
+
+```py
+>>> print(o1.method == o2.method)
+False
+>>> print(o1.method == o1.method)
+True
+>>> print(o1.method is o1.method)
+False
+>>> print(o1.classm is o1.classm)
+False
+>>> print(o1.classm == o1.classm == o2.classm == SomeClass.classm)
+True
+>>> print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)
+True
+```
+
+دسترسی به `classm` یا `method` دو بار، اشیایی برابر اما نه _یکسان_ را برای همان نمونه از `SomeClass` ایجاد میکند.
+
+#### 💡 توضیح
+
+- تابعها [وصاف](https://docs.python.org/3/howto/descriptor.html) هستند. هر زمان که تابعی به عنوان یک ویژگی فراخوانی شود، وصف فعال میشود و یک شیء متد ایجاد میکند که تابع را به شیء صاحب آن ویژگی "متصل" میکند. اگر این متد فراخوانی شود، تابع را با ارسال ضمنی شیء متصلشده به عنوان اولین آرگومان صدا میزند (به این ترتیب است که `self` را به عنوان اولین آرگومان دریافت میکنیم، با وجود اینکه آن را بهطور صریح ارسال نکردهایم).
+
+```py
+>>> o1.method
+>
+```
+
+- دسترسی به ویژگی چندین بار، هر بار یک شیء متد جدید ایجاد میکند! بنابراین عبارت `o1.method is o1.method` هرگز درست (truthy) نیست. با این حال، دسترسی به تابعها به عنوان ویژگیهای کلاس (و نه نمونه) متد ایجاد نمیکند؛ بنابراین عبارت `SomeClass.method is SomeClass.method` درست است.
+
+```py
+>>> SomeClass.method
+
+```
+
+- `classmethod` توابع را به متدهای کلاس تبدیل میکند. متدهای کلاس وصافهایی هستند که هنگام دسترسی، یک شیء متد ایجاد میکنند که به _کلاس_ (نوع) شیء متصل میشود، نه خود شیء.
+
+```py
+>>> o1.classm
+>
+```
+
+- برخلاف توابع، `classmethod`ها هنگام دسترسی به عنوان ویژگیهای کلاس نیز یک شیء متد ایجاد میکنند (که در این حالت به خود کلاس متصل میشوند، نه نوع آن). بنابراین عبارت `SomeClass.classm is SomeClass.classm` نادرست (falsy) است.
+
+```py
+>>> SomeClass.classm
+>
+```
+
+- یک شیء متد زمانی برابر در نظر گرفته میشود که هم تابعها برابر باشند و هم شیءهای متصلشده یکسان باشند. بنابراین عبارت `o1.method == o1.method` درست (truthy) است، هرچند که آنها در حافظه شیء یکسانی نیستند.
+- `staticmethod` توابع را به یک وصف "بدون عملیات" (no-op) تبدیل میکند که تابع را به همان صورت بازمیگرداند. هیچ شیء متدی ایجاد نمیشود، بنابراین مقایسه با `is` نیز درست (truthy) است.
+
+```py
+>>> o1.staticm
+
+>>> SomeClass.staticm
+
+```
+
+- ایجاد شیءهای "متد" جدید در هر بار فراخوانی متدهای نمونه و نیاز به اصلاح آرگومانها برای درج `self`، عملکرد را به شدت تحت تأثیر قرار میداد.
+ CPython 3.7 [این مشکل را حل کرد](https://bugs.python.org/issue26110) با معرفی opcodeهای جدیدی که فراخوانی متدها را بدون ایجاد شیء متد موقتی مدیریت میکنند. این به شرطی است که تابع دسترسییافته واقعاً فراخوانی شود، بنابراین قطعهکدهای اینجا تحت تأثیر قرار نمیگیرند و همچنان متد ایجاد میکنند :)
+
+### ◀ آل-ترو-یشن \*
+
+
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+چرا این تغییر درست-نادرسته؟
+
+#### 💡 توضیحات:
+
+- پیادهسازی تابع `all` معادل است با
+
+- ```py
+ def all(iterable):
+ for element in iterable:
+ if not element:
+ return False
+ return True
+ ```
+
+- `all([])` مقدار `True` را برمیگرداند چون iterable خالی است.
+- `all([[]])` مقدار `False` را برمیگرداند چون آرایهی دادهشده یک عنصر دارد، یعنی `[]`، و در پایتون، لیست خالی مقدار falsy دارد.
+- `all([[[]]])` و نسخههای بازگشتی بالاتر همیشه `True` هستند. دلیلش این است که عنصر واحد آرایهی دادهشده (`[[...]]`) دیگر خالی نیست، و لیستهایی که دارای مقدار باشند، truthy در نظر گرفته میشوند.
+
+---
+
+### ◀ کامای شگفتانگیز
+
+
+
+**خروجی (< 3.6):**
+
+```py
+>>> def f(x, y,):
+... print(x, y)
+...
+>>> def g(x=4, y=5,):
+... print(x, y)
+...
+>>> def h(x, **kwargs,):
+ File "", line 1
+ def h(x, **kwargs,):
+ ^
+SyntaxError: invalid syntax
+
+>>> def h(*args,):
+ File "", line 1
+ def h(*args,):
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 توضیح:
+
+- کامای انتهایی همیشه در لیست پارامترهای رسمی یک تابع در پایتون قانونی نیست.
+- در پایتون، لیست آرگومانها تا حدی با کاماهای ابتدایی و تا حدی با کاماهای انتهایی تعریف میشود. این تضاد باعث ایجاد موقعیتهایی میشود که در آن یک کاما در وسط گیر میافتد و هیچ قانونی آن را نمیپذیرد.
+- **نکته:** مشکل کامای انتهایی در [پایتون ۳.۶ رفع شده است](https://bugs.python.org/issue9232). توضیحات در [این پست](https://bugs.python.org/issue9232#msg248399) بهطور خلاصه کاربردهای مختلف کاماهای انتهایی در پایتون را بررسی میکند.
+
+---
+
+### ◀ رشتهها و بکاسلشها
+
+
+
+**خروجی:**
+
+```py
+>>> print("\"")
+"
+
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "", line 1
+ print(r"\")
+ ^
+SyntaxError: EOL while scanning string literal
+
+>>> r'\'' == "\\'"
+True
+```
+
+#### 💡 توضیح:
+
+- در یک رشتهی معمولی در پایتون، بکاسلش برای فرار دادن (escape) نویسههایی استفاده میشود که ممکن است معنای خاصی داشته باشند (مانند تکنقلقول، دوتانقلقول، و خودِ بکاسلش).
+
+ ```py
+ >>> "wt\"f"
+ 'wt"f'
+ ```
+
+- در یک رشتهی خام (raw string literal) که با پیشوند `r` مشخص میشود، بکاسلشها خودشان به همان شکل منتقل میشوند، بههمراه رفتار فرار دادن نویسهی بعدی.
+
+ ```py
+ >>> r'wt\"f' == 'wt\\"f'
+ True
+ >>> print(repr(r'wt\"f'))
+ 'wt\\"f'
+
+ >>> print("\n")
+
+ >>> print(r"\\n")
+ '\\n'
+ ```
+
+- در یک رشتهی خام (raw string) که با پیشوند `r` مشخص میشود، بکاسلشها خودشان به همان صورت منتقل میشوند، همراه با رفتاری که کاراکتر بعدی را فرار میدهد (escape میکند).
+
+---
+
+### ◀ گره نیست، نَه!
+
+
+
+```py
+x = True
+y = False
+```
+
+**خروجی:**
+
+```py
+>>> not x == y
+True
+>>> x == not y
+ File " at 0x7f70b0a4ad58>
+>>> list([(yield x) for x in some_iterable])
+['a', 'b']
+>>> list((yield x) for x in some_iterable)
+['a', None, 'b', None]
+>>> list(some_func((yield x)) for x in some_iterable)
+['a', 'something', 'b', 'something']
+```
+
+#### 💡 توضیح:
+
+- این یک باگ در نحوهی مدیریت `yield` توسط CPython در ژنراتورها و درک لیستی (comprehensions) است.
+- منبع و توضیحات را میتوانید اینجا ببینید: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
+- گزارش باگ مرتبط: https://bugs.python.org/issue10544
+- از نسخهی ۳.۸ به بعد، پایتون دیگر اجازهی استفاده از `yield` در داخل درک لیستی را نمیدهد و خطای `SyntaxError` ایجاد خواهد کرد.
+
+---
+
+### ◀ بازگرداندن با استفاده از `yield from`!
+
+
+
+1\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ yield from range(x)
+```
+
+**خروجی (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+چی شد که `"wtf"` ناپدید شد؟ آیا به خاطر اثر خاصی از `yield from` است؟ بیایید این موضوع را بررسی کنیم،
+
+2\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ for i in range(x):
+ yield i
+```
+
+**خروجی:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+همان نتیجه، این یکی هم کار نکرد.
+
+#### 💡 توضیح:
+
+- از پایتون نسخه ۳.۳ به بعد، امکان استفاده از عبارت `return` همراه با مقدار در داخل ژنراتورها فراهم شد (نگاه کنید به [PEP380](https://www.python.org/dev/peps/pep-0380/)). [مستندات رسمی](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) میگویند:
+
+> دلیل: "... `return expr` در یک ژنراتور باعث میشود که هنگام خروج از ژنراتور، `StopIteration(expr)` ایجاد شود."
+
+- در حالت `some_func(3)`، استثنای `StopIteration` در ابتدای اجرا به دلیل وجود دستور `return` رخ میدهد. این استثنا بهطور خودکار درون پوشش `list(...)` و حلقه `for` گرفته میشود. بنابراین، دو قطعهکد بالا منجر به یک لیست خالی میشوند.
+
+- برای اینکه مقدار `["wtf"]` را از ژنراتور `some_func` بگیریم، باید استثنای `StopIteration` را خودمان مدیریت کنیم،
+
+ ```py
+ try:
+ next(some_func(3))
+ except StopIteration as e:
+ some_string = e.value
+ ```
+
+ ```py
+ >>> some_string
+ ["wtf"]
+ ```
+
+---
+
+### ◀ بازتابناپذیری \*
+
+
+
+1\.
+
+```py
+a = float('inf')
+b = float('nan')
+c = float('-iNf') # این رشتهها نسبت به حروف بزرگ و کوچک حساس نیستند
+d = float('nan')
+```
+
+**خروجی:**
+
+```py
+>>> a
+inf
+>>> b
+nan
+>>> c
+-inf
+>>> float('some_other_string')
+ValueError: could not convert string to float: some_other_string
+>>> a == -c # inf==inf
+True
+>>> None == None # None == None
+True
+>>> b == d # اما nan!=nan
+False
+>>> 50 / a
+0.0
+>>> a / a
+nan
+>>> 23 + b
+nan
+```
+
+2\.
+
+```py
+>>> x = float('nan')
+>>> y = x / x
+>>> y is y # برابری هویتی برقرار است
+True
+>>> y == y #برابری در مورد y برقرار نیست
+False
+>>> [y] == [y] # اما برابری برای لیستی که شامل y است برقرار میشود
+True
+```
+
+#### 💡 توضیح:
+
+- در اینجا، `'inf'` و `'nan'` رشتههایی خاص هستند (نسبت به حروف بزرگ و کوچک حساس نیستند) که وقتی بهطور صریح به نوع `float` تبدیل شوند، به ترتیب برای نمایش "بینهایت" ریاضی و "عدد نیست" استفاده میشوند.
+
+- از آنجا که طبق استاندارد IEEE، `NaN != NaN`، پایبندی به این قانون فرض بازتابپذیری (reflexivity) یک عنصر در مجموعهها را در پایتون نقض میکند؛ یعنی اگر `x` عضوی از مجموعهای مثل `list` باشد، پیادهسازیهایی مانند مقایسه، بر اساس این فرض هستند که `x == x`. به دلیل همین فرض، ابتدا هویت (identity) دو عنصر مقایسه میشود (چون سریعتر است) و فقط زمانی مقادیر مقایسه میشوند که هویتها متفاوت باشند. قطعهکد زیر موضوع را روشنتر میکند،
+
+ ```py
+ >>> x = float('nan')
+ >>> x == x, [x] == [x]
+ (False, True)
+ >>> y = float('nan')
+ >>> y == y, [y] == [y]
+ (False, True)
+ >>> x == y, [x] == [y]
+ (False, False)
+ ```
+
+ از آنجا که هویتهای `x` و `y` متفاوت هستند، مقادیر آنها در نظر گرفته میشوند که آنها نیز متفاوتاند؛ بنابراین مقایسه این بار `False` را برمیگرداند.
+
+- خواندنی جالب: [بازتابپذیری و دیگر ارکان تمدن](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+
+---
+
+### ◀ تغییر دادن اشیای تغییرناپذیر!
+
+
+
+این موضوع ممکن است بدیهی به نظر برسد اگر با نحوهی کار ارجاعها در پایتون آشنا باشید.
+
+```py
+some_tuple = ("A", "tuple", "with", "values")
+another_tuple = ([1, 2], [3, 4], [5, 6])
+```
+
+**خروجی:**
+
+```py
+>>> some_tuple[2] = "change this"
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple[2].append(1000) #This throws no error
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000])
+>>> another_tuple[2] += [99, 999]
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000, 99, 999])
+```
+
+اما من فکر میکردم تاپلها تغییرناپذیر هستند...
+
+#### 💡 توضیح:
+
+- نقلقول از https://docs.python.org/3/reference/datamodel.html
+
+ > دنبالههای تغییرناپذیر
+
+ ```text
+ شیئی از نوع دنبالهی تغییرناپذیر، پس از ایجاد دیگر قابل تغییر نیست. (اگر شیء شامل ارجاعهایی به اشیای دیگر باشد، این اشیای دیگر ممکن است قابل تغییر باشند و تغییر کنند؛ اما مجموعهی اشیایی که مستقیماً توسط یک شیء تغییرناپذیر ارجاع داده میشوند، نمیتواند تغییر کند.)
+ ```
+
+- عملگر `+=` لیست را بهصورت درجا (in-place) تغییر میدهد. تخصیص به یک عضو کار نمیکند، اما زمانی که استثنا ایجاد میشود، عضو موردنظر پیش از آن بهصورت درجا تغییر کرده است.
+- همچنین توضیحی در [پرسشهای متداول رسمی پایتون](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works) وجود دارد.
+
+---
+
+### ◀ متغیری که از اسکوپ بیرونی ناپدید میشود
+
+
+
+```py
+e = 7
+try:
+ raise Exception()
+except Exception as e:
+ pass
+```
+
+**Output (Python 2.x):**
+
+```py
+>>> print(e)
+# چیزی چاپ نمی شود.
+```
+
+**Output (Python 3.x):**
+
+```py
+>>> print(e)
+NameError: name 'e' is not defined
+```
+
+#### 💡 توضیح:
+
+- منبع: [مستندات رسمی پایتون](https://docs.python.org/3/reference/compound_stmts.html#except)
+
+هنگامی که یک استثنا (Exception) با استفاده از کلمهی کلیدی `as` به متغیری تخصیص داده شود، این متغیر در انتهای بلاکِ `except` پاک میشود. این رفتار مشابه کد زیر است:
+
+```py
+except E as N:
+ foo
+```
+
+به این شکل ترجمه شده باشد:
+
+```py
+except E as N:
+ try:
+ foo
+ finally:
+ del N
+```
+
+این بدان معناست که استثنا باید به نام دیگری انتساب داده شود تا بتوان پس از پایان بند `except` به آن ارجاع داد. استثناها پاک میشوند چون با داشتن «ردیابی» (traceback) ضمیمهشده، یک چرخهی مرجع (reference cycle) با قاب پشته (stack frame) تشکیل میدهند که باعث میشود تمام متغیرهای محلی (locals) در آن قاب تا زمان پاکسازی حافظه (garbage collection) باقی بمانند.
+
+- در پایتون، بندها (`clauses`) حوزهی مستقل ندارند. در مثال بالا، همهچیز در یک حوزهی واحد قرار دارد، و متغیر `e` در اثر اجرای بند `except` حذف میشود. این موضوع در مورد توابع صادق نیست، زیرا توابع حوزههای داخلی جداگانهای دارند. مثال زیر این نکته را نشان میدهد:
+
+ ```py
+ def f(x):
+ del(x)
+ print(x)
+
+ x = 5
+ y = [5, 4, 3]
+ ```
+
+ **خروجی:**
+
+ ```py
+ >>> f(x)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> f(y)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> x
+ 5
+ >>> y
+ [5, 4, 3]
+ ```
+
+- در پایتون نسخهی ۲.x، نام متغیر `e` به یک نمونه از `Exception()` انتساب داده میشود، بنابراین وقتی سعی کنید آن را چاپ کنید، چیزی نمایش داده نمیشود.
+
+ **خروجی (Python 2.x):**
+
+ ```py
+ >>> e
+ Exception()
+ >>> print e
+ # چیزی چاپ نمی شود.
+ ```
+
+---
+
+### ◀ تبدیل اسرارآمیز نوع کلید
+
+
+
+```py
+class SomeClass(str):
+ pass
+
+some_dict = {'s': 42}
+```
+
+**خروجی:**
+
+```py
+>>> type(list(some_dict.keys())[0])
+str
+>>> s = SomeClass('s')
+>>> some_dict[s] = 40
+>>> some_dict # دو عدد کلید-مقدار توقع می رود.
+{'s': 40}
+>>> type(list(some_dict.keys())[0])
+str
+```
+
+#### 💡 توضیح:
+
+- هر دو شیء `s` و رشتهی `"s"` به دلیل ارثبری `SomeClass` از متد `__hash__` کلاس `str`، هش یکسانی دارند.
+- عبارت `SomeClass("s") == "s"` به دلیل ارثبری `SomeClass` از متد `__eq__` کلاس `str` برابر با `True` ارزیابی میشود.
+- از آنجا که این دو شیء هش یکسان و برابری دارند، به عنوان یک کلید مشترک در دیکشنری در نظر گرفته میشوند.
+- برای رسیدن به رفتار دلخواه، میتوانیم متد `__eq__` را در کلاس `SomeClass` بازتعریف کنیم.
+
+ ```py
+ class SomeClass(str):
+ def __eq__(self, other):
+ return (
+ type(self) is SomeClass
+ and type(other) is SomeClass
+ and super().__eq__(other)
+ )
+
+ # هنگامی که متد __eq__ را بهطور دلخواه تعریف میکنیم، پایتون دیگر متد __hash__ را به صورت خودکار به ارث نمیبرد،
+ # بنابراین باید متد __hash__ را نیز مجدداً تعریف کنیم.
+ __hash__ = str.__hash__
+
+ some_dict = {'s':42}
+ ```
+
+ **خروجی:**
+
+ ```py
+ >>> s = SomeClass('s')
+ >>> some_dict[s] = 40
+ >>> some_dict
+ {'s': 40, 's': 42}
+ >>> keys = list(some_dict.keys())
+ >>> type(keys[0]), type(keys[1])
+ (__main__.SomeClass, str)
+ ```
+
+---
+
+### ◀ ببینیم میتوانید این را حدس بزنید؟
+
+
+
+```py
+a, b = a[b] = {}, 5
+```
+
+**خروجی:**
+
+```py
+>>> a
+{5: ({...}, 5)}
+```
+
+#### 💡 توضیح:
+
+- طبق [مرجع زبان پایتون](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)، دستورات انتساب فرم زیر را دارند:
+
+ ```text
+ (target_list "=")+ (expression_list | yield_expression)
+ ```
+
+ و
+
+> یک دستور انتساب ابتدا فهرست عبارتها (expression list) را ارزیابی میکند (توجه کنید این عبارت میتواند یک عبارت تکی یا فهرستی از عبارتها جداشده با ویرگول باشد که دومی به یک تاپل منجر میشود)، سپس شیء حاصل را به هریک از اهداف انتساب از **چپ به راست** تخصیص میدهد.
+
+- علامت `+` در `(target_list "=")+` به این معناست که میتوان **یک یا چند** هدف انتساب داشت. در این حالت، اهداف انتساب ما `a, b` و `a[b]` هستند (توجه کنید که عبارت ارزیابیشده دقیقاً یکی است، که در اینجا `{}` و `5` است).
+
+- پس از ارزیابی عبارت، نتیجه از **چپ به راست** به اهداف انتساب داده میشود. در این مثال ابتدا تاپل `({}, 5)` به `a, b` باز میشود، بنابراین `a = {}` و `b = 5` خواهیم داشت.
+
+- حالا `a` یک شیء قابل تغییر (mutable) است (`{}`).
+
+- هدف انتساب بعدی `a[b]` است (شاید انتظار داشته باشید که اینجا خطا بگیریم زیرا پیش از این هیچ مقداری برای `a` و `b` مشخص نشده است؛ اما به یاد داشته باشید که در گام قبل به `a` مقدار `{}` و به `b` مقدار `5` دادیم).
+
+- اکنون، کلید `5` در دیکشنری به تاپل `({}, 5)` مقداردهی میشود و یک مرجع دوری (Circular Reference) ایجاد میکند (علامت `{...}` در خروجی به همان شیئی اشاره دارد که قبلاً توسط `a` به آن ارجاع داده شده است). یک مثال سادهتر از مرجع دوری میتواند به این صورت باشد:
+
+ ```py
+ >>> some_list = some_list[0] = [0]
+ >>> some_list
+ [[...]]
+ >>> some_list[0]
+ [[...]]
+ >>> some_list is some_list[0]
+ True
+ >>> some_list[0][0][0][0][0][0] == some_list
+ True
+ ```
+
+ در مثال ما نیز شرایط مشابه است (`a[b][0]` همان شیئی است که `a` به آن اشاره دارد).
+
+- بنابراین برای جمعبندی، میتوانید مثال بالا را به این صورت ساده کنید:
+
+ ```py
+ a, b = {}, 5
+ a[b] = a, b
+ ```
+
+ و مرجع دوری به این دلیل قابل توجیه است که `a[b][0]` همان شیئی است که `a` به آن اشاره دارد.
+
+ ```py
+ >>> a[b][0] is a
+ True
+ ```
+
+---
+
+### ◀ از حد مجاز برای تبدیل رشته به عدد صحیح فراتر میرود
+
+```py
+>>> # Python 3.10.6
+>>> int("2" * 5432)
+
+>>> # Python 3.10.8
+>>> int("2" * 5432)
+```
+
+**خروجی:**
+
+```py
+>>> # Python 3.10.6
+222222222222222222222222222222222222222222222222222222222222222...
+
+>>> # Python 3.10.8
+Traceback (most recent call last):
+ ...
+ValueError: Exceeds the limit (4300) for integer string conversion:
+ value has 5432 digits; use sys.set_int_max_str_digits()
+ to increase the limit.
+```
+
+#### 💡 توضیح:
+
+فراخوانی تابع `int()` در نسخهی Python 3.10.6 بهخوبی کار میکند اما در نسخهی Python 3.10.8 منجر به خطای `ValueError` میشود. توجه کنید که پایتون همچنان قادر به کار با اعداد صحیح بزرگ است. این خطا تنها هنگام تبدیل اعداد صحیح به رشته یا برعکس رخ میدهد.
+
+خوشبختانه میتوانید در صورت انتظار عبور از این حد مجاز، مقدار آن را افزایش دهید. برای انجام این کار میتوانید از یکی از روشهای زیر استفاده کنید:
+
+- استفاده از فلگ خط فرمان `-X int_max_str_digits`
+- تابع `set_int_max_str_digits()` از ماژول `sys`
+- متغیر محیطی `PYTHONINTMAXSTRDIGITS`
+
+برای جزئیات بیشتر دربارهی تغییر مقدار پیشفرض این حد مجاز، [مستندات رسمی پایتون](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) را مشاهده کنید.
+
+---
+
+## بخش: شیبهای لغزنده
+
+### ◀ تغییر یک دیکشنری هنگام پیمایش روی آن
+
+
+
+```py
+x = {0: None}
+
+for i in x:
+ del x[i]
+ x[i+1] = None
+ print(i)
+```
+
+**خروجی (پایتون 2.7تا پایتون 3.5):**
+
+```text
+0
+1
+2
+3
+4
+5
+6
+7
+```
+
+بله، دقیقاً **هشت** مرتبه اجرا میشود و سپس متوقف میشود.
+
+#### 💡 توضیح:
+
+- پیمایش روی یک دیکشنری در حالی که همزمان آن را ویرایش میکنید پشتیبانی نمیشود.
+- هشت بار اجرا میشود چون در آن لحظه دیکشنری برای نگهداری کلیدهای بیشتر تغییر اندازه میدهد (ما هشت ورودی حذف داریم، بنابراین تغییر اندازه لازم است). این در واقع یک جزئیات پیادهسازی است.
+- اینکه کلیدهای حذفشده چگونه مدیریت میشوند و چه زمانی تغییر اندازه اتفاق میافتد ممکن است در پیادهسازیهای مختلف پایتون متفاوت باشد.
+- بنابراین در نسخههای دیگر پایتون (به جز Python 2.7 - Python 3.5)، تعداد ممکن است متفاوت از ۸ باشد (اما هر چه که باشد، در هر بار اجرا یکسان خواهد بود). میتوانید برخی مباحث پیرامون این موضوع را [اینجا](https://github.com/satwikkansal/wtfpython/issues/53) یا در این [رشتهی StackOverflow](https://stackoverflow.com/questions/44763802/bug-in-python-dict) مشاهده کنید.
+- از نسخهی Python 3.7.6 به بعد، در صورت تلاش برای انجام این کار، خطای `RuntimeError: dictionary keys changed during iteration` را دریافت خواهید کرد.
+
+---
+
+### ◀ عملیات سرسختانهی `del`
+
+
+
+
+```py
+class SomeClass:
+ def __del__(self):
+ print("Deleted!")
+```
+
+**خروجی:**
+1\.
+
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x # باید این عبارت را چاپ کند "Deleted!"
+>>> del y
+Deleted!
+```
+
+«خُب، بالاخره حذف شد.» احتمالاً حدس زدهاید چه چیزی جلوی فراخوانی `__del__` را در اولین تلاشی که برای حذف `x` داشتیم، گرفته بود. بیایید مثال را پیچیدهتر کنیم.
+
+2\.
+
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x
+>>> y # بررسی وجود y
+<__main__.SomeClass instance at 0x7f98a1a67fc8>
+>>> del y # مثل قبل، باید این عبارت را چاپ کند "Deleted!"
+>>> globals() # اوه، چاپ نکرد. بیایید مقادیر گلوبال را بررسی کنیم.
+Deleted!
+{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}
+```
+
+«باشه، حالا حذف شد» :confused:
+
+#### 💡 توضیح:
+
+- عبارت `del x` مستقیماً باعث فراخوانی `x.__del__()` نمیشود.
+- وقتی به دستور `del x` میرسیم، پایتون نام `x` را از حوزهی فعلی حذف کرده و شمارندهی مراجع شیٔای که `x` به آن اشاره میکرد را یک واحد کاهش میدهد. فقط وقتی شمارندهی مراجع شیٔ به صفر برسد، تابع `__del__()` فراخوانی میشود.
+- در خروجی دوم، متد `__del__()` فراخوانی نشد چون دستور قبلی (`>>> y`) در مفسر تعاملی یک ارجاع دیگر به شیٔ ایجاد کرده بود (به صورت خاص، متغیر جادویی `_` به مقدار آخرین عبارت غیر `None` در REPL اشاره میکند). بنابراین مانع از رسیدن شمارندهی مراجع به صفر در هنگام اجرای `del y` شد.
+- فراخوانی `globals` (یا هر چیزی که نتیجهاش `None` نباشد) باعث میشود که `_` به نتیجهی جدید اشاره کند و ارجاع قبلی از بین برود. حالا شمارندهی مراجع به صفر میرسد و عبارت «Deleted!» (حذف شد!) نمایش داده میشود.
+
+---
+
+### ◀ متغیری که از حوزه خارج است
+
+
+
+1\.
+
+```py
+a = 1
+def some_func():
+ return a
+
+def another_func():
+ a += 1
+ return a
+```
+
+2\.
+
+```py
+def some_closure_func():
+ a = 1
+ def some_inner_func():
+ return a
+ return some_inner_func()
+
+def another_closure_func():
+ a = 1
+ def another_inner_func():
+ a += 1
+ return a
+ return another_inner_func()
+```
+
+**خروجی:**
+
+```py
+>>> some_func()
+1
+>>> another_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+
+>>> some_closure_func()
+1
+>>> another_closure_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+```
+
+#### 💡 توضیح:
+
+- وقتی در محدوده (Scope) یک تابع به متغیری مقداردهی میکنید، آن متغیر در همان حوزه محلی تعریف میشود. بنابراین `a` در تابع `another_func` تبدیل به متغیر محلی میشود، اما پیشتر در همان حوزه مقداردهی نشده است، و این باعث خطا میشود.
+- برای تغییر متغیر سراسری `a` در تابع `another_func`، باید از کلیدواژهی `global` استفاده کنیم.
+
+ ```py
+ def another_func()
+ global a
+ a += 1
+ return a
+ ```
+
+ **خروجی:**
+
+ ```py
+ >>> another_func()
+ 2
+ ```
+
+- در تابع `another_closure_func`، متغیر `a` در حوزهی `another_inner_func` محلی میشود ولی پیشتر در آن حوزه مقداردهی نشده است. به همین دلیل خطا میدهد.
+- برای تغییر متغیر حوزهی بیرونی `a` در `another_inner_func`، باید از کلیدواژهی `nonlocal` استفاده کنیم. دستور `nonlocal` به مفسر میگوید که متغیر را در نزدیکترین حوزهی بیرونی (بهجز حوزهی global) جستجو کند.
+
+ ```py
+ def another_func():
+ a = 1
+ def another_inner_func():
+ nonlocal a
+ a += 1
+ return a
+ return another_inner_func()
+ ```
+
+ **خروجی:**
+
+ ```py
+ >>> another_func()
+ 2
+ ```
+
+- کلیدواژههای `global` و `nonlocal` به مفسر پایتون میگویند که متغیر جدیدی را تعریف نکند و به جای آن در حوزههای بیرونی (سراسری یا میانجی) آن را بیابد.
+- برای مطالعهی بیشتر در مورد نحوهی کار فضای نامها و مکانیزم تعیین حوزهها در پایتون، میتوانید این [مقاله کوتاه ولی عالی](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) را بخوانید.
+
+---
+
+### ◀ حذف المانهای لیست در حین پیمایش
+
+
+
+```py
+list_1 = [1, 2, 3, 4]
+list_2 = [1, 2, 3, 4]
+list_3 = [1, 2, 3, 4]
+list_4 = [1, 2, 3, 4]
+
+for idx, item in enumerate(list_1):
+ del item
+
+for idx, item in enumerate(list_2):
+ list_2.remove(item)
+
+for idx, item in enumerate(list_3[:]):
+ list_3.remove(item)
+
+for idx, item in enumerate(list_4):
+ list_4.pop(idx)
+```
+
+**خروجی:**
+
+```py
+>>> list_1
+[1, 2, 3, 4]
+>>> list_2
+[2, 4]
+>>> list_3
+[]
+>>> list_4
+[2, 4]
+```
+
+میتوانید حدس بزنید چرا خروجی `[2, 4]` است؟
+
+#### 💡 توضیح:
+
+- هیچوقت ایدهی خوبی نیست که شیئی را که روی آن پیمایش میکنید تغییر دهید. روش درست این است که روی یک کپی از آن شیء پیمایش کنید؛ در اینجا `list_3[:]` دقیقاً همین کار را میکند.
+
+ ```py
+ >>> some_list = [1, 2, 3, 4]
+ >>> id(some_list)
+ 139798789457608
+ >>> id(some_list[:]) # دقت کنید که پایتون برای اسلایس کردن، یک شی جدید میسازد
+ 139798779601192
+ ```
+
+**تفاوت بین `del`، `remove` و `pop`:**
+
+- اینجا، `del var_name` فقط اتصال `var_name` را از فضای نام محلی یا سراسری حذف میکند (به همین دلیل است که `list_1` تحت تأثیر قرار نمیگیرد).
+- متد `remove` اولین مقدار مطابق را حذف میکند، نه یک اندیس خاص را؛ اگر مقدار مورد نظر پیدا نشود، خطای `ValueError` ایجاد میشود.
+- متد `pop` عنصری را در یک اندیس مشخص حذف کرده و آن را برمیگرداند؛ اگر اندیس نامعتبری مشخص شود، خطای `IndexError` ایجاد میشود.
+
+**چرا خروجی `[2, 4]` است؟**
+
+- پیمایش لیست به صورت اندیس به اندیس انجام میشود، و هنگامی که عدد `1` را از `list_2` یا `list_4` حذف میکنیم، محتوای لیست به `[2, 3, 4]` تغییر میکند. در این حالت عناصر باقیمانده به سمت چپ جابهجا شده و جایگاهشان تغییر میکند؛ یعنی عدد `2` در اندیس 0 و عدد `3` در اندیس 1 قرار میگیرد. از آنجا که در مرحله بعدی حلقه به سراغ اندیس 1 میرود (که اکنون مقدار آن `3` است)، عدد `2` به طور کامل نادیده گرفته میشود. این اتفاق مشابه برای هر عنصر یکدرمیان در طول پیمایش لیست رخ خواهد داد.
+
+- برای توضیح بیشتر این مثال، این [تاپیک StackOverflow](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) را ببینید.
+- همچنین برای نمونه مشابهی مربوط به دیکشنریها در پایتون، این [تاپیک مفید StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) را ببینید.
+
+---
+
+### ◀ زیپِ دارای اتلاف برای پیمایشگرها \*
+
+
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three))
+[(0, 0), (1, 1), (2, 2)]
+# تاحالا که خوب بوده، حالا روی باقی مانده های زیپ رو امتحان می کنیم.
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+
+عنصر `3` از لیست `numbers` چه شد؟
+
+#### 💡 توضیح:
+
+- بر اساس [مستندات](https://docs.python.org/3.3/library/functions.html#zip) پایتون، پیادهسازی تقریبی تابع `zip` به شکل زیر است:
+
+ ```py
+ def zip(*iterables):
+ sentinel = object()
+ iterators = [iter(it) for it in iterables]
+ while iterators:
+ result = []
+ for it in iterators:
+ elem = next(it, sentinel)
+ if elem is sentinel: return
+ result.append(elem)
+ yield tuple(result)
+ ```
+
+- بنابراین این تابع تعداد دلخواهی از اشیای قابل پیمایش (_iterable_) را دریافت میکند، و با فراخوانی تابع `next` روی آنها، هر یک از عناصرشان را به لیست `result` اضافه میکند. این فرایند زمانی متوقف میشود که اولین پیمایشگر به انتها برسد.
+- نکته مهم اینجاست که هر زمان یکی از پیمایشگرها به پایان برسد، عناصر موجود در لیست `result` نیز دور ریخته میشوند. این دقیقاً همان اتفاقی است که برای عدد `3` در `numbers_iter` رخ داد.
+- روش صحیح برای انجام عملیات بالا با استفاده از تابع `zip` چنین است:
+
+ ```py
+ >>> numbers = list(range(7))
+ >>> numbers_iter = iter(numbers)
+ >>> list(zip(first_three, numbers_iter))
+ [(0, 0), (1, 1), (2, 2)]
+ >>> list(zip(remaining, numbers_iter))
+ [(3, 3), (4, 4), (5, 5), (6, 6)]
+ ```
+
+ اولین آرگومانِ تابع `zip` باید پیمایشگری باشد که کمترین تعداد عنصر را دارد.
+
+---
+
+### ◀ نشت کردن متغیرهای حلقه!
+
+
+
+1\.
+
+```py
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**خروجی:**
+
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+اما متغیر `x` هرگز خارج از محدوده (scope) حلقه `for` تعریف نشده بود...
+
+2\.
+
+```py
+# این دفعه، مقدار ایکس را در ابتدا مقداردهی اولیه میکنیم.
+x = -1
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**خروجی:**
+
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+3\.
+
+**خروجی (Python 2.x):**
+
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+4
+```
+
+**خروجی (Python 3.x):**
+
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+1
+```
+
+#### 💡 توضیح:
+
+- در پایتون، حلقههای `for` از حوزه (_scope_) فعلی که در آن قرار دارند استفاده میکنند و متغیرهای تعریفشده در حلقه حتی بعد از اتمام حلقه نیز باقی میمانند. این قاعده حتی در مواردی که متغیر حلقه پیشتر در فضای نام سراسری (_global namespace_) تعریف شده باشد نیز صدق میکند؛ در چنین حالتی، متغیر موجود مجدداً به مقدار جدید متصل میشود.
+
+- تفاوتهای موجود در خروجی مفسرهای Python 2.x و Python 3.x در مثال مربوط به «لیستهای ادراکی» (_list comprehension_) به دلیل تغییراتی است که در مستند [«تغییرات جدید در Python 3.0»](https://docs.python.org/3/whatsnew/3.0.html) آمده است:
+
+ > «لیستهای ادراکی دیگر فرم نحوی `[... for var in item1, item2, ...]` را پشتیبانی نمیکنند و به جای آن باید از `[... for var in (item1, item2, ...)]` استفاده شود. همچنین توجه داشته باشید که لیستهای ادراکی در Python 3.x معنای متفاوتی دارند: آنها از لحاظ معنایی به بیان سادهتر، مشابه یک عبارت تولیدکننده (_generator expression_) درون تابع `list()` هستند و در نتیجه، متغیرهای کنترل حلقه دیگر به فضای نام بیرونی نشت نمیکنند.»
+
+---
+
+### ◀ مراقب آرگومانهای تغییرپذیر پیشفرض باشید!
+
+
+
+```py
+def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+```
+
+**خروجی:**
+
+```py
+>>> some_func()
+['some_string']
+>>> some_func()
+['some_string', 'some_string']
+>>> some_func([])
+['some_string']
+>>> some_func()
+['some_string', 'some_string', 'some_string']
+```
+
+#### 💡 توضیح:
+
+- آرگومانهای تغییرپذیر پیشفرض در توابع پایتون، هر بار که تابع فراخوانی میشود مقداردهی نمیشوند؛ بلکه مقداردهی آنها تنها یک بار در زمان تعریف تابع انجام میشود و مقدار اختصاصیافته به آنها به عنوان مقدار پیشفرض برای فراخوانیهای بعدی استفاده خواهد شد. هنگامی که به صراحت مقدار `[]` را به عنوان آرگومان به `some_func` ارسال کردیم، مقدار پیشفرض برای متغیر `default_arg` مورد استفاده قرار نگرفت، بنابراین تابع همانطور که انتظار داشتیم عمل کرد.
+
+ ```py
+ def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+ **خروجی:**
+
+ ```py
+ >>> some_func.__defaults__ # مقادیر پیشفرض این تابع را نمایش می دهد.
+ ([],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string'],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ >>> some_func([])
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ ```
+
+- یک روش رایج برای جلوگیری از باگهایی که به دلیل آرگومانهای تغییرپذیر رخ میدهند، این است که مقدار پیشفرض را `None` قرار داده و سپس درون تابع بررسی کنیم که آیا مقداری به آن آرگومان ارسال شده است یا خیر. مثال:
+
+ ```py
+ def some_func(default_arg=None):
+ if default_arg is None:
+ default_arg = []
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+---
+
+### ◀ گرفتن استثناها (Exceptions)
+
+
+
+```py
+some_list = [1, 2, 3]
+try:
+ # این باید یک `IndexError` ایجاد کند
+ print(some_list[4])
+except IndexError, ValueError:
+ print("Caught!")
+
+try:
+ # این باید یک `ValueError` ایجاد کند
+ some_list.remove(4)
+except IndexError, ValueError:
+ print("Caught again!")
+```
+
+**خروجی (Python 2.x):**
+
+```py
+Caught!
+
+ValueError: list.remove(x): x not in list
+```
+
+**خروجی (Python 3.x):**
+
+```py
+ File "", line 1, in
+ AssertionError
+
+ >>> assert (a == b, "Values are not equal")
+ :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+ >>> assert a == b, "Values are not equal"
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError: Values are not equal
+ ```
+
+- در قطعهی پنجم، بیشتر متدهایی که اشیای ترتیبی (Sequence) یا نگاشتها (Mapping) را تغییر میدهند (مانند `list.append`، `dict.update`، `list.sort` و غیره)، شیء اصلی را بهصورت درجا (in-place) تغییر داده و مقدار `None` برمیگردانند. منطق پشت این تصمیم، بهبود عملکرد با جلوگیری از کپی کردن شیء است (به این [منبع](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list) مراجعه کنید).
+
+- قطعهی آخر نیز نسبتاً واضح است؛ شیء تغییرپذیر (mutable)، مثل `list`، میتواند در داخل تابع تغییر کند، درحالیکه انتساب دوبارهی یک شیء تغییرناپذیر (مانند `a -= 1`) باعث تغییر مقدار اصلی آن نخواهد شد.
+
+- آگاهی از این نکات ظریف در بلندمدت میتواند ساعتها از زمان شما برای رفع اشکال را صرفهجویی کند.
+
+---
+
+### ◀ تقسیمها \*
+
+
+
+```py
+>>> 'a'.split()
+['a']
+
+# معادل است با
+>>> 'a'.split(' ')
+['a']
+
+# اما
+>>> len(''.split())
+0
+
+# معادل نیست با
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 توضیح:
+
+- در نگاه اول ممکن است به نظر برسد جداکنندهی پیشفرض متد `split` یک فاصلهی تکی (`' '`) است؛ اما مطابق با [مستندات رسمی](https://docs.python.org/3/library/stdtypes.html#str.split):
+ > اگر `sep` مشخص نشده یا برابر با `None` باشد، یک الگوریتم متفاوت برای جدا کردن اعمال میشود: رشتههایی از فاصلههای متوالی به عنوان یک جداکنندهی واحد در نظر گرفته شده و در نتیجه، هیچ رشتهی خالیای در ابتدا یا انتهای لیست خروجی قرار نمیگیرد، حتی اگر رشتهی اولیه دارای فاصلههای اضافی در ابتدا یا انتها باشد. به همین دلیل، تقسیم یک رشتهی خالی یا رشتهای که فقط شامل فضای خالی است با جداکنندهی `None` باعث بازگشت یک لیست خالی `[]` میشود.
+ > اگر `sep` مشخص شود، جداکنندههای متوالی در کنار هم قرار نمیگیرند و هر جداکننده، یک رشتهی خالی جدید ایجاد میکند. (مثلاً `'1,,2'.split(',')` مقدار `['1', '', '2']` را برمیگرداند.) تقسیم یک رشتهی خالی با یک جداکنندهی مشخصشده نیز باعث بازگشت `['']` میشود.
+- توجه به اینکه چگونه فضای خالی در ابتدا و انتهای رشته در قطعهی کد زیر مدیریت شده است، این مفهوم را روشنتر میکند:
+
+ ```py
+ >>> ' a '.split(' ')
+ ['', 'a', '']
+ >>> ' a '.split()
+ ['a']
+ >>> ''.split(' ')
+ ['']
+ ```
+
+---
+
+### ◀ واردسازیهای عمومی \*
+
+
+
+
+```py
+# File: module.py
+
+def some_weird_name_func_():
+ print("works!")
+
+def _another_weird_name_func():
+ print("works!")
+
+```
+
+**خروجی**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 توضیح:
+
+- اغلب توصیه میشود از واردسازی عمومی (wildcard imports) استفاده نکنید. اولین دلیل واضح آن این است که در این نوع واردسازیها، اسامی که با زیرخط (`_`) شروع شوند، وارد نمیشوند. این مسئله ممکن است در زمان اجرا به خطا منجر شود.
+- اگر از ساختار `from ... import a, b, c` استفاده کنیم، خطای `NameError` فوق اتفاق نمیافتاد.
+
+ ```py
+ >>> from module import some_weird_name_func_, _another_weird_name_func
+ >>> _another_weird_name_func()
+ works!
+ ```
+
+- اگر واقعاً تمایل دارید از واردسازی عمومی استفاده کنید، لازم است فهرستی به نام `__all__` را در ماژول خود تعریف کنید که شامل نام اشیاء عمومی (public) قابلدسترس هنگام واردسازی عمومی است.
+
+ ```py
+ __all__ = ['_another_weird_name_func']
+
+ def some_weird_name_func_():
+ print("works!")
+
+ def _another_weird_name_func():
+ print("works!")
+ ```
+
+ **خروجی**
+
+ ```py
+ >>> _another_weird_name_func()
+ "works!"
+ >>> some_weird_name_func_()
+ Traceback (most recent call last):
+ File "", line 1, in
+ NameError: name 'some_weird_name_func_' is not defined
+ ```
+
+---
+
+### ◀ همه چیز مرتب شده؟ \*
+
+
+
+```py
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
+
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
+```
+
+#### 💡 توضیح:
+
+- متد `sorted` همیشه یک لیست (`list`) برمیگرداند، و در پایتون مقایسهی لیستها و تاپلها (`tuple`) همیشه مقدار `False` را برمیگرداند.
+
+- ```py
+ >>> [] == tuple()
+ False
+ >>> x = 7, 8, 9
+ >>> type(x), type(sorted(x))
+ (tuple, list)
+ ```
+
+- برخلاف متد `sorted`، متد `reversed` یک تکرارکننده (iterator) برمیگرداند. چرا؟ زیرا مرتبسازی نیاز به تغییر درجا (in-place) یا استفاده از ظرف جانبی (مانند یک لیست اضافی) دارد، در حالی که معکوس کردن میتواند بهسادگی با پیمایش از اندیس آخر به اول انجام شود.
+
+- بنابراین در مقایسهی `sorted(y) == sorted(y)`، فراخوانی اولِ `sorted()` تمام عناصرِ تکرارکنندهی `y` را مصرف میکند، و فراخوانی بعدی یک لیست خالی برمیگرداند.
+
+ ```py
+ >>> x = 7, 8, 9
+ >>> y = reversed(x)
+ >>> sorted(y), sorted(y)
+ ([7, 8, 9], [])
+ ```
+
+---
+
+### ◀ زمان نیمهشب وجود ندارد؟
+
+
+
+```py
+from datetime import datetime
+
+midnight = datetime(2018, 1, 1, 0, 0)
+midnight_time = midnight.time()
+
+noon = datetime(2018, 1, 1, 12, 0)
+noon_time = noon.time()
+
+if midnight_time:
+ print("Time at midnight is", midnight_time)
+
+if noon_time:
+ print("Time at noon is", noon_time)
+```
+
+**خروجی (< 3.5):**
+
+```py
+('Time at noon is', datetime.time(12, 0))
+```
+
+زمان نیمهشب چاپ نمیشود.
+
+#### 💡 توضیح:
+
+پیش از پایتون 3.5، مقدار بولی برای شیء `datetime.time` اگر نشاندهندهٔ نیمهشب به وقت UTC بود، برابر با `False` در نظر گرفته میشد. این رفتار در استفاده از دستور `if obj:` برای بررسی تهی بودن شیء یا برابر بودن آن با مقدار "خالی"، ممکن است باعث بروز خطا شود.
+
+---
+
+---
+
+## بخش: گنجینههای پنهان!
+
+این بخش شامل چند مورد جالب و کمتر شناختهشده دربارهی پایتون است که بیشتر مبتدیهایی مثل من از آن بیخبرند (البته دیگر اینطور نیست).
+
+### ◀ خب پایتون، میتوانی کاری کنی پرواز کنم؟
+
+
+
+خب، بفرمایید
+
+```py
+import antigravity
+```
+
+**خروجی:**
+Sshh... It's a super-secret.
+
+#### 💡 توضیح:
+
+- ماژول `antigravity` یکی از معدود ایستر اِگهایی است که توسط توسعهدهندگان پایتون ارائه شده است.
+- دستور `import antigravity` باعث میشود مرورگر وب به سمت [کمیک کلاسیک XKCD](https://xkcd.com/353/) در مورد پایتون باز شود.
+- البته موضوع عمیقتر است؛ در واقع یک **ایستر اگ دیگر داخل این ایستر اگ** وجود دارد. اگر به [کد منبع](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17) نگاه کنید، یک تابع تعریف شده که ادعا میکند [الگوریتم جئوهشینگ XKCD](https://xkcd.com/426/) را پیادهسازی کرده است.
+
+---
+
+### ◀ `goto`، ولی چرا؟
+
+
+
+```py
+from goto import goto, label
+for i in range(9):
+ for j in range(9):
+ for k in range(9):
+ print("I am trapped, please rescue!")
+ if k == 2:
+ goto .breakout # خروج از یک حلقهی تودرتوی عمیق
+label .breakout
+print("Freedom!")
+```
+
+**خروجی (پایتون ۲.۳):**
+
+```py
+I am trapped, please rescue!
+I am trapped, please rescue!
+Freedom!
+```
+
+#### 💡 توضیح:
+
+- نسخهی قابل استفادهای از `goto` در پایتون به عنوان یک شوخی [در اول آوریل ۲۰۰۴ معرفی شد](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html).
+- نسخههای فعلی پایتون فاقد این ماژول هستند.
+- اگرچه این ماژول واقعاً کار میکند، ولی لطفاً از آن استفاده نکنید. در [این صفحه](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) میتوانید دلیل عدم حضور دستور `goto` در پایتون را مطالعه کنید.
+
+---
+
+### ◀ خودتان را آماده کنید!
+
+
+
+اگر جزو افرادی هستید که دوست ندارند در پایتون برای مشخص کردن محدودهها از فضای خالی (whitespace) استفاده کنند، میتوانید با ایمپورت کردن ماژول زیر از آکولاد `{}` به سبک زبان C استفاده کنید:
+
+```py
+from __future__ import braces
+```
+
+**خروجی:**
+
+```py
+ File "some_file.py", line 1
+ from __future__ import braces
+SyntaxError: not a chance
+```
+
+آکولاد؟ هرگز! اگر از این بابت ناامید شدید، بهتر است از جاوا استفاده کنید. خب، یک چیز شگفتآور دیگر؛ آیا میتوانید تشخیص دهید که ارور `SyntaxError` در کجای کد ماژول `__future__` [اینجا](https://github.com/python/cpython/blob/master/Lib/__future__.py) ایجاد میشود؟
+
+#### 💡 توضیح:
+
+- ماژول `__future__` معمولاً برای ارائه قابلیتهایی از نسخههای آینده پایتون به کار میرود. اما کلمه «future» (آینده) در این زمینه خاص، حالت طنز و کنایه دارد.
+- این مورد یک «ایستر اگ» (easter egg) است که به احساسات جامعه برنامهنویسان پایتون در این خصوص اشاره دارد.
+- کد مربوط به این موضوع در واقع [اینجا](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) در فایل `future.c` قرار دارد.
+- زمانی که کامپایلر CPython با یک [عبارت future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements) مواجه میشود، ابتدا کد مرتبط در `future.c` را اجرا کرده و سپس آن را همانند یک دستور ایمپورت عادی در نظر میگیرد.
+
+---
+
+### ◀ بیایید با «عمو زبان مهربان برای همیشه» آشنا شویم
+
+
+
+**خروجی (Python 3.x)**
+
+```py
+>>> from __future__ import barry_as_FLUFL
+>>> "Ruby" != "Python" # شکی در این نیست.
+ File "some_file.py", line 1
+ "Ruby" != "Python"
+ ^
+SyntaxError: invalid syntax
+
+>>> "Ruby" <> "Python"
+True
+```
+
+حالا میرسیم به اصل ماجرا.
+
+#### 💡 توضیح:
+
+- این مورد مربوط به [PEP-401](https://www.python.org/dev/peps/pep-0401/) است که در تاریخ ۱ آوریل ۲۰۰۹ منتشر شد (اکنون میدانید این یعنی چه!).
+- نقل قولی از PEP-401:
+
+ > با توجه به اینکه عملگر نابرابری `!=` در پایتون ۳.۰ یک اشتباه وحشتناک و انگشتسوز (!) بوده است، عمو زبان مهربان برای همیشه (FLUFL) عملگر الماسیشکل `<>` را مجدداً بهعنوان تنها روش درست برای این منظور بازگردانده است.
+
+- البته «عمو بَری» چیزهای بیشتری برای گفتن در این PEP داشت؛ میتوانید آنها را [اینجا](https://www.python.org/dev/peps/pep-0401/) مطالعه کنید.
+- این قابلیت در محیط تعاملی به خوبی عمل میکند، اما در زمان اجرای کد از طریق فایل پایتون، با خطای `SyntaxError` روبرو خواهید شد (برای اطلاعات بیشتر به این [issue](https://github.com/satwikkansal/wtfpython/issues/94) مراجعه کنید). با این حال، میتوانید کد خود را درون یک `eval` یا `compile` قرار دهید تا این قابلیت فعال شود.
+
+ ```py
+ from __future__ import barry_as_FLUFL
+ print(eval('"Ruby" <> "Python"'))
+ ```
+
+---
+
+### ◀ حتی پایتون هم میداند که عشق پیچیده است
+
+
+
+```py
+import this
+```
+
+صبر کن، **این** چیه؟ `this` عشقه :heart:
+
+**خروجی:**
+
+```text
+The Zen of Python, by Tim Peters
+
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it.
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than *right* now.
+If the implementation is hard to explain, it's a bad idea.
+If the implementation is easy to explain, it may be a good idea.
+Namespaces are one honking great idea -- let's do more of those!
+```
+
+این ذنِ پایتون است!
+
+```py
+>>> love = this
+>>> this is love
+True
+>>> love is True
+False
+>>> love is False
+False
+>>> love is not True or False
+True
+>>> love is not True or False; love is love # عشق پیجیده است
+True
+```
+
+#### 💡 توضیح:
+
+- ماژول `this` در پایتون، یک ایستر اگ برای «ذنِ پایتون» ([PEP 20](https://www.python.org/dev/peps/pep-0020)) است.
+- اگر این موضوع بهاندازه کافی جالب است، حتماً پیادهسازی [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py) را ببینید. نکته جالب این است که **کد مربوط به ذنِ پایتون، خودش اصول ذن را نقض کرده است** (و احتمالاً این تنها جایی است که چنین اتفاقی میافتد).
+- درباره جمله `love is not True or False; love is love`، اگرچه طعنهآمیز است، اما خود گویاست. (اگر واضح نیست، لطفاً مثالهای مربوط به عملگرهای `is` و `is not` را مشاهده کنید.)
+
+---
+
+### ◀ بله، این واقعاً وجود دارد!
+
+
+
+**عبارت `else` برای حلقهها.** یک مثال معمول آن میتواند چنین باشد:
+
+```py
+ def does_exists_num(l, to_find):
+ for num in l:
+ if num == to_find:
+ print("Exists!")
+ break
+ else:
+ print("Does not exist")
+```
+
+**خروجی:**
+
+```py
+>>> some_list = [1, 2, 3, 4, 5]
+>>> does_exists_num(some_list, 4)
+Exists!
+>>> does_exists_num(some_list, -1)
+Does not exist
+```
+
+**عبارت `else` در مدیریت استثناها.** مثالی از آن:
+
+```py
+try:
+ pass
+except:
+ print("Exception occurred!!!")
+else:
+ print("Try block executed successfully...")
+```
+
+**خروجی:**
+
+```py
+Try block executed successfully...
+```
+
+#### 💡 توضیح:
+
+- عبارت `else` بعد از حلقهها تنها زمانی اجرا میشود که در هیچکدام از تکرارها (`iterations`) از دستور `break` استفاده نشده باشد. میتوانید آن را به عنوان یک شرط «بدون شکست» (nobreak) در نظر بگیرید.
+- عبارت `else` پس از بلاک `try` به عنوان «عبارت تکمیل» (`completion clause`) نیز شناخته میشود؛ چراکه رسیدن به عبارت `else` در ساختار `try` به این معنی است که بلاک `try` بدون رخ دادن استثنا با موفقیت تکمیل شده است.
+
+---
+
+### ◀ عملگر Ellipsis \*
+
+
+
+```py
+def some_func():
+ Ellipsis
+```
+
+**خروجی**
+
+```py
+>>> some_func()
+# بدون خروجی و بدون خطا
+
+>>> SomeRandomString
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡توضیح
+
+- در پایتون، `Ellipsis` یک شیء درونی (`built-in`) است که به صورت سراسری (`global`) در دسترس است و معادل `...` است.
+
+ ```py
+ >>> ...
+ Ellipsis
+ ```
+
+- عملگر `Ellipsis` میتواند برای چندین منظور استفاده شود:
+
+ - به عنوان یک نگهدارنده برای کدی که هنوز نوشته نشده است (مانند دستور `pass`)
+ - در سینتکس برش (`slicing`) برای نمایش برش کامل در ابعاد باقیمانده
+
+ ```py
+ >>> import numpy as np
+ >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
+ array([
+ [
+ [0, 1],
+ [2, 3]
+ ],
+
+ [
+ [4, 5],
+ [6, 7]
+ ]
+ ])
+ ```
+
+ بنابراین، آرایهی `three_dimensional_array` ما، آرایهای از آرایهها از آرایهها است. فرض کنیم میخواهیم عنصر دوم (اندیس `1`) از تمامی آرایههای درونی را چاپ کنیم؛ در این حالت میتوانیم از `Ellipsis` برای عبور از تمامی ابعاد قبلی استفاده کنیم:
+
+ ```py
+ >>> three_dimensional_array[:,:,1]
+ array([[1, 3],
+ [5, 7]])
+ >>> three_dimensional_array[..., 1] # با استفاده از Ellipsis.
+ array([[1, 3],
+ [5, 7]])
+ ```
+
+ نکته: این روش برای آرایههایی با هر تعداد بُعد کار میکند. حتی میتوانید از برش (`slice`) در بُعد اول و آخر استفاده کرده و ابعاد میانی را نادیده بگیرید (به صورت `n_dimensional_array[first_dim_slice, ..., last_dim_slice]`).
+
+ - در [نوعدهی (`type hinting`)](https://docs.python.org/3/library/typing.html) برای اشاره به بخشی از نوع (مانند `Callable[..., int]` یا `Tuple[str, ...]`) استفاده میشود.
+ - همچنین میتوانید از `Ellipsis` به عنوان آرگومان پیشفرض تابع استفاده کنید (برای مواردی که میخواهید میان «آرگومانی ارسال نشده است» و «مقدار `None` ارسال شده است» تمایز قائل شوید).
+
+---
+
+### ◀ بینهایت (`Inpinity`)
+
+
+
+این املای کلمه تعمداً به همین شکل نوشته شده است. لطفاً برای اصلاح آن درخواست (`patch`) ارسال نکنید.
+
+**خروجی (پایتون 3.x):**
+
+```py
+>>> infinity = float('infinity')
+>>> hash(infinity)
+314159
+>>> hash(float('-inf'))
+-314159
+```
+
+#### 💡 توضیح:
+
+- هش (`hash`) مقدار بینهایت برابر با 10⁵ × π است.
+- نکته جالب اینکه در پایتون ۳ هشِ مقدار `float('-inf')` برابر با «-10⁵ × π» است، در حالی که در پایتون ۲ برابر با «-10⁵ × e» است.
+
+---
+
+### ◀ بیایید خرابکاری کنیم
+
+
+
+1\.
+
+```py
+class Yo(object):
+ def __init__(self):
+ self.__honey = True
+ self.bro = True
+```
+
+**خروجی:**
+
+```py
+>>> Yo().bro
+True
+>>> Yo().__honey
+AttributeError: 'Yo' object has no attribute '__honey'
+>>> Yo()._Yo__honey
+True
+```
+
+2\.
+
+```py
+class Yo(object):
+ def __init__(self):
+ # این بار بیایید چیزی متقارن را امتحان کنیم
+ self.__honey__ = True
+ self.bro = True
+```
+
+**خروجی:**
+
+```py
+>>> Yo().bro
+True
+
+>>> Yo()._Yo__honey__
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
+چرا کد `Yo()._Yo__honey` کار کرد؟
+
+3\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+ def some_func(self):
+ return __variable # هنوز در هیچ جا مقداردهی اولیه نشده است
+```
+
+**خروجی:**
+
+```py
+>>> A().__variable
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> A().some_func()
+'Some value'
+```
+
+#### 💡 توضیح:
+
+- [تغییر نام](https://en.wikipedia.org/wiki/Name_mangling) برای جلوگیری از برخورد نامها بین فضاهای نام مختلف استفاده میشود.
+- در پایتون، مفسر نامهای اعضای کلاس که با `__` (دو آندرلاین که به عنوان "دندر" شناخته میشود) شروع میشوند و بیش از یک آندرلاین انتهایی ندارند را با اضافه کردن `_NameOfTheClass` در ابتدای آنها تغییر میدهد.
+- بنابراین، برای دسترسی به ویژگی `__honey` در اولین قطعه کد، مجبور بودیم `_Yo` را به ابتدای آن اضافه کنیم، که از بروز تعارض با ویژگی با همان نام تعریفشده در هر کلاس دیگری جلوگیری میکند.
+- اما چرا در دومین قطعه کد کار نکرد؟ زیرا تغییر نام، نامهایی که با دو آندرلاین خاتمه مییابند را شامل نمیشود.
+- قطعه سوم نیز نتیجه تغییر نام بود. نام `__variable` در عبارت `return __variable` به `_A__variable` تغییر یافت، که همچنین همان نام متغیری است که در محدوده بیرونی تعریف کرده بودیم.
+- همچنین، اگر نام تغییر یافته بیش از ۲۵۵ کاراکتر باشد، برش داده میشود.
+
+---
+
+---
+
+## بخش: ظاهرها فریبندهاند!
+
+### ◀ خطوط را رد میکند؟
+
+
+
+**خروجی:**
+
+```py
+>>> value = 11
+>>> valuе = 32
+>>> value
+11
+```
+
+چی?
+
+**نکته:** سادهترین روش برای بازتولید این رفتار، کپی کردن دستورات از کد بالا و جایگذاری (paste) آنها در فایل یا محیط تعاملی (shell) خودتان است.
+
+#### 💡 توضیح
+
+برخی از حروف غیرغربی کاملاً مشابه حروف الفبای انگلیسی به نظر میرسند، اما مفسر پایتون آنها را متفاوت در نظر میگیرد.
+
+```py
+>>> ord('е') # حرف سیریلیک «е» (Ye)
+1077
+>>> ord('e') # حرف لاتین «e»، که در انگلیسی استفاده میشود و با صفحهکلید استاندارد تایپ میگردد
+101
+>>> 'е' == 'e'
+False
+
+>>> value = 42 # حرف لاتین e
+>>> valuе = 23 # حرف سیریلیک «е»؛ مفسر پایتون نسخه ۲ در اینجا خطای `SyntaxError` ایجاد میکند
+>>> value
+42
+```
+
+تابع داخلی `ord()`، [کدپوینت](https://fa.wikipedia.org/wiki/کدپوینت) یونیکد مربوط به یک نویسه را برمیگرداند. موقعیتهای کدی متفاوت برای حرف سیریلیک «е» و حرف لاتین «e»، علت رفتار مثال بالا را توجیه میکنند.
+
+---
+
+### ◀ تلهپورت کردن
+
+
+
+```py
+# `pip install numpy` first.
+import numpy as np
+
+def energy_send(x):
+ # مقداردهی اولیه یک آرایه numpy
+ np.array([float(x)])
+
+def energy_receive():
+ # بازگرداندن یک آرایهی خالی numpy
+ return np.empty((), dtype=np.float).tolist()
+```
+
+**خروجی:**
+
+```py
+>>> energy_send(123.456)
+>>> energy_receive()
+123.456
+```
+
+جایزه نوبل کجاست؟
+
+#### 💡 توضیح:
+
+- توجه کنید که آرایهی numpy ایجادشده در تابع `energy_send` برگردانده نشده است، بنابراین فضای حافظهی آن آزاد شده و مجدداً قابل استفاده است.
+- تابع `numpy.empty()` نزدیکترین فضای حافظهی آزاد را بدون مقداردهی مجدد برمیگرداند. این فضای حافظه معمولاً همان فضایی است که بهتازگی آزاد شده است (البته معمولاً این اتفاق میافتد و نه همیشه).
+
+---
+
+### ◀ خب، یک جای کار مشکوک است...
+
+
+
+```py
+def square(x):
+ """
+ یک تابع ساده برای محاسبهی مربع یک عدد با استفاده از جمع.
+ """
+ sum_so_far = 0
+ for counter in range(x):
+ sum_so_far = sum_so_far + x
+ return sum_so_far
+```
+
+**خروجی (پایتون 2.X):**
+
+```py
+>>> square(10)
+10
+```
+
+آیا این نباید ۱۰۰ باشد؟
+
+**نکته:** اگر نمیتوانید این مشکل را بازتولید کنید، سعی کنید فایل [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) را از طریق شِل اجرا کنید.
+
+#### 💡 توضیح
+
+- **تبها و فاصلهها (space) را با هم ترکیب نکنید!** کاراکتری که دقیقاً قبل از دستور return آمده یک «تب» است، در حالی که در بقیۀ مثال، کد با مضربی از «۴ فاصله» تورفتگی دارد.
+- نحوۀ برخورد پایتون با تبها به این صورت است:
+
+ > ابتدا تبها (از چپ به راست) با یک تا هشت فاصله جایگزین میشوند بهطوری که تعداد کل کاراکترها تا انتهای آن جایگزینی، مضربی از هشت باشد <...>
+
+- بنابراین «تب» در آخرین خط تابع `square` با هشت فاصله جایگزین شده و به همین دلیل داخل حلقه قرار میگیرد.
+- پایتون ۳ آنقدر هوشمند هست که چنین مواردی را بهصورت خودکار با خطا اعلام کند.
+
+ **خروجی (Python 3.x):**
+
+ ```py
+ TabError: inconsistent use of tabs and spaces in indentation
+ ```
+
+---
+
+---
+
+## بخش: متفرقه
+
+### ◀ `+=` سریعتر است
+
+
+
+```py
+# استفاده از "+"، سه رشته:
+>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.25748300552368164
+# استفاده از "+="، سه رشته:
+>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.012188911437988281
+```
+
+#### 💡 توضیح:
+
+- استفاده از `+=` برای اتصال بیش از دو رشته سریعتر از `+` است، زیرا هنگام محاسبه رشتهی نهایی، رشتهی اول (بهعنوان مثال `s1` در عبارت `s1 += s2 + s3`) از بین نمیرود.
+
+---
+
+### ◀ بیایید یک رشتهی بزرگ بسازیم!
+
+
+
+```py
+def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s += "xyz"
+ assert len(s) == 3*iters
+
+def add_bytes_with_plus(iters):
+ s = b""
+ for i in range(iters):
+ s += b"xyz"
+ assert len(s) == 3*iters
+
+def add_string_with_format(iters):
+ fs = "{}"*iters
+ s = fs.format(*(["xyz"]*iters))
+ assert len(s) == 3*iters
+
+def add_string_with_join(iters):
+ l = []
+ for i in range(iters):
+ l.append("xyz")
+ s = "".join(l)
+ assert len(s) == 3*iters
+
+def convert_list_to_string(l, iters):
+ s = "".join(l)
+ assert len(s) == 3*iters
+```
+
+**خروجی:**
+
+اجرا شده در پوستهی ipython با استفاده از `%timeit` برای خوانایی بهتر نتایج.
+همچنین میتوانید از ماژول `timeit` در پوسته یا اسکریپت عادی پایتون استفاده کنید؛ نمونهی استفاده در زیر آمده است:
+timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())
+
+```py
+
+>>> NUM_ITERS = 1000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
+124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
+211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
+61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
+117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
+10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+بیایید تعداد تکرارها را ۱۰ برابر افزایش دهیم.
+
+```py
+>>> NUM_ITERS = 10000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # افزایش خطی در زمان اجرا
+1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # افزایش درجه دو (افزایش مربعی)
+6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # افزایش خطی
+645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # افزایش خطی
+1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # افزایش خطی
+86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+#### 💡 توضیح
+
+توضیحات
+
+- برای اطلاعات بیشتر دربارهی [timeit](https://docs.python.org/3/library/timeit.html) یا [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit)، میتوانید به این لینکها مراجعه کنید. این توابع برای اندازهگیری زمان اجرای قطعهکدها استفاده میشوند.
+- برای تولید رشتههای طولانی از `+` استفاده نکنید — در پایتون، نوع دادهی `str` تغییرناپذیر (immutable) است؛ بنابراین برای هر الحاق (concatenation)، رشتهی چپ و راست باید در رشتهی جدید کپی شوند. اگر چهار رشتهی ۱۰ حرفی را متصل کنید، بهجای کپی ۴۰ کاراکتر، باید `(10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90` کاراکتر کپی کنید. این وضعیت با افزایش تعداد و طول رشتهها بهصورت درجه دو (مربعی) بدتر میشود (که توسط زمان اجرای تابع `add_bytes_with_plus` تأیید شده است).
+- بنابراین توصیه میشود از `.format` یا سینتکس `%` استفاده کنید (البته این روشها برای رشتههای بسیار کوتاه کمی کندتر از `+` هستند).
+- اما بهتر از آن، اگر محتوای شما از قبل بهشکل یک شیء قابل تکرار (iterable) موجود است، از دستور `''.join(iterable_object)` استفاده کنید که بسیار سریعتر است.
+- برخلاف تابع `add_bytes_with_plus` و بهدلیل بهینهسازیهای انجامشده برای عملگر `+=` (که در مثال قبلی توضیح داده شد)، تابع `add_string_with_plus` افزایشی درجه دو در زمان اجرا نشان نداد. اگر دستور بهصورت `s = s + "x" + "y" + "z"` بود (بهجای `s += "xyz"`)، افزایش زمان اجرا درجه دو میشد.
+
+ ```py
+ def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s = s + "x" + "y" + "z"
+ assert len(s) == 3*iters
+
+ >>> %timeit -n100 add_string_with_plus(1000)
+ 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+ >>> %timeit -n100 add_string_with_plus(10000) # افزایش درجه دو در زمان اجرا
+ 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+ ```
+
+- وجود راههای متعدد برای قالببندی و ایجاد رشتههای بزرگ تا حدودی در تضاد با [ذِن پایتون](https://www.python.org/dev/peps/pep-0020/) است که میگوید:
+
+ > «باید یک راه — و ترجیحاً فقط یک راه — واضح برای انجام آن وجود داشته باشد.»
+
+---
+
+### ◀ کُند کردن جستجوها در `dict` \*
+
+
+
+```py
+some_dict = {str(i): 1 for i in range(1_000_000)}
+another_dict = {str(i): 1 for i in range(1_000_000)}
+```
+
+**خروجی:**
+
+```py
+>>> %timeit some_dict['5']
+28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> some_dict[1] = 1
+>>> %timeit some_dict['5']
+37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+>>> %timeit another_dict['5']
+28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> another_dict[1] # تلاش برای دسترسی به کلیدی که وجود ندارد
+Traceback (most recent call last):
+ File "", line 1, in
+KeyError: 1
+>>> %timeit another_dict['5']
+38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+```
+
+چرا جستجوهای یکسان کندتر میشوند؟
+
+#### 💡 توضیح:
+
+- در CPython یک تابع عمومی برای جستجوی کلید در دیکشنریها وجود دارد که از تمام انواع کلیدها (`str`، `int` و هر شیء دیگر) پشتیبانی میکند؛ اما برای حالت متداولی که تمام کلیدها از نوع `str` هستند، یک تابع بهینهشدهی اختصاصی نیز وجود دارد.
+- تابع اختصاصی (که در کد منبع CPython با نام [`lookdict_unicode`](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841) شناخته میشود) فرض میکند که تمام کلیدهای موجود در دیکشنری (از جمله کلیدی که در حال جستجوی آن هستید) رشته (`str`) هستند و برای مقایسهی کلیدها، بهجای فراخوانی متد `__eq__`، از مقایسهی سریعتر و سادهتر رشتهای استفاده میکند.
+- اولین باری که یک دیکشنری (`dict`) با کلیدی غیر از `str` فراخوانی شود، این حالت تغییر میکند و جستجوهای بعدی از تابع عمومی استفاده خواهند کرد.
+- این فرایند برای آن نمونهی خاص از دیکشنری غیرقابل بازگشت است و حتی لازم نیست کلید موردنظر در دیکشنری موجود باشد. به همین دلیل است که حتی تلاش ناموفق برای دسترسی به کلیدی ناموجود نیز باعث ایجاد همین تأثیر (کند شدن جستجو) میشود.
+
+### ◀ حجیم کردن دیکشنری نمونهها (`instance dicts`) \*
+
+
+
+```py
+import sys
+
+class SomeClass:
+ def __init__(self):
+ self.some_attr1 = 1
+ self.some_attr2 = 2
+ self.some_attr3 = 3
+ self.some_attr4 = 4
+
+
+def dict_size(o):
+ return sys.getsizeof(o.__dict__)
+
+```
+
+**خروجی:** (پایتون ۳.۸؛ سایر نسخههای پایتون ۳ ممکن است کمی متفاوت باشند)
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104
+>>> dict_size(o2)
+104
+>>> del o1.some_attr1
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+>>> dict_size(o1)
+232
+```
+
+بیایید دوباره امتحان کنیم... در یک مفسر (interpreter) جدید:
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104 # همانطور که انتظار میرفت
+>>> o1.some_attr5 = 5
+>>> o1.some_attr6 = 6
+>>> dict_size(o1)
+360
+>>> dict_size(o2)
+272
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+```
+
+چه چیزی باعث حجیمشدن این دیکشنریها میشود؟ و چرا اشیاء تازه ساختهشده نیز حجیم هستند؟
+
+#### 💡 توضیح:
+
+- در CPython، امکان استفادهی مجدد از یک شیء «کلیدها» (`keys`) در چندین دیکشنری وجود دارد. این ویژگی در [PEP 412](https://www.python.org/dev/peps/pep-0412/) معرفی شد تا مصرف حافظه کاهش یابد، بهویژه برای دیکشنریهایی که به نمونهها (instances) تعلق دارند و معمولاً کلیدها (نام صفات نمونهها) بین آنها مشترک است.
+- این بهینهسازی برای دیکشنریهای نمونهها کاملاً شفاف و خودکار است؛ اما اگر بعضی فرضیات نقض شوند، غیرفعال میشود.
+- دیکشنریهایی که کلیدهایشان به اشتراک گذاشته شده باشد، از حذف کلید پشتیبانی نمیکنند؛ بنابراین اگر صفتی از یک نمونه حذف شود، دیکشنریِ آن نمونه «غیر مشترک» (`unshared`) شده و این قابلیت اشتراکگذاری کلیدها برای تمام نمونههایی که در آینده از آن کلاس ساخته میشوند، غیرفعال میگردد.
+- همچنین اگر اندازهی دیکشنری بهعلت اضافهشدن کلیدهای جدید تغییر کند (`resize` شود)، اشتراکگذاری کلیدها تنها زمانی ادامه مییابد که فقط یک دیکشنری در حال استفاده از آنها باشد (این اجازه میدهد در متد `__init__` برای اولین نمونهی ساختهشده، صفات متعددی تعریف کنید بدون آنکه اشتراکگذاری کلیدها از بین برود). اما اگر چند نمونه همزمان وجود داشته باشند و تغییر اندازهی دیکشنری رخ دهد، قابلیت اشتراکگذاری کلیدها برای نمونههای بعدی همان کلاس غیرفعال خواهد شد. زیرا CPython دیگر نمیتواند مطمئن باشد که آیا نمونههای بعدی دقیقاً از مجموعهی یکسانی از صفات استفاده خواهند کرد یا خیر.
+- نکتهای کوچک برای کاهش مصرف حافظهی برنامه: هرگز صفات نمونهها را حذف نکنید و حتماً تمام صفات را در متد `__init__` تعریف و مقداردهی اولیه کنید!
+
+### ◀ موارد جزئی \*
+
+
+
+- متد `join()` عملیاتی مربوط به رشته (`str`) است، نه لیست (`list`). (در نگاه اول کمی برخلاف انتظار است.)
+
+ **توضیح:** اگر `join()` بهعنوان متدی روی رشته پیادهسازی شود، میتواند روی هر شیء قابل پیمایش (`iterable`) از جمله لیست، تاپل و هر نوع تکرارشوندهی دیگر کار کند. اگر بهجای آن روی لیست تعریف میشد، باید بهطور جداگانه برای هر نوع دیگری نیز پیادهسازی میشد. همچنین منطقی نیست که یک متد مختص رشته روی یک شیء عمومی مانند `list` پیاده شود.
+
+- تعدادی عبارت با ظاهری عجیب اما از نظر معنا صحیح:
+
+ - عبارت `[] = ()` از نظر معنایی صحیح است (باز کردن یا `unpack` کردن یک تاپل خالی درون یک لیست خالی).
+ - عبارت `'a'[0][0][0][0][0]` نیز از نظر معنایی صحیح است، زیرا پایتون برخلاف زبانهایی که از C منشعب شدهاند، نوع دادهای جداگانهای برای کاراکتر ندارد. بنابراین انتخاب یک کاراکتر از یک رشته، منجر به بازگشت یک رشتهی تککاراکتری میشود.
+ - عبارات `3 --0-- 5 == 8` و `--5 == 5` هر دو از لحاظ معنایی درست بوده و مقدارشان برابر `True` است.
+
+- با فرض اینکه `a` یک عدد باشد، عبارات `++a` و `--a` هر دو در پایتون معتبر هستند؛ اما رفتاری مشابه با عبارات مشابه در زبانهایی مانند C، ++C یا جاوا ندارند.
+
+ ```py
+ >>> a = 5
+ >>> a
+ 5
+ >>> ++a
+ 5
+ >>> --a
+ 5
+ ```
+
+ 💡 **توضیح:**
+
+- در گرامر پایتون عملگری بهنام `++` وجود ندارد. در واقع `++` دو عملگر `+` جداگانه است.
+- عبارت `++a` بهشکل `+(+a)` تفسیر میشود که معادل `a` است. بههمین ترتیب، خروجی عبارت `--a` نیز قابل توجیه است.
+- این [تاپیک در StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) دلایل نبودن عملگرهای افزایش (`++`) و کاهش (`--`) در پایتون را بررسی میکند.
+
+- احتمالاً با عملگر Walrus (گراز دریایی) در پایتون آشنا هستید؛ اما تا به حال در مورد _عملگر Space-invader (مهاجم فضایی)_ شنیدهاید؟
+
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+
+از آن بهعنوان جایگزینی برای عملگر افزایش (increment)، در ترکیب با یک عملگر دیگر استفاده میشود.
+
+```py
+>>> a +=+ 1
+>>> a
+>>> 44
+```
+
+**💡 توضیح:** این شوخی از [توییت Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en) برگرفته شده است. عملگر «مهاجم فضایی» در واقع همان عبارت بدفرمتشدهی `a -= (-1)` است که معادل با `a = a - (- 1)` میباشد. حالت مشابهی برای عبارت `a += (+ 1)` نیز وجود دارد.
+
+- پایتون یک عملگر مستندنشده برای [استلزام معکوس (converse implication)](https://en.wikipedia.org/wiki/Converse_implication) دارد.
+
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 توضیح:** اگر مقادیر `False` و `True` را بهترتیب با اعداد ۰ و ۱ جایگزین کرده و محاسبات را انجام دهید، جدول درستی حاصل، معادل یک عملگر استلزام معکوس خواهد بود. ([منبع](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+- حالا که صحبت از عملگرها شد، عملگر `@` نیز برای ضرب ماتریسی در پایتون وجود دارد (نگران نباشید، این بار واقعی است).
+
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 توضیح:** عملگر `@` در پایتون ۳٫۵ با در نظر گرفتن نیازهای جامعه علمی اضافه شد. هر شیای میتواند متد جادویی `__matmul__` را بازنویسی کند تا رفتار این عملگر را مشخص نماید.
+
+- از پایتون ۳٫۸ به بعد میتوانید از نحو متداول f-string مانند `f'{some_var=}'` برای اشکالزدایی سریع استفاده کنید. مثال,
+
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+- پایتون برای ذخیرهسازی متغیرهای محلی در توابع از ۲ بایت استفاده میکند. از نظر تئوری، این به معنای امکان تعریف حداکثر ۶۵۵۳۶ متغیر در یک تابع است. با این حال، پایتون راهکار مفیدی ارائه میکند که میتوان با استفاده از آن بیش از ۲^۱۶ نام متغیر را ذخیره کرد. کد زیر نشان میدهد وقتی بیش از ۶۵۵۳۶ متغیر محلی تعریف شود، در پشته (stack) چه اتفاقی رخ میدهد (هشدار: این کد تقریباً ۲^۱۸ خط متن چاپ میکند، بنابراین آماده باشید!):
+
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+- چندین رشته (Thread) در پایتون، کدِ _پایتونی_ شما را بهصورت همزمان اجرا نمیکنند (بله، درست شنیدید!). شاید به نظر برسد که ایجاد چندین رشته و اجرای همزمان آنها منطقی است، اما به دلیل وجود [قفل مفسر سراسری (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock) در پایتون، تمام کاری که انجام میدهید این است که رشتههایتان بهنوبت روی یک هسته اجرا میشوند. رشتهها در پایتون برای وظایفی مناسب هستند که عملیات I/O دارند، اما برای رسیدن به موازیسازی واقعی در وظایف پردازشی سنگین (CPU-bound)، بهتر است از ماژول [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) در پایتون استفاده کنید.
+
+- گاهی اوقات، متد `print` ممکن است مقادیر را فوراً چاپ نکند. برای مثال،
+
+ ```py
+ # File some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
+
+ این کد عبارت `wtfpython` را به دلیل آرگومان `end` پس از ۳ ثانیه چاپ میکند؛ چرا که بافر خروجی تنها پس از رسیدن به کاراکتر `\n` یا در زمان اتمام اجرای برنامه تخلیه میشود. برای تخلیهی اجباری بافر میتوانید از آرگومان `flush=True` استفاده کنید.
+
+- برش لیستها (List slicing) با اندیسهای خارج از محدوده، خطایی ایجاد نمیکند.
+
+ ```py
+ >>> some_list = [1, 2, 3, 4, 5]
+ >>> some_list[111:]
+ []
+ ```
+
+- برش زدن (slicing) یک شئ قابل پیمایش (iterable) همیشه یک شئ جدید ایجاد نمیکند. بهعنوان مثال،
+
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # انتظار میرود False باشد چون یک شیء جدید ایجاد شده است.
+ False
+ >>> some_str is some_str[:] # True چون رشتهها تغییرناپذیر هستند، بنابراین ساختن یک شیء جدید فایدهای ندارد.
+ True
+ ```
+
+- در پایتون ۳، فراخوانی `int('١٢٣٤٥٦٧٨٩')` مقدار `123456789` را برمیگرداند. در پایتون، نویسههای دهدهی (Decimal characters) شامل تمام ارقامی هستند که میتوانند برای تشکیل اعداد در مبنای ده استفاده شوند؛ بهعنوان مثال نویسهی U+0660 که همان رقم صفر عربی-هندی است. [اینجا](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) داستان جالبی درباره این رفتار پایتون آمده است.
+
+- از پایتون ۳ به بعد، میتوانید برای افزایش خوانایی، اعداد را با استفاده از زیرخط (`_`) جدا کنید.
+
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+- عبارت `'abc'.count('') == 4` مقدار `True` برمیگرداند. در اینجا یک پیادهسازی تقریبی از متد `count` آورده شده که این موضوع را شفافتر میکند:
+
+ ```py
+ def count(s, sub):
+ result = 0
+ for i in range(len(s) + 1 - len(sub)):
+ result += (s[i:i + len(sub)] == sub)
+ return result
+ ```
+
+این رفتار به این دلیل است که زیررشتهی خالی (`''`) با برشهایی (slices) به طول صفر در رشتهی اصلی مطابقت پیدا میکند.
+
+---
+
+---
+
+# مشارکت
+
+چند روشی که میتوانید در wtfpython مشارکت داشته باشید:
+
+- پیشنهاد مثالهای جدید
+- کمک به ترجمه (به [مشکلات برچسب ترجمه](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation) مراجعه کنید)
+- اصلاحات جزئی مثل اشاره به تکهکدهای قدیمی، اشتباهات تایپی، خطاهای قالببندی و غیره.
+- شناسایی نواقص (مانند توضیحات ناکافی، مثالهای تکراری و ...)
+- هر پیشنهاد خلاقانهای برای مفیدتر و جذابتر شدن این پروژه
+
+برای اطلاعات بیشتر [CONTRIBUTING.md](/CONTRIBUTING.md) را مشاهده کنید. برای بحث درباره موارد مختلف میتوانید یک [مشکل جدید](https://github.com/satwikkansal/wtfpython/issues/new) ایجاد کنید.
+
+نکته: لطفاً برای درخواست بکلینک (backlink) تماس نگیرید. هیچ لینکی اضافه نمیشود مگر اینکه ارتباط بسیار زیادی با پروژه داشته باشد.
+
+# تقدیر و تشکر
+
+ایده و طراحی این مجموعه ابتدا از پروژه عالی [wtfjs](https://github.com/denysdovhan/wtfjs) توسط Denys Dovhan الهام گرفته شد. حمایت فوقالعاده جامعه پایتون باعث شد پروژه به شکل امروزی خود درآید.
+
+#### چند لینک جالب!
+
+- https://www.youtube.com/watch?v=sH4XF6pKKmk
+- https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+- https://sopython.com/wiki/Common_Gotchas_In_Python
+- https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+- https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+- https://www.python.org/doc/humor/
+- https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+- https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+- WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
+
+# 🎓 مجوز
+
+[![WTFPL 2.0][license-image]][license-url]
+
+© [Satwik Kansal](https://satwikkansal.xyz)
+
+[license-url]: http://www.wtfpl.net
+[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
+
+## دوستانتان را هم شگفتزده کنید!
+
+اگر از wtfpython خوشتان آمد، میتوانید با این لینکهای سریع آن را با دوستانتان به اشتراک بگذارید:
+
+[توییتر](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [لینکدین](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [فیسبوک](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+
+## آیا به یک نسخه pdf نیاز دارید؟
+
+من چند درخواست برای نسخه PDF (و epub) کتاب wtfpython دریافت کردهام. برای دریافت این نسخهها به محض آماده شدن، میتوانید اطلاعات خود را [اینجا](https://form.jotform.com/221593245656057) وارد کنید.
+
+**همین بود دوستان!** برای دریافت مطالب آینده مشابه این، میتوانید ایمیل خود را [اینجا](https://form.jotform.com/221593598380062) اضافه کنید.
diff --git a/translations/ru-russian/CONTRIBUTING.md b/translations/ru-russian/CONTRIBUTING.md
new file mode 100644
index 00000000..a5428149
--- /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 00000000..2599f8ab
--- /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 00000000..03fc771c
--- /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`)
+
+
+
+
+
+
+
+
+Мы можем избежать этого сценария, не используя переменную `row` для генерации `board`. (Подробнее в [issue](https://github.com/satwikkansal/wtfpython/issues/68)).
+
+```py
+>>> board = [['']*3 for _ in range(3)]
+>>> board[0][0] = "X"
+>>> board
+[['X', '', ''], ['', '', ''], ['', '', '']]
+```
+
+---
+
+
+### ▶ Переменная Шредингера *
+
+
+
+```py
+funcs = []
+results = []
+for x in range(7):
+ def some_func():
+ return x
+ funcs.append(some_func)
+ results.append(some_func()) # обратите внимание на вызов функции
+
+funcs_results = [func() for func in funcs]
+```
+
+**Вывод:**
+```py
+>>> results
+[0, 1, 2, 3, 4, 5, 6]
+>>> funcs_results
+[6, 6, 6, 6, 6, 6, 6]
+```
+
+Значения `x` были разными в каждой итерации до добавления `some_func` к `funcs`, но все функции возвращают `6`, когда они исполняются после завершения цикла.
+
+2.
+
+```py
+>>> powers_of_x = [lambda x: x**i for i in range(10)]
+>>> [f(2) for f in powers_of_x]
+[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]
+```
+
+#### 💡 Объяснение:
+* При определении функции внутри цикла, которая использует переменную цикла в своем теле, цикл функции привязывается к *переменной*, а не к ее *значению*. Функция ищет `x` в окружающем контексте, а не использует значение `x` на момент создания функции. Таким образом, все функции используют для вычислений последнее значение, присвоенное переменной. Мы можем видеть, что используется `x` из глобального контекста (т.е. *не* локальная переменная):
+```py
+>>> import inspect
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())
+```
+Так как `x` - глобальная переменная, можно изменить ее значение, которое будет использовано и возвращено из `funcs`
+
+```py
+>>> x = 42
+>>> [func() for func in funcs]
+[42, 42, 42, 42, 42, 42, 42]
+```
+
+* Чтобы получить желаемое поведение, вы можете передать переменную цикла как именованную аргумент в функцию. **Почему это работает?** Потому что это определит переменную *внутри* области видимости функции. Она больше не будет обращаться к глобальной области видимости для поиска значения переменной, а создаст локальную переменную, которая будет хранить значение `x` в данный момент времени.
+
+```py
+funcs = []
+for x in range(7):
+ def some_func(x=x):
+ return x
+ funcs.append(some_func)
+```
+
+**Вывод:**
+
+```py
+>>> funcs_results = [func() for func in funcs]
+>>> funcs_results
+[0, 1, 2, 3, 4, 5, 6]
+```
+
+`x` больше не используется в глобальной области видимости
+
+```py
+>>> inspect.getclosurevars(funcs[0])
+ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())
+```
+
+---
+
+
+### ▶ Проблема курицы и яйца *
+
+1\.
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+Так какой же базовый класс является "родительским"? Кстати, это еще не все,
+
+2\.
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+
+#### 💡 Объяснение
+
+- `type` - это [метакласс](https://realpython.com/python-metaclasses/) в Python.
+- **Все** в Python является `объектом`, что включает в себя как классы, так и их объекты (экземпляры).
+- Класс `type` является метаклассом класса `object`, и каждый класс (включая `type`) наследуется прямо или косвенно от `object`.
+- У `object` и `type` нет реального базового класса. Путаница в приведенных выше фрагментах возникает потому, что мы думаем об этих отношениях (`issubclass` и `isinstance`) в терминах классов Python. Отношения между `object` и `type` не могут быть воспроизведены в чистом Python. Точнее говоря, следующие отношения не могут быть воспроизведены в чистом Python,
+ + класс A является экземпляром класса B, а класс B является экземпляром класса A.
+ + класс A является экземпляром самого себя.
+- Эти отношения между `object` и `type` (оба являются экземплярами друг друга, а также самих себя) существуют в Python из-за "обмана" на уровне реализации.
+
+---
+
+
+### ▶ Отношения между подклассами
+
+**Вывод:**
+```py
+>>> from collections import Hashable
+>>> issubclass(list, object)
+True
+>>> issubclass(object, Hashable)
+True
+>>> issubclass(list, Hashable)
+False
+```
+
+Предполагается, что отношения подклассов должны быть транзитивными, верно? (т.е. если `A` является подклассом `B`, а `B` является подклассом `C`, то `A` _должен_ быть подклассом `C`)
+
+#### 💡 Объяснение
+
+* Отношения подклассов не обязательно являются транзитивными в Python. Можно переопределить магический метод `__subclasscheck__` в метаклассе.
+* Когда вызывается `issubclass(cls, Hashable)`, он просто ищет не-фальшивый метод "`__hash__`" в `cls` или во всем, от чего он наследуется.
+* Поскольку `object` является хэшируемым, а `list` - нет, это нарушает отношение транзитивности.
+* Более подробное объяснение можно найти [здесь](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).
+
+---
+
+### ▶ Равенство и тождество методов
+
+
+1.
+```py
+class SomeClass:
+ def method(self):
+ pass
+
+ @classmethod
+ def classm(cls):
+ pass
+
+ @staticmethod
+ def staticm():
+ pass
+```
+
+**Результат:**
+```py
+>>> print(SomeClass.method is SomeClass.method)
+True
+>>> print(SomeClass.classm is SomeClass.classm)
+False
+>>> print(SomeClass.classm == SomeClass.classm)
+True
+>>> print(SomeClass.staticm is SomeClass.staticm)
+True
+```
+
+Обращаясь к `classm` дважды, мы получаем одинаковый объект, но не *тот же самый*? Давайте посмотрим, что происходит
+с экземплярами `SomeClass`:
+
+2.
+```py
+o1 = SomeClass()
+o2 = SomeClass()
+```
+
+**Вывод:**
+```py
+>>> print(o1.method == o2.method)
+False
+>>> print(o1.method == o1.method)
+True
+>>> print(o1.method is o1.method)
+False
+>>> print(o1.classm is o1.classm)
+False
+>>> print(o1.classm == o1.classm == o2.classm == SomeClass.classm)
+True
+>>> print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)
+True
+```
+
+Повторный доступ к `классу` или `методу` создает одинаковые, но не *те же самые* объекты для одного и того же экземпляра `какого-либо класса`.
+
+#### 💡 Объяснение
+* Функции являются [дескрипторами](https://docs.python.org/3/howto/descriptor.html). Всякий раз, когда к функции обращаются как к
+атрибуту, вызывается дескриптор, создавая объект метода, который "связывает" функцию с объектом, владеющим атрибутом. При вызове метод вызывает функцию, неявно передавая связанный объект в качестве первого аргумента
+(именно так мы получаем `self` в качестве первого аргумента, несмотря на то, что не передаем его явно).
+```py
+>>> o1.method
+>
+```
+* При многократном обращении к атрибуту каждый раз создается объект метода! Поэтому `o1.method is o1.method` всегда ложно. Однако доступ к функциям как к атрибутам класса (в отличие от экземпляра) не создает методов; поэтому
+`SomeClass.method is SomeClass.method` является истинным.
+```py
+>>> SomeClass.method
+
+```
+* `classmethod` преобразует функции в методы класса. Методы класса - это дескрипторы, которые при обращении к ним создают
+объект метода, который связывает *класс* (тип) объекта, а не сам объект.
+```py
+>>> o1.classm
+>
+```
+* В отличие от функций, `classmethod` будет создавать метод и при обращении к нему как к атрибуту класса (в этом случае они
+привязываются к классу, а не к его типу). Поэтому `SomeClass.classm is SomeClass.classm` является ошибочным.
+```py
+>>> SomeClass.classm
+>
+```
+* Объект-метод равен, если обе функции равны, а связанные объекты одинаковы. Поэтому
+`o1.method == o1.method` является истинным, хотя и не является одним и тем же объектом в памяти.
+* `staticmethod` преобразует функции в дескриптор "no-op", который возвращает функцию как есть. Методы-объекты
+никогда не создается, поэтому сравнение с `is` является истинным.
+```py
+>>> o1.staticm
+
+>>> SomeClass.staticm
+
+```
+* Необходимость создавать новые объекты "метод" каждый раз, когда Python вызывает методы экземпляра, и необходимость изменять аргументы
+каждый раз, чтобы вставить `self`, сильно сказывается на производительности.
+CPython 3.7 [решил эту проблему](https://bugs.python.org/issue26110), введя новые опкоды, которые работают с вызовом методов
+без создания временных объектов методов. Это используется только при фактическом вызове функции доступа, так что
+приведенные здесь фрагменты не затронуты и по-прежнему генерируют методы :)
+
+---
+
+
+### ▶ All-true-ation (непереводимая игра слов) *
+
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+Почему это изменение True-False?
+
+#### 💡 Объяснение:
+
+- Реализация функции `all`:
+
+- ```py
+ def all(iterable):
+ for element in iterable:
+ if not element:
+ return False
+ return True
+ ```
+
+- `all([])` возвращает `True`, поскольку итерируемый массив пуст.
+- `all([[]])` возвращает `False`, поскольку переданный массив имеет один элемент, `[]`, а в python пустой список является ложным.
+- `all([[[[]]])` и более высокие рекурсивные варианты всегда `True`. Это происходит потому, что единственный элемент переданного массива (`[[...]]`) уже не пуст, а списки со значениями являются истинными.
+
+---
+
+
+### ▶ Неожиданная запятая
+
+**Вывод (< 3.6):**
+
+```py
+>>> def f(x, y,):
+... print(x, y)
+...
+>>> def g(x=4, y=5,):
+... print(x, y)
+...
+>>> def h(x, **kwargs,):
+ File "", line 1
+ def h(x, **kwargs,):
+ ^
+SyntaxError: invalid syntax
+
+>>> def h(*args,):
+ File "", line 1
+ def h(*args,):
+ ^
+SyntaxError: invalid syntax
+```
+
+#### 💡 Объяснение:
+
+- Запятая в конце списка аргументов функции Python не всегда законна.
+- В Python список аргументов определяется частично с помощью ведущих запятых, а частично с помощью запятых в конце списка. Этот конфликт приводит к ситуациям, когда запятая оказывается в середине, и ни одно из правил не выполняется.
+- **Примечание:** Проблема с запятыми в конце списка аргументов [исправлена в Python 3.6](https://bugs.python.org/issue9232). Варианты использования запятых в конце выражения приведены в [обсуждении](https://bugs.python.org/issue9232#msg248399).
+
+---
+
+
+### ▶ Строки и обратные слэши
+
+**Вывод:**
+```py
+>>> print("\"")
+"
+
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "", line 1
+ print(r"\")
+ ^
+SyntaxError: EOL while scanning string literal
+
+>>> r'\'' == "\\'"
+True
+```
+
+#### 💡 Объяснение
+
+- В обычной строке обратный слэш используется для экранирования символов, которые могут иметь специальное значение (например, одинарная кавычка, двойная кавычка и сам обратный слэш).
+ ```py
+ >>> "wt\"f"
+ 'wt"f'
+ ```
+- В необработанном строковом литерале (на что указывает префикс `r`) обратный слэш передается как есть, вместе с поведением экранирования следующего символа.
+ ```py
+ >>> r'wt\"f' == 'wt\\"f'
+ True
+ >>> print(repr(r'wt\"f')
+ 'wt\\"f'
+
+ >>> print("\n")
+
+ >>> print(r"\\n")
+ '\\n'
+ ```
+- Это означает, что когда синтаксический анализатор встречает обратный слэш в необработанной строке, он ожидает, что за ней последует другой символ. А в нашем случае (`print(r"\")`) обратный слэш экранирует двойную кавычку, оставив синтаксический анализатор без завершающей кавычки (отсюда `SyntaxError`). Вот почему обратный слэш не работает в конце необработанной строки.
+
+---
+
+
+### ▶ Не узел! (англ. not knot!)
+
+```py
+x = True
+y = False
+```
+
+**Результат:**
+```py
+>>> not x == y
+True
+>>> x == not y
+ File " at 0x7f70b0a4ad58>
+>>> list([(yield x) for x in some_iterable])
+['a', 'b']
+>>> list((yield x) for x in some_iterable)
+['a', None, 'b', None]
+>>> list(some_func((yield x)) for x in some_iterable)
+['a', 'something', 'b', 'something']
+```
+
+#### 💡 Объяснение:
+- Это баг в обработке yield в генераторах и списочных выражениях CPython.
+- Исходный код и объяснение можно найти [здесь](https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions)
+- Связанный [отчет об ошибке](https://bugs.python.org/issue10544)
+- В Python 3.8+ yield внутри списочных выражений больше не допускается и выдает `SyntaxError`.
+
+---
+
+
+### ▶ Yield from возвращает... *
+
+1\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ yield from range(x)
+```
+
+**Результат (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Куда исчезло `"wtf"`? Это связано с каким-то особым эффектом `yield from`? Проверим это.
+
+2\.
+
+```py
+def some_func(x):
+ if x == 3:
+ return ["wtf"]
+ else:
+ for i in range(x):
+ yield i
+```
+
+**Результат:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Опять не сработало. Что происходит?
+
+#### 💡 Объяснение:
+
++ С Python 3.3 стало возможным использовать оператор `return` в генераторах с возвращением значения (см. [PEP380](https://www.python.org/dev/peps/pep-0380/)). В [официальной документации](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) говорится, что
+
+> "... `return expr` в генераторе вызывает исключение `StopIteration(expr)` при выходе из генератора."
+
++ В случае `some_func(3)` `StopIteration` возникает в начале из-за оператора `return`. Исключение `StopIteration` автоматически перехватывается внутри обертки `list(...)` и цикла `for`. Поэтому два вышеприведенных фрагмента возвращают пустой список.
+
++ Чтобы получить `["wtf"]` из генератора `some_func`, нужно перехватить исключение `StopIteration`.
+
+ ```py
+ try:
+ next(some_func(3))
+ except StopIteration as e:
+ some_string = e.value
+ ```
+
+ ```py
+ >>> some_string
+ ["wtf"]
+ ```
+
+---
+
+
+### ▶ Nan-рефлексивность *
+
+
+
+1\.
+
+```py
+a = float('inf')
+b = float('nan')
+c = float('-iNf') # Эти строки не чувствительны к регистру
+d = float('nan')
+```
+
+**Результат:**
+
+```py
+>>> a
+inf
+>>> b
+nan
+>>> c
+-inf
+>>> float('some_other_string')
+ValueError: could not convert string to float: some_other_string
+>>> a == -c # inf==inf
+True
+>>> None == None # None == None
+True
+>>> b == d # но nan!=nan
+False
+>>> 50 / a
+0.0
+>>> a / a
+nan
+>>> 23 + b
+nan
+```
+
+2\.
+
+```py
+>>> x = float('nan')
+>>> y = x / x
+>>> y is y # идентичность сохраняется
+True
+>>> y == y # сравнение ложно для y
+False
+>>> [y] == [y] # но сравнение истинно для списка, содержащего y
+True
+```
+
+#### 💡 Объяснение:
+
+- `'inf'` и `'nan'` - это специальные строки (без учета регистра), которые при явном приведении к типу `float` используются для представления математической "бесконечности" и "не число" соответственно.
+
+- Согласно стандартам IEEE, `NaN != NaN`, но соблюдение этого правила нарушает предположение о рефлексивности элемента коллекции в Python, то есть если `x` является частью коллекции, такой как `list`, реализации методов сравнения предполагают, что `x == x`. Поэтому при сравнении элементов сначала сравниваются их идентификаторы (так как это быстрее), а значения сравниваются только при несовпадении идентификаторов. Следующий фрагмент сделает вещи более ясными:
+
+ ```py
+ >>> x = float('nan')
+ >>> x == x, [x] == [x]
+ (False, True)
+ >>> y = float('nan')
+ >>> y == y, [y] == [y]
+ (False, True)
+ >>> x == y, [x] == [y]
+ (False, False)
+ ```
+
+ Поскольку идентификаторы `x` и `y` разные, рассматриваются значения, которые также различаются; следовательно, на этот раз сравнение возвращает `False`.
+
+- Интересное чтение: [Рефлексивность и другие основы цивилизации](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+
+---
+
+
+### ▶ Изменяем неизменяемое!
+
+
+
+Это может показаться тривиальным, если вы знаете, как работают ссылки в Python.
+
+```py
+some_tuple = ("A", "tuple", "with", "values")
+another_tuple = ([1, 2], [3, 4], [5, 6])
+```
+
+**Результат:**
+```py
+>>> some_tuple[2] = "change this"
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple[2].append(1000) # Не приводит к исключениям
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000])
+>>> another_tuple[2] += [99, 999]
+TypeError: 'tuple' object does not support item assignment
+>>> another_tuple
+([1, 2], [3, 4], [5, 6, 1000, 99, 999])
+```
+
+Но кортежи неизменяемы... Что происходит?
+
+#### 💡 Объяснение:
+
+* Перевод цитаты из [документации](https://docs.python.org/3/reference/datamodel.html)
+
+ > Объект неизменяемого типа последовательности не может измениться после создания. (Если объект содержит ссылки на другие объекты, эти объекты могут быть изменяемыми и могут быть изменены; однако набор объектов, на которые непосредственно ссылается неизменяемый объект, не может изменяться.)
+
+* Оператор `+=` изменяет список на месте. Присваивание элемента не работает, но когда возникает исключение, элемент уже был изменен на месте.
+* Также есть объяснение в официальном [Python FAQ](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works).
+
+---
+
+
+### ▶ Исчезающая переменная из внешней области видимости
+
+
+```py
+e = 7
+try:
+ raise Exception()
+except Exception as e:
+ pass
+```
+
+**Результат (Python 2.x):**
+```py
+>>> print(e)
+# Ничего не выводит
+```
+
+**Результат (Python 3.x):**
+```py
+>>> print(e)
+NameError: name 'e' is not defined
+```
+
+#### 💡 Объяснение:
+
+* [Источник](https://docs.python.org/3/reference/compound_stmts.html#except)
+
+Когда исключение было назначено с помощью ключевого слова `as`, оно очищается в конце блока `except`. Это происходит так, как если бы
+
+ ```py
+ except E as N:
+ foo
+ ```
+
+разворачивалось до
+
+ ```py
+ except E as N:
+ try:
+ foo
+ finally:
+ del N
+ ```
+
+Это означает, что исключению должно быть присвоено другое имя, чтобы на него можно было ссылаться после завершения блока `except`. Исключения очищаются, потому что с прикрепленным к ним трейсбэком они образуют цикл ссылок со стэком вызовов, сохраняя все локальные объекты в этой стэке до следующей сборки мусора.
+
+* В Python clauses не имеют области видимости. В примере все объекты в одной области видимости, а переменная `e` была удалена из-за выполнения блока `except`. Этого нельзя сказать о функциях, которые имеют отдельные внутренние области видимости. Пример ниже иллюстрирует это:
+
+ ```py
+ def f(x):
+ del(x)
+ print(x)
+
+ x = 5
+ y = [5, 4, 3]
+ ```
+
+ **Результат:**
+ ```py
+ >>> f(x)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> f(y)
+ UnboundLocalError: local variable 'x' referenced before assignment
+ >>> x
+ 5
+ >>> y
+ [5, 4, 3]
+ ```
+
+* В Python 2.x, имя переменной `e` назначается на экземпляр `Exception()`, и при попытки вывести значение `e` ничего не выводится.
+
+ **Результат (Python 2.x):**
+ ```py
+ >>> e
+ Exception()
+ >>> print e
+ # Ничего не выводится!
+ ```
+
+---
+
+
+### ▶ Загадочное преобразование типов ключей
+
+```py
+class SomeClass(str):
+ pass
+
+some_dict = {'s': 42}
+```
+
+**Результат:**
+```py
+>>> type(list(some_dict.keys())[0])
+str
+>>> s = SomeClass('s')
+>>> some_dict[s] = 40
+>>> some_dict # Ожидается 2 разные пары ключ-значение
+{'s': 40}
+>>> type(list(some_dict.keys())[0])
+str
+```
+
+#### 💡 Объяснение:
+
+* И объект `s`, и строка `"s"` хэшируются до одного и того же значения, потому что `SomeClass` наследует метод `__hash__` класса `str`.
+* Выражение `SomeClass("s") == "s"` эквивалентно `True`, потому что `SomeClass` также наследует метод `__eq__` класса `str`.
+* Поскольку оба объекта хэшируются на одно и то же значение и равны, они представлены одним и тем же ключом в словаре.
+* Чтобы добиться желаемого поведения, мы можем переопределить метод `__eq__` в `SomeClass`.
+ ```py
+ class SomeClass(str):
+ def __eq__(self, other):
+ return (
+ type(self) is SomeClass
+ and type(other) is SomeClass
+ and super().__eq__(other)
+ )
+
+ # При переопределении метода __eq__, Python прекращает автоматическое наследование метода
+ # __hash__, поэтому его нужно вручную определить
+ __hash__ = str.__hash__
+
+ some_dict = {'s':42}
+ ```
+
+ **Результат:**
+ ```py
+ >>> s = SomeClass('s')
+ >>> some_dict[s] = 40
+ >>> some_dict
+ {'s': 40, 's': 42}
+ >>> keys = list(some_dict.keys())
+ >>> type(keys[0]), type(keys[1])
+ (__main__.SomeClass, str)
+ ```
+
+---
+
+
+### ▶ Посмотрим, сможете ли вы угадать что здесь?
+
+```py
+a, b = a[b] = {}, 5
+```
+
+**Результат:**
+```py
+>>> a
+{5: ({...}, 5)}
+```
+
+#### 💡 Объяснение:
+
+* Согласно [документации](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), выражения присваивания имеют вид
+ ```
+ (target_list "=")+ (expression_list | yield_expression)
+ ```
+ и
+
+> Оператор присваивания исполняет список выражений (помните, что это может быть одно выражение или список, разделенный запятыми, в последнем случае получается кортеж) и присваивает единственный результирующий объект каждому из целевых списков, слева направо.
+
+* `+` в `(target_list "=")+` означает, что может быть **один или более** целевых списков. В данном случае целевыми списками являются `a, b` и `a[b]` (обратите внимание, что список выражений ровно один, в нашем случае это `{}, 5`).
+* После исполнения списка выражений его значение распаковывается в целевые списки **слева направо**. Так, в нашем случае сначала кортеж `{}, 5` распаковывается в `a, b`, и теперь у нас есть `a = {}` и `b = 5`.
+* Теперь `a` имеет значение `{}`, которое является изменяемым объектом.
+* Вторым целевым списком является `a[b]` (вы можете ожидать, что это вызовет ошибку, поскольку `a` и `b` не были определены в предыдущих утверждениях. Но помните, мы только что присвоили `a` значение `{}` и `b` - `5`).
+* Теперь мы устанавливаем ключ `5` в словаре в кортеж `({}, 5)`, создавая круговую ссылку (`{...}` в выводе ссылается на тот же объект, на который уже ссылается `a`). Другим более простым примером круговой ссылки может быть
+
+```py
+ >>> some_list
+ [[...]]
+ >>> some_list[0]
+ [[...]]
+ >>> some_list is some_list[0]
+ True
+ >>> some_list[0][0][0][0][0][0] == some_list
+ True
+ ```
+ Аналогичный случай в примере выше (`a[b][0]` - это тот же объект, что и `a`)
+
+* Подводя итог, можно разбить пример на следующие пункты
+ ```py
+ a, b = {}, 5
+ a[b] = a, b
+ ```
+ А циклическая ссылка может быть оправдана тем, что `a[b][0]` - тот же объект, что и `a`
+ ```py
+ >>> a[b][0] is a
+ True
+ ```
+
+ ---
+
+
+### ▶ Превышение предела целочисленного преобразования строк
+```py
+>>> # Python 3.10.6
+>>> int("2" * 5432)
+>>> # Python 3.10.8
+>>> int("2" * 5432)
+```
+**Вывод:**
+```py
+>>> # Python 3.10.6
+222222222222222222222222222222222222222222222222222222222222222...
+>>> # Python 3.10.8
+Traceback (most recent call last):
+ ...
+ValueError: Exceeds the limit (4300) for integer string conversion:
+ value has 5432 digits; use sys.set_int_max_str_digits()
+ to increase the limit.
+```
+#### 💡 Объяснение:
+Этот вызов `int()` прекрасно работает в Python 3.10.6 и вызывает ошибку `ValueError` в Python 3.10.8, 3.11. Обратите внимание, что Python все еще может работать с большими целыми числами. Ошибка возникает только при преобразовании между целыми числами и строками.
+К счастью, вы можете увеличить предел допустимого количества цифр. Для этого можно воспользоваться одним из следующих способов:
+- `-X int_max_str_digits` - флаг командной строки
+- `set_int_max_str_digits()` - функция из модуля `sys`
+- `PYTHONINTMAXSTRDIGITS` - переменная окружения
+
+[Смотри документацию](https://docs.python.org/3/library/stdtypes.html#int-max-str-digits) для получения более подробной информации об изменении лимита по умолчанию, если вы ожидаете, что ваш код превысит это значение.
+
+---
+
+
+## Раздел: Скользкие склоны
+
+### ▶ Изменение словаря во время прохода по нему
+
+```py
+x = {0: None}
+
+for i in x:
+ del x[i]
+ x[i+1] = None
+ print(i)
+```
+
+**Результат (Python 2.7- Python 3.5):**
+
+```
+0
+1
+2
+3
+4
+5
+6
+7
+```
+
+Да, цикл выполняет ровно **восемь** итераций и завершается.
+
+#### 💡 Объяснение:
+
+* Проход по словарю и его одновременное редактирование не поддерживается.
+* Выполняется восемь проходов, потому что именно в этот момент словарь изменяет размер, чтобы вместить больше ключей (у нас есть восемь записей об удалении, поэтому необходимо изменить размер). На самом деле это деталь реализации.
+* То, как обрабатываются удаленные ключи и когда происходит изменение размера, может отличаться в разных реализациях Python.
+* Так что для версий Python, отличных от Python 2.7 - Python 3.5, количество записей может отличаться от 8 (но каким бы ни было количество записей, оно будет одинаковым при каждом запуске). Обсуждения по этому поводу имеются в [issue](https://github.com/satwikkansal/wtfpython/issues/53) и на [StackOverflow](https://stackoverflow.com/questions/44763802/bug-in-python-dict).
+* В Python 3.7.6 и выше при попытке запустить пример вызывается исключение `RuntimeError: dictionary keys changed during iteration`.
+
+---
+
+
+### ▶ Упрямая операция `del`
+
+
+
+```py
+class SomeClass:
+ def __del__(self):
+ print("Deleted!")
+```
+
+**Результат:**
+1\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x # должно быть выведено "Deleted!"
+>>> del y
+Deleted!
+```
+
+Фух, наконец-то удалили. Вы, наверное, догадались, что спасло `__del__` от вызова в нашей первой попытке удалить `x`. Давайте добавим в пример еще больше изюминок.
+
+2\.
+```py
+>>> x = SomeClass()
+>>> y = x
+>>> del x
+>>> y # проверяем, существует ли y
+<__main__.SomeClass instance at 0x7f98a1a67fc8>
+>>> del y # Как и в прошлом примере, вывод должен содержать "Deleted!"
+>>> globals() # но вывод пуст. Проверим все глобальные переменные
+Deleted!
+{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}
+```
+
+Вот сейчас переменная `y` удалена :confused:
+
+#### 💡 Объяснение:
+
++ `del x` не вызывает напрямую `x.__del__()`.
++ Когда встречается `del x`, Python удаляет имя `x` из текущей области видимости и уменьшает на 1 количество ссылок на объект, на который ссылается `x`. `__del__()` вызывается только тогда, когда счетчик ссылок объекта достигает нуля.
++ Во втором фрагменте вывода `__del__()` не была вызвана, потому что предыдущий оператор (`>>> y`) в интерактивном интерпретаторе создал еще одну ссылку на тот же объект (в частности, магическую переменную `_`, которая ссылается на значение результата последнего не `None` выражения в REPL), тем самым не позволив счетчику ссылок достичь нуля, когда было встречено `del y`.
++ Вызов `globals` (или вообще выполнение чего-либо, что будет иметь результат, отличный от `None`) заставил `_` сослаться на новый результат, отбросив существующую ссылку. Теперь количество ссылок достигло 0, и мы можем видеть, как выводится "Deleted!" (наконец-то!).
+
+---
+
+
+### ▶ Переменная за пределами видимости
+
+
+1\.
+```py
+a = 1
+def some_func():
+ return a
+
+def another_func():
+ a += 1
+ return a
+```
+
+2\.
+```py
+def some_closure_func():
+ a = 1
+ def some_inner_func():
+ return a
+ return some_inner_func()
+
+def another_closure_func():
+ a = 1
+ def another_inner_func():
+ a += 1
+ return a
+ return another_inner_func()
+```
+
+**Результат:**
+```py
+>>> some_func()
+1
+>>> another_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+
+>>> some_closure_func()
+1
+>>> another_closure_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+```
+
+#### 💡 Объяснение:
+* Когда вы делаете присваивание переменной в области видимости, она становится локальной для этой области. Так `a` становится локальной для области видимости `another_func`, но она не была инициализирована ранее в той же области видимости, что приводит к ошибке.
+* Для изменения переменной `a` из внешней области видимости внутри функции `another_func`, необходимо использовать ключевое слово `global`.
+ ```py
+ def another_func()
+ global a
+ a += 1
+ return a
+ ```
+
+ **Результат:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+* В `another_closure_func` переменная `a` становится локальной для области видимости `another_inner_func`, но она не была инициализирована ранее в той же области видимости, поэтому выдает ошибку.
+* Чтобы изменить переменную внешней области видимости `a` в `another_inner_func`, используйте ключевое слово `nonlocal`. Утверждение nonlocal используется для обращения к переменным, определенным в ближайшей внешней (за исключением глобальной) области видимости.
+
+ ```py
+ def another_func():
+ a = 1
+ def another_inner_func():
+ nonlocal a
+ a += 1
+ return a
+ return another_inner_func()
+ ```
+
+ **Результат:**
+ ```py
+ >>> another_func()
+ 2
+ ```
+
+* Ключевые слова `global` и `nonlocal` указывают интерпретатору python не объявлять новые переменные и искать их в соответствующих внешних областях видимости.
+* Прочитайте [это](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) короткое, но потрясающее руководство, чтобы узнать больше о том, как работают пространства имен и разрешение областей видимости в Python.
+
+---
+
+
+### ▶ Удаление элемента списка во время прохода по списку
+
+```py
+list_1 = [1, 2, 3, 4]
+list_2 = [1, 2, 3, 4]
+list_3 = [1, 2, 3, 4]
+list_4 = [1, 2, 3, 4]
+
+for idx, item in enumerate(list_1):
+ del item
+
+for idx, item in enumerate(list_2):
+ list_2.remove(item)
+
+for idx, item in enumerate(list_3[:]):
+ list_3.remove(item)
+
+for idx, item in enumerate(list_4):
+ list_4.pop(idx)
+```
+
+**Результат:**
+```py
+>>> list_1
+[1, 2, 3, 4]
+>>> list_2
+[2, 4]
+>>> list_3
+[]
+>>> list_4
+[2, 4]
+```
+
+Есть предположения, почему вывод `[2, 4]`?
+
+#### 💡 Объяснение:
+
+* Никогда не стоит изменять объект, над которым выполняется итерация. Правильным способом будет итерация по копии объекта, и `list_3[:]` делает именно это.
+ ```py
+ >>> some_list = [1, 2, 3, 4]
+ >>> id(some_list)
+ 139798789457608
+ >>> id(some_list[:]) # Обратите внимание, создается новый объект из среза списка
+ 139798779601192
+ ```
+
+**Разница между `del`, `remove` и `pop`:**
+* `del var_name` просто удаляет привязку `var_name` из локального или глобального пространства имен (поэтому `list_1` не затрагивается).
+* `remove` удаляет первое подходящее значение, а не конкретный индекс, вызывает `ValueError`, если значение не найдено.
+* `pop` удаляет элемент по определенному индексу и возвращает его, вызывает `IndexError`, если указан неверный индекс.
+
+**Почему на выходе получается `[2, 4]`?**
+- Проход по списку выполняется индекс за индексом, и когда мы удаляем `1` из `list_2` или `list_4`, содержимое списков становится `[2, 3, 4]`. Оставшиеся элементы сдвинуты вниз, то есть `2` находится на индексе 0, а `3` - на индексе 1. Поскольку на следующей итерации будет просматриваться индекс 1 (который и есть `3`), `2` будет пропущен полностью. Аналогичное произойдет с каждым альтернативным элементом в последовательности списка.
+
+* Объяснение примера можно найти на [StackOverflow](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it).
+* Также посмотрите на похожий пример на [StackOverflow](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items), связанный со словарями.
+
+---
+
+
+### ▶ Сжатие итераторов с потерями *
+
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three))
+[(0, 0), (1, 1), (2, 2)]
+# пока все хорошо, сожмем оставшуюся часть итератора
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Куда пропал элемент `3` из списка `numbers`?
+
+#### 💡 Объяснение:
+
+- Согласно [документации](https://docs.python.org/3.12/library/functions.html#zip), примерная реализация функции `zip` выглядит так,
+ ```py
+ def zip(*iterables):
+ sentinel = object()
+ iterators = [iter(it) for it in iterables]
+ while iterators:
+ result = []
+ for it in iterators:
+ elem = next(it, sentinel)
+ if elem is sentinel: return
+ result.append(elem)
+ yield tuple(result)
+ ```
+- Таким образом, функция принимает произвольное количество итерируемых объектов, добавляет каждый из их элементов в список `result`, вызывая для них функцию `next`, и останавливается всякий раз, когда любой из итерируемых объектов исчерпывается.
+- Нюанс заключается в том, что при исчерпании любого итерируемого объекта существующие элементы в списке `result` отбрасываются. Именно это произошло с `3` в `numbers_iter`.
+- Правильный способ выполнения вышеописанных действий с помощью `zip` будет следующим,
+ ```py
+ >>> numbers = list(range(7))
+ >>> numbers_iter = iter(numbers)
+ >>> list(zip(first_three, numbers_iter))
+ [(0, 0), (1, 1), (2, 2)]
+ >>> list(zip(remaining, numbers_iter))
+ [(3, 3), (4, 4), (5, 5), (6, 6)]
+ ```
+ Первый аргумент сжатия должен иметь наименьшее число элементов
+
+---
+
+
+### ▶ Утечка переменных внутри цикла
+
+1\.
+```py
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Вывод:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+Но `x` не была определена за пределами цикла `for`...
+
+2\.
+```py
+# В этот раз определим x до цикла
+x = -1
+for x in range(7):
+ if x == 6:
+ print(x, ': for x inside loop')
+print(x, ': x in global')
+```
+
+**Вывод:**
+```py
+6 : for x inside loop
+6 : x in global
+```
+
+3\.
+
+**Вывод (Python 2.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+4
+```
+
+**Вывод (Python 3.x):**
+```py
+>>> x = 1
+>>> print([x for x in range(5)])
+[0, 1, 2, 3, 4]
+>>> print(x)
+1
+```
+
+#### 💡 Объяснение:
+
+- В Python циклы for используют область видимости, в которой они существуют, и оставляют свою определенную переменную цикла после завершения. Это также относится к случаям, когда мы явно определили переменную цикла for в глобальном пространстве имен. В этом случае будет произведена повторная привязка существующей переменной.
+
+- Различия в выводе интерпретаторов Python 2.x и Python 3.x для примера с пониманием списков можно объяснить следующим изменением, задокументированным в журнале изменений [What's New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html):
+
+ > "Генераторы списков ("list comprehensions") больше не поддерживает синтаксическую форму `[... for var in item1, item2, ...]`. Вместо этого используйте `[... for var in (item1, item2, ...)]`. Кроме того, обратите внимание, что генераторы списков имеют другую семантику: они ближе к синтаксическому сахару для генераторного выражения внутри конструктора `list()`, и, в частности, управляющие переменные цикла больше не просачиваются в окружающую область видимости."
+
+---
+
+
+### ▶ Остерегайтесь изменяемых аргументов по умолчанию!
+
+
+```py
+def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+```
+
+**Результат:**
+```py
+>>> some_func()
+['some_string']
+>>> some_func()
+['some_string', 'some_string']
+>>> some_func([])
+['some_string']
+>>> some_func()
+['some_string', 'some_string', 'some_string']
+```
+
+#### 💡 Объяснение:
+
+- Изменяемые аргументы функций по умолчанию в Python на самом деле не инициализируются каждый раз, когда вы вызываете функцию. Вместо этого в качестве значения по умолчанию используется недавно присвоенное им значение. Когда мы явно передали `[]` в `some_func` в качестве аргумента, значение по умолчанию переменной `default_arg` не было использовано, поэтому функция вернулась, как и ожидалось.
+
+ ```py
+ def some_func(default_arg=[]):
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+ **Результат:**
+ ```py
+ >>> some_func.__defaults__ # Выражение выведет значения стандартных аргументов функции
+ ([],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string'],)
+ >>> some_func()
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ >>> some_func([])
+ >>> some_func.__defaults__
+ (['some_string', 'some_string'],)
+ ```
+
+- Чтобы избежать ошибок, связанных с изменяемыми аргументами, принято использовать `None` в качестве значения по умолчанию, а затем проверять, передано ли какое-либо значение в функцию, соответствующую этому аргументу. Пример:
+
+ ```py
+ def some_func(default_arg=None):
+ if default_arg is None:
+ default_arg = []
+ default_arg.append("some_string")
+ return default_arg
+ ```
+
+---
+
+
+### ▶ Ловля исключений
+
+```py
+some_list = [1, 2, 3]
+try:
+ # Должно вернуться ``IndexError``
+ print(some_list[4])
+except IndexError, ValueError:
+ print("Caught!")
+
+try:
+ # Должно вернуться ``ValueError``
+ some_list.remove(4)
+except IndexError, ValueError:
+ print("Caught again!")
+```
+
+**Результат (Python 2.x):**
+```py
+Caught!
+
+ValueError: list.remove(x): x not in list
+```
+
+**Результат (Python 3.x):**
+```py
+ File "", line 1, in
+ AssertionError
+
+ >>> assert (a == b, "Values are not equal")
+ :1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+ >>> assert a == b, "Values are not equal"
+ Traceback (most recent call last):
+ File "", line 1, in
+ AssertionError: Values are not equal
+ ```
+* Что касается пятого фрагмента, то большинство методов, изменяющих элементы последовательности/маппингов, такие как `list.append`, `dict.update`, `list.sort` и т. д., изменяют объекты на месте и возвращают `None`. Это делается для того, чтобы повысить производительность, избегая создания копии объекта, если операция может быть выполнена на месте (подробнее в [документации](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+
+* Последнее должно быть достаточно очевидным, изменяемый объект (например, `list`) может быть изменен в функции, а переназначение неизменяемого (`a -= 1`) не является изменением значения.
+
+* Знание этих тонкостей может сэкономить вам часы отладки в долгосрочной перспективе.
+
+---
+
+
+### ▶ Сплиты (splitsies) *
+
+```py
+>>> 'a'.split()
+['a']
+
+# эквивалентно
+>>> 'a'.split(' ')
+['a']
+
+# но
+>>> len(''.split())
+0
+
+# не эквивалентно
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Объяснение
+
+- Может показаться, что разделителем по умолчанию для split является одиночный пробел `' '`, но согласно [документации](https://docs.python.org/3/library/stdtypes.html#str.split)
+ > если sep не указан или равен `none`, применяется другой алгоритм разбиения: последовательные пробельные символы рассматриваются как один разделитель, и результат не будет содержать пустых строк в начале или конце, если в строке есть ведущие или завершающие пробелы. Следовательно, разбиение пустой строки или строки, состоящей только из пробельных символов, с разделителем none возвращает `[]`.
+ > если задан sep, то последовательные разделители не группируются вместе и считаются разделителями пустых строк (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Разделение пустой строки с указанным разделителем возвращает `['']`.
+- Обратите внимание, как обрабатываются ведущие и завершающие пробелы в следующем фрагменте,
+ ```py
+ >>> ' a '.split(' ')
+ ['', 'a', '']
+ >>> ' a '.split()
+ ['a']
+ >>> ''.split(' ')
+ ['']
+ ```
+
+---
+
+
+### ▶ Подстановочное импортирование (wild imports) *
+
+
+
+```py
+# File: module.py
+
+def some_weird_name_func_():
+ print("works!")
+
+def _another_weird_name_func():
+ print("works!")
+
+```
+
+**Результат**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Объяснение:
+
+- Часто рекомендуется не использовать импорт с подстановочными знаками (wildcard import). Первая очевидная причина заключается в том, что при импорте с подстановочным знаком имена с ведущим подчеркиванием не импортируются. Это может привести к ошибкам во время выполнения.
+
+- Если бы мы использовали синтаксис `from ... import a, b, c`, приведенная выше `NameError` не возникла бы.
+ ```py
+ >>> from module import some_weird_name_func_, _another_weird_name_func
+ >>> _another_weird_name_func()
+ works!
+ ```
+- Если вы действительно хотите использовать импорт с подстановочными знаками, то нужно определить список `__all__` в вашем модуле, который будет содержать публичные объекты, доступные при wildcard импортировании.
+ ```py
+ __all__ = ['_another_weird_name_func']
+
+ def some_weird_name_func_():
+ print("works!")
+
+ def _another_weird_name_func():
+ print("works!")
+ ```
+ **Результат**
+
+ ```py
+ >>> _another_weird_name_func()
+ "works!"
+ >>> some_weird_name_func_()
+ Traceback (most recent call last):
+ File "", line 1, in
+ NameError: name 'some_weird_name_func_' is not defined
+ ```
+
+---
+
+
+### ▶ Все ли отсортировано? *
+
+
+
+```py
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
+
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
+```
+
+#### 💡 Объяснение:
+
+- Метод `sorted` всегда возвращает список, а сравнение списка и кортежа всегда возвращает `False`.
+
+- ```py
+ >>> [] == tuple()
+ False
+ >>> x = 7, 8, 9
+ >>> type(x), type(sorted(x))
+ (tuple, list)
+ ```
+
+- В отличие от метода `sorted`, метод `reversed` возвращает итератор. Почему? Потому что сортировка требует, чтобы итератор либо изменялся на месте, либо использовал дополнительный контейнер (список), в то время как реверсирование может работать просто путем итерации от последнего индекса к первому.
+
+- Поэтому при сравнении `sorted(y) == sorted(y)` первый вызов `sorted()` будет потреблять итератор `y`, а следующий вызов просто вернет пустой список.
+
+ ```py
+ >>> x = 7, 8, 9
+ >>> y = reversed(x)
+ >>> sorted(y), sorted(y)
+ ([7, 8, 9], [])
+ ```
+
+---
+
+
+### ▶ Полночи не существует?
+
+```py
+from datetime import datetime
+
+midnight = datetime(2018, 1, 1, 0, 0)
+midnight_time = midnight.time()
+
+noon = datetime(2018, 1, 1, 12, 0)
+noon_time = noon.time()
+
+if midnight_time:
+ print("Time at midnight is", midnight_time)
+
+if noon_time:
+ print("Time at noon is", noon_time)
+```
+
+**Результат (< 3.5):**
+
+```py
+('Time at noon is', datetime.time(12, 0))
+```
+Полночное время не выведено.
+
+#### 💡 Объяснение:
+
+
+До Python 3.5 булево значение для объекта `datetime.time` считалось `False`, если оно представляло полночь по UTC. При использовании синтаксиса `if obj:` для проверки того, что `obj` является null или эквивалентом "пусто", возникает ошибка.
+
+---
+---
+
+## Раздел: Скрытые сокровища!
+
+Раздел содержит менее известные интересные нюансы работы Python, которые неизвестны большинству новичков.
+
+### ▶ Python, можешь ли ты помочь взлететь?
+
+Что ж, поехали
+
+```py
+import antigravity
+```
+
+**Результат:**
+Sshh... It's a super-secret.
+
+#### 💡 Объяснение:
+
++ Модуль `antigravity` - одно из немногих пасхальных яиц, выпущенных разработчиками Python.
++ `import antigravity` открывает веб-браузер, указывающий на [классический комикс XKCD](https://xkcd.com/353/) о Python.
++ Это еще не все. Внутри пасхального яйца находится **еще одно пасхальное яйцо**. Если вы посмотрите на [код](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), там определена функция, которая якобы реализует алгоритм [XKCD](https://xkcd.com/426/).
+
+---
+
+
+### ▶ `goto`, но почему?
+
+
+```py
+from goto import goto, label
+for i in range(9):
+ for j in range(9):
+ for k in range(9):
+ print("I am trapped, please rescue!")
+ if k == 2:
+ goto .breakout # выход из глубоко вложенного цикла
+label .breakout
+print("Freedom!")
+```
+
+**Результат (Python 2.3):**
+```py
+I am trapped, please rescue!
+I am trapped, please rescue!
+Freedom!
+```
+
+#### 💡 Объяснение:
+- Рабочая версия `goto` в Python была [анонсирована](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) в качестве первоапрельской шутки 1 апреля 2004 года.
+- В текущих версиях Python этот модуль отсутствует.
+- Хотя он работает, но, пожалуйста, не используйте его. Вот [причина](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) того, почему `goto` отсутствует в Python.
+
+---
+
+
+### ▶ Держитесь!
+
+Если вы относитесь к тем людям, которым не нравится использование пробелов в Python для обозначения диапазонов, вы можете использовать C-стиль {} импортировав это,
+
+```py
+from __future__ import braces
+```
+
+**Результат:**
+```py
+ File "some_file.py", line 1
+ from __future__ import braces
+SyntaxError: not a chance
+```
+
+Скобочки? Ни за что! Если это разочаровывало вас, используйте Java. Хорошо, еще одна удивительная вещь, можете ли вы найти ошибку
+`SyntaxError` которая вызвана в модуле `__future__` [код](https://github.com/python/cpython/blob/master/Lib/__future__.py)?
+
+#### 💡 Объяснение:
+
++ Модуль `__future__` обычно используется для предоставления возможностей из будущих версий Python. Однако "будущее" в данном конкретном контексте - это ирония.
++ Это пасхальное яйцо, связанное с мнением сообщества по этому вопросу.
++ Код на самом деле присутствует [здесь](https://github.com/python/cpython/blob/025eb98dc0c1dc27404df6c544fc2944e0fa9f3a/Python/future.c#L49) в файле `future.c`.
++ Когда компилятор CPython встречает оператор [future](https://docs.python.org/3.3/reference/simple_stmts.html#future-statements), он сначала запускает соответствующий код в `future.c`, а затем рассматривает его как обычный оператор импорта.
+
+---
+
+
+### ▶ Давайте познакомимся с дружелюбным Дядей Барри
+
+Непереводимая игра слов: Friendly Language Uncle For Life (FLUFL)
+
+**Результат (Python 3.x)**
+```py
+>>> from __future__ import barry_as_FLUFL
+>>> "Ruby" != "Python" # в этом нет сомнений
+ File "some_file.py", line 1
+ "Ruby" != "Python"
+ ^
+SyntaxError: invalid syntax
+
+>>> "Ruby" <> "Python"
+True
+```
+
+Вот так просто.
+
+#### 💡 Объяснение:
+- Это относится к [PEP-401](https://www.python.org/dev/peps/pep-0401/), выпущенному 1 Апреля 2009 (вы знаете, о чем это говорит).
+- Цитата из PEP-401
+
+ > Признав, что оператор неравенства `!=` в Python 3.0 был ужасной, вызывающей боль ошибкой, FLUFL восстанавливает оператор `<>` (ромб) в качестве единственного написания.
+- У Дяди Барри было еще много чего рассказать в PEP; вы можете прочитать их [здесь](https://www.python.org/dev/peps/pep-0401/).
+- Это работает хорошо в интерактивной среде, но при запуске через файл python вызывает `SyntaxError` (смотри этот [issue](https://github.com/satwikkansal/wtfpython/issues/94)). Однако вы можете обернуть оператор внутри `eval` или `compile`, чтобы заставить его работать (но зачем?)
+ ```py
+ from __future__ import barry_as_FLUFL
+ print(eval('"Ruby" <> "Python"'))
+ ```
+
+---
+
+
+### ▶ Даже Python понимает, что любовь - это сложно.
+
+```py
+import this
+```
+
+Подождите, что **это** (this) такое? Это любовь! :heart:
+
+**Результат:**
+```
+Дзен Python, от Тима Петерса
+
+Красивое лучше, чем уродливое.
+Явное лучше, чем неявное.
+Простое лучше, чем сложное.
+Сложное лучше, чем запутанное.
+Плоское лучше, чем вложенное.
+Разреженное лучше, чем плотное.
+Читаемость имеет значение.
+Особые случаи не настолько особые, чтобы нарушать правила.
+При этом практичность важнее безупречности.
+Ошибки никогда не должны замалчиваться.
+Если они не замалчиваются явно.
+Встретив двусмысленность, отбрось искушение угадать.
+Должен существовать один и, желательно, только один очевидный способ сделать это.
+Хотя он поначалу может быть и не очевиден, если вы не голландец [^1].
+Сейчас лучше, чем никогда.
+Хотя никогда зачастую лучше, чем прямо сейчас.
+Если реализацию сложно объяснить — идея плоха.
+Если реализацию легко объяснить — идея, возможно, хороша.
+Пространства имён — отличная штука! Будем делать их больше!
+```
+
+Это Дзен Python!
+
+```py
+>>> love = this
+>>> this is love
+True
+>>> love is True
+False
+>>> love is False
+False
+>>> love is not True or False
+True
+>>> love is not True or False; love is love # Love is complicated
+True
+```
+
+#### 💡 Объяснение:
+
+* Модуль `this` в Python - это пасхальное яйцо для The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
+* И если вы думаете, что это уже достаточно интересно, посмотрите реализацию [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Забавный факт - **код для дзена нарушает сам себя** (и это, вероятно, единственное место, где это происходит, но это не точно).
+* Что касается утверждения `любовь не является истиной или ложью; любовь - это любовь`, иронично, но описательно (если нет, пожалуйста, посмотрите примеры, связанные с операторами `is` и `is not`).
+
+---
+
+
+### ▶ Да, оно существует!
+
+**Ключевое слово `else` в связке с циклом `for`.** Один из стандартных примеров:
+
+```py
+ def does_exists_num(l, to_find):
+ for num in l:
+ if num == to_find:
+ print("Exists!")
+ break
+ else:
+ print("Does not exist")
+```
+
+**Результат:**
+```py
+>>> some_list = [1, 2, 3, 4, 5]
+>>> does_exists_num(some_list, 4)
+Exists!
+>>> does_exists_num(some_list, -1)
+Does not exist
+```
+
+**Использование `else` блока во время обработки исключения.** Пример,
+
+```py
+try:
+ pass
+except:
+ print("Exception occurred!!!")
+else:
+ print("Try block executed successfully...")
+```
+
+**Результат:**
+```py
+Try block executed successfully...
+```
+
+#### 💡 Объяснение:
+
+- Блок `else` после цикла выполняется только тогда, когда нет явного `break` после всех итераций. Вы можете думать об этом как о блоке "nobreak".
+- Блок `else` после блока `try` также называется "блоком завершения", поскольку достижение `else` в операторе `try` означает, что блок попыток действительно успешно завершен.
+
+---
+
+
+### ▶ Многоточие *
+
+```py
+def some_func():
+ Ellipsis
+```
+
+**Результат**
+```py
+>>> some_func()
+# Ни вывода, ни ошибки
+
+>>> SomeRandomString
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Объяснение
+- В Python, `Ellipsis` - глобальный встроенный объект, эквивалентный `...`.
+ ```py
+ >>> ...
+ Ellipsis
+ ```
+- Многоточие может использоваться в нескольких случаях,
+ + В качестве заполнителя для кода, который еще не написан (аналогично оператору `pass`)
+ + В синтаксисе срезов (slices) для представления полных срезов в оставшемся направлении
+ ```py
+ >>> import numpy as np
+ >>> three_dimensional_array = np.arange(8).reshape(2, 2, 2)
+ array([
+ [
+ [0, 1],
+ [2, 3]
+ ],
+
+ [
+ [4, 5],
+ [6, 7]
+ ]
+ ])
+ ```
+ Таким образом, наш `трехмерный_массив` представляет собой массив массивов массивов. Допустим, мы хотим вывести второй элемент (индекс `1`) всех внутренних массивов, мы можем использовать `Ellipsis`, чтобы обойти все предыдущие измерения
+ ```py
+ >>> three_dimensional_array[:,::,1]
+ array([[1, 3],
+ [5, 7]])
+ >>> three_dimensional_array[..., 1] # использование Ellipsis.
+ array([[1, 3],
+ [5, 7]])
+ ```
+ Примечание: это будет работать для любого количества измерений. Можно даже выбрать срез в первом и последнем измерении и игнорировать средние (`n_dimensional_array[firs_dim_slice, ..., last_dim_slice]`)
+ + В [подсказках типов](https://docs.python.org/3/library/typing.html) для указания только части типа (например, `Callable[..., int]` или `Tuple[str, ...]`)
+ + Вы также можете использовать `Ellipsis` в качестве аргумента функции по умолчанию (в случаях, когда вы хотите провести различие между сценариями "аргумент не передан" и "значение не передано").
+
+---
+
+
+### ▶ Писконечность (Inpinity)
+
+В заголовке нет ошибки, так и задумано, пожалуйста, не создавайте issue или pull request с изменением.
+
+**Результат (Python 3.x):**
+```py
+>>> infinity = float('infinity')
+>>> hash(infinity)
+314159
+>>> hash(float('-inf'))
+-314159
+```
+
+#### 💡 Объяснение:
+- Хэш бесконечности - 10⁵ x π.
+- Интересно, что хэш `float('-inf')` - "-10⁵ x π" в Python 3, тогда как в Python 2 - "-10⁵ x e".
+
+---
+
+
+### ▶ Давайте искажать
+
+1\.
+```py
+class Yo(object):
+ def __init__(self):
+ self.__honey = True
+ self.bro = True
+```
+
+**Результат:**
+```py
+>>> Yo().bro
+True
+>>> Yo().__honey
+AttributeError: 'Yo' object has no attribute '__honey'
+>>> Yo()._Yo__honey
+True
+```
+
+2\.
+```py
+class Yo(object):
+ def __init__(self):
+ # Попробуем симметричные двойные подчеркивания в названии атрибута
+ self.__honey__ = True
+ self.bro = True
+```
+
+**Результат:**
+```py
+>>> Yo().bro
+True
+
+>>> Yo()._Yo__honey__
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
+Почему обращение к `Yo()._Yo__honey` сработало?
+
+3\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+ def some_func(self):
+ return __variable # переменная еще не инициализирована
+```
+
+**Результат:**
+```py
+>>> A().__variable
+Traceback (most recent call last):
+ File "", line 1, in
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> A().some_func()
+'Some value'
+```
+
+
+#### 💡 Объяснение:
+
+* [Искажение имени](https://en.wikipedia.org/wiki/Name_mangling) используется для предотвращения коллизий имен между различными пространствами имен.
+* В Python интерпретатор изменяет (mangles) имена членов класса, начинающиеся с `__` (двойное подчеркивание, оно же "дундер") и не заканчивающиеся более чем одним подчеркиванием в конце, добавляя перед ними `_NameOfTheClass`.
+* Таким образом, чтобы получить доступ к атрибуту `__honey` в первом фрагменте, мы должны были добавить `_Yo` спереди, что предотвратило бы конфликты с тем же атрибутом `name`, определенным в любом другом классе.
+* Но почему тогда это не сработало во втором фрагменте? Потому что при манипулировании именами исключаются имена, заканчивающиеся двойным подчеркиванием.
+* Третий фрагмент также является следствием манипулирования именами. Имя `__variable` в операторе `return __variable` было искажено до `_A__variable`, что также является именем переменной, которую мы объявили во внешней области видимости.
+* Кроме того, если длина искаженного имени превышает 255 символов, произойдет усечение (truncation).
+
+---
+---
+
+## Раздел: Внешность обманчива!
+
+### ▶ Пропускаем строки?
+
+**Результат:**
+```py
+>>> value = 11
+>>> valuе = 32
+>>> value
+11
+```
+
+Что за дела?
+
+**Заметка:** самый простой способ воспроизвести это - просто скопировать утверждения из приведенного выше фрагмента и вставить их в свой файл/оболочку.
+
+#### 💡 Объяснение
+
+Некоторые незападные символы выглядят идентично буквам английского алфавита, но интерпретатор считает их разными.
+
+```py
+>>> ord('е') # кириллическое 'е' (ye)
+1077
+>>> ord('e') # латинское 'e', используемое в английском языке и набираемое с помощью стандартной клавиатуры
+101
+>>> 'е' == 'е'
+false
+
+>>> value = 42 # латинское "е
+>>> valuе = 23 # кириллическое "е", интерпретатор python 2.x вызовет здесь `syntaxerror`
+>>> value
+42
+```
+
+Встроенная функция `ord()` возвращает юникод [кодовую точку символа](https://en.wikipedia.org/wiki/code_point), и разные кодовые позиции кириллического 'e' и латинского 'e' оправдывают поведение приведенного выше примера.
+
+---
+
+
+### ▶ Телепортация
+
+
+
+```py
+# Прежде всего выполним `pip install numpy`.
+import numpy as np
+
+def energy_send(x):
+ # Инициализация numpy массива
+ np.array([float(x)])
+
+def energy_receive():
+ # Возвращаем пустой numpy массив
+ return np.empty((), dtype=np.float).tolist()
+```
+
+**Результат:**
+```py
+>>> energy_send(123.456)
+>>> energy_receive()
+123.456
+```
+
+Где моя Нобелевская премия?
+
+#### 💡 Объяснение:
+
+* Обратите внимание, что массив `numpy`, созданный в функции `energy_send`, не возвращается, так что место в памяти свободно для перераспределения.
+* `numpy.empty()` возвращает следующий свободный участок памяти без его повторной инициализации. Этот участок памяти просто оказывается тем же самым, который был только что освобожден (обычно, но не всегда).
+
+---
+
+
+### ▶ Что-то не так...
+
+```py
+def square(x):
+ """
+ Простая функция по вычислению квадрата числа путем суммирования.
+ """
+ sum_so_far = 0
+ for counter in range(x):
+ sum_so_far = sum_so_far + x
+ return sum_so_far
+```
+
+**Результат (Python 2.x):**
+
+```py
+>>> square(10)
+10
+```
+
+Разве не должно быть 100?
+
+**Заметка:** Если у вас не получается воспроизвести это, попробуйте запустить файл [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) через оболочку.
+
+#### 💡 Объяснение
+
+* **Не смешивайте табы и пробелы!** Символ, непосредственно предшествующий return, является "табом", а код в других местах примера имеет отступ в 4 пробела.
+* Вот как Python обрабатывает табы:
+
+ > Сначала табы заменяются (слева направо) на пробелы от одного до восьми так, чтобы общее количество символов до замены включительно было кратно восьми <...>.
+* Таким образом, "табы" в последней строке функции `square` заменяется восемью пробелами, и она попадает в цикл.
+* Python 3 достаточно любезен, чтобы автоматически выдавать ошибку для таких случаев.
+
+ **Результат (Python 3.x):**
+ ```py
+ TabError: inconsistent use of tabs and spaces in indentation
+ ```
+
+---
+---
+
+## Раздел: Разное
+
+
+### ▶ `+=` быстрее `+`
+
+
+```py
+# Использование "+", 3 строки:
+>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.25748300552368164
+# Использование "+=", 3 строки:
+>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
+0.012188911437988281
+```
+
+#### 💡 Объяснение:
++ Операнд `+=` быстрее `+` для "сложения" 2 и более строк, так как первая строка (например, `s1` for `s1 += s2 + s3`) не уничтожается во время формирования финальной строки.
+
+---
+
+
+### ▶ Сделаем гигантскую строку!
+
+```py
+def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s += "xyz"
+ assert len(s) == 3*iters
+
+def add_bytes_with_plus(iters):
+ s = b""
+ for i in range(iters):
+ s += b"xyz"
+ assert len(s) == 3*iters
+
+def add_string_with_format(iters):
+ fs = "{}"*iters
+ s = fs.format(*(["xyz"]*iters))
+ assert len(s) == 3*iters
+
+def add_string_with_join(iters):
+ l = []
+ for i in range(iters):
+ l.append("xyz")
+ s = "".join(l)
+ assert len(s) == 3*iters
+
+def convert_list_to_string(l, iters):
+ s = "".join(l)
+ assert len(s) == 3*iters
+```
+
+**Результат:**
+
+```py
+# Фрагменты выполняются в оболочке `ipython` с использованием `%timeit` для лучшей читаемости результатов.
+# Вы также можете использовать модуль timeit в обычной оболочке python shell/scriptm=, пример использования ниже
+# timeit.timeit('add_string_with_plus(10000)', number=1000, globals=globals())
+
+>>> NUM_ITERS = 1000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS)
+124 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS)
+211 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS)
+61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS)
+117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS)
+10.1 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+Увеличим число итераций в 10 раз.
+
+```py
+>>> NUM_ITERS = 10000
+>>> %timeit -n1000 add_string_with_plus(NUM_ITERS) # Линейное увеличение времени выполнения
+1.26 ms ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_bytes_with_plus(NUM_ITERS) # Квадратичное увеличение
+6.82 ms ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_format(NUM_ITERS) # Линейное увеличение
+645 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> %timeit -n1000 add_string_with_join(NUM_ITERS) # Линейное увеличение
+1.17 ms ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+>>> l = ["xyz"]*NUM_ITERS
+>>> %timeit -n1000 convert_list_to_string(l, NUM_ITERS) # Линейное увеличение
+86.3 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+```
+
+#### 💡 Объяснение
+
+- Подробнее о [timeit](https://docs.python.org/3/library/timeit.html) или [%timeit](https://ipython.org/ipython-doc/dev/interactive/magics.html#magic-timeit) вы можете прочитать по этим ссылкам. Они используются для измерения времени выполнения фрагментов кода.
+- Не используйте `+` для генерации длинных строк - В Python `str` неизменяема, поэтому левая и правая строки должны быть скопированы в новую строку для каждой пары конкатенаций. Если вы конкатенируете четыре строки длины 10, то вместо 40 символов вы скопируете (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 символов. С увеличением количества и размера строки ситуация ухудшается в квадратичной прогрессии (что подтверждается временем выполнения функции `add_bytes_with_plus`).
+- Поэтому рекомендуется использовать синтаксис `.format.` или `%` (правда, для очень коротких строк они немного медленнее, чем `+`).
+- Или лучше, если у вас уже есть содержимое в виде итерируемого объекта, тогда используйте `''.join(iterable_object)`, что гораздо быстрее.
+- В отличие от `add_bytes_with_plus` из-за оптимизаций `+=`, рассмотренных в предыдущем примере, `add_string_with_plus` не показало квадратичного увеличения времени выполнения. Если бы оператор был `s = s + "x" + "y" + "z"` вместо `s += "xyz"`, увеличение было бы квадратичным.
+ ```py
+ def add_string_with_plus(iters):
+ s = ""
+ for i in range(iters):
+ s = s + "x" + "y" + "z"
+ assert len(s) == 3*iters
+
+ >>> %timeit -n100 add_string_with_plus(1000)
+ 388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+ >>> %timeit -n100 add_string_with_plus(10000) # Квадратичное увеличение времени выполнения
+ 9 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+ ```
+
+- Такое число способов форматирования и создания гигантской строки несколько противоречит [Zen of Python](https://www.python.org/dev/peps/pep-0020/), согласно которому,
+
+ > должен быть один - и желательно только один - очевидный способ сделать это.
+
+---
+
+
+### ▶ Замедляем поиск по `dict` *
+
+```py
+some_dict = {str(i): 1 for i in range(1_000_000)}
+another_dict = {str(i): 1 for i in range(1_000_000)}
+```
+
+**Результат:**
+```py
+>>> %timeit some_dict['5']
+28.6 ns ± 0.115 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> some_dict[1] = 1
+>>> %timeit some_dict['5']
+37.2 ns ± 0.265 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+>>> %timeit another_dict['5']
+28.5 ns ± 0.142 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+>>> another_dict[1] # Пытаемся получить значение по несуществующему ключу
+Traceback (most recent call last):
+ File "", line 1, in
+KeyError: 1
+>>> %timeit another_dict['5']
+38.5 ns ± 0.0913 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+```
+Почему одни и те же выражения становятся медленнее?
+
+#### 💡 Объяснение:
+
++ В CPython есть общая функция поиска по словарю, которая работает со всеми типами ключей (`str`, `int`, любой объект ...), и специализированная для распространенного случая словарей, состоящих только из `str`-ключей.
++ Специализированная функция (названная `lookdict_unicode` в [CPython](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) знает, что все существующие ключи (включая искомый ключ) являются строками, и использует более быстрое и простое сравнение строк для сравнения ключей, вместо вызова метода `__eq__`.
++ При первом обращении к экземпляру `dict` с ключом, не являющимся `str`, он модифицируется, чтобы в дальнейшем для поиска использовалась общая функция.
++ Этот процесс не обратим для конкретного экземпляра `dict`, и ключ даже не обязательно должен существовать в словаре. Поэтому попытка неудачного поиска имеет тот же эффект.
+
+---
+
+
+### ▶ Раздуваем экземпляры словарей *
+
+```py
+import sys
+
+class SomeClass:
+ def __init__(self):
+ self.some_attr1 = 1
+ self.some_attr2 = 2
+ self.some_attr3 = 3
+ self.some_attr4 = 4
+
+
+def dict_size(o):
+ return sys.getsizeof(o.__dict__)
+
+```
+
+**Результат:** (Python 3.8, другие версии Python 3 могут немного отличаться)
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104
+>>> dict_size(o2)
+104
+>>> del o1.some_attr1
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+>>> dict_size(o1)
+232
+```
+
+Попробуем снова... В новом сессии интерпретатора:
+
+```py
+>>> o1 = SomeClass()
+>>> o2 = SomeClass()
+>>> dict_size(o1)
+104 # как ожидается
+>>> o1.some_attr5 = 5
+>>> o1.some_attr6 = 6
+>>> dict_size(o1)
+360
+>>> dict_size(o2)
+272
+>>> o3 = SomeClass()
+>>> dict_size(o3)
+232
+```
+
+Что заставляет эти словари раздуваться? И почему только созданные объекты также раздуваются?
+
+#### 💡 Объяснение:
++ CPython может повторно использовать один и тот же объект "keys" в нескольких словарях. Это было добавлено в [PEP 412](https://www.python.org/dev/peps/pep-0412/) с целью сокращения использования памяти, особенно в экземплярах словарей - где ключи (атрибуты экземпляра), как правило, общие для всех экземпляров.
++ Эта оптимизация совершенно беспроблемна для экземпляров словарей, но она не работает, если нарушены некоторые условия.
++ Словари с общим доступом к ключам не поддерживают удаление; если атрибут экземпляра удаляется, словарь становится "не общим", и общий доступ к ключам отключается для всех последующих экземпляров того же класса.
++ Кроме того, если размер ключей словаря был изменен (из-за вставки новых ключей), они остаются общими *только* если они используются только одним словарем (это позволяет добавить много атрибутов в `__init__` самого первого созданного экземпляра, не вызывая "unshare"). Если на момент изменения размера существует несколько экземпляров, совместное использование ключей отключается для всех последующих экземпляров одного класса: CPython не может определить, используют ли ваши экземпляры один и тот же набор атрибутов, и решает отказаться от попытки поделиться ключами.
++ Небольшой совет, если вы стремитесь уменьшить занимаемый программой объем памяти: не удаляйте атрибуты экземпляров и обязательно инициализируйте все атрибуты в `__init__`!
+
+---
+
+
+### ▶ Минорное *
+
+* `join()` - строковая операция вместо списочной. (может показаться неочевидным при первом использовании)
+
+ **💡 Объяснение:** Если `join()` - это строковый метод, то он может работать с любым итеруемыми объектами (список, кортеж, итераторы). Если бы это был списковый метод, то его пришлось бы реализовывать отдельно для каждого типа. Кроме того, нет особого смысла помещать метод, специфичный для строки, в общий API объекта `list`.
+
+* Несколько странных, но семантически правильных утверждений:
+ + `[] = ()` - семантически корректное утверждение (распаковка пустого `кортежа` в пустой `список`)
+ + `'a'[0][0][0][0][0]` также является семантически корректным утверждением, поскольку в Python строки являются [последовательностями](https://docs.python.org/3/glossary.html#term-sequence) (итерируемыми объектами, поддерживающими доступ к элементам с использованием целочисленных индексов).
+ + `3 --0-- 5 == 8` и `--5 == 5` - оба семантически корректные утверждения и имеют значение `True`.
+
+* Учитывая, что `a` - это число, `++a` и `--a` являются корректными утверждениями Python, но ведут себя не так, как аналогичные утверждения в таких языках, как C, C++ или Java.
+ ```py
+ >>> a = 5
+ >>> a
+ 5
+ >>> ++a
+ 5
+ >>> --a
+ 5
+ ```
+
+ **💡 Объяснение:**
+ + В грамматике Python нет оператора `++`. На самом деле это два оператора `+`.
+ + `++a` преобразуется в `+(+a)`, а затем в `a`. Аналогично для утверждения `--a`.
+ + На [StackOverflow](https://stackoverflow.com/questions/3654830/why-are-there-no-and-operators-in-python) обсуждается обоснование отсутствия операторов инкремента и декремента в Python.
+
+* Вы наверняка знаете об операторе Walrus в Python. Но слышали ли вы когда-нибудь об операторе *пространственного инкремента*?
+ ```py
+ >>> a = 42
+ >>> a -=- 1
+ >>> a
+ 43
+ ```
+ Он используется как альтернативный оператор инкрементации, вместе с другим оператором
+ ```py
+ >>> a +=+ 1
+ >>> a
+ >>> 44
+ ```
+ **💡 Объяснение:** Этот розыгрыш взят из твита [Raymond Hettinger](https://twitter.com/raymondh/status/1131103570856632321?lang=en). На самом деле оператор захвата пространства - это просто неправильно отформатированное `a -= (-1)`. Что эквивалентно `a = a - (- 1)`. Аналогично для случая `a += (+ 1)`.
+
+* В Python есть недокументированный оператор [обратная импликация](https://en.wikipedia.org/wiki/Converse_implication).
+ ```py
+ >>> False ** False == True
+ True
+ >>> False ** True == False
+ True
+ >>> True ** False == True
+ True
+ >>> True ** True == True
+ True
+ ```
+
+ **💡 Объяснение:** Если заменить `False` и `True` на 0 и 1 и произвести математические вычисления, то таблица истинности будет эквивалентна оператору обратной импликации. ([Источник](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+
+* Раз уж мы заговорили об операторах, есть еще оператор `@` для умножения матриц (не волнуйтесь, на этот раз он настоящий).
+ ```py
+ >>> import numpy as np
+ >>> np.array([2, 2, 2]) @ np.array([7, 8, 8])
+ 46
+ ```
+
+ **💡 Объяснение:** Оператор `@` был добавлен в Python 3.5 с учетом пожеланий научного сообщества. Любой объект может перегрузить магический метод `__matmul__`, чтобы определить поведение этого оператора.
+
+* Начиная с Python 3.8 для быстрой отладки можно использовать типичный синтаксис f-строк, например `f'{some_var=}`. Пример,
+ ```py
+ >>> some_string = "wtfpython"
+ >>> f'{some_string=}'
+ "some_string='wtfpython'"
+ ```
+
+* Python использует 2 байта для хранения локальных переменных в функциях. Теоретически это означает, что в функции может быть определено только 65536 переменных. Однако в python есть удобное решение, которое можно использовать для хранения более 2^16 имен переменных. Следующий код демонстрирует, что происходит в стеке, когда определено более 65536 локальных переменных (Внимание: этот код печатает около 2^18 строк текста, так что будьте готовы!):
+ ```py
+ import dis
+ exec("""
+ def f():
+ """ + """
+ """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
+
+ f()
+
+ print(dis.dis(f))
+ ```
+
+* Несколько потоков Python не смогут выполнять ваш *Python-код* одновременно (да, вы не ослышались!). Может показаться интуитивно понятным породить несколько потоков и позволить им выполнять ваш Python код одновременно, но из-за [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) в Python, все, что вы делаете, это заставляете ваши потоки выполняться на одном и том же ядре по очереди. Потоки Python хороши для задач, связанных с IO, но чтобы добиться реального распараллеливания в Python для задач, связанных с процессором, вы можете использовать модуль Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html).
+
+* Иногда метод `print` может выводить значения с задержкой. Например,
+ ```py
+ # Файл some_file.py
+ import time
+
+ print("wtfpython", end="_")
+ time.sleep(3)
+ ```
+
+ Это выведет `wtfpython` через 3 секунды из-за аргумента `end`, потому что выходной буфер очищается либо при появлении `\n`, либо когда программа завершает выполнение. Мы можем принудительно отчистить буфер, передав аргумент `flush=True`.
+
+* Срез списка индексом, превышающим длину списка, не приводит к ошибкам
+ ```py
+ >>> some_list = [1, 2, 3, 4, 5]
+ >>> some_list[111:]
+ []
+ ```
+
+* При срезе итерируемого объекта не всегда создается новый объект. Например,
+ ```py
+ >>> some_str = "wtfpython"
+ >>> some_list = ['w', 't', 'f', 'p', 'y', 't', 'h', 'o', 'n']
+ >>> some_list is some_list[:] # Ожидается False, так как создан новый объект.
+ False
+ >>> some_str is some_str[:] # Возвращается True, потому что строки неизменны, создание нового объекта ничего не меняет
+ True
+ ```
+
+* `int('١٢٣٤٥٦٧٨٩')` возвращает `123456789` в Python 3. В Python десятичные символы включают в себя символы цифр и все символы, которые могут быть использованы для формирования десятично-радиксных чисел, например U+0660, ARABIC-INDIC DIGIT ZERO. Вот [интересная история](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/), связанная с таким поведением Python.
+
+* Начиная с Python 3 вы можете разделять числовые литералы символами подчеркивания (для лучшей читаемости).
+ ```py
+ >>> six_million = 6_000_000
+ >>> six_million
+ 6000000
+ >>> hex_address = 0xF00D_CAFE
+ >>> hex_address
+ 4027435774
+ ```
+
+* `'abc'.count('') == 4`. Вот примерная реализация метода `count`, которая немного разъяснит ситуацию
+ ```py
+ def count(s, sub):
+ result = 0
+ for i in range(len(s) + 1 - len(sub)):
+ result += (s[i:i + len(sub)] == sub)
+ return result
+ ```
+ Такое поведение связано с совпадением пустой подстроки(`''`) со срезами длины 0 в исходной строке.
+
+---
+---
+
+# Вклад в проект
+
+Как можно внести свой вклад в развитие wtfpython,
+
+- Предложить новые примеры
+- Помочь в переводе (См. [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))
+- Мелкие исправления, такие как указание на устаревшие фрагменты, опечатки, ошибки форматирования и т.д.
+- Выявление пробелов (таких как недостаточное объяснение, избыточные примеры и т. д.)
+- Любые творческие предложения, чтобы сделать этот проект более интересным и полезным.
+
+Пожалуйста, смотрите [CONTRIBUTING.md](/CONTRIBUTING.md) для более подробной информации. Не стесняйтесь создать новый [issue](https://github.com/satwikkansal/wtfpython/issues/new) для обсуждения.
+
+PS: Пожалуйста, не обращайтесь к нам с просьбами об обратной ссылке, ссылки не будут добавлены, если они не имеют отношения к проекту.
+
+# Благодарности
+
+Идея и дизайн этой коллекции были изначально вдохновлены потрясающим проектом Дениса Дована [wtfjs](https://github.com/denysdovhan/wtfjs). Подавляющая поддержка со стороны питонистов придала проекту ту форму, в которой он находится сейчас.
+
+#### Несколько хороших ссылок!
+* https://www.youtube.com/watch?v=sH4XF6pKKmk
+* https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
+* https://sopython.com/wiki/Common_Gotchas_In_Python
+* https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
+* https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
+* https://www.python.org/doc/humor/
+* https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
+* https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
+* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+* Ветки обсуждения WFTPython на [Hacker News](https://news.ycombinator.com/item?id=21862073) и [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
+
+# 🎓 Лицензия
+
+[![WTFPL 2.0][license-image]][license-url]
+
+© [Satwik Kansal](https://satwikkansal.xyz)
+
+[license-url]: http://www.wtfpl.net
+[license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
+
+## Удиви своих друзей!
+
+Если вам нравится `wtfpython`, вы можете поделиться проектом, используя быстрые ссылки,
+
+[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hashtags=python,wtfpython) | [Linkedin](https://www.linkedin.com/shareArticle?url=https://github.com/satwikkansal&title=What%20the%20f*ck%20Python!&summary=If%20you%20really%20thing%20you%20know%20Python,%20think%20once%20more!) | [Facebook](https://www.facebook.com/dialog/share?app_id=536779657179021&display=page&href=https%3A%2F%2Fgithub.com%2Fsatwikkansal%2Fwtfpython"e=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+
+### Нужна PDF версия?
+
+Я получил несколько запросов на pdf (и epub) версию wtfpython. Вы можете добавить свои данные [здесь](https://form.jotform.com/221593245656057), чтобы получить их, как только они будут готовы.
+
+**Вот и все, друзья!** Для получения новых материалов, подобных этому, вы можете добавить свой email [сюда](https://form.jotform.com/221593598380062).
diff --git a/translations/ru-russian/code-of-conduct.md b/translations/ru-russian/code-of-conduct.md
new file mode 100644
index 00000000..2aa521fc
--- /dev/null
+++ b/translations/ru-russian/code-of-conduct.md
@@ -0,0 +1,70 @@
+# Кодекс Поведения участника
+
+## Наши обязательства
+
+Мы, как участники, авторы и лидеры обязуемся сделать участие в сообществе
+свободным от притеснений для всех, независимо от возраста, телосложения,
+видимых или невидимых ограничений способности, этнической принадлежности,
+половых признаков, гендерной идентичности и выражения, уровня опыта,
+образования, социально-экономического статуса, национальности, внешности,
+расы, религии, или сексуальной идентичности и ориентации.
+
+Мы обещаем действовать и взаимодействовать таким образом, чтобы вносить вклад в открытое,
+дружелюбное, многообразное, инклюзивное и здоровое сообщество.
+
+## Наши стандарты
+
+Примеры поведения, создающие условия для благоприятных взаимоотношений включают в себя:
+
+* Проявление доброты и эмпатии к другим участникам проекта
+* Уважение к чужой точке зрения и опыту
+* Конструктивная критика и принятие конструктивной критики
+* Принятие ответственности, принесение извинений тем, кто пострадал от наших ошибок
+ и извлечение уроков из опыта
+* Ориентирование на то, что лучше подходит для сообщества, а не только для нас лично
+
+Примеры неприемлемого поведения участников включают в себя:
+
+* Использование выражений или изображений сексуального характера и нежелательное сексуальное внимание или домогательство в любой форме
+* Троллинг, оскорбительные или уничижительные комментарии, переход на личности или затрагивание политических убеждений
+* Публичное или приватное домогательство
+* Публикация личной информации других лиц, например, физического или электронного адреса, без явного разрешения
+* Иное поведение, которое обоснованно считать неуместным в профессиональной обстановке
+
+## Обязанности
+
+Лидеры сообщества отвечают за разъяснение и применение наших стандартов приемлемого
+поведения и будут предпринимать соответствующие и честные меры по исправлению положения
+в ответ на любое поведение, которое они сочтут неприемлемым, угрожающим, оскорбительным или вредным.
+
+Лидеры сообщества обладают правом и обязанностью удалять, редактировать или отклонять
+комментарии, коммиты, код, изменения в вики, вопросы и другой вклад, который не совпадает
+с Кодексом Поведения, и предоставят причины принятого решения, когда сочтут нужным.
+
+## Область применения
+
+Данный Кодекс Поведения применим во всех публичных физических и цифровых пространства сообщества,
+а также когда человек официально представляет сообщество в публичных местах.
+Примеры представления проекта или сообщества включают использование официальной электронной почты,
+публикации в официальном аккаунте в социальных сетях,
+или упоминания как представителя в онлайн или офлайн мероприятии.
+
+## Приведение в исполнение
+
+О случаях домогательства, а так же оскорбительного или иного другого неприемлемого
+поведения можно сообщить ответственным лидерам сообщества с помощью email.
+Все жалобы будут рассмотрены и расследованы оперативно и беспристрастно.
+
+Все лидеры сообщества обязаны уважать неприкосновенность частной жизни и личную
+неприкосновенность автора сообщения.
+
+## Атрибуция
+
+Данный Кодекс Поведения основан на [Кодекс Поведения участника][homepage],
+версии 2.0, доступной по адресу
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Принципы Воздействия в Сообществе были вдохновлены [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
diff --git a/wtfpython b/wtfpython
deleted file mode 100644
index b8a3fa6a..00000000
--- a/wtfpython
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const obj = require('through2').obj;
-const pager = require('default-pager');
-const msee = require('msee');
-const join = require('path').join;
-const boxen = require('boxen');
-const chalk = require('chalk');
-const updateNotifier = require('update-notifier');
-const pkg = require('./package.json');
-const meow = require('meow');
-
-const cli = meow([
- 'Usage',
- ' bash-handbook',
- '',
- 'Options',
- ' --lang, -l Translation language',
- '',
- 'Examples',
- ' bash-handbook',
- ' bash-handbook --lang pt-br'
-], {
- string: [
- 'lang'
- ],
- alias: {
- l: 'lang',
- h: 'help'
- },
- default: {
- lang: ''
- }
-});
-
-const boxenOpts = {
- borderColor: 'yellow',
- margin: {
- bottom: 1
- },
- padding: {
- right: 1,
- left: 1
- }
-};
-
-const mseeOpts = {
- paragraphEnd: '\n\n'
-};
-
-const notifier = updateNotifier({ pkg });
-
-process.env.PAGER = process.env.PAGER || 'less';
-process.env.LESS = process.env.LESS || 'FRX';
-
-const lang = cli.flags.lang
- .toLowerCase()
- .split('-')
- .map((l, i) => i === 0 ? l : l.toUpperCase())
- .join('-');
-
-const translation = join(__dirname, !lang ? './README.md' : `./README-${lang}.md`);
-
-fs.stat(translation, function (err, stats) {
- if (err) {
- console.log('The %s translation does not exist', chalk.bold(lang));
- return;
- }
-
- fs.createReadStream(translation)
- .pipe(obj(function (chunk, enc, cb) {
- const message = [];
-
- if (notifier.update) {
- message.push(`Update available: {green.bold ${notifier.update.latest}} {dim current: ${notifier.update.current}}`);
- message.push(`Run {blue npm install -g ${pkg.name}} to update.`);
- this.push(boxen(message.join('\n'), boxenOpts));
- }
-
- this.push(msee.parse(chunk.toString(), mseeOpts));
- cb();
- }))
- .pipe(pager());
-});
diff --git a/wtfpython-pypi/content.md b/wtfpython-pypi/content.md
deleted file mode 100644
index 3fd8a132..00000000
--- a/wtfpython-pypi/content.md
+++ /dev/null
@@ -1,2340 +0,0 @@
-
- What the f*ck Python! 🐍
- An interesting collection of tricky Python snippets and lesser known features.
-
-[![WTFPL 2.0][license-image]][license-url]
-
-
-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 to a regular user at first sight.
-
-Here is a fun project attempting to collect such classic & tricky examples of unexpected behaviors and lesser known features in Python, and discuss what exactly is happening under the hood!
-
-While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I think you'll find them interesting as well!
-
-If you're an experienced Python programmer, you can take it as a challenge to get most of them right in first attempt. You may be already familiar with some of these examples, and I might be able to revive sweet old memories of yours being bitten by these gotchas :sweat_smile: And if you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).
-
-So, here we go...
-
-# Table of Contents
-
-
-
-
-
-- [Structure of the Examples](#structure-of-the-examples)
-- [Usage](#usage)
-- [👀 Examples](#-examples)
- - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
- - [▶ Skipping lines?](#-skipping-lines)
- - [▶ Teleportation *](#-teleportation-)
- - [▶ Well, something is fishy...](#-well-something-is-fishy)
- - [Section: The Hidden treasures!](#section-the-hidden-treasures)
- - [▶ Okay Python, Can you make me fly? *](#-okay-python-can-you-make-me-fly-)
- - [▶ `goto`, but why? *](#-goto-but-why-)
- - [▶ Brace yourself! *](#-brace-yourself-)
- - [▶ Let's meet Friendly Language Uncle For Life *](#-lets-meet-friendly-language-uncle-for-life-)
- - [▶ Even Python understands that love is complicated *](#-even-python-understands-that-love-is-complicated-)
- - [▶ Yes, it exists!](#-yes-it-exists)
- - [▶ Inpinity *](#-inpinity-)
- - [▶ Mangling time! *](#-mangling-time-)
- - [Section: Strain your brain!](#section-strain-your-brain)
- - [▶ Strings can be tricky sometimes *](#-strings-can-be-tricky-sometimes-)
- - [▶ Time for some hash brownies!](#-time-for-some-hash-brownies)
- - [▶ Return return everywhere!](#-return-return-everywhere)
- - [▶ Deep down, we're all the same. *](#-deep-down-were-all-the-same-)
- - [▶ For what?](#-for-what)
- - [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
- - [▶ `is` is not what it is!](#-is-is-not-what-it-is)
- - [▶ 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)
- - [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
- - [▶ The surprising comma](#-the-surprising-comma)
- - [▶ Backslashes at the end of string](#-backslashes-at-the-end-of-string)
- - [▶ not knot!](#-not-knot)
- - [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
- - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)
- - [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)
- - [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes)
- - [▶ yielding None](#-yielding-none)
- - [▶ Mutating the immutable!](#-mutating-the-immutable)
- - [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)
- - [▶ When True is actually False](#-when-true-is-actually-false)
- - [▶ From filled to None in one instruction...](#-from-filled-to-none-in-one-instruction)
- - [▶ Subclass relationships *](#-subclass-relationships-)
- - [▶ The mysterious key type conversion *](#-the-mysterious-key-type-conversion-)
- - [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this)
- - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines)
- - [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
- - [▶ Stubborn `del` operator *](#-stubborn-del-operator-)
- - [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)
- - [▶ Loop variables leaking out!](#-loop-variables-leaking-out)
- - [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)
- - [▶ Catching the Exceptions](#-catching-the-exceptions)
- - [▶ Same operands, different story!](#-same-operands-different-story)
- - [▶ The out of scope variable](#-the-out-of-scope-variable)
- - [▶ Be careful with chained operations](#-be-careful-with-chained-operations)
- - [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope)
- - [▶ Needle in a Haystack](#-needle-in-a-haystack)
- - [Section: Miscallaneous](#section-miscallaneous)
- - [▶ `+=` is faster](#--is-faster)
- - [▶ Let's make a giant string!](#-lets-make-a-giant-string)
- - [▶ Explicit typecast of strings](#-explicit-typecast-of-strings)
- - [▶ Minor Ones](#-minor-ones)
-- [Contributing](#contributing)
-- [Acknowledgements](#acknowledgements)
-- [🎓 License](#-license)
-- [Help](#help)
- - [Want to share WTFpython with friends?](#want-to-share-wtfpython-with-friends)
- - [Need a pdf version?](#need-a-pdf-version)
-
-
-
-# Structure of the Examples
-
-All the examples are structured like below:
-
-> ### ▶ Some fancy Title *
-> The asterisk at the end of the title indicates the example was not present in the first release and has been recently added.
->
-> ```py
-> # Setting up the code.
-> # Preparation for the magic...
-> ```
->
-> **Output (Python version):**
-> ```py
-> >>> triggering_statement
-> Probably unexpected output
-> ```
-> (Optional): One line describing the unexpected output.
->
->
-> #### 💡 Explanation:
->
-> * Brief explanation of what's happening and why is it happening.
-> ```py
-> Setting up examples for clarification (if necessary)
-> ```
-> **Output:**
-> ```py
-> >>> trigger # some example that makes it easy to unveil the magic
-> # some justified output
-> ```
-
-**Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified in the description.
-
-# Usage
-
-A nice way to get the most out of these examples, in my opinion, will be just to read the examples chronologically, and for every example:
-- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, most of the times you will successfully anticipate what's going to happen next.
-- Read the output snippets and,
- + Check if the outputs are the same as you'd expect.
- + Make sure if you know the exact reason behind the output being the way it is.
- - If no, 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)).
- - 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. There's a pypi package and an npm package (supports colored formatting) for the same.
-
-To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython)
-```sh
-$ npm install -g wtfpython
-```
-
-Alternatively, to install the pypi package [`wtfpython`](https://pypi.python.org/pypi/wtfpython)
-```sh
-$ pip install wtfpython -U
-```
-
-Now, just run `wtfpython` at the command line which will open this collection in your selected `$PAGER`.
-
----
-
-# 👀 Examples
-
-## Section: Appearances are deceptive!
-
-This section is a gentle warm up before we focus on real Python concepts.
-
-### ▶ Skipping lines?
-
-**Output:**
-```py
->>> value = 11
->>> valuе = 32
->>> value
-11
-```
-
-Wut?
-
-**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.
-
-#### 💡 Explanation
-
-Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.
-
-```py
->>> ord('е') # cyrillic 'e' (Ye)
-1077
->>> ord('e') # latin 'e', as used in English and typed using standard keyboard
-101
->>> 'е' == 'e'
-False
-
->>> value = 42 # latin e
->>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here
->>> value
-42
-```
-
-The built-in `ord()` function returns a character's Unicode [code point](https://en.wikipedia.org/wiki/Code_point), and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.
-
----
-
-### ▶ Teleportation *
-
-```py
-import numpy as np
-
-def energy_send(x):
- # Initializing a numpy array
- np.array([float(x)])
-
-def energy_receive():
- # Return an empty numpy array
- return np.empty((), dtype=np.float).tolist()
-```
-
-**Output:**
-```py
->>> energy_send(123.456)
->>> energy_receive()
-123.456
-```
-
-Where's the Nobel Prize?
-
-#### 💡 Explanation:
-
-* Notice that the numpy array created in the `energy_send` function is not returned, so that memory space is free to reallocate.
-* `numpy.empty()` returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).
-
----
-
-### ▶ Well, something is fishy...
-
-```py
-def square(x):
- """
- A simple function to calculate the square of a number by addition.
- """
- sum_so_far = 0
- for counter in range(x):
- sum_so_far = sum_so_far + x
- return sum_so_far
-```
-
-**Output (Python 2.x):**
-
-```py
->>> square(10)
-10
-```
-
-Shouldn't that be 100?
-
-**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.
-
-#### 💡 Explanation
-
-* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.
-* This is how Python handles tabs:
- > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
-* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.
-* Python 3 is kind enough to throw an error for such cases automatically.
-
- **Output (Python 3.x):**
- ```py
- TabError: inconsistent use of tabs and spaces in indentation
- ```
-
----
-
----
-
-## Section: The Hidden treasures!
-
-This section contains few of the lesser-known interesting things about Python that most beginners like me are unaware of (well, not anymore).
-
-### ▶ Okay Python, Can you make me fly? *
-
-Well, here you go
-
-```py
-import antigravity
-```
-
-**Output:**
-Sshh.. It's a super secret.
-
-#### 💡 Explanation:
-+ `antigravity` module is one of the few easter eggs released by Python developers.
-+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python.
-+ Well, there's more to it. There's **another easter egg inside the easter egg**. If look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/).
-
----
-
-### ▶ `goto`, but why? *
-
-```py
-from goto import goto, label
-for i in range(9):
- for j in range(9):
- for k in range(9):
- print("I'm trapped, please rescue!")
- if k == 2:
- goto .breakout # breaking out from a deeply nested loop
-label .breakout
-print("Freedom!")
-```
-
-**Output (Python 2.3):**
-```py
-I'm trapped, please rescue!
-I'm trapped, please rescue!
-Freedom!
-```
-
-#### 💡 Explanation:
-- A working version of `goto` in Python was [announced](https://mail.python.org/pipermail/python-announce-list/2004-April/002982.html) as an April Fool's joke on 1st April 2004.
-- Current versions of Python do not have this module.
-- Although it works, but please don't use it. Here's the [reason](https://docs.python.org/3/faq/design.html#why-is-there-no-goto) to why `goto` is not present in Python.
-
----
-
-### ▶ Brace yourself! *
-
-If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing,
-
-```py
-from __future__ import braces
-```
-
-**Output:**
-```py
- File "some_file.py", line 1
- from __future__ import braces
-SyntaxError: not a chance
-```
-
-Braces? No way! If you think that's disappointing, use Java.
-
-#### 💡 Explanation:
-+ The `__future__` module is normally used to provide features from future versions of Python. The "future" here is however ironic.
-+ This is an easter egg concerned with the community's feelings on this issue.
-
----
-
-### ▶ Let's meet Friendly Language Uncle For Life *
-
-**Output (Python 3.x)**
-```py
->>> from __future__ import barry_as_FLUFL
->>> "Ruby" != "Python" # there's no doubt about it
- File "some_file.py", line 1
- "Ruby" != "Python"
- ^
-SyntaxError: invalid syntax
-
->>> "Ruby" <> "Python"
-True
-```
-
-There we go.
-
-#### 💡 Explanation:
-- This is relevant to [PEP-401](https://www.python.org/dev/peps/pep-0401/) released on April 1, 2009 (now you know, what it means).
-- Quoting from the PEP-401
- Recognized that the != inequality operator in Python 3.0 was a horrible, finger pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.
-- There were more things that Uncle Barry had to share in the PEP; you can read them [here](https://www.python.org/dev/peps/pep-0401/).
-
----
-
-### ▶ Even Python understands that love is complicated *
-
-```py
-import this
-```
-
-Wait, what's **this**? `this` is love :heart:
-
-**Output:**
-```
-The Zen of Python, by Tim Peters
-
-Beautiful is better than ugly.
-Explicit is better than implicit.
-Simple is better than complex.
-Complex is better than complicated.
-Flat is better than nested.
-Sparse is better than dense.
-Readability counts.
-Special cases aren't special enough to break the rules.
-Although practicality beats purity.
-Errors should never pass silently.
-Unless explicitly silenced.
-In the face of ambiguity, refuse the temptation to guess.
-There should be one-- and preferably only one --obvious way to do it.
-Although that way may not be obvious at first unless you're Dutch.
-Now is better than never.
-Although never is often better than *right* now.
-If the implementation is hard to explain, it's a bad idea.
-If the implementation is easy to explain, it may be a good idea.
-Namespaces are one honking great idea -- let's do more of those!
-```
-
-It's the Zen of Python!
-
-```py
->>> love = this
->>> this is love
-True
->>> love is True
-False
->>> love is False
-False
->>> love is not True or False
-True
->>> love is not True or False; love is love # Love is complicated
-True
-```
-
-#### 💡 Explanation:
-
-* `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
-* And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, the code for the Zen violates itself (and that's probably the only place where this happens).
-* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory.
-
----
-
-### ▶ Yes, it exists!
-
-**The `else` clause for loops.** One typical example might be:
-
-```py
- def does_exists_num(l, to_find):
- for num in l:
- if num == to_find:
- print("Exists!")
- break
- else:
- print("Does not exist")
-```
-
-**Output:**
-```py
->>> some_list = [1, 2, 3, 4, 5]
->>> does_exists_num(some_list, 4)
-Exists!
->>> does_exists_num(some_list, -1)
-Does not exist
-```
-
-**The `else` clause in exception handling.** An example,
-
-```py
-try:
- pass
-except:
- print("Exception occurred!!!")
-else:
- print("Try block executed successfully...")
-```
-
-**Output:**
-```py
-Try block executed successfully...
-```
-
-#### 💡 Explanation:
-- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations.
-- `else` clause after try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
-
----
-
-### ▶ Inpinity *
-
-The spelling is intended. Please, don't submit a patch for this.
-
-**Output (Python 3.x):**
-```py
->>> infinity = float('infinity')
->>> hash(infinity)
-314159
->>> hash(float('-inf'))
--314159
-```
-
-#### 💡 Explanation:
-- Hash of infinity is 10⁵ x π.
-- Interestingly, the hash of `float('-inf')` is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2.
-
----
-
-### ▶ Mangling time! *
-
-```py
-class Yo(object):
- def __init__(self):
- self.__honey = True
- self.bitch = True
-```
-
-**Output:**
-```py
->>> Yo().bitch
-True
->>> Yo().__honey
-AttributeError: 'Yo' object has no attribute '__honey'
->>> Yo()._Yo__honey
-True
-```
-
-Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
-
-#### 💡 Explanation:
-
-* [Name Mangling](https://en.wikipedia.org/wiki/Name_mangling) is used to avoid naming collisions between different namespaces.
-* In Python, the interpreter modifies (mangles) the class member names starting with `__` (double underscore) and not ending with more than one trailing underscore by adding `_NameOfTheClass` in front.
-* So, to access `__honey` attribute, we are required to append `_Yo` to the front which would prevent conflicts with the same name attribute defined in any other class.
-
----
-
----
-
-## Section: Strain your brain!
-
-Alright, it's time to strain your brain and test your understanding of Python concepts. All the best!
-
-### ▶ Strings can be tricky sometimes *
-
-1\.
-```py
->>> a = "some_string"
->>> id(a)
-140420665652016
->>> id("some" + "_" + "string") # Notice that both the ids are same.
-140420665652016
-```
-
-2\.
-```py
->>> a = "wtf"
->>> b = "wtf"
->>> a is b
-True
-
->>> a = "wtf!"
->>> b = "wtf!"
->>> a is b
-False
-
->>> a, b = "wtf!", "wtf!"
->>> a is b
-True
-```
-
-3\.
-```py
->>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
-True
->>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
-False
-```
-
-Makes sense, right?
-
-#### 💡 Explanation:
-+ Such behavior is due to CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.
-+ After being interned, many variables may point to the same string object in memory (thereby saving memory).
-+ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some facts that can be used to guess if a string will be interned or not:
- * All length 0 and length 1 strings are interned.
- * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)
- * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`.
- ", line 1
- def h(x, **kwargs,):
- ^
-SyntaxError: invalid syntax
->>> def h(*args,):
- File "", line 1
- def h(*args,):
- ^
-SyntaxError: invalid syntax
-```
-
-#### 💡 Explanation:
-
-- Trailing comma is not always legal in formal parameters list of a Python function.
-- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.
-- **Note:** The trailing comma problem is [fixed in Python 3.6](https://bugs.python.org/issue9232). The remarks in [this](https://bugs.python.org/issue9232#msg248399) post discuss in brief different usages of trailing commas in Python.
-
----
-
-### ▶ Backslashes at the end of string
-
-**Output:**
-```
->>> print("\\ C:\\")
-\ C:\
->>> print(r"\ C:")
-\ C:
->>> print(r"\ C:\")
-
- File "", line 1
- print(r"\ C:\")
- ^
-SyntaxError: EOL while scanning string literal
-```
-
-#### 💡 Explanation
-
-- In a raw string literal, as indicated by the prefix `r`, the backslash doesn't have the special meaning.
- ```py
- >>> print(repr(r"wt\"f"))
- 'wt\\"f'
- ```
-- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string.
-
----
-
-### ▶ not knot!
-
-```py
-x = True
-y = False
-```
-
-**Output:**
-```py
->>> not x == y
-True
->>> x == not y
- File " at 0x7f70b0a4ad58>
->>> list([(yield x) for x in some_iterable])
-['a', 'b']
->>> list((yield x) for x in some_iterable)
-['a', None, 'b', None]
->>> list(some_func((yield x)) for x in some_iterable)
-['a', 'something', 'b', 'something']
-```
-
-#### 💡 Explanation:
-- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
-- Related bug report: http://bugs.python.org/issue10544
-
----
-
-### ▶ Mutating the immutable!
-
-```py
-some_tuple = ("A", "tuple", "with", "values")
-another_tuple = ([1, 2], [3, 4], [5, 6])
-```
-
-**Output:**
-```py
->>> some_tuple[2] = "change this"
-TypeError: 'tuple' object does not support item assignment
->>> another_tuple[2].append(1000) #This throws no error
->>> another_tuple
-([1, 2], [3, 4], [5, 6, 1000])
->>> another_tuple[2] += [99, 999]
-TypeError: 'tuple' object does not support item assignment
->>> another_tuple
-([1, 2], [3, 4], [5, 6, 1000, 99, 999])
-```
-
-But I thought tuples were immutable...
-
-#### 💡 Explanation:
-
-* Quoting from https://docs.python.org/2/reference/datamodel.html
-
- > Immutable sequences
- An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.)
-
-* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place.
-
----
-
-### ▶ The disappearing variable from outer scope
-
-```py
-e = 7
-try:
- raise Exception()
-except Exception as e:
- pass
-```
-
-**Output (Python 2.x):**
-```py
->>> print(e)
-# prints nothing
-```
-
-**Output (Python 3.x):**
-```py
->>> print(e)
-NameError: name 'e' is not defined
-```
-
-#### 💡 Explanation:
-
-* Source: https://docs.python.org/3/reference/compound_stmts.html#except
-
- When an exception has been assigned using `as` target, it is cleared at the end of the except clause. This is as if
-
- ```py
- except E as N:
- foo
- ```
-
- was translated into
-
- ```py
- except E as N:
- try:
- foo
- finally:
- del N
- ```
-
- This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.
-
-* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions which have their separate inner-scopes. The example below illustrates this:
-
- ```py
- def f(x):
- del(x)
- print(x)
-
- x = 5
- y = [5, 4, 3]
- ```
-
- **Output:**
- ```py
- >>>f(x)
- UnboundLocalError: local variable 'x' referenced before assignment
- >>>f(y)
- UnboundLocalError: local variable 'x' referenced before assignment
- >>> x
- 5
- >>> y
- [5, 4, 3]
- ```
-
-* In Python 2.x the variable name `e` gets assigned to `Exception()` instance, so when you try to print, it prints nothing.
-
- **Output (Python 2.x):**
- ```py
- >>> e
- Exception()
- >>> print e
- # Nothing is printed!
- ```
-
----
-
-### ▶ When True is actually False
-
-```py
-True = False
-if True == False:
- print("I've lost faith in truth!")
-```
-
-**Output:**
-```
-I've lost faith in truth!
-```
-
-#### 💡 Explanation:
-
-- Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true). Then they added `True`, `False`, and a `bool` type, but, for backward compatibility, they couldn't make `True` and `False` constants- they just were built-in variables.
-- Python 3 was backward-incompatible, so it was now finally possible to fix that, and so this example won't work with Python 3.x!
-
----
-
-### ▶ From filled to None in one instruction...
-
-```py
-some_list = [1, 2, 3]
-some_dict = {
- "key_1": 1,
- "key_2": 2,
- "key_3": 3
-}
-
-some_list = some_list.append(4)
-some_dict = some_dict.update({"key_4": 4})
-```
-
-**Output:**
-```py
->>> print(some_list)
-None
->>> print(some_dict)
-None
-```
-
-#### 💡 Explanation
-
-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))
-
----
-
-### ▶ Subclass relationships *
-
-**Output:**
-```py
->>> from collections import Hashable
->>> issubclass(list, object)
-True
->>> issubclass(object, Hashable)
-True
->>> issubclass(list, Hashable)
-False
-```
-
-The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`)
-
-#### 💡 Explanation:
-
-* Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass.
-* When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey "`__hash__`" method in `cls` or anything it inherits from.
-* Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation.
-* More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).
-
----
-
-### ▶ The mysterious key type conversion *
-
-```py
-class SomeClass(str):
- pass
-
-some_dict = {'s':42}
-```
-
-**Output:**
-```py
->>> type(list(some_dict.keys())[0])
-str
->>> s = SomeClass('s')
->>> some_dict[s] = 40
->>> some_dict # expected: Two different keys-value pairs
-{'s': 40}
->>> type(list(some_dict.keys())[0])
-str
-```
-
-#### 💡 Explanation:
-
-* Both the object `s` and the string `"s"` hash to the same value because `SomeClass` inherits the `__hash__` method of `str` class.
-* `SomeClass("s") == "s"` evaluates to `True` because `SomeClass` also inherits `__eq__` method from `str` class.
-* Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary.
-* For the desired behavior, we can redefine the `__eq__` method in `SomeClass`
- ```py
- class SomeClass(str):
- def __eq__(self, other):
- return (
- type(self) is SomeClass
- and type(other) is SomeClass
- and super().__eq__(other)
- )
-
- # When we define a custom __eq__, Python stops automatically inheriting the
- # __hash__ method, so we need to define it as well
- __hash__ = str.__hash__
-
- some_dict = {'s':42}
- ```
-
- **Output:**
- ```py
- >>> s = SomeClass('s')
- >>> some_dict[s] = 40
- >>> some_dict
- {'s': 40}
- >>> keys = list(some_dict.keys())
- >>> type(keys[0]), type(keys[1])
- (__main__.SomeClass, str)
- ```
-
----
-
-### ▶ Let's see if you can guess this?
-
-```py
-a, b = a[b] = {}, 5
-```
-
-**Output:**
-```py
->>> a
-{5: ({...}, 5)}
-```
-
-#### 💡 Explanation:
-
-* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form
- ```
- (target_list "=")+ (expression_list | yield_expression)
- ```
- and
- > An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
-
-* The `+` in `(target_list "=")+` means there can be **one or more** target lists. In this case, target lists are `a, b` and `a[b]` (note the expression list is exactly one, which in our case is `{}, 5`).
-
-* After the expression list is evaluated, it's value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`.
-
-* `a` is now assigned to `{}` which is a mutable object.
-
-* The second target list is `a[b]` (you may expect this to throw an error because both `a` and `b` have not been defined in the statements before. But remember, we just assigned `a` to `{}` and `b` to `5`).
-
-* Now, we are setting the key `5` in the dictionary to the tuple `({}, 5)` creating a circular reference (the `{...}` in the output refers to the same object that `a` is already referencing). Another simpler example of circular reference could be
- ```py
- >>> some_list = some_list[0] = [0]
- >>> some_list
- [[...]]
- >>> some_list[0]
- [[...]]
- >>> some_list is some_list[0]
- True
- >>> some_list[0][0][0][0][0][0] == some_list
- True
- ```
- Similar is the case in our example (`a[b][0]` is the same object as `a`)
-
-* So to sum it up, you can break the example down to
- ```py
- a, b = {}, 5
- a[b] = a, b
- ```
- And the circular reference can be justified by the fact that `a[b][0]` is the same object as `a`
- ```py
- >>> a[b][0] is a
- True
- ```
-
----
-
----
-
-## Section: Watch out for the landmines!
-
-
-### ▶ Modifying a dictionary while iterating over it
-
-```py
-x = {0: None}
-
-for i in x:
- del x[i]
- x[i+1] = None
- print(i)
-```
-
-**Output (Python 2.7- Python 3.5):**
-
-```
-0
-1
-2
-3
-4
-5
-6
-7
-```
-
-Yes, it runs for exactly **eight** times and stops.
-
-#### 💡 Explanation:
-
-* Iteration over a dictionary that you edit at the same time is not supported.
-* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
-* How deleted keys are handled and when the resize occurs might be different for different Python implementations.
-* For more information, you may refer to this StackOverflow [thread](https://stackoverflow.com/questions/44763802/bug-in-python-dict) explaining a similar example in detail.
-
----
-
-### ▶ Stubborn `del` operator *
-
-```py
-class SomeClass:
- def __del__(self):
- print("Deleted!")
-```
-
-**Output:**
-1\.
-```py
->>> x = SomeClass()
->>> y = x
->>> del x # this should print "Deleted!"
->>> del y
-Deleted!
-```
-
-Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twist to the example.
-
-2\.
-```py
->>> x = SomeClass()
->>> y = x
->>> del x
->>> y # check if y exists
-<__main__.SomeClass instance at 0x7f98a1a67fc8>
->>> del y # Like previously, this should print "Deleted!"
->>> globals() # oh, it didn't. Let's check all our global variables and confirm
-Deleted!
-{'__builtins__': , 'SomeClass': , '__package__': None, '__name__': '__main__', '__doc__': None}
-```
-
-Okay, now it's deleted :confused:
-
-#### 💡 Explanation:
-+ `del x` doesn’t directly call `x.__del__()`.
-+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero.
-+ 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 to reach zero when `del y` was encountered.
-+ Calling `globals` caused the existing reference to be destroyed and hence we can see "Deleted!" being printed (finally!).
-
----
-
-### ▶ Deleting a list item while iterating
-
-```py
-list_1 = [1, 2, 3, 4]
-list_2 = [1, 2, 3, 4]
-list_3 = [1, 2, 3, 4]
-list_4 = [1, 2, 3, 4]
-
-for idx, item in enumerate(list_1):
- del item
-
-for idx, item in enumerate(list_2):
- list_2.remove(item)
-
-for idx, item in enumerate(list_3[:]):
- list_3.remove(item)
-
-for idx, item in enumerate(list_4):
- list_4.pop(idx)
-```
-
-**Output:**
-```py
->>> list_1
-[1, 2, 3, 4]
->>> list_2
-[2, 4]
->>> list_3
-[]
->>> list_4
-[2, 4]
-```
-
-Can you guess why the output is `[2, 4]`?
-
-#### 💡 Explanation:
-
-* It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and `list_3[:]` does just that.
-
- ```py
- >>> some_list = [1, 2, 3, 4]
- >>> id(some_list)
- 139798789457608
- >>> id(some_list[:]) # Notice that python creates new object for sliced list.
- 139798779601192
- ```
-
-**Difference between `del`, `remove`, and `pop`:**
-* `del var_name` just removes the binding of the `var_name` from the local or global namespace (That's why the `list_1` is unaffected).
-* `remove` removes the first matching value, not a specific index, raises `ValueError` if the value is not found.
-* `pop` removes the element at a specific index and returns it, raises `IndexError` if an invalid index is specified.
-
-**Why the output is `[2, 4]`?**
-- The list iteration is done index by index, and when we remove `1` from `list_2` or `list_4`, the contents of the lists are now `[2, 3, 4]`. The remaining elements are shifted down, i.e., `2` is at index 0, and `3` is at index 1. Since the next iteration is going to look at index 1 (which is the `3`), the `2` gets skipped entirely. A similar thing will happen with every alternate element in the list sequence.
-
-* Refer to this StackOverflow [thread](https://stackoverflow.com/questions/45946228/what-happens-when-you-try-to-delete-a-list-element-while-iterating-over-it) explaining the example
-* See also this nice StackOverflow [thread](https://stackoverflow.com/questions/45877614/how-to-change-all-the-dictionary-keys-in-a-for-loop-with-d-items) for a similar example related to dictionaries in Python.
-
----
-
-### ▶ Loop variables leaking out!
-
-1\.
-```py
-for x in range(7):
- if x == 6:
- print(x, ': for x inside loop')
-print(x, ': x in global')
-```
-
-**Output:**
-```py
-6 : for x inside loop
-6 : x in global
-```
-
-But `x` was never defined outside the scope of for loop...
-
-2\.
-```py
-# This time let's initialize x first
-x = -1
-for x in range(7):
- if x == 6:
- print(x, ': for x inside loop')
-print(x, ': x in global')
-```
-
-**Output:**
-```py
-6 : for x inside loop
-6 : x in global
-```
-
-3\.
-```
-x = 1
-print([x for x in range(5)])
-print(x, ': x in global')
-```
-
-**Output (on Python 2.x):**
-```
-[0, 1, 2, 3, 4]
-(4, ': x in global')
-```
-
-**Output (on Python 3.x):**
-```
-[0, 1, 2, 3, 4]
-1 : x in global
-```
-
-#### 💡 Explanation:
-
-- In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable.
-
-- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) documentation:
-
- > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular the loop control variables are no longer leaked into the surrounding scope."
-
----
-
-### ▶ Beware of default mutable arguments!
-
-```py
-def some_func(default_arg=[]):
- default_arg.append("some_string")
- return default_arg
-```
-
-**Output:**
-```py
->>> some_func()
-['some_string']
->>> some_func()
-['some_string', 'some_string']
->>> some_func([])
-['some_string']
->>> some_func()
-['some_string', 'some_string', 'some_string']
-```
-
-#### 💡 Explanation:
-
-- The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed `[]` to `some_func` as the argument, the default value of the `default_arg` variable was not used, so the function returned as expected.
-
- ```py
- def some_func(default_arg=[]):
- default_arg.append("some_string")
- return default_arg
- ```
-
- **Output:**
- ```py
- >>> some_func.__defaults__ #This will show the default argument values for the function
- ([],)
- >>> some_func()
- >>> some_func.__defaults__
- (['some_string'],)
- >>> some_func()
- >>> some_func.__defaults__
- (['some_string', 'some_string'],)
- >>> some_func([])
- >>> some_func.__defaults__
- (['some_string', 'some_string'],)
- ```
-
-- A common practice to avoid bugs due to mutable arguments is to assign `None` as the default value and later check if any value is passed to the function corresponding to that argument. Example:
-
- ```py
- def some_func(default_arg=None):
- if not default_arg:
- default_arg = []
- default_arg.append("some_string")
- return default_arg
- ```
-
----
-
-### ▶ Catching the Exceptions
-
-```py
-some_list = [1, 2, 3]
-try:
- # This should raise an ``IndexError``
- print(some_list[4])
-except IndexError, ValueError:
- print("Caught!")
-
-try:
- # This should raise a ``ValueError``
- some_list.remove(4)
-except IndexError, ValueError:
- print("Caught again!")
-```
-
-**Output (Python 2.x):**
-```py
-Caught!
-
-ValueError: list.remove(x): x not in list
-```
-
-**Output (Python 3.x):**
-```py
- File " 
+ 
-+ 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.
+>>> (a := 6, 9)
+(6, 9)
+>>> a
+6
----
+>>> a, b = 6, 9 # Typical unpacking
+>>> a, b
+(6, 9)
+>>> (a, b = 16, 19) # Oops
+ File "
+ 
+ 
+ ![\"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 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"
+ ]
+ },
+ {
+ "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/3/reference/expressions.html#membership-test-operations\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": {},
+ "source": [
+ "### \u25b6 How not to use `is` operator\n",
+ "The following is a very famous example present all over the internet.\n",
+ "\n",
+ "1\\.\n",
+ "\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": [
+ "a = 256\n",
+ "b = 256\n",
+ "a is b\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": [
+ "a = 257\n",
+ "b = 257\n",
+ "a is b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "2\\.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "False\n",
+ "\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a = []\n",
+ "b = []\n",
+ "a is 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": [
+ "a = tuple()\n",
+ "b = tuple()\n",
+ "a is b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "3\\.\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": [
+ "a, b = 257, 257\n",
+ "a is b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python 3.7.x specifically)**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ">> a is b\n",
+ "False\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a, b = 257, 257\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "**The difference between `is` and `==`**\n",
+ "\n",
+ "* `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).\n",
+ "* `==` operator compares the values of both the operands and checks if they are the same.\n",
+ "* So `is` is for reference equality and `==` is for value equality. An example to clear things up,\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": [
+ " class A: pass\n",
+ " A() is A() # These are two empty objects at two different memory locations.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**`256` is an existing object but `257` isn't**\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Quoting from https://docs.python.org/3/c-api/long.html\n",
+ "> 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. :-)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10922528\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(256)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10922528\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a = 256\n",
+ "b = 256\n",
+ "id(a)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10922528\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(b)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140084850247312\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(257)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140084850247440\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "x = 257\n",
+ "y = 257\n",
+ "id(x)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140084850247344\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(y)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "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.\n",
+ "\n",
+ "Similar optimization applies to other **immutable** objects like empty tuples as well. Since lists are mutable, that's why `[] is []` will return `False` and `() is ()` will return `True`. This explains our second snippet. Let's move on to the third one, \n",
+ "\n",
+ "**Both `a` and `b` refer to the same object when initialized with same value in the same line.**\n",
+ "\n",
+ "**Output**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140640774013296\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a, b = 257, 257\n",
+ "id(a)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140640774013296\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(b)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140640774013392\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "a = 257\n",
+ "b = 257\n",
+ "id(a)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "140640774013488\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "id(b)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "* 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.\n",
+ "\n",
+ "* It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a `.py` file, you would not see the same behavior, because the file is compiled all at once. This optimization is not limited to integers, it works for other immutable data types like strings (check the \"Strings are tricky example\") and floats as well,\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": [
+ " a, b = 257.0, 257.0\n",
+ " a is b\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "* Why didn't this work for Python 3.7? The abstract reason is because such compiler optimizations are implementation specific (i.e. may change with version, OS, etc). I'm still figuring out what exact implementation change cause the issue, you can check out this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for updates.\n",
+ "\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 \"![\"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",
+ "![\"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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[['X', '', ''], ['', '', ''], ['', '', '']]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "board = [['']*3 for _ in range(3)]\n",
+ "board[0][0] = \"X\"\n",
+ "board\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Schr\u00f6dinger's variable *\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "funcs = []\n",
+ "results = []\n",
+ "for x in range(7):\n",
+ " def some_func():\n",
+ " return x\n",
+ " funcs.append(some_func)\n",
+ " results.append(some_func()) # note the function call here\n",
+ "\n",
+ "funcs_results = [func() for func in funcs]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output (Python version):**\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 1, 2, 3, 4, 5, 6]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "results\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[6, 6, 6, 6, 6, 6, 6]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "funcs_results\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "powers_of_x = [lambda x: x**i for i in range(10)]\n",
+ "[f(2) for f in powers_of_x]\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \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",
+ "* 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"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": []
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "funcs = []\n",
+ "for x in range(7):\n",
+ " def some_func(x=x):\n",
+ " return x\n",
+ " funcs.append(some_func)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "**Output:**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 1, 2, 3, 4, 5, 6]\n"
+ ]
+ },
+ "output_type": "execute_result",
+ "metadata": {},
+ "execution_count": null
+ }
+ ],
+ "source": [
+ "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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 The chicken-egg problem *\n",
+ "1\\.\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": [
+ "isinstance(3, int)\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": [
+ "isinstance(type, object)\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": [
+ "isinstance(object, type)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "So which is the \"ultimate\" base class? There's more to the confusion by the way,\n",
+ "\n",
+ "2\\. \n",
+ "\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": [
+ "class A: pass\n",
+ "isinstance(A, A)\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": [
+ "isinstance(type, type)\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": [
+ "isinstance(object, object)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "3\\.\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": [
+ "issubclass(int, object)\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": [
+ "issubclass(type, object)\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": [
+ "issubclass(object, type)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation\n",
+ "\n",
+ "- `type` is a [metaclass](https://realpython.com/python-metaclasses/) in Python.\n",
+ "- **Everything** is an `object` in Python, which includes classes as well as their objects (instances).\n",
+ "- class `type` is the metaclass of class `object`, and every class (including `type`) has inherited directly or indirectly from `object`.\n",
+ "- There is no real base class among `object` and `type`. The confusion in the above snippets is arising because we're thinking about these relationships (`issubclass` and `isinstance`) in terms of Python classes. The relationship between `object` and `type` can't be reproduced in pure python. To be more precise the following relationships can't be reproduced in pure Python,\n",
+ " + class A is an instance of class B, and class B is an instance of class A.\n",
+ " + class A is an instance of itself.\n",
+ "- These relationships between `object` and `type` (both being instances of each other as well as themselves) exist in Python because of \"cheating\" at the implementation level.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### \u25b6 Subclass relationships\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": [
+ "from collections import Hashable\n",
+ "issubclass(list, object)\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": [
+ "issubclass(object, Hashable)\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": [
+ "issubclass(list, Hashable)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "The Subclass relationships were expected to be transitive, right? (i.e., if `A` is a subclass of `B`, and `B` is a subclass of `C`, the `A` _should_ a subclass of `C`)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### \ud83d\udca1 Explanation:\n",
+ "\n",
+ "* Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary `__subclasscheck__` in a metaclass.\n",
+ "* When `issubclass(cls, Hashable)` is called, it simply looks for non-Falsey \"`__hash__`\" method in `cls` or anything it inherits from.\n",
+ "* Since `object` is hashable, but `list` is non-hashable, it breaks the transitivity relation.\n",
+ "* More detailed explanation can be found [here](https://www.naftaliharris.com/blog/python-subclass-intransitivity/).\n",
+ "\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": [
+ "