From d7477885b863dc8194ac65eefed49a7c22dfd43d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Wed, 5 Dec 2018 04:16:32 +0530
Subject: [PATCH 001/146] Update broken link

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index d9b9563..855e2ac 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ While some of the examples you see below may not be WTFs in the truest sense, bu
 
 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/).
+PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).
 
 So, here we go...
 
@@ -2358,7 +2358,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * 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.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
 
 # 🎓 License
 
@@ -2373,9 +2373,9 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 If you have any wtfs, ideas or suggestions, please share.
 
-## Want to surprise your geeky pythonist friends?
+## Surprise your geeky pythonist friends?
 
-You can recommend wtfpython to your friends on Twitter and Linkedin by using these quick links,
+You can use these quick links to recommend wtfpython to your friends,
 
 [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.)

From b0e7a816ec356197699d8c4d799d7c86457dbbaf Mon Sep 17 00:00:00 2001
From: Hannes <kannes@users.noreply.github.com>
Date: Wed, 5 Dec 2018 20:45:59 +0100
Subject: [PATCH 002/146] make the function *call* more visible (#104)

It is easy to overlook the () in that appending operation, I propose adding a short comment.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 855e2ac..9049fdb 100644
--- a/README.md
+++ b/README.md
@@ -555,7 +555,7 @@ 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]
 ```

From 9c5f26e7588e561a716a93165a5696356c179715 Mon Sep 17 00:00:00 2001
From: Hannes <kannes@users.noreply.github.com>
Date: Wed, 5 Dec 2018 20:50:17 +0100
Subject: [PATCH 003/146] match order of display to if/else order (#105)

I was WTFing for way too long until I realised that the results were displayed in opposite order of the if/else statement.
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 9049fdb..79820a0 100644
--- a/README.md
+++ b/README.md
@@ -774,10 +774,10 @@ for item in mixed_list:
 
 **Output:**
 ```py
->>> booleans_found_so_far
-0
 >>> integers_found_so_far
 4
+>>> booleans_found_so_far
+0
 ```
 
 2\.

From 64b310953a58ddcb3dc65173d1d4fafdc18c8d49 Mon Sep 17 00:00:00 2001
From: 1f604 <1f604@users.noreply.github.com>
Date: Thu, 6 Dec 2018 18:54:45 +0000
Subject: [PATCH 004/146] fix typo (#107)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 79820a0..d59943d 100644
--- a/README.md
+++ b/README.md
@@ -838,7 +838,7 @@ class C(A):
     pass
 ```
 
-**Ouptut:**
+**Output:**
 ```py
 >>> A.x, B.x, C.x
 (1, 1, 1)

From 30e05a5973930c38cdb59f1c02b85b19b22ac531 Mon Sep 17 00:00:00 2001
From: kyblockstacking <40349734+kyblockstacking@users.noreply.github.com>
Date: Sun, 9 Dec 2018 06:53:28 -0800
Subject: [PATCH 005/146] Rephrase sentence to make more sense (#109)

---
 CONTRIBUTORS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 142de18..7f672ac 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -11,4 +11,4 @@ I'm really grateful to all the contributors. Following are the wonderful people
 | 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) |
 
-Thank you all for taking out time, and helping to make this project awesome! :smile:
+Thank you all for taking out the time to make this project more awesome! :smile:

From b262f2975641da1493853a390a171a051f561914 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 16 Dec 2018 16:23:39 +0530
Subject: [PATCH 006/146] Add reference to chinese translation

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index d59943d..9827fc4 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@
 
 [![WTFPL 2.0][license-image]][license-url]
 
+Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
 
 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.
 

From 54883f5134896870436f716b849e935a23e23340 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 31 Mar 2019 19:08:19 +0530
Subject: [PATCH 007/146] Use http instead of https

This will avoid CERTIFICATE_VERIFY_FAILED errors due to SSL.
---
 wtfpython-pypi/wtf_python/main.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wtfpython-pypi/wtf_python/main.py b/wtfpython-pypi/wtf_python/main.py
index 73de9b8..621995a 100644
--- a/wtfpython-pypi/wtf_python/main.py
+++ b/wtfpython-pypi/wtf_python/main.py
@@ -4,7 +4,7 @@ try:
 except ImportError:
     from urllib import urlretrieve
 
-url = ("https://raw.githubusercontent.com/satwikkansal/"
+url = ("http://raw.githubusercontent.com/satwikkansal/"
        "wtfpython/master/README.md")
 file_name = "content.md"
 

From 596186d81c82cfef0290d28cd2ddb227e916a306 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Wed, 1 May 2019 19:12:17 +0530
Subject: [PATCH 008/146] Add json generator

---
 irrelevant/json_generator.py | 156 +++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 irrelevant/json_generator.py

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
new file mode 100644
index 0000000..86820f1
--- /dev/null
+++ b/irrelevant/json_generator.py
@@ -0,0 +1,156 @@
+import pprint
+fname = "/Users/300041709/code/self/wtfpython/README.md"
+examples = []
+
+# The globals
+current_example = 1
+current_section_name = ""
+
+
+def parse_example_parts(lines):
+    parts = {
+        "build_up": [],
+        "explanation": []
+    }
+    next_line = next(lines)
+    sequence_num = 1
+    content = []
+    # store build_up till an H4 (explanation) is encountered
+    while not next_line.startswith("#### "):
+        # Watching out for the snippets
+        if next_line.startswith("```"):
+            # It's a snippet, whatever found until now is text
+            if content:
+                parts["build_up"].append(
+                    {
+                        "type": "text",
+                        "sequence_num": sequence_num,
+                        "value": content
+                    }
+                )
+                sequence_num += 1
+                content = []
+
+            next_line = next(lines)
+            while not next_line.startswith("```"):
+                content.append(next_line)
+                next_line = next(lines)
+            # Snippet is over
+            parts["build_up"].append(
+                {
+                    "type": "code",
+                    "sequence_num": sequence_num,
+                    "value": content
+                }
+            )
+            sequence_num += 1
+            content = []
+            next_line = next(lines)
+            continue
+        else:
+            # It's a text, go on.
+            content.append(next_line)
+            next_line = next(lines)
+
+    # Explanation encountered, save any content till now (if any)
+    if content:
+        parts["build_up"].append(
+            {
+                "type": "text",
+                "sequence_num": sequence_num,
+                "value": content
+            }
+        )
+
+    # Reset stuff
+    sequence_num = 1
+    content = []
+
+    # store lines again until --- or another H3 is encountered
+    while not (next_line.startswith("---") or
+               next_line.startswith("### ")):
+
+        if next_line.startswith("```"):
+            # It's a snippet, whatever found until now is text
+            if content:
+                parts["explanation"].append(
+                    {
+                        "type": "text",
+                        "sequence_num": sequence_num,
+                        "value": content
+                    }
+                )
+                sequence_num += 1
+                content = []
+
+            next_line = next(lines)
+            while not next_line.startswith("```"):
+                content.append(next_line)
+                next_line = next(lines)
+            # Snippet is over
+            parts["explanation"].append(
+                {
+                    "type": "code",
+                    "sequence_num": sequence_num,
+                    "value": content
+                }
+            )
+            sequence_num += 1
+            content = []
+            next_line = next(lines)
+            continue
+        else:
+            # It's a text, go on.
+            content.append(next_line)
+            next_line = next(lines)
+
+    # All done
+    if content:
+        parts["explanation"].append(
+            {
+                "type": "text",
+                "sequence_num": sequence_num,
+                "value": content
+            }
+        )
+
+    return next_line, parts
+
+
+with open(fname, 'r+', encoding="utf-8") as f:
+    lines = iter(f.readlines())
+    line = next(lines)
+    result = []
+    try:
+        while True:
+            if line.startswith("## "):
+                # A section is encountered
+                current_section_name = line.replace("## ", "").strip()
+                line = next(lines)
+                # Until a new section is encountered
+                while not (line.startswith("## " )):
+                    # check if it's a H3
+                    if line.startswith("### "):
+                        # An example is encountered
+                        title = line.replace("### ", "")
+                        example_details = {
+                            "id": current_example,
+                            "title": line.replace("### ", ""),
+                            "section": current_section_name
+                        }
+                        line, example_details["parts"] = parse_example_parts(lines)
+                        result.append(example_details)
+                        current_example += 1
+                    else:
+                        # todo catch section text
+                        line = next(lines)
+            else:
+                line = next(lines)
+
+    except StopIteration:
+        pprint.pprint(result, indent=2)
+        print(len(result))
+
+
+
+

From c475cbfe826f2b65d3674f3acf724f14f97c50dc Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Wed, 1 May 2019 19:55:46 +0530
Subject: [PATCH 009/146] Use absolute path for the pager.

Fixes https://github.com/satwikkansal/wtfpython/issues/119
---
 wtfpython-pypi/wtf_python/main.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/wtfpython-pypi/wtf_python/main.py b/wtfpython-pypi/wtf_python/main.py
index 73de9b8..b8bfdce 100644
--- a/wtfpython-pypi/wtf_python/main.py
+++ b/wtfpython-pypi/wtf_python/main.py
@@ -1,3 +1,5 @@
+from os.path import dirname, join, realpath
+
 import pydoc
 try:
     from urllib.request import urlretrieve
@@ -6,13 +8,14 @@ except ImportError:
 
 url = ("https://raw.githubusercontent.com/satwikkansal/"
        "wtfpython/master/README.md")
-file_name = "content.md"
+
+file_path = join(dirname(dirname(realpath(__file__))), "content.md")
 
 
 def fetch_updated_doc():
     try:
         print("Fetching the latest version...")
-        urlretrieve(url, file_name)
+        urlretrieve(url, file_path)
         print("Done!")
     except Exception as e:
         print(e)
@@ -21,7 +24,7 @@ def fetch_updated_doc():
 
 
 def render_doc():
-    with open(file_name, 'r') as f:
+    with open(file_path, 'r', encoding="utf-8") as f:
         content = f.read()
         pydoc.pager(content)
 

From 5c8c4c58439dd2ce020c536343b2b4460ce3cd02 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 6 May 2019 23:47:24 +0530
Subject: [PATCH 010/146] Get the generator in a working state

---
 irrelevant/json_generator.py | 239 +++++++++++++++++++++++++----------
 1 file changed, 175 insertions(+), 64 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index 86820f1..ea75cb5 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -1,52 +1,85 @@
+import json
 import pprint
 fname = "/Users/300041709/code/self/wtfpython/README.md"
 examples = []
 
 # The globals
 current_example = 1
+sequence_num = 1
 current_section_name = ""
 
 
-def parse_example_parts(lines):
+STATEMENT_PREFIXES = ["...", ">>> ", "$ "]
+
+
+def generate_code_block(statements, output):
+    global sequence_num
+    result = {
+        "type": "code",
+        "sequence_num": sequence_num,
+        "statements": statements,
+        "output": output
+    }
+    sequence_num += 1
+    return result
+
+
+def generate_markdown_block(lines):
+    global sequence_num
+    result = {
+        "type": "markdown",
+        "sequence_num": sequence_num,
+        "value": lines
+    }
+    sequence_num += 1
+    return result
+
+def is_interactive_statement(line):
+    for prefix in STATEMENT_PREFIXES:
+        if line.startswith(prefix):
+            return True
+    return False
+
+def parse_example_parts(lines, example_title_line):
     parts = {
         "build_up": [],
         "explanation": []
     }
-    next_line = next(lines)
-    sequence_num = 1
     content = []
+    statements_so_far = []
+    output_so_far = []
+    next_line = example_title_line
     # store build_up till an H4 (explanation) is encountered
     while not next_line.startswith("#### "):
         # Watching out for the snippets
         if next_line.startswith("```"):
             # It's a snippet, whatever found until now is text
+            is_interactive = False
             if content:
-                parts["build_up"].append(
-                    {
-                        "type": "text",
-                        "sequence_num": sequence_num,
-                        "value": content
-                    }
-                )
-                sequence_num += 1
+                parts["build_up"].append(generate_markdown_block(content))
                 content = []
 
             next_line = next(lines)
+
             while not next_line.startswith("```"):
-                content.append(next_line)
+                if is_interactive_statement(next_line):
+                    is_interactive = True
+                    if (output_so_far):
+                        parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+                        statements_so_far, output_so_far = [], []
+                    statements_so_far.append(next_line)
+                else:
+                    # can be either output or normal code
+                    if is_interactive:
+                        output_so_far.append(next_line)
+                    else:
+                        statements_so_far.append(next_line)
                 next_line = next(lines)
+
             # Snippet is over
-            parts["build_up"].append(
-                {
-                    "type": "code",
-                    "sequence_num": sequence_num,
-                    "value": content
-                }
-            )
-            sequence_num += 1
-            content = []
+            parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+            statements_so_far, output_so_far = [], []
             next_line = next(lines)
-            continue
         else:
             # It's a text, go on.
             content.append(next_line)
@@ -54,51 +87,43 @@ def parse_example_parts(lines):
 
     # Explanation encountered, save any content till now (if any)
     if content:
-        parts["build_up"].append(
-            {
-                "type": "text",
-                "sequence_num": sequence_num,
-                "value": content
-            }
-        )
+        parts["build_up"].append(generate_markdown_block(content))
 
     # Reset stuff
-    sequence_num = 1
     content = []
+    statements_so_far, output_so_far = [], []
 
     # store lines again until --- or another H3 is encountered
     while not (next_line.startswith("---") or
                next_line.startswith("### ")):
-
         if next_line.startswith("```"):
             # It's a snippet, whatever found until now is text
+            is_interactive = False
             if content:
-                parts["explanation"].append(
-                    {
-                        "type": "text",
-                        "sequence_num": sequence_num,
-                        "value": content
-                    }
-                )
-                sequence_num += 1
+                parts["build_up"].append(generate_markdown_block(content))
                 content = []
 
             next_line = next(lines)
+
             while not next_line.startswith("```"):
-                content.append(next_line)
+                if is_interactive_statement(next_line):
+                    is_interactive = True
+                    if (output_so_far):
+                        parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+                        statements_so_far, output_so_far = [], []
+                    statements_so_far.append(next_line)
+                else:
+                    # can be either output or normal code
+                    if is_interactive:
+                        output_so_far.append(next_line)
+                    else:
+                        statements_so_far.append(next_line)
                 next_line = next(lines)
+
             # Snippet is over
-            parts["explanation"].append(
-                {
-                    "type": "code",
-                    "sequence_num": sequence_num,
-                    "value": content
-                }
-            )
-            sequence_num += 1
-            content = []
+            parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+            statements_so_far, output_so_far = [], []
             next_line = next(lines)
-            continue
         else:
             # It's a text, go on.
             content.append(next_line)
@@ -106,16 +131,105 @@ def parse_example_parts(lines):
 
     # All done
     if content:
-        parts["explanation"].append(
-            {
-                "type": "text",
-                "sequence_num": sequence_num,
-                "value": content
-            }
-        )
+        parts["explanation"].append(generate_markdown_block(content))
 
     return next_line, parts
 
+def remove_from_beginning(tokens, line):
+    for token in tokens:
+        if line.startswith(token):
+            line = line.replace(token, "")
+    return line
+
+
+def inspect_and_sanitize_code_lines(lines):
+    tokens_to_remove = STATEMENT_PREFIXES
+    result = []
+    is_print_present = False
+    for line in lines:
+        line = remove_from_beginning(tokens_to_remove, line)
+        if line.startswith("print ") or line.startswith("print("):
+            is_print_present = True
+        result.append(line)
+    return is_print_present, result
+
+def convert_to_cells(cell_contents):
+    cells = []
+    for stuff in cell_contents:
+        if stuff["type"] == "markdown":
+            # todo add metadata later
+            cells.append(
+                {
+                    "cell_type": "markdown",
+                    "metadata": {},
+                    "source": stuff["value"]
+                }
+            )
+        elif stuff["type"] == "code":
+            is_print_present, sanitized_code = inspect_and_sanitize_code_lines(stuff["statements"])
+            if is_print_present:
+                cells.append(
+                    {
+                        "cell_type": "code",
+                        "metadata": {
+                            "collapsed": True
+                        },
+                        "execution_count": None,
+                        "outputs": [{
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": stuff["output"]
+                        }],
+                        "source": sanitized_code
+                    }
+                )
+            else:
+                cells.append(
+                    {
+                        "cell_type": "code",
+                        "execution_count": None,
+                        "metadata": {
+                            "collapsed": True
+                        },
+                        "outputs": [{
+                            "data": {
+                                "text/plain": stuff["output"]
+                            },
+                            "output_type": "execute_result",
+                            "metadata": {},
+                            "execution_count": None
+                        }],
+                        "source": sanitized_code
+                    }
+                )
+
+    return cells
+
+
+def convert_to_notebook(parsed_json):
+    result = {
+        "cells": [],
+        "metadata": {},
+        "nbformat": 4,
+        "nbformat_minor": 2
+    }
+    for example in parsed_json:
+        parts = example["parts"]
+        build_up = parts.get("build_up")
+        explanation = parts.get("explanation")
+        notebook_path = "test.ipynb"
+
+        if(build_up):
+            result["cells"] += convert_to_cells(build_up)
+
+        if(explanation):
+            result["cells"] += convert_to_cells(explanation)
+
+    pprint.pprint(result, indent=2)
+    with open(notebook_path, "w") as f:
+        json.dump(result, f)
+
+
 
 with open(fname, 'r+', encoding="utf-8") as f:
     lines = iter(f.readlines())
@@ -126,6 +240,7 @@ with open(fname, 'r+', encoding="utf-8") as f:
             if line.startswith("## "):
                 # A section is encountered
                 current_section_name = line.replace("## ", "").strip()
+                section_text = []
                 line = next(lines)
                 # Until a new section is encountered
                 while not (line.startswith("## " )):
@@ -138,19 +253,15 @@ with open(fname, 'r+', encoding="utf-8") as f:
                             "title": line.replace("### ", ""),
                             "section": current_section_name
                         }
-                        line, example_details["parts"] = parse_example_parts(lines)
+                        line, example_details["parts"] = parse_example_parts(lines, line)
                         result.append(example_details)
                         current_example += 1
                     else:
-                        # todo catch section text
+                        section_text.append(line)
                         line = next(lines)
             else:
                 line = next(lines)
 
     except StopIteration:
         pprint.pprint(result, indent=2)
-        print(len(result))
-
-
-
-
+        convert_to_notebook(result)

From 45bec627d1511690fa7f1b5623860da94bb74822 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 6 May 2019 23:49:57 +0530
Subject: [PATCH 011/146] Add todos

---
 irrelevant/json_generator.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index ea75cb5..cfebf4f 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -1,3 +1,15 @@
+"""
+An inefficient monolithic piece of code that'll generate jupyter notebook
+from the projects main README.
+
+TODO
+
+- CLI arguments for running this thing.
+- Add it to prepush hook
+- Use templates?
+
+"""
+
 import json
 import pprint
 fname = "/Users/300041709/code/self/wtfpython/README.md"

From 31dcd9b0629f61e6f577c76c31addaf55609109c Mon Sep 17 00:00:00 2001
From: hippie <hippieZhou@outlook.com>
Date: Fri, 7 Jun 2019 02:15:34 +0800
Subject: [PATCH 012/146] add encoding (#122)

if not set encoding attr,there maybe have some exceptions when open reading.
---
 wtfpython-pypi/wtf_python/main.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wtfpython-pypi/wtf_python/main.py b/wtfpython-pypi/wtf_python/main.py
index 621995a..5799178 100644
--- a/wtfpython-pypi/wtf_python/main.py
+++ b/wtfpython-pypi/wtf_python/main.py
@@ -21,7 +21,7 @@ def fetch_updated_doc():
 
 
 def render_doc():
-    with open(file_name, 'r') as f:
+    with open(file_name, 'r', encoding='utf-8') as f:
         content = f.read()
         pydoc.pager(content)
 

From f03f7dcad956c941e9f9d9247f50e8ffde98e013 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Fri, 7 Jun 2019 23:48:07 +0530
Subject: [PATCH 013/146] Some hideous typora corrections and a new snippets
 added

Also closes https://github.com/satwikkansal/wtfpython/issues/73
---
 README.md | 55 +++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 47 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 8f116bd..d4de4d7 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<p align="center"><img src="/images/logo.png" alt=""></p>
+<p align="center"><img src="images/logo.png" alt=""></p>
 <h1 align="center">What the f*ck Python! 🐍</h1>
 <p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
 
@@ -201,11 +201,10 @@ Makes sense, right?
   * All length 0 and length 1 strings are interned.
   * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)
   * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. Cpython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
-  <img src="/images/string-intern/string_intern.png" alt="">
+  <img src="images/string-intern/string_intern.png" alt="">
 + When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
 + Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 
-
 ---
 
 ### ▶ Time for some hash brownies!
@@ -246,7 +245,7 @@ some_dict[5] = "Python"
 
 ---
 
-### ▶ Return return everywhere!
+### ▶ Keep trying? *
 
 ```py
 def some_func():
@@ -254,18 +253,55 @@ def some_func():
         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 ocurred", e)
 ```
 
 **Output:**
+
 ```py
 >>> some_func()
 'from_finally'
+
+>>> another_func()
+Finally!
+Finally!
+Finally!
+
+>>> 1 / 0
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ZeroDivisionError: division by zero
+
+>>> one_more_func()
+Iteration 0
+
 ```
 
 #### 💡 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.
 
 ---
 
@@ -529,11 +565,11 @@ We didn't assign 3 "X"s or did we?
 
 When we initialize `row` variable, this visualization explains what happens in the memory
 
-![image](/images/tic-tac-toe/after_row_initialized.png)
+![image](images/tic-tac-toe/after_row_initialized.png)
 
 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`)
 
-![image](/images/tic-tac-toe/after_board_initialized.png)
+![image](images/tic-tac-toe/after_board_initialized.png)
 
 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).
 
@@ -1183,8 +1219,9 @@ a, b = a[b] = {}, 5
   (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.
-
+  
+> 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`.
@@ -1318,6 +1355,7 @@ Shouldn't that be 100?
 
 * **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.
@@ -1978,6 +2016,7 @@ 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/).
 

From 3806284f78b1631fb693bd828c55b9ed4885c5cc Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Fri, 7 Jun 2019 23:48:51 +0530
Subject: [PATCH 014/146] Update content.md

---
 wtfpython-pypi/content.md | 79 ++++++++++++++++++++++-----------------
 1 file changed, 44 insertions(+), 35 deletions(-)

diff --git a/wtfpython-pypi/content.md b/wtfpython-pypi/content.md
index 486a98e..9827fc4 100644
--- a/wtfpython-pypi/content.md
+++ b/wtfpython-pypi/content.md
@@ -1,9 +1,10 @@
 <p align="center"><img src="/images/logo.png" alt=""></p>
-<h1 align="center"> What the f*ck Python! 🐍 </h1>
-<p align="center"> An interesting collection of surprising snippets and lesser-known Python features.</p>
+<h1 align="center">What the f*ck Python! 🐍</h1>
+<p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
 
 [![WTFPL 2.0][license-image]][license-url]
 
+Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
 
 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.
 
@@ -13,7 +14,7 @@ While some of the examples you see below may not be WTFs in the truest sense, bu
 
 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/).
+PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).
 
 So, here we go...
 
@@ -77,7 +78,7 @@ So, here we go...
     - [▶ Yes, it exists!](#-yes-it-exists)
     - [▶ Inpinity *](#-inpinity-)
     - [▶ Mangling time! *](#-mangling-time-)
-  - [Section: Miscallaneous](#section-miscallaneous)
+  - [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)
@@ -97,22 +98,22 @@ 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)
@@ -200,10 +201,10 @@ Makes sense, right?
 + 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 `!`.
+  * 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)
   <img src="/images/string-intern/string_intern.png" alt="">
 + When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. But since the python bytecode generated after compilation is stored in `.pyc` files, the strings greater than length of 20 are discarded for peephole optimization (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`)
++ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 
 
 ---
@@ -241,7 +242,7 @@ some_dict[5] = "Python"
   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`.
+* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
 * This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
 
 ---
@@ -296,16 +297,24 @@ True
 * 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 ")
+    def __init__(self): print("I")
+    def __del__(self): print("D")
   ```
 
   **Output:**
   ```py
   >>> WTF() is WTF()
-  I I D D
+  I
+  I
+  D
+  D
+  False
   >>> id(WTF()) == id(WTF())
-  I D I D
+  I
+  D
+  I
+  D
+  True
   ```
   As you may observe, the order in which the objects are destroyed is what made all the difference here.
 
@@ -530,7 +539,7 @@ And when the `board` is initialized by multiplying the `row`, this is what happe
 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)*3] # board = = [['']*3 for _ in range(3)]
+>>> board = [['']*3 for _ in range(3)]
 >>> board[0][0] = "X"
 >>> board
 [['X', '', ''], ['', '', ''], ['', '', '']]
@@ -547,7 +556,7 @@ 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]
 ```
@@ -766,10 +775,10 @@ for item in mixed_list:
 
 **Output:**
 ```py
->>> booleans_found_so_far
-0
 >>> integers_found_so_far
 4
+>>> booleans_found_so_far
+0
 ```
 
 2\.
@@ -830,7 +839,7 @@ class C(A):
     pass
 ```
 
-**Ouptut:**
+**Output:**
 ```py
 >>> A.x, B.x, C.x
 (1, 1, 1)
@@ -1135,7 +1144,7 @@ str
             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__
@@ -1148,7 +1157,7 @@ str
   >>> s = SomeClass('s')
   >>> some_dict[s] = 40
   >>> some_dict
-  {'s': 40}
+  {'s': 40, 's': 42}
   >>> keys = list(some_dict.keys())
   >>> type(keys[0]), type(keys[1])
   (__main__.SomeClass, str)
@@ -1313,7 +1322,7 @@ Shouldn't that be 100?
   > 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
@@ -1697,7 +1706,7 @@ a += [5, 6, 7, 8]
 
 * The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.
 
-* The expression `a + =[5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.
+* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.
 
 ---
 
@@ -1731,7 +1740,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
       a += 1
       return a
   ```
-  
+
   **Output:**
   ```py
   >>> another_func()
@@ -1895,7 +1904,7 @@ 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/).
++ 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/).
 
 ---
 
@@ -2115,7 +2124,7 @@ AttributeError: 'Yo' object has no attribute '__honey'
 True
 ```
 
-Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
+Why did `Yo()._Yo__honey` work? Only Indian readers would understand.
 
 #### 💡 Explanation:
 
@@ -2127,7 +2136,7 @@ Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
 
 ---
 
-## Section: Miscallaneous
+## Section: Miscellaneous
 
 
 ### ▶ `+=` is faster
@@ -2272,7 +2281,7 @@ nan
 ### ▶ 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.
 
@@ -2350,7 +2359,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * 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.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
 
 # 🎓 License
 
@@ -2365,12 +2374,12 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 If you have any wtfs, ideas or suggestions, please share.
 
-## Want to share wtfpython with friends?
+## Surprise your geeky pythonist friends?
 
-You can use these quick links for Twitter and Linkedin.
+You can use these quick links to recommend wtfpython to your friends,
 
-[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&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.)
 
 ## Need a pdf version?
 

From bc68ae0ff32480c715f08800ece3bd0d709be912 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 00:23:33 +0530
Subject: [PATCH 015/146] Update evaluation time discrepency example: Add
 another snippet

Resolves https://github.com/satwikkansal/wtfpython/issues/41
---
 README.md | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d4de4d7..116032d 100644
--- a/README.md
+++ b/README.md
@@ -408,7 +408,7 @@ for i, some_dict[i] in enumerate(some_string):
 
 ---
 
-### ▶ Evaluation time discrepancy
+### ▶ Evaluation time discrepancy ^
 
 1\.
 ```py
@@ -444,6 +444,23 @@ array_2[:] = [1,2,3,4,5]
 [1,2,3,4,5]
 ```
 
+3\.
+
+```py
+array_3 = [1, 2, 3]
+array_4 = [10, 20, 30]
+g = (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(g))
+[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.
@@ -451,6 +468,9 @@ array_2[:] = [1,2,3,4,5]
 - The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.
 - In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
 - In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
+- 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)
+    > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
+ 
 
 ---
 
@@ -1221,7 +1241,7 @@ a, b = a[b] = {}, 5
   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`.

From e0cb30bf3be6cd0e9988a0530536f239dfc9d6a7 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 00:41:58 +0530
Subject: [PATCH 016/146] Modifying a dictionary while iterating over it: Add
 note

Resolves https://github.com/satwikkansal/wtfpython/issues/53
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 116032d..8378981 100644
--- a/README.md
+++ b/README.md
@@ -469,8 +469,8 @@ array_4 = [400, 500, 600]
 - In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
 - In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
 - 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)
+    
     > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
- 
 
 ---
 
@@ -1423,7 +1423,7 @@ Yes, it runs for exactly **eight** times and stops.
 * Iteration over a dictionary that you edit at the same time is not supported.
 * It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
 * How deleted keys are handled and when the resize occurs might be different for different Python implementations.
-* 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.
+* 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.
 
 ---
 

From 092dd096bfc8cf9ceebef444597958ee5f4c0b98 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 02:53:53 +0530
Subject: [PATCH 017/146] Expand strings and backslashes

Resolves https://github.com/satwikkansal/wtfpython/issues/69
---
 README.md | 51 ++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/README.md b/README.md
index 8378981..05bbe15 100644
--- a/README.md
+++ b/README.md
@@ -469,7 +469,7 @@ array_4 = [400, 500, 600]
 - In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
 - In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
 - 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)
-    
+  
     > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
 
 ---
@@ -702,30 +702,47 @@ SyntaxError: invalid syntax
 
 ---
 
-### ▶ Backslashes at the end of string
+### ▶ Strings and the backslashes\
 
 **Output:**
-```
->>> print("\\ C:\\")
-\ C:\
->>> print(r"\ C:")
-\ C:
->>> print(r"\ C:\")
+```py
+>>> print("\"")
+"
 
-    File "<stdin>", line 1
-      print(r"\ C:\")
-                     ^
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "<stdin>", 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.
-  ```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.
+- In a normal python string, the backslash is used to escape characters that may have special meaning (like single-quote, double-quote and the backslash itself).
+    ```py
+    >>> 'wt\"f'
+    'wt"f'
+    ```
+- In a raw string literal (as indicated by the prefix `r`),  the backslashes pass themselves as is along with the behavior of escaping the following character.
+    ```py
+    >>> r'wt\"f' == 'wt\\"f'
+    True
+    >>> print(repr(r'wt\"f')
+    'wt\\"f'
+
+    >>> print("\n")
+
+
+    >>> print(r"\\n")
+    '\\\\n'
+    ```
+- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string.
 
 ---
 

From c52919b9ec6b3c945b30730a786af15ad9507ca3 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 14:21:19 +0530
Subject: [PATCH 018/146] Add new snippet: Splitsies

Resolves https://github.com/satwikkansal/wtfpython/issues/80
---
 README.md | 40 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 05bbe15..2947bb7 100644
--- a/README.md
+++ b/README.md
@@ -207,6 +207,44 @@ Makes sense, right?
 
 ---
 
+### ▶ Splitsies ^
+
+```py
+>>> 'a'.split()
+['a']
+
+# is same as
+>>> 'a'.split(' ')
+['a']
+
+# but
+>>> len(''.split())
+0
+
+# isn't the same as
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Explanation:
+
+- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split),
+    > If sep is not specified or is None, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
+    > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
+- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
+    ```py
+    >>> ' a '.split(' ')
+    ['', 'a', '']
+    >>> ' a '.split()
+    ['a']
+    >>> ''.split(' ')
+    ['']
+    ```
+
+---
+
+
+
 ### ▶ Time for some hash brownies!
 
 1\.
@@ -702,7 +740,7 @@ SyntaxError: invalid syntax
 
 ---
 
-### ▶ Strings and the backslashes\
+### ▶ Strings and the backslashes\ ^
 
 **Output:**
 ```py

From a33f715b2620e60d1ae2a15c998e907e8d5e4d17 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 14:49:59 +0530
Subject: [PATCH 019/146] Let's meet Friendly Language Uncle For Life: Add
 notes for non-interactive evn

Resolves https://github.com/satwikkansal/wtfpython/issues/94
---
 README.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2947bb7..dc6fd7f 100644
--- a/README.md
+++ b/README.md
@@ -2071,7 +2071,7 @@ Braces? No way! If you think that's disappointing, use Java.
 
 ---
 
-### ▶ Let's meet Friendly Language Uncle For Life *
+### ▶ Let's meet Friendly Language Uncle For Life ^
 
 **Output (Python 3.x)**
 ```py
@@ -2094,6 +2094,11 @@ There we go.
   
   > 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 on 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"'))
+    ```
 
 ---
 

From 85352fc45d80f20d46fc4d6cb5a0cea483408089 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 16:30:53 +0530
Subject: [PATCH 020/146] Add example: Ellipsis

Resolves https://github.com/satwikkansal/wtfpython/issues/96
---
 README.md | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/README.md b/README.md
index dc6fd7f..e32e1ce 100644
--- a/README.md
+++ b/README.md
@@ -2203,6 +2203,66 @@ Try block executed successfully...
 - `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.
 
 ---
+### ▶ Ellipsis ^
+
+```py
+def some_func():
+    Ellipsis
+```
+
+**Output**
+```py
+>>> some_func()
+# No output, No Error
+
+>>> SomeRandomString
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Explanation
+- In Python, `Ellipsis` is a globally available builtin object which is equivalent to `...`.
+    ```py
+    >>> ...
+    Ellipsis
+    ```
+- Eliipsis 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 *
 

From 72e39d3248facb57b11f01f30dee8f99cda6548d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 23:25:37 +0530
Subject: [PATCH 021/146] Update example "is is not what it is"

Related to https://github.com/satwikkansal/wtfpython/issues/100
---
 README.md | 49 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 42 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index cbe9c68..72e1ebd 100644
--- a/README.md
+++ b/README.md
@@ -180,7 +180,7 @@ True
 >>> a is b
 False
 
->>> a, b = "wtf!", "wtf!"
+>>> a = "wtf!"; b = "wtf!";
 >>> a is b
 True
 ```
@@ -513,10 +513,11 @@ array_4 = [400, 500, 600]
 
 ---
 
-### ▶ `is` is not what it is!
+### ▶ Messing around with `is` operator^
 
 The following is a very famous example present all over the internet.
 
+1\.
 ```py
 >>> a = 256
 >>> b = 256
@@ -527,6 +528,37 @@ 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 (< Python 3.7)**
+```
+>>> a, b = 257, 257
+True
+
+>>> a = 257; b = 257
+>>> a is b
+True
+```
+
+**Output (Python 3.7)**
+```
+>>> a, b = 257, 257
+False
 
 >>> a = 257; b = 257
 >>> a is b
@@ -541,9 +573,8 @@ True
 * `==` 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
   ```
 
@@ -575,8 +606,11 @@ 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 (< Python 3.7)**
 ```py
 >>> a, b = 257, 257
 >>> id(a)
@@ -593,6 +627,7 @@ Here the interpreter isn't smart enough while executing `y = 257` to recognize t
 
 * 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.
+* 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.
 
 ---
 
@@ -776,6 +811,7 @@ True
     'wt\\"f'
 
     >>> print("\n")
+    ```
 
 
     >>> print(r"\\n")
@@ -2262,8 +2298,7 @@ Ellipsis
     + 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 *
 

From 9ea7ab0c5a05cbafc41c4432293202a7836d908f Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 00:07:02 +0530
Subject: [PATCH 022/146] New example: The chicken-egg problem

Closes https://github.com/satwikkansal/wtfpython/issues/101
---
 README.md | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/README.md b/README.md
index 72e1ebd..c9b68ee 100644
--- a/README.md
+++ b/README.md
@@ -730,6 +730,54 @@ Even when the values of `x` were different in every iteration prior to appending
 
 ---
 
+### ▶ The chicken-egg problem ^
+
+1\.
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+2\. So which is the ultimate, base class? And wait, there's more to the confusion
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+
+#### 💡 Explanation
+
+- `type` is a [metaclass](https://realpython.com/python-metaclasses/) in Python.
+- **Everything** is an `object` in Python, which includes classes as well as their objects (instances).
+- class `type` is the metaclass of class `object`, and every class (including `type`) has inherited directly or indirectly from `object`.
+- There is no real base class among `object` and `type`. The confusion in the above snippets is arising because we're thinking 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 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 eachother as well as themselves) exist in Python because of "cheating" at implementation level.
+
+---
+
 ### ▶ `is not ...` is not `is (not ...)`
 
 ```py

From 2bfa6d2e5bb123a177d6c4c4c20a20ac3f822fca Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 03:59:09 +0530
Subject: [PATCH 023/146] Let's make a giant string: Use %timeit for measuring
 time

Fixes https://github.com/satwikkansal/wtfpython/issues/106
---
 README.md | 63 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 28 deletions(-)

diff --git a/README.md b/README.md
index c9b68ee..f9a22ab 100644
--- a/README.md
+++ b/README.md
@@ -2450,40 +2450,47 @@ 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 readablity 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.
   ```py
@@ -2493,10 +2500,10 @@ 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)
   ```
 
 ---

From 80a969a556f2a018941e537031367b1cca30a37a Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 17:34:50 +0530
Subject: [PATCH 024/146] Brace yourself: Add to explanation

Resolves https://github.com/satwikkansal/wtfpython/issues/114
---
 README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index f9a22ab..fbba80a 100644
--- a/README.md
+++ b/README.md
@@ -2148,11 +2148,13 @@ 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.
++ 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.
 
 ---
 

From bf967b0332ff2c5d645ab4f420f1c24a9b0702db Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 17:56:36 +0530
Subject: [PATCH 025/146] String can be tricky: Remove outdated snippet

Related to https://github.com/satwikkansal/wtfpython/issues/120
---
 README.md | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index fbba80a..71088cd 100644
--- a/README.md
+++ b/README.md
@@ -179,13 +179,12 @@ True
 >>> b = "wtf!"
 >>> a is b
 False
-
->>> a = "wtf!"; b = "wtf!";
->>> a is b
-True
 ```
 
 3\.
+
+**Output (< Python3.7 )**
+
 ```py
 >>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
 True
@@ -203,8 +202,8 @@ Makes sense, right?
   * 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)
   <img src="images/string-intern/string_intern.png" alt="">
-+ When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
 + Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
 
 ---
 

From 4d5a2f0d97d4dc348ad5f0754855268c6daa99dd Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 19:45:13 +0530
Subject: [PATCH 026/146] New example: Lossy zip of iterators

Resolves https://github.com/satwikkansal/wtfpython/issues/121
---
 README.md | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/README.md b/README.md
index 71088cd..c8de242 100644
--- a/README.md
+++ b/README.md
@@ -1251,6 +1251,55 @@ I've lost faith in truth!
 
 ---
 
+### ▶ Lossy zip of iterators
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three)) 
+[(0, 0), (1, 1), (2, 2)]
+# so far so good, let's zip the remaining
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Where did element `3` go from the `numbers` list?
+
+#### 💡 Explanation:
+
+- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,
+    ```py
+    def zip(*iterables):
+        sentinel = object()
+        iterators = [iter(it) for it in iterables]
+        while iterators:
+            result = []
+            for it in iterators:
+                elem = next(it, sentinel)
+                if elem is sentinel:
+                    return
+                result.append(elem)
+            yield tuple(result)
+    ```
+- So the function takes in arbitrary number of itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. 
+- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.
+- The correct way to do the above using `zip` would be,
+    ```py
+    >>> numbers = list(range(7))
+    >>> numbers_iter = iter(numbers)
+    >>> list(zip(first_three, numbers_iter))
+    [(0, 0), (1, 1), (2, 2)]
+    >>> list(zip(remaining, numbers_iter))
+    [(3, 3), (4, 4), (5, 5), (6, 6)]
+    ```
+    The first argument of zip should be the one with fewest elements.
+
+---
+
 ### ▶ From filled to None in one instruction...
 
 ```py

From 362447a5d252c3be58d76d68285bde9d077c87de Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 10 Jun 2019 00:14:01 +0530
Subject: [PATCH 027/146] Add new example: Disorder within order

Resolves https://github.com/satwikkansal/wtfpython/issues/77
---
 README.md | 115 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 109 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index c8de242..27995d3 100644
--- a/README.md
+++ b/README.md
@@ -261,26 +261,131 @@ some_dict[5] = "Python"
 "Ruby"
 >>> some_dict[5.0]
 "Python"
->>> some_dict[5]
+>>> some_dict[5] # "Python" destroyed the existence of "JavaScript"?
+"Python"
+
+>>> complex_five = 5 + 0j
+>>> type(complex_five)
+complex
+>>> some_dict[complex_five]
 "Python"
 ```
 
-"Python" destroyed the existence of "JavaScript"?
+So, why is Python all over the place?
+
 
 #### 💡 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
+  >>> 5 == 5.0 == 5 + 0j
   True
-  >>> hash(5) == hash(5.0)
+  >>> hash(5) == hash(5.0) == hash(5 + 0j)
   True
   ```
   **Note:** Objects with different values may also have same hash (known as hash collision).
 * When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
 * This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
 
+---
+
+### ▶ The 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):
+    """
+    A dict 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 # the 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 "<stdin>", line 1, in <module>
+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 is 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 lenght 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? *
@@ -858,8 +963,6 @@ True
     'wt\\"f'
 
     >>> print("\n")
-    ```
-
 
     >>> print(r"\\n")
     '\\\\n'

From c6e0d795ff712032144c4d795d6eaa8a5b0df7d0 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 10 Jun 2019 23:22:08 +0530
Subject: [PATCH 028/146] Some minor changes, and add assertion example

---
 README.md | 53 +++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 45 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 27995d3..6283d3e 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Python, being a beautifully designed high-level and interpreter-based programmin
 
 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!
+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 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:
 
@@ -104,10 +104,10 @@ All the examples are structured like below:
 > # 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.
 >
@@ -118,7 +118,7 @@ All the examples are structured like below:
 >   ```py
 >   Setting up examples for clarification (if necessary)
 >   ```
->   **Output:**
+>   **Output Output (Python version(s)):**
 >   ```py
 >   >>> trigger # some example that makes it easy to unveil the magic
 >   # some justified output
@@ -128,15 +128,15 @@ All the examples are structured like below:
 
 # 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:
+A nice way to get the most out of these examples, in my opinion, will be to just read them 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 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)).
     - 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.
+PS: You can also read WTFPython at the command line. There's a pypi package and an npm package (which supports colored formatting) for the same.
 
 To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython)
 ```sh
@@ -2185,7 +2185,10 @@ class SomeClass:
 
 ---
 
-### ▶ Needle in a Haystack
+
+---
+
+### ▶ Needles in a Haystack
 
 1\.
 ```py
@@ -2224,13 +2227,45 @@ e
 tuple()
 ```
 
+3\. Not asserting strongly enough
+
+```py
+a = "python"
+b = "javascript"
+```
+**Output:**
+```py
+# An assert statement with an assertion failure message.
+>>> assert(a == b, "Both languages are different")
+# No AssertionError is raised
+```
+
 #### 💡 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`.
+* For 3, no `AssertionError` was raised because we're asserting entire tuple, instead of asserting the individual expression `a == b`. The following snippet will clear things up,
+    ```py
+    >>> a = "python"
+    >>> b = "javascript"
+    >>> assert a == b
+    Traceback (most recent call last):
+        File "<stdin>", line 1, in <module>
+    AssertionError
+
+    >>> assert (a == b, "Values are not equal")
+    <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+    >>> assert a == b, "Values are not equal"
+    Traceback (most recent call last):
+        File "<stdin>", line 1, in <module>
+    AssertionError: Values aren not equal
+    ```
 
 ---
 
+
+
 ---
 
 
@@ -2658,6 +2693,8 @@ Let's increase the number of iterations by a factor of 10.
   >>> %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.
 
 ---
 

From 8b4bbb219658477480474198a6b462b49aa73c8f Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Tue, 11 Jun 2019 00:43:32 +0530
Subject: [PATCH 029/146] Add new example: Wild imports

---
 README.md | 115 +++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 100 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 6283d3e..841d40a 100644
--- a/README.md
+++ b/README.md
@@ -1856,21 +1856,22 @@ print(x, ': x in global')
 ```
 
 3\.
-```
-x = 1
-print([x for x in range(5)])
-print(x, ': x in global')
-```
 
-**Output (on Python 2.x):**
+**Output (Python 2.x):**
 ```
+>>> x = 1
+>>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
+>>> print(x, ': x in global')
 (4, ': x in global')
 ```
 
-**Output (on Python 3.x):**
+**Output (Python 3.x):**
 ```
+>>> x = 1
+>>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
+>>> print(x, ': x in global')
 1 : x in global
 ```
 
@@ -2183,12 +2184,10 @@ class SomeClass:
 - A generator expression has its own scope.
 - Starting from Python 3.X, list comprehensions also have their own scope.
 
----
-
 
 ---
 
-### ▶ Needles in a Haystack
+### ▶ Needles in a Haystack ^
 
 1\.
 ```py
@@ -2227,7 +2226,31 @@ e
 tuple()
 ```
 
-3\. Not asserting strongly enough
+3\.
+
+```
+ten_words_list = [
+    "some",
+    "very",
+    "big",
+    "list",
+    "that"
+    "consists",
+    "of",
+    "exactly",
+    "ten",
+    "words"
+]
+```
+
+**Output**
+
+```py
+>>> len(ten_words_list)
+9
+```
+
+4\. Not asserting strongly enough
 
 ```py
 a = "python"
@@ -2244,7 +2267,12 @@ b = "javascript"
 * 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`.
-* For 3, no `AssertionError` was raised because we're asserting entire tuple, instead of asserting the individual expression `a == b`. The following snippet will clear things up,
+* In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation,
+    ```py
+    >>> ten_words_list
+    ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
+    ```
+* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,
     ```py
     >>> a = "python"
     >>> b = "javascript"
@@ -2264,7 +2292,60 @@ b = "javascript"
 
 ---
 
+### ▶ Wild imports
 
+```py
+# File: module.py
+
+def some_weird_name_func_():
+    print("works!")
+
+def _another_weird_name_func():
+    print("works!")
+
+```
+
+**Output**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Explanation:
+
+- It if often adivsable to not use wildcard imports. In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
+- Had we used `from ... import a, b, c` syntax, the above `NameError` won'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 "<stdin>", line 1, in <module>
+NameError: name 'some_weird_name_func_' is not defined
+```
 
 ---
 
@@ -2561,12 +2642,12 @@ The spelling is intended. Please, don't submit a patch for this.
 class Yo(object):
     def __init__(self):
         self.__honey = True
-        self.bitch = True
+        self.bro = True
 ```
 
 **Output:**
 ```py
->>> Yo().bitch
+>>> Yo().bro
 True
 >>> Yo().__honey
 AttributeError: 'Yo' object has no attribute '__honey'
@@ -2574,7 +2655,7 @@ AttributeError: 'Yo' object has no attribute '__honey'
 True
 ```
 
-Why did `Yo()._Yo__honey` work? Only Indian readers would understand.
+Why did `Yo()._Yo__honey` work?
 
 #### 💡 Explanation:
 
@@ -2584,6 +2665,10 @@ Why did `Yo()._Yo__honey` work? Only Indian readers would understand.
 
 ---
 
+
+
+
+
 ---
 
 ## Section: Miscellaneous

From 14e03a37662f52e5a06d5af1b3d5ef1e2d7cba93 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Fri, 28 Jun 2019 07:03:12 +0200
Subject: [PATCH 030/146] Add automated testing using Travis CI

The repo switch would need to be turned on at https://travis-ci.com/satwikkansal/wtfpython to enable free automated testing of all code changes.
---
 .travis.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .travis.yml

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..8d2ea6b
--- /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

From a4776a6b672d4fd0f1c4b91e8ca07ddb4537faae Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Tue, 2 Jul 2019 15:36:23 +0200
Subject: [PATCH 031/146] Use ==/!= to compare str, bytes, and int literals

Identity is not the same thing as equality in Python.

$ __[flake8](http://flake8.pycqa.org)  . --count --select=E9,F63,F7,F82 --show-source --statistics__
```
    if resp.status_code is 200:
       ^
1     F632 use ==/!= to compare str, bytes, and int literals
1
```
---
 irrelevant/generate_contributions.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/irrelevant/generate_contributions.py b/irrelevant/generate_contributions.py
index 136f653..f396f32 100644
--- a/irrelevant/generate_contributions.py
+++ b/irrelevant/generate_contributions.py
@@ -39,7 +39,7 @@ for handle, issues in contribs.items():
     issue_string = ', '.join([issue_format.format(i, i) for i in issues])
     resp = requests.get(github_rest_api.format(handle))
     name = handle
-    if resp.status_code is 200:
+    if resp.status_code == 200:
         pprint.pprint(resp.json()['name'])
     else:
         print(handle, resp.content)
@@ -48,4 +48,4 @@ for handle, issues in contribs.items():
                                         handle,
                                         issue_string))
 
-print(table_header + "\n".join(rows_so_far))
\ No newline at end of file
+print(table_header + "\n".join(rows_so_far))

From e611f24e7f1b43ec1ec019f49e891504693286e9 Mon Sep 17 00:00:00 2001
From: zachkirsch <zachkirsch@users.noreply.github.com>
Date: Wed, 3 Jul 2019 11:39:57 -0400
Subject: [PATCH 032/146] Change constant-folding max from <20 to <=20

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9827fc4..0e6fd1c 100644
--- a/README.md
+++ b/README.md
@@ -204,7 +204,7 @@ Makes sense, right?
   * 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)
   <img src="/images/string-intern/string_intern.png" alt="">
 + When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than or equal to 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 
 
 ---

From 12a1ac10cbc83c46eab4aed3b8f2f37593d656da Mon Sep 17 00:00:00 2001
From: Zach Kirsch <zkirsch@palantir.com>
Date: Wed, 3 Jul 2019 11:46:31 -0400
Subject: [PATCH 033/146] Fix github URL typos in CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 7f672ac..a5e440e 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -2,13 +2,13 @@ I'm really grateful to all the contributors. Following are the wonderful people
 
 | 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) |
-| sohaibfarooqi | [sohaibfarooqi](https://github.com/sohaibfarooqi) | [#63](https:/github.com/satwikkansal/wtfpython/issues/63) |
+| 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) |
 
 Thank you all for taking out the time to make this project more awesome! :smile:

From 96455422efc903d14c4c35818d231d7a5cfc5c86 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 7 Jul 2019 22:17:33 +0530
Subject: [PATCH 034/146] Update the booleans example

Fix some technically incorrect terminologies and snippets.
---
 README.md | 96 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 71 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index 841d40a..f29fd25 100644
--- a/README.md
+++ b/README.md
@@ -1057,7 +1057,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 
 1\.
 ```py
-# A simple example to count the number of boolean and
+# A simple example to count the number of booleans and
 # integers in an iterable of mixed data types.
 mixed_list = [False, 1.0, "some_string", 3, True, [], False]
 integers_found_so_far = 0
@@ -1078,33 +1078,27 @@ for item in mixed_list:
 0
 ```
 
+
 2\.
 ```py
-another_dict = {}
-another_dict[True] = "JavaScript"
-another_dict[1] = "Ruby"
-another_dict[1.0] = "Python"
-```
-
-**Output:**
-```py
->>> another_dict[True]
-"Python"
-```
-
-3\.
-```py
 >>> some_bool = True
->>> "wtf"*some_bool
+>>> "wtf" * some_bool
 'wtf'
 >>> some_bool = False
->>> "wtf"*some_bool
+>>> "wtf" * some_bool
 ''
 ```
 
 #### 💡 Explanation:
 
-* Booleans are a subclass of `int`
+* `bool` is a subclass of `int` in Python
+    ```py
+    >>> issubclass(bool, int)
+    True
+    >>> issubclass(int, bool)
+    False
+    ```
+* And thus, `True` and `False` are instances of `int`
   ```py
   >>> isinstance(True, int)
   True
@@ -1114,8 +1108,10 @@ another_dict[1.0] = "Python"
 
 * The integer value of `True` is `1` and that of `False` is `0`.
   ```py
-  >>> True == 1 == 1.0 and False == 0 == 0.0
-  True
+  >>> int(True)
+  1
+  >>> int(False)
+  0
   ```
 
 * See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.
@@ -1718,7 +1714,7 @@ Yes, it runs for exactly **eight** times and stops.
 
 ---
 
-### ▶ Stubborn `del` operator *
+### ▶ Stubborn `del` operation *
 
 ```py
 class SomeClass:
@@ -2319,7 +2315,7 @@ NameError: name '_another_weird_name_func' is not defined
 
 #### 💡 Explanation:
 
-- It if often adivsable to not use wildcard imports. In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
+- It if often adivsable to not use wildcard imports. The first obvious reason for this is In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
 - Had we used `from ... import a, b, c` syntax, the above `NameError` won't have occurred.
     ```py
     >>> from module import some_weird_name_func_, _another_weird_name_func
@@ -2636,8 +2632,9 @@ The spelling is intended. Please, don't submit a patch for this.
 
 ---
 
-### ▶ Mangling time! *
+### ▶ Let's mangle ^
 
+1\.
 ```py
 class Yo(object):
     def __init__(self):
@@ -2655,13 +2652,62 @@ AttributeError: 'Yo' object has no attribute '__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 "<stdin>", line 1, in <module>
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
 Why did `Yo()._Yo__honey` work?
 
+2\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+    def some_func(self):
+        return __variable # not initiatlized anywhere yet
+```
+
+**Output:**
+```py
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> >>> A().some_func()
+'Some value'
+```
+
+3\.
+
+```py
+
+```
+
+
 #### 💡 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.
+* 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 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 outer scope.
 
 ---
 

From 4d8e5795a324c10dfd9f78e017c4e2a1550ddb3d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 7 Jul 2019 22:18:35 +0530
Subject: [PATCH 035/146] Update TOC

---
 README.md | 167 +++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 115 insertions(+), 52 deletions(-)

diff --git a/README.md b/README.md
index f29fd25..0152d13 100644
--- a/README.md
+++ b/README.md
@@ -28,66 +28,129 @@ So, here we go...
 - [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-)
-    - [▶ 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)
+    - [▶ Strings can be tricky sometimes *](#%E2%96%B6-strings-can-be-tricky-sometimes-)
+      - [💡 Explanation:](#-explanation)
+    - [▶ Splitsies ^](#%E2%96%B6-splitsies-%5E)
+      - [💡 Explanation:](#-explanation-1)
+    - [▶ Time for some hash brownies!](#%E2%96%B6-time-for-some-hash-brownies)
+      - [💡 Explanation](#-explanation)
+    - [▶ The disorder within order ^](#%E2%96%B6-the-disorder-within-order-%5E)
+      - [💡 Explanation:](#-explanation-2)
+    - [▶ Keep trying? *](#%E2%96%B6-keep-trying-)
+      - [💡 Explanation:](#-explanation-3)
+    - [▶ Deep down, we're all the same. *](#%E2%96%B6-deep-down-were-all-the-same-)
+      - [💡 Explanation:](#-explanation-4)
+    - [▶ For what?](#%E2%96%B6-for-what)
+      - [💡 Explanation:](#-explanation-5)
+    - [▶ Evaluation time discrepancy ^](#%E2%96%B6-evaluation-time-discrepancy-%5E)
+      - [💡 Explanation](#-explanation-1)
+    - [▶ Messing around with `is` operator^](#%E2%96%B6-messing-around-with-is-operator%5E)
+      - [💡 Explanation:](#-explanation-6)
+    - [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+      - [💡 Explanation:](#-explanation-7)
+    - [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
+      - [💡 Explanation](#-explanation-2)
+    - [▶ The chicken-egg problem ^](#%E2%96%B6-the-chicken-egg-problem-%5E)
+      - [💡 Explanation](#-explanation-3)
+    - [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
+      - [💡 Explanation](#-explanation-4)
+    - [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
+      - [💡 Explanation:](#-explanation-8)
+    - [▶ Strings and the backslashes\ ^](#%E2%96%B6-strings-and-the-backslashes%5C-%5E)
+      - [💡 Explanation](#-explanation-5)
+    - [▶ not knot!](#%E2%96%B6-not-knot)
+      - [💡 Explanation:](#-explanation-9)
+    - [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
+      - [💡 Explanation:](#-explanation-10)
+    - [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
+      - [💡 Explanation:](#-explanation-11)
+    - [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
+      - [💡 Explanation:](#-explanation-12)
+    - [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
+      - [💡 Explanation:](#-explanation-13)
+    - [▶ yielding None](#%E2%96%B6-yielding-none)
+      - [💡 Explanation:](#-explanation-14)
+    - [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
+      - [💡 Explanation:](#-explanation-15)
+    - [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
+      - [💡 Explanation:](#-explanation-16)
+    - [▶ When True is actually False](#%E2%96%B6-when-true-is-actually-false)
+      - [💡 Explanation:](#-explanation-17)
+    - [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
+      - [💡 Explanation:](#-explanation-18)
+    - [▶ From filled to None in one instruction...](#%E2%96%B6-from-filled-to-none-in-one-instruction)
+      - [💡 Explanation](#-explanation-6)
+    - [▶ Subclass relationships *](#%E2%96%B6-subclass-relationships-)
+      - [💡 Explanation:](#-explanation-19)
+    - [▶ The mysterious key type conversion *](#%E2%96%B6-the-mysterious-key-type-conversion-)
+      - [💡 Explanation:](#-explanation-20)
+    - [▶ Let's see if you can guess this?](#%E2%96%B6-lets-see-if-you-can-guess-this)
+      - [💡 Explanation:](#-explanation-21)
   - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
-    - [▶ Skipping lines?](#-skipping-lines)
-    - [▶ Teleportation *](#-teleportation-)
-    - [▶ Well, something is fishy...](#-well-something-is-fishy)
+    - [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
+      - [💡 Explanation](#-explanation-7)
+    - [▶ Teleportation *](#%E2%96%B6-teleportation-)
+      - [💡 Explanation:](#-explanation-22)
+    - [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
+      - [💡 Explanation](#-explanation-8)
   - [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)
+    - [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
+      - [💡 Explanation:](#-explanation-23)
+    - [▶ Stubborn `del` operation *](#%E2%96%B6-stubborn-del-operation-)
+      - [💡 Explanation:](#-explanation-24)
+    - [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
+      - [💡 Explanation:](#-explanation-25)
+    - [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
+      - [💡 Explanation:](#-explanation-26)
+    - [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
+      - [💡 Explanation:](#-explanation-27)
+    - [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
+      - [💡 Explanation](#-explanation-9)
+    - [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
+      - [💡 Explanation:](#-explanation-28)
+    - [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
+      - [💡 Explanation:](#-explanation-29)
+    - [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
+      - [💡 Explanation:](#-explanation-30)
+    - [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
+      - [💡 Explanation](#-explanation-10)
+    - [▶ Needles in a Haystack ^](#%E2%96%B6-needles-in-a-haystack-%5E)
+      - [💡 Explanation:](#-explanation-31)
+    - [▶ Wild imports](#%E2%96%B6-wild-imports)
+      - [💡 Explanation:](#-explanation-32)
   - [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-)
+    - [▶ Okay Python, Can you make me fly? *](#%E2%96%B6-okay-python-can-you-make-me-fly-)
+      - [💡 Explanation:](#-explanation-33)
+    - [▶ `goto`, but why? *](#%E2%96%B6-goto-but-why-)
+      - [💡 Explanation:](#-explanation-34)
+    - [▶ Brace yourself! *](#%E2%96%B6-brace-yourself-)
+      - [💡 Explanation:](#-explanation-35)
+    - [▶ Let's meet Friendly Language Uncle For Life ^](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life-%5E)
+      - [💡 Explanation:](#-explanation-36)
+    - [▶ Even Python understands that love is complicated *](#%E2%96%B6-even-python-understands-that-love-is-complicated-)
+      - [💡 Explanation:](#-explanation-37)
+    - [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
+      - [💡 Explanation:](#-explanation-38)
+    - [▶ Ellipsis ^](#%E2%96%B6-ellipsis-%5E)
+      - [💡 Explanation](#-explanation-11)
+    - [▶ Inpinity *](#%E2%96%B6-inpinity-)
+      - [💡 Explanation:](#-explanation-39)
+    - [▶ Let's mangle ^](#%E2%96%B6-lets-mangle-%5E)
+      - [💡 Explanation:](#-explanation-40)
   - [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)
+    - [▶ `+=` is faster](#%E2%96%B6--is-faster)
+      - [💡 Explanation:](#-explanation-41)
+    - [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
+      - [💡 Explanation](#-explanation-12)
+    - [▶ Explicit typecast of strings](#%E2%96%B6-explicit-typecast-of-strings)
+      - [💡 Explanation:](#-explanation-42)
+    - [▶ Minor Ones](#%E2%96%B6-minor-ones)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
+      - [Some nice Links!](#some-nice-links)
 - [🎓 License](#-license)
   - [Help](#help)
-  - [Want to share wtfpython with friends?](#want-to-share-wtfpython-with-friends)
+  - [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
   - [Need a pdf version?](#need-a-pdf-version)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->

From 98701351c617aff53c2ad24c109867ff7ab80550 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 02:54:49 +0530
Subject: [PATCH 036/146] Add uuids to examples

---
 README.md | 114 +++++++++++++++++++++++++++---------------------------
 1 file changed, 57 insertions(+), 57 deletions(-)

diff --git a/README.md b/README.md
index 0326d05..c6833f3 100644
--- a/README.md
+++ b/README.md
@@ -221,7 +221,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 ## Section: Strain your brain!
 
 ### ▶ Strings can be tricky sometimes *
-
+<!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --!>
 1\.
 ```py
 >>> a = "some_string"
@@ -271,7 +271,7 @@ Makes sense, right?
 ---
 
 ### ▶ Splitsies ^
-
+<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --!>
 ```py
 >>> 'a'.split()
 ['a']
@@ -308,7 +308,7 @@ Makes sense, right?
 
 
 ### ▶ Time for some hash brownies!
-
+<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --!>
 1\.
 ```py
 some_dict = {}
@@ -353,7 +353,7 @@ So, why is Python all over the place?
 ---
 
 ### ▶ The disorder within order ^
-
+<!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --!>
 ```py
 from collections import OrderedDict
 
@@ -451,7 +451,7 @@ What is going on here?
 ---
 
 ### ▶ Keep trying? *
-
+<!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --!>
 ```py
 def some_func():
     try:
@@ -511,7 +511,7 @@ Iteration 0
 ---
 
 ### ▶ Deep down, we're all the same. *
-
+<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --!>
 ```py
 class WTF:
   pass
@@ -561,7 +561,7 @@ True
 ---
 
 ### ▶ For what?
-
+<!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --!>
 ```py
 some_string = "wtf"
 some_dict = {}
@@ -614,7 +614,7 @@ for i, some_dict[i] in enumerate(some_string):
 ---
 
 ### ▶ Evaluation time discrepancy ^
-
+<!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --!>
 1\.
 ```py
 array = [1, 8, 15]
@@ -680,7 +680,7 @@ array_4 = [400, 500, 600]
 ---
 
 ### ▶ Messing around with `is` operator^
-
+<!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --!>
 The following is a very famous example present all over the internet.
 
 1\.
@@ -798,7 +798,7 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 ---
 
 ### ▶ A tic-tac-toe where X wins in the first attempt!
-
+<!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --!>
 ```py
 # Let's initialize a row
 row = [""]*3 #row i['', '', '']
@@ -843,7 +843,7 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
 ---
 
 ### ▶ The sticky output function
-
+<!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --!>
 ```py
 funcs = []
 results = []
@@ -897,7 +897,7 @@ Even when the values of `x` were different in every iteration prior to appending
 ---
 
 ### ▶ The chicken-egg problem ^
-
+<!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --!>
 1\.
 ```py
 >>> isinstance(3, int)
@@ -945,7 +945,7 @@ False
 ---
 
 ### ▶ `is not ...` is not `is (not ...)`
-
+<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --!>
 ```py
 >>> 'something' is not None
 True
@@ -961,7 +961,7 @@ False
 ---
 
 ### ▶ The surprising comma
-
+<!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --!>
 **Output:**
 ```py
 >>> def f(x, y,):
@@ -991,7 +991,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Strings and the backslashes\ ^
-
+<!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --!>
 **Output:**
 ```py
 >>> print("\"")
@@ -1034,7 +1034,7 @@ True
 ---
 
 ### ▶ not knot!
-
+<!-- Example ID: 7034deb1-7443-417d-94ee-29a800524de8 --!>
 ```py
 x = True
 y = False
@@ -1061,7 +1061,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Half triple-quoted strings
-
+<!-- Example ID: c55da3e2-1034-43b9-abeb-a7a970a2ad9e --!>
 **Output:**
 ```py
 >>> print('wtfpython''')
@@ -1086,7 +1086,7 @@ wtfpython
 ---
 
 ### ▶ Midnight time doesn't exist?
-
+<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --!>
 ```py
 from datetime import datetime
 
@@ -1116,7 +1116,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 ---
 
 ### ▶ What's wrong with booleans?
-
+<!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --!>
 1\.
 ```py
 # A simple example to count the number of booleans and
@@ -1181,7 +1181,7 @@ for item in mixed_list:
 ---
 
 ### ▶ Class attributes and instance attributes
-
+<!-- Example ID: 6f332208-33bd-482d-8106-42863b739ed9 --!>
 1\.
 ```py
 class A:
@@ -1251,7 +1251,7 @@ True
 ---
 
 ### ▶ yielding None
-
+<!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --!>
 ```py
 some_iterable = ('a', 'b')
 
@@ -1280,7 +1280,7 @@ def some_func(val):
 ---
 
 ### ▶ Mutating the immutable!
-
+<!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --!>
 ```py
 some_tuple = ("A", "tuple", "with", "values")
 another_tuple = ([1, 2], [3, 4], [5, 6])
@@ -1313,7 +1313,7 @@ But I thought tuples were immutable...
 ---
 
 ### ▶ The disappearing variable from outer scope
-
+<!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --!>
 ```py
 e = 7
 try:
@@ -1393,7 +1393,7 @@ NameError: name 'e' is not defined
 ---
 
 ### ▶ When True is actually False
-
+<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --!>
 ```py
 True = False
 if True == False:
@@ -1413,7 +1413,7 @@ I've lost faith in truth!
 ---
 
 ### ▶ Lossy zip of iterators
-
+<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --!>
 ```py
 >>> numbers = list(range(7))
 >>> numbers
@@ -1462,7 +1462,7 @@ Where did element `3` go from the `numbers` list?
 ---
 
 ### ▶ From filled to None in one instruction...
-
+<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --!>
 ```py
 some_list = [1, 2, 3]
 some_dict = {
@@ -1490,7 +1490,7 @@ Most methods that modify the items of sequence/mapping objects like `list.append
 ---
 
 ### ▶ Subclass relationships *
-
+<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --!>
 **Output:**
 ```py
 >>> from collections import Hashable
@@ -1514,7 +1514,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 ---
 
 ### ▶ The mysterious key type conversion *
-
+<!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --!>
 ```py
 class SomeClass(str):
     pass
@@ -1570,7 +1570,7 @@ str
 ---
 
 ### ▶ Let's see if you can guess this?
-
+<!-- Example ID: 81aa9fbe-bd63-4283-b56d-6fdd14c9105e --!>
 ```py
 a, b = a[b] = {}, 5
 ```
@@ -1631,7 +1631,7 @@ a, b = a[b] = {}, 5
 ## Section: Appearances are deceptive!
 
 ### ▶ Skipping lines?
-
+<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --!>
 **Output:**
 ```py
 >>> value = 11
@@ -1667,7 +1667,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 ---
 
 ### ▶ Teleportation *
-
+<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --!>
 ```py
 import numpy as np
 
@@ -1697,7 +1697,7 @@ Where's the Nobel Prize?
 ---
 
 ### ▶ Well, something is fishy...
-
+<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --!>
 ```py
 def square(x):
     """
@@ -1742,7 +1742,7 @@ Shouldn't that be 100?
 
 
 ### ▶ Modifying a dictionary while iterating over it
-
+<!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --!>
 ```py
 x = {0: None}
 
@@ -1777,7 +1777,7 @@ Yes, it runs for exactly **eight** times and stops.
 ---
 
 ### ▶ Stubborn `del` operation *
-
+<!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --!>
 ```py
 class SomeClass:
     def __del__(self):
@@ -1820,7 +1820,7 @@ Okay, now it's deleted :confused:
 ---
 
 ### ▶ Deleting a list item while iterating
-
+<!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --!>
 ```py
 list_1 = [1, 2, 3, 4]
 list_2 = [1, 2, 3, 4]
@@ -1880,7 +1880,7 @@ Can you guess why the output is `[2, 4]`?
 ---
 
 ### ▶ Loop variables leaking out!
-
+<!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --!>
 1\.
 ```py
 for x in range(7):
@@ -1944,7 +1944,7 @@ print(x, ': x in global')
 ---
 
 ### ▶ Beware of default mutable arguments!
-
+<!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --!>
 ```py
 def some_func(default_arg=[]):
     default_arg.append("some_string")
@@ -2001,7 +2001,7 @@ def some_func(default_arg=[]):
 ---
 
 ### ▶ Catching the Exceptions
-
+<!-- Example ID: b5ca5e6a-47b9-4f69-9375-cda0f8c6755d --!>
 ```py
 some_list = [1, 2, 3]
 try:
@@ -2076,7 +2076,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Same operands, different story!
-
+<!-- Example ID: ca052cdf-dd2d-4105-b936-65c28adc18a0 --!>
 1\.
 ```py
 a = [1, 2, 3, 4]
@@ -2118,7 +2118,7 @@ a += [5, 6, 7, 8]
 ---
 
 ### ▶ The out of scope variable
-
+<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --!>
 ```py
 a = 1
 def some_func():
@@ -2157,7 +2157,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
 ---
 
 ### ▶ Be careful with chained operations
-
+<!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --!>
 ```py
 >>> (False == False) in [False] # makes sense
 False
@@ -2202,7 +2202,7 @@ While such behavior might seem silly to you in the above examples, it's fantasti
 ---
 
 ### ▶ Name resolution ignoring class scope
-
+<!-- Example ID: 03f73d96-151c-4929-b0a8-f74430788324 --!>
 1\.
 ```py
 x = 5
@@ -2246,7 +2246,7 @@ class SomeClass:
 ---
 
 ### ▶ Needles in a Haystack ^
-
+<!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --!>
 1\.
 ```py
 x, y = (0, 1) if True else None, None
@@ -2351,7 +2351,7 @@ b = "javascript"
 ---
 
 ### ▶ Wild imports
-
+<!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --!>
 ```py
 # File: module.py
 
@@ -2413,7 +2413,7 @@ NameError: name 'some_weird_name_func_' is not defined
 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? *
-
+<!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --!>
 Well, here you go
 
 ```py
@@ -2431,7 +2431,7 @@ Sshh.. It's a super secret.
 ---
 
 ### ▶ `goto`, but why? *
-
+<!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --!>
 ```py
 from goto import goto, label
 for i in range(9):
@@ -2459,7 +2459,7 @@ Freedom!
 ---
 
 ### ▶ Brace yourself! *
-
+<!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --!>
 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
@@ -2484,7 +2484,7 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr
 ---
 
 ### ▶ Let's meet Friendly Language Uncle For Life ^
-
+<!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --!>
 **Output (Python 3.x)**
 ```py
 >>> from __future__ import barry_as_FLUFL
@@ -2515,7 +2515,7 @@ There we go.
 ---
 
 ### ▶ Even Python understands that love is complicated *
-
+<!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --!>
 ```py
 import this
 ```
@@ -2572,7 +2572,7 @@ True
 ---
 
 ### ▶ Yes, it exists!
-
+<!-- Example ID: 4286db3d-1ea7-47c9-8fb6-a9a04cac6e49 --!>
 **The `else` clause for loops.** One typical example might be:
 
 ```py
@@ -2616,7 +2616,7 @@ Try block executed successfully...
 
 ---
 ### ▶ Ellipsis ^
-
+<!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --!>
 ```py
 def some_func():
     Ellipsis
@@ -2676,7 +2676,7 @@ Ellipsis
 ---
 
 ### ▶ Inpinity *
-
+<!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --!>
 The spelling is intended. Please, don't submit a patch for this.
 
 **Output (Python 3.x):**
@@ -2695,7 +2695,7 @@ The spelling is intended. Please, don't submit a patch for this.
 ---
 
 ### ▶ Let's mangle ^
-
+<!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --!>
 1\.
 ```py
 class Yo(object):
@@ -2783,7 +2783,7 @@ AttributeError: 'A' object has no attribute '__variable'
 
 
 ### ▶ `+=` is faster
-
+<!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --!>
 ```py
 # using "+", three strings:
 >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
@@ -2799,7 +2799,7 @@ AttributeError: 'A' object has no attribute '__variable'
 ---
 
 ### ▶ Let's make a giant string!
-
+<!-- Example ID: c7a07424-63fe-4504-9842-8f3d334f28fc --!>
 ```py
 def add_string_with_plus(iters):
     s = ""
@@ -2892,7 +2892,7 @@ Let's increase the number of iterations by a factor of 10.
 ---
 
 ### ▶ Explicit typecast of strings
-
+<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --!>
 ```py
 a = float('inf')
 b = float('nan')
@@ -2931,7 +2931,7 @@ nan
 ---
 
 ### ▶ Minor Ones
-
+<!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --!>
 * `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
 
   **💡 Explanation:**

From 863e1f4512fd91ae0dde79833377c629c21dee77 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 03:00:33 +0530
Subject: [PATCH 037/146] Fix uuid comments

---
 README.md | 114 +++++++++++++++++++++++++++---------------------------
 1 file changed, 57 insertions(+), 57 deletions(-)

diff --git a/README.md b/README.md
index c6833f3..8128119 100644
--- a/README.md
+++ b/README.md
@@ -221,7 +221,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 ## Section: Strain your brain!
 
 ### ▶ Strings can be tricky sometimes *
-<!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --!>
+<!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --->
 1\.
 ```py
 >>> a = "some_string"
@@ -271,7 +271,7 @@ Makes sense, right?
 ---
 
 ### ▶ Splitsies ^
-<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --!>
+<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
 ```py
 >>> 'a'.split()
 ['a']
@@ -308,7 +308,7 @@ Makes sense, right?
 
 
 ### ▶ Time for some hash brownies!
-<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --!>
+<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --->
 1\.
 ```py
 some_dict = {}
@@ -353,7 +353,7 @@ So, why is Python all over the place?
 ---
 
 ### ▶ The disorder within order ^
-<!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --!>
+<!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
 from collections import OrderedDict
 
@@ -451,7 +451,7 @@ What is going on here?
 ---
 
 ### ▶ Keep trying? *
-<!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --!>
+<!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --->
 ```py
 def some_func():
     try:
@@ -511,7 +511,7 @@ Iteration 0
 ---
 
 ### ▶ Deep down, we're all the same. *
-<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --!>
+<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
 ```py
 class WTF:
   pass
@@ -561,7 +561,7 @@ True
 ---
 
 ### ▶ For what?
-<!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --!>
+<!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --->
 ```py
 some_string = "wtf"
 some_dict = {}
@@ -614,7 +614,7 @@ for i, some_dict[i] in enumerate(some_string):
 ---
 
 ### ▶ Evaluation time discrepancy ^
-<!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --!>
+<!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --->
 1\.
 ```py
 array = [1, 8, 15]
@@ -680,7 +680,7 @@ array_4 = [400, 500, 600]
 ---
 
 ### ▶ Messing around with `is` operator^
-<!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --!>
+<!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --->
 The following is a very famous example present all over the internet.
 
 1\.
@@ -798,7 +798,7 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 ---
 
 ### ▶ A tic-tac-toe where X wins in the first attempt!
-<!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --!>
+<!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --->
 ```py
 # Let's initialize a row
 row = [""]*3 #row i['', '', '']
@@ -843,7 +843,7 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
 ---
 
 ### ▶ The sticky output function
-<!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --!>
+<!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --->
 ```py
 funcs = []
 results = []
@@ -897,7 +897,7 @@ Even when the values of `x` were different in every iteration prior to appending
 ---
 
 ### ▶ The chicken-egg problem ^
-<!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --!>
+<!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --->
 1\.
 ```py
 >>> isinstance(3, int)
@@ -945,7 +945,7 @@ False
 ---
 
 ### ▶ `is not ...` is not `is (not ...)`
-<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --!>
+<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --->
 ```py
 >>> 'something' is not None
 True
@@ -961,7 +961,7 @@ False
 ---
 
 ### ▶ The surprising comma
-<!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --!>
+<!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --->
 **Output:**
 ```py
 >>> def f(x, y,):
@@ -991,7 +991,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Strings and the backslashes\ ^
-<!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --!>
+<!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --->
 **Output:**
 ```py
 >>> print("\"")
@@ -1034,7 +1034,7 @@ True
 ---
 
 ### ▶ not knot!
-<!-- Example ID: 7034deb1-7443-417d-94ee-29a800524de8 --!>
+<!-- Example ID: 7034deb1-7443-417d-94ee-29a800524de8 --->
 ```py
 x = True
 y = False
@@ -1061,7 +1061,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Half triple-quoted strings
-<!-- Example ID: c55da3e2-1034-43b9-abeb-a7a970a2ad9e --!>
+<!-- Example ID: c55da3e2-1034-43b9-abeb-a7a970a2ad9e --->
 **Output:**
 ```py
 >>> print('wtfpython''')
@@ -1086,7 +1086,7 @@ wtfpython
 ---
 
 ### ▶ Midnight time doesn't exist?
-<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --!>
+<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --->
 ```py
 from datetime import datetime
 
@@ -1116,7 +1116,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 ---
 
 ### ▶ What's wrong with booleans?
-<!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --!>
+<!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --->
 1\.
 ```py
 # A simple example to count the number of booleans and
@@ -1181,7 +1181,7 @@ for item in mixed_list:
 ---
 
 ### ▶ Class attributes and instance attributes
-<!-- Example ID: 6f332208-33bd-482d-8106-42863b739ed9 --!>
+<!-- Example ID: 6f332208-33bd-482d-8106-42863b739ed9 --->
 1\.
 ```py
 class A:
@@ -1251,7 +1251,7 @@ True
 ---
 
 ### ▶ yielding None
-<!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --!>
+<!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --->
 ```py
 some_iterable = ('a', 'b')
 
@@ -1280,7 +1280,7 @@ def some_func(val):
 ---
 
 ### ▶ Mutating the immutable!
-<!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --!>
+<!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --->
 ```py
 some_tuple = ("A", "tuple", "with", "values")
 another_tuple = ([1, 2], [3, 4], [5, 6])
@@ -1313,7 +1313,7 @@ But I thought tuples were immutable...
 ---
 
 ### ▶ The disappearing variable from outer scope
-<!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --!>
+<!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --->
 ```py
 e = 7
 try:
@@ -1393,7 +1393,7 @@ NameError: name 'e' is not defined
 ---
 
 ### ▶ When True is actually False
-<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --!>
+<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --->
 ```py
 True = False
 if True == False:
@@ -1413,7 +1413,7 @@ I've lost faith in truth!
 ---
 
 ### ▶ Lossy zip of iterators
-<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --!>
+<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --->
 ```py
 >>> numbers = list(range(7))
 >>> numbers
@@ -1462,7 +1462,7 @@ Where did element `3` go from the `numbers` list?
 ---
 
 ### ▶ From filled to None in one instruction...
-<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --!>
+<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --->
 ```py
 some_list = [1, 2, 3]
 some_dict = {
@@ -1490,7 +1490,7 @@ Most methods that modify the items of sequence/mapping objects like `list.append
 ---
 
 ### ▶ Subclass relationships *
-<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --!>
+<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
 **Output:**
 ```py
 >>> from collections import Hashable
@@ -1514,7 +1514,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 ---
 
 ### ▶ The mysterious key type conversion *
-<!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --!>
+<!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --->
 ```py
 class SomeClass(str):
     pass
@@ -1570,7 +1570,7 @@ str
 ---
 
 ### ▶ Let's see if you can guess this?
-<!-- Example ID: 81aa9fbe-bd63-4283-b56d-6fdd14c9105e --!>
+<!-- Example ID: 81aa9fbe-bd63-4283-b56d-6fdd14c9105e --->
 ```py
 a, b = a[b] = {}, 5
 ```
@@ -1631,7 +1631,7 @@ a, b = a[b] = {}, 5
 ## Section: Appearances are deceptive!
 
 ### ▶ Skipping lines?
-<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --!>
+<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --->
 **Output:**
 ```py
 >>> value = 11
@@ -1667,7 +1667,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 ---
 
 ### ▶ Teleportation *
-<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --!>
+<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
 ```py
 import numpy as np
 
@@ -1697,7 +1697,7 @@ Where's the Nobel Prize?
 ---
 
 ### ▶ Well, something is fishy...
-<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --!>
+<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --->
 ```py
 def square(x):
     """
@@ -1742,7 +1742,7 @@ Shouldn't that be 100?
 
 
 ### ▶ Modifying a dictionary while iterating over it
-<!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --!>
+<!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --->
 ```py
 x = {0: None}
 
@@ -1777,7 +1777,7 @@ Yes, it runs for exactly **eight** times and stops.
 ---
 
 ### ▶ Stubborn `del` operation *
-<!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --!>
+<!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --->
 ```py
 class SomeClass:
     def __del__(self):
@@ -1820,7 +1820,7 @@ Okay, now it's deleted :confused:
 ---
 
 ### ▶ Deleting a list item while iterating
-<!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --!>
+<!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --->
 ```py
 list_1 = [1, 2, 3, 4]
 list_2 = [1, 2, 3, 4]
@@ -1880,7 +1880,7 @@ Can you guess why the output is `[2, 4]`?
 ---
 
 ### ▶ Loop variables leaking out!
-<!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --!>
+<!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --->
 1\.
 ```py
 for x in range(7):
@@ -1944,7 +1944,7 @@ print(x, ': x in global')
 ---
 
 ### ▶ Beware of default mutable arguments!
-<!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --!>
+<!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --->
 ```py
 def some_func(default_arg=[]):
     default_arg.append("some_string")
@@ -2001,7 +2001,7 @@ def some_func(default_arg=[]):
 ---
 
 ### ▶ Catching the Exceptions
-<!-- Example ID: b5ca5e6a-47b9-4f69-9375-cda0f8c6755d --!>
+<!-- Example ID: b5ca5e6a-47b9-4f69-9375-cda0f8c6755d --->
 ```py
 some_list = [1, 2, 3]
 try:
@@ -2076,7 +2076,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Same operands, different story!
-<!-- Example ID: ca052cdf-dd2d-4105-b936-65c28adc18a0 --!>
+<!-- Example ID: ca052cdf-dd2d-4105-b936-65c28adc18a0 --->
 1\.
 ```py
 a = [1, 2, 3, 4]
@@ -2118,7 +2118,7 @@ a += [5, 6, 7, 8]
 ---
 
 ### ▶ The out of scope variable
-<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --!>
+<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --->
 ```py
 a = 1
 def some_func():
@@ -2157,7 +2157,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
 ---
 
 ### ▶ Be careful with chained operations
-<!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --!>
+<!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --->
 ```py
 >>> (False == False) in [False] # makes sense
 False
@@ -2202,7 +2202,7 @@ While such behavior might seem silly to you in the above examples, it's fantasti
 ---
 
 ### ▶ Name resolution ignoring class scope
-<!-- Example ID: 03f73d96-151c-4929-b0a8-f74430788324 --!>
+<!-- Example ID: 03f73d96-151c-4929-b0a8-f74430788324 --->
 1\.
 ```py
 x = 5
@@ -2246,7 +2246,7 @@ class SomeClass:
 ---
 
 ### ▶ Needles in a Haystack ^
-<!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --!>
+<!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
 1\.
 ```py
 x, y = (0, 1) if True else None, None
@@ -2351,7 +2351,7 @@ b = "javascript"
 ---
 
 ### ▶ Wild imports
-<!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --!>
+<!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
 ```py
 # File: module.py
 
@@ -2413,7 +2413,7 @@ NameError: name 'some_weird_name_func_' is not defined
 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? *
-<!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --!>
+<!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --->
 Well, here you go
 
 ```py
@@ -2431,7 +2431,7 @@ Sshh.. It's a super secret.
 ---
 
 ### ▶ `goto`, but why? *
-<!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --!>
+<!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --->
 ```py
 from goto import goto, label
 for i in range(9):
@@ -2459,7 +2459,7 @@ Freedom!
 ---
 
 ### ▶ Brace yourself! *
-<!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --!>
+<!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --->
 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
@@ -2484,7 +2484,7 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr
 ---
 
 ### ▶ Let's meet Friendly Language Uncle For Life ^
-<!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --!>
+<!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --->
 **Output (Python 3.x)**
 ```py
 >>> from __future__ import barry_as_FLUFL
@@ -2515,7 +2515,7 @@ There we go.
 ---
 
 ### ▶ Even Python understands that love is complicated *
-<!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --!>
+<!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --->
 ```py
 import this
 ```
@@ -2572,7 +2572,7 @@ True
 ---
 
 ### ▶ Yes, it exists!
-<!-- Example ID: 4286db3d-1ea7-47c9-8fb6-a9a04cac6e49 --!>
+<!-- Example ID: 4286db3d-1ea7-47c9-8fb6-a9a04cac6e49 --->
 **The `else` clause for loops.** One typical example might be:
 
 ```py
@@ -2616,7 +2616,7 @@ Try block executed successfully...
 
 ---
 ### ▶ Ellipsis ^
-<!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --!>
+<!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --->
 ```py
 def some_func():
     Ellipsis
@@ -2676,7 +2676,7 @@ Ellipsis
 ---
 
 ### ▶ Inpinity *
-<!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --!>
+<!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --->
 The spelling is intended. Please, don't submit a patch for this.
 
 **Output (Python 3.x):**
@@ -2695,7 +2695,7 @@ The spelling is intended. Please, don't submit a patch for this.
 ---
 
 ### ▶ Let's mangle ^
-<!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --!>
+<!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --->
 1\.
 ```py
 class Yo(object):
@@ -2783,7 +2783,7 @@ AttributeError: 'A' object has no attribute '__variable'
 
 
 ### ▶ `+=` is faster
-<!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --!>
+<!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --->
 ```py
 # using "+", three strings:
 >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
@@ -2799,7 +2799,7 @@ AttributeError: 'A' object has no attribute '__variable'
 ---
 
 ### ▶ Let's make a giant string!
-<!-- Example ID: c7a07424-63fe-4504-9842-8f3d334f28fc --!>
+<!-- Example ID: c7a07424-63fe-4504-9842-8f3d334f28fc --->
 ```py
 def add_string_with_plus(iters):
     s = ""
@@ -2892,7 +2892,7 @@ Let's increase the number of iterations by a factor of 10.
 ---
 
 ### ▶ Explicit typecast of strings
-<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --!>
+<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --->
 ```py
 a = float('inf')
 b = float('nan')
@@ -2931,7 +2931,7 @@ nan
 ---
 
 ### ▶ Minor Ones
-<!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --!>
+<!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --->
 * `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
 
   **💡 Explanation:**

From 4618bed5f6ef4cf02996ee0198ffc31488349cad Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 22:01:41 +0530
Subject: [PATCH 038/146] Remove asterisks and carets from titles

---
 README.md | 146 +++++++++++++++++-------------------------------------
 1 file changed, 45 insertions(+), 101 deletions(-)

diff --git a/README.md b/README.md
index 8128119..4a7157f 100644
--- a/README.md
+++ b/README.md
@@ -28,126 +28,71 @@ So, here we go...
 - [Usage](#usage)
 - [👀 Examples](#-examples)
   - [Section: Strain your brain!](#section-strain-your-brain)
-    - [▶ Strings can be tricky sometimes *](#%E2%96%B6-strings-can-be-tricky-sometimes-)
-      - [💡 Explanation:](#-explanation)
-    - [▶ Splitsies ^](#%E2%96%B6-splitsies-%5E)
-      - [💡 Explanation:](#-explanation-1)
+    - [▶ Strings can be tricky sometimes](#%E2%96%B6-strings-can-be-tricky-sometimes)
+    - [▶ Splitsies](#%E2%96%B6-splitsies)
+- [is same as](#is-same-as)
+- [but](#but)
+- [isn't the same as](#isnt-the-same-as)
     - [▶ Time for some hash brownies!](#%E2%96%B6-time-for-some-hash-brownies)
-      - [💡 Explanation](#-explanation)
-    - [▶ The disorder within order ^](#%E2%96%B6-the-disorder-within-order-%5E)
-      - [💡 Explanation:](#-explanation-2)
-    - [▶ Keep trying? *](#%E2%96%B6-keep-trying-)
-      - [💡 Explanation:](#-explanation-3)
-    - [▶ Deep down, we're all the same. *](#%E2%96%B6-deep-down-were-all-the-same-)
-      - [💡 Explanation:](#-explanation-4)
+    - [▶ The disorder within order](#%E2%96%B6-the-disorder-within-order)
+    - [▶ Keep trying?](#%E2%96%B6-keep-trying)
+    - [▶ Deep down, we're all the same](#%E2%96%B6-deep-down-were-all-the-same)
     - [▶ For what?](#%E2%96%B6-for-what)
-      - [💡 Explanation:](#-explanation-5)
-    - [▶ Evaluation time discrepancy ^](#%E2%96%B6-evaluation-time-discrepancy-%5E)
-      - [💡 Explanation](#-explanation-1)
+    - [▶ Evaluation time discrepancy](#%E2%96%B6-evaluation-time-discrepancy)
     - [▶ Messing around with `is` operator^](#%E2%96%B6-messing-around-with-is-operator%5E)
-      - [💡 Explanation:](#-explanation-6)
     - [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
-      - [💡 Explanation:](#-explanation-7)
     - [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
-      - [💡 Explanation](#-explanation-2)
-    - [▶ The chicken-egg problem ^](#%E2%96%B6-the-chicken-egg-problem-%5E)
-      - [💡 Explanation](#-explanation-3)
+    - [▶ The chicken-egg problem](#%E2%96%B6-the-chicken-egg-problem)
     - [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
-      - [💡 Explanation](#-explanation-4)
     - [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
-      - [💡 Explanation:](#-explanation-8)
-    - [▶ Strings and the backslashes\ ^](#%E2%96%B6-strings-and-the-backslashes%5C-%5E)
-      - [💡 Explanation](#-explanation-5)
+    - [▶ Strings and the backslashes](#%E2%96%B6-strings-and-the-backslashes)
     - [▶ not knot!](#%E2%96%B6-not-knot)
-      - [💡 Explanation:](#-explanation-9)
     - [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
-      - [💡 Explanation:](#-explanation-10)
     - [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
-      - [💡 Explanation:](#-explanation-11)
     - [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
-      - [💡 Explanation:](#-explanation-12)
     - [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
-      - [💡 Explanation:](#-explanation-13)
     - [▶ yielding None](#%E2%96%B6-yielding-none)
-      - [💡 Explanation:](#-explanation-14)
     - [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
-      - [💡 Explanation:](#-explanation-15)
     - [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
-      - [💡 Explanation:](#-explanation-16)
     - [▶ When True is actually False](#%E2%96%B6-when-true-is-actually-false)
-      - [💡 Explanation:](#-explanation-17)
     - [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
-      - [💡 Explanation:](#-explanation-18)
     - [▶ From filled to None in one instruction...](#%E2%96%B6-from-filled-to-none-in-one-instruction)
-      - [💡 Explanation](#-explanation-6)
-    - [▶ Subclass relationships *](#%E2%96%B6-subclass-relationships-)
-      - [💡 Explanation:](#-explanation-19)
-    - [▶ The mysterious key type conversion *](#%E2%96%B6-the-mysterious-key-type-conversion-)
-      - [💡 Explanation:](#-explanation-20)
+    - [▶ Subclass relationships](#%E2%96%B6-subclass-relationships)
+    - [▶ The mysterious key type conversion](#%E2%96%B6-the-mysterious-key-type-conversion)
     - [▶ Let's see if you can guess this?](#%E2%96%B6-lets-see-if-you-can-guess-this)
-      - [💡 Explanation:](#-explanation-21)
   - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
     - [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
-      - [💡 Explanation](#-explanation-7)
-    - [▶ Teleportation *](#%E2%96%B6-teleportation-)
-      - [💡 Explanation:](#-explanation-22)
+    - [▶ Teleportation](#%E2%96%B6-teleportation)
     - [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
-      - [💡 Explanation](#-explanation-8)
   - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines)
     - [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
-      - [💡 Explanation:](#-explanation-23)
-    - [▶ Stubborn `del` operation *](#%E2%96%B6-stubborn-del-operation-)
-      - [💡 Explanation:](#-explanation-24)
     - [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
-      - [💡 Explanation:](#-explanation-25)
     - [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
-      - [💡 Explanation:](#-explanation-26)
     - [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
-      - [💡 Explanation:](#-explanation-27)
     - [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
-      - [💡 Explanation](#-explanation-9)
     - [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
-      - [💡 Explanation:](#-explanation-28)
     - [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
-      - [💡 Explanation:](#-explanation-29)
     - [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
-      - [💡 Explanation:](#-explanation-30)
     - [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
-      - [💡 Explanation](#-explanation-10)
-    - [▶ Needles in a Haystack ^](#%E2%96%B6-needles-in-a-haystack-%5E)
-      - [💡 Explanation:](#-explanation-31)
+    - [▶ Needles in a Haystack](#%E2%96%B6-needles-in-a-haystack)
     - [▶ Wild imports](#%E2%96%B6-wild-imports)
-      - [💡 Explanation:](#-explanation-32)
   - [Section: The Hidden treasures!](#section-the-hidden-treasures)
-    - [▶ Okay Python, Can you make me fly? *](#%E2%96%B6-okay-python-can-you-make-me-fly-)
-      - [💡 Explanation:](#-explanation-33)
-    - [▶ `goto`, but why? *](#%E2%96%B6-goto-but-why-)
-      - [💡 Explanation:](#-explanation-34)
-    - [▶ Brace yourself! *](#%E2%96%B6-brace-yourself-)
-      - [💡 Explanation:](#-explanation-35)
-    - [▶ Let's meet Friendly Language Uncle For Life ^](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life-%5E)
-      - [💡 Explanation:](#-explanation-36)
-    - [▶ Even Python understands that love is complicated *](#%E2%96%B6-even-python-understands-that-love-is-complicated-)
-      - [💡 Explanation:](#-explanation-37)
+    - [▶ Okay Python, Can you make me fly?](#%E2%96%B6-okay-python-can-you-make-me-fly)
+    - [▶ `goto`, but why?](#%E2%96%B6-goto-but-why)
+    - [▶ Brace yourself!](#%E2%96%B6-brace-yourself)
+    - [▶ Let's meet Friendly Language Uncle For Life](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life)
+    - [▶ Even Python understands that love is complicated](#%E2%96%B6-even-python-understands-that-love-is-complicated)
     - [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
-      - [💡 Explanation:](#-explanation-38)
-    - [▶ Ellipsis ^](#%E2%96%B6-ellipsis-%5E)
-      - [💡 Explanation](#-explanation-11)
-    - [▶ Inpinity *](#%E2%96%B6-inpinity-)
-      - [💡 Explanation:](#-explanation-39)
-    - [▶ Let's mangle ^](#%E2%96%B6-lets-mangle-%5E)
-      - [💡 Explanation:](#-explanation-40)
+    - [▶ Ellipsis](#%E2%96%B6-ellipsis)
+    - [▶ Inpinity](#%E2%96%B6-inpinity)
+    - [▶ Let's mangle](#%E2%96%B6-lets-mangle)
   - [Section: Miscellaneous](#section-miscellaneous)
     - [▶ `+=` is faster](#%E2%96%B6--is-faster)
-      - [💡 Explanation:](#-explanation-41)
     - [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
-      - [💡 Explanation](#-explanation-12)
     - [▶ Explicit typecast of strings](#%E2%96%B6-explicit-typecast-of-strings)
-      - [💡 Explanation:](#-explanation-42)
     - [▶ Minor Ones](#%E2%96%B6-minor-ones)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
-      - [Some nice Links!](#some-nice-links)
 - [🎓 License](#-license)
   - [Help](#help)
   - [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
@@ -159,8 +104,7 @@ So, here we go...
 
 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.
+> ### ▶ Some fancy Title
 >
 > ```py
 > # Setting up the code.
@@ -220,7 +164,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 
 ## Section: Strain your brain!
 
-### ▶ Strings can be tricky sometimes *
+### ▶ Strings can be tricky sometimes
 <!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --->
 1\.
 ```py
@@ -270,7 +214,7 @@ Makes sense, right?
 
 ---
 
-### ▶ Splitsies ^
+### ▶ Splitsies
 <!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
 ```py
 >>> 'a'.split()
@@ -352,7 +296,7 @@ So, why is Python all over the place?
 
 ---
 
-### ▶ The disorder within order ^
+### ▶ The disorder within order
 <!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
 from collections import OrderedDict
@@ -450,7 +394,7 @@ What is going on here?
 
 ---
 
-### ▶ Keep trying? *
+### ▶ Keep trying?
 <!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --->
 ```py
 def some_func():
@@ -510,7 +454,7 @@ Iteration 0
 
 ---
 
-### ▶ Deep down, we're all the same. *
+### ▶ Deep down, we're all the same
 <!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
 ```py
 class WTF:
@@ -613,7 +557,7 @@ for i, some_dict[i] in enumerate(some_string):
 
 ---
 
-### ▶ Evaluation time discrepancy ^
+### ▶ Evaluation time discrepancy
 <!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --->
 1\.
 ```py
@@ -896,7 +840,7 @@ Even when the values of `x` were different in every iteration prior to appending
 
 ---
 
-### ▶ The chicken-egg problem ^
+### ▶ The chicken-egg problem
 <!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --->
 1\.
 ```py
@@ -990,7 +934,7 @@ SyntaxError: invalid syntax
 
 ---
 
-### ▶ Strings and the backslashes\ ^
+### ▶ Strings and the backslashes
 <!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --->
 **Output:**
 ```py
@@ -1489,7 +1433,7 @@ Most methods that modify the items of sequence/mapping objects like `list.append
 
 ---
 
-### ▶ Subclass relationships *
+### ▶ Subclass relationships
 <!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
 **Output:**
 ```py
@@ -1513,7 +1457,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 
 ---
 
-### ▶ The mysterious key type conversion *
+### ▶ The mysterious key type conversion
 <!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --->
 ```py
 class SomeClass(str):
@@ -1666,7 +1610,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 
 ---
 
-### ▶ Teleportation *
+### ▶ Teleportation
 <!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
 ```py
 import numpy as np
@@ -1776,7 +1720,7 @@ Yes, it runs for exactly **eight** times and stops.
 
 ---
 
-### ▶ Stubborn `del` operation *
+### ▶ Stubborn `del` operation
 <!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --->
 ```py
 class SomeClass:
@@ -2245,7 +2189,7 @@ class SomeClass:
 
 ---
 
-### ▶ Needles in a Haystack ^
+### ▶ Needles in a Haystack
 <!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
 1\.
 ```py
@@ -2412,7 +2356,7 @@ NameError: name 'some_weird_name_func_' is not defined
 
 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? *
+### ▶ Okay Python, Can you make me fly?
 <!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --->
 Well, here you go
 
@@ -2430,7 +2374,7 @@ Sshh.. It's a super secret.
 
 ---
 
-### ▶ `goto`, but why? *
+### ▶ `goto`, but why?
 <!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --->
 ```py
 from goto import goto, label
@@ -2458,7 +2402,7 @@ Freedom!
 
 ---
 
-### ▶ Brace yourself! *
+### ▶ Brace yourself!
 <!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --->
 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,
 
@@ -2483,7 +2427,7 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr
 
 ---
 
-### ▶ Let's meet Friendly Language Uncle For Life ^
+### ▶ Let's meet Friendly Language Uncle For Life
 <!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --->
 **Output (Python 3.x)**
 ```py
@@ -2514,7 +2458,7 @@ There we go.
 
 ---
 
-### ▶ Even Python understands that love is complicated *
+### ▶ Even Python understands that love is complicated
 <!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --->
 ```py
 import this
@@ -2615,7 +2559,7 @@ Try block executed successfully...
 - `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.
 
 ---
-### ▶ Ellipsis ^
+### ▶ Ellipsis
 <!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --->
 ```py
 def some_func():
@@ -2675,7 +2619,7 @@ Ellipsis
 
 ---
 
-### ▶ Inpinity *
+### ▶ Inpinity
 <!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --->
 The spelling is intended. Please, don't submit a patch for this.
 
@@ -2694,7 +2638,7 @@ The spelling is intended. Please, don't submit a patch for this.
 
 ---
 
-### ▶ Let's mangle ^
+### ▶ Let's mangle
 <!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --->
 1\.
 ```py

From d3157d61a303e31082ac7a82ebfd5e39e5ae8eb9 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 22:22:04 +0530
Subject: [PATCH 039/146] Fix toc

---
 README.md | 141 ++++++++++++++++++++++++++----------------------------
 1 file changed, 69 insertions(+), 72 deletions(-)

diff --git a/README.md b/README.md
index 4a7157f..5787e06 100644
--- a/README.md
+++ b/README.md
@@ -20,85 +20,82 @@ So, here we go...
 
 # Table of Contents
 
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-
+<!-- toc -->
 
 - [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](#%E2%96%B6-strings-can-be-tricky-sometimes)
-    - [▶ Splitsies](#%E2%96%B6-splitsies)
-- [is same as](#is-same-as)
-- [but](#but)
-- [isn't the same as](#isnt-the-same-as)
-    - [▶ Time for some hash brownies!](#%E2%96%B6-time-for-some-hash-brownies)
-    - [▶ The disorder within order](#%E2%96%B6-the-disorder-within-order)
-    - [▶ Keep trying?](#%E2%96%B6-keep-trying)
-    - [▶ Deep down, we're all the same](#%E2%96%B6-deep-down-were-all-the-same)
-    - [▶ For what?](#%E2%96%B6-for-what)
-    - [▶ Evaluation time discrepancy](#%E2%96%B6-evaluation-time-discrepancy)
-    - [▶ Messing around with `is` operator^](#%E2%96%B6-messing-around-with-is-operator%5E)
-    - [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
-    - [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
-    - [▶ The chicken-egg problem](#%E2%96%B6-the-chicken-egg-problem)
-    - [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
-    - [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
-    - [▶ Strings and the backslashes](#%E2%96%B6-strings-and-the-backslashes)
-    - [▶ not knot!](#%E2%96%B6-not-knot)
-    - [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
-    - [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
-    - [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
-    - [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
-    - [▶ yielding None](#%E2%96%B6-yielding-none)
-    - [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
-    - [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
-    - [▶ When True is actually False](#%E2%96%B6-when-true-is-actually-false)
-    - [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
-    - [▶ From filled to None in one instruction...](#%E2%96%B6-from-filled-to-none-in-one-instruction)
-    - [▶ Subclass relationships](#%E2%96%B6-subclass-relationships)
-    - [▶ The mysterious key type conversion](#%E2%96%B6-the-mysterious-key-type-conversion)
-    - [▶ Let's see if you can guess this?](#%E2%96%B6-lets-see-if-you-can-guess-this)
-  - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
-    - [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
-    - [▶ Teleportation](#%E2%96%B6-teleportation)
-    - [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
-  - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines)
-    - [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
-    - [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
-    - [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
-    - [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
-    - [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
-    - [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
-    - [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
-    - [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
-    - [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
-    - [▶ Needles in a Haystack](#%E2%96%B6-needles-in-a-haystack)
-    - [▶ Wild imports](#%E2%96%B6-wild-imports)
-  - [Section: The Hidden treasures!](#section-the-hidden-treasures)
-    - [▶ Okay Python, Can you make me fly?](#%E2%96%B6-okay-python-can-you-make-me-fly)
-    - [▶ `goto`, but why?](#%E2%96%B6-goto-but-why)
-    - [▶ Brace yourself!](#%E2%96%B6-brace-yourself)
-    - [▶ Let's meet Friendly Language Uncle For Life](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life)
-    - [▶ Even Python understands that love is complicated](#%E2%96%B6-even-python-understands-that-love-is-complicated)
-    - [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
-    - [▶ Ellipsis](#%E2%96%B6-ellipsis)
-    - [▶ Inpinity](#%E2%96%B6-inpinity)
-    - [▶ Let's mangle](#%E2%96%B6-lets-mangle)
-  - [Section: Miscellaneous](#section-miscellaneous)
-    - [▶ `+=` is faster](#%E2%96%B6--is-faster)
-    - [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
-    - [▶ Explicit typecast of strings](#%E2%96%B6-explicit-typecast-of-strings)
-    - [▶ Minor Ones](#%E2%96%B6-minor-ones)
+  * [Section: Strain your brain!](#section-strain-your-brain)
+    + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
+    + [▶ Splitsies](#-splitsies)
+    + [▶ Time for some hash brownies!](#-time-for-some-hash-brownies)
+    + [▶ The disorder within order](#-the-disorder-within-order)
+    + [▶ Keep trying?](#-keep-trying)
+    + [▶ Deep down, we're all the same](#-deep-down-were-all-the-same)
+    + [▶ For what?](#-for-what)
+    + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
+    + [▶ Messing around with `is` operator](#-messing-around-with-is-operator)
+    + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+    + [▶ The sticky output function](#-the-sticky-output-function)
+    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)
+    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+    + [▶ The surprising comma](#-the-surprising-comma)
+    + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
+    + [▶ not knot!](#-not-knot)
+    + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
+    + [▶ 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)
+    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)
+    + [▶ 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: 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)
+    + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
+    + [▶ Stubborn `del` operation](#-stubborn-del-operation)
+    + [▶ 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)
+    + [▶ Needles in a Haystack](#-needles-in-a-haystack)
+    + [▶ Wild imports](#-wild-imports)
+  * [Section: The Hidden treasures!](#section-the-hidden-treasures)
+    + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
+    + [▶ `goto`, but why?](#-goto-but-why)
+    + [▶ Brace yourself!](#-brace-yourself)
+    + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
+    + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
+    + [▶ Yes, it exists!](#-yes-it-exists)
+    + [▶ Ellipsis](#-ellipsis)
+    + [▶ Inpinity](#-inpinity)
+    + [▶ Let's mangle](#-lets-mangle)
+  * [Section: 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)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
 - [🎓 License](#-license)
-  - [Help](#help)
-  - [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
-  - [Need a pdf version?](#need-a-pdf-version)
+  * [Help](#help)
+  * [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
+  * [Need a pdf version?](#need-a-pdf-version)
 
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+<!-- tocstop -->
 
 # Structure of the Examples
 
@@ -623,7 +620,7 @@ array_4 = [400, 500, 600]
 
 ---
 
-### ▶ Messing around with `is` operator^
+### ▶ Messing around with `is` operator
 <!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --->
 The following is a very famous example present all over the internet.
 

From 772a96c36fbecfa74f314c3b60c3f58315b068a5 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 13 Jul 2019 22:41:27 +0530
Subject: [PATCH 040/146] change order

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 5787e06..f140259 100644
--- a/README.md
+++ b/README.md
@@ -262,9 +262,9 @@ some_dict[5] = "Python"
 ```py
 >>> some_dict[5.5]
 "Ruby"
->>> some_dict[5.0]
+>>> some_dict[5.0] # "Python" destroyed the existence of "JavaScript"?
 "Python"
->>> some_dict[5] # "Python" destroyed the existence of "JavaScript"?
+>>> some_dict[5] 
 "Python"
 
 >>> complex_five = 5 + 0j

From ffe64385762b91d9548777b165a4120f3ff2eccd Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 21 Jul 2019 18:57:01 +0530
Subject: [PATCH 041/146] Commit insert_ids script

---
 irrelevant/insert_ids.py | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 irrelevant/insert_ids.py

diff --git a/irrelevant/insert_ids.py b/irrelevant/insert_ids.py
new file mode 100644
index 0000000..a16bf5f
--- /dev/null
+++ b/irrelevant/insert_ids.py
@@ -0,0 +1,24 @@
+import uuid
+
+new_file = []
+original_file = []
+
+fname = "../README.md"
+
+
+def generate_random_id_comment():
+    random_id = uuid.uuid4()
+    return f"<!-- Example ID: {random_id} --!>"
+
+
+with open(fname, "r") as f:
+    original_file = f.readlines()
+
+
+for line in original_file:
+    new_file.append(line)
+    if line.strip().startswith("### "):
+        new_file.append(generate_random_id_comment())
+
+with open(fname, "w") as f:
+    f.write("".join(new_file))

From b0622a10ad2d1a5b5b339e89e2836002f6e008c6 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Tue, 30 Jul 2019 00:34:58 +0300
Subject: [PATCH 042/146] Fixes code highlight

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0e6fd1c..d66d632 100644
--- a/README.md
+++ b/README.md
@@ -1845,7 +1845,7 @@ x, y = (0, 1) if True else None, None
 ```
 
 **Output:**
-```
+```py
 >>> x, y  # expected (0, 1)
 ((0, 1), None)
 ```

From cedbfba829b894d1d6d45cd5f00e5611ee339a01 Mon Sep 17 00:00:00 2001
From: Kislov Dmitry <kislov@easydan.com>
Date: Fri, 13 Sep 2019 12:03:27 +1000
Subject: [PATCH 043/146] New snippet: yielding from... return!

---
 README.md | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/README.md b/README.md
index d66d632..47bf681 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,7 @@ So, here we go...
     - [▶ 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)
+    - [▶ Yielding from... return!](#-yielding-from-return)
   - [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-)
@@ -1883,6 +1884,64 @@ tuple()
 
 ---
 
+### ▶ Yielding from... return!
+
+1\.
+```py
+def func(k):
+    if k == 3:
+        return ["A string..."]
+    else:
+        yield from range(k)
+```
+
+**Output:**
+```py
+>>> list(func(3))  # expected: ["A string..."]
+[]
+```
+
+The same behavior is true if we rewrite `yield from` as a for loop.
+
+2\.
+```py
+def func(k):
+    if k == 3:
+        return ["A string..."]
+    else:
+        for j in range(k):
+            yield j
+```
+
+**Output:**
+```py
+>>> list(func(3))  # expected: ["A string..."]
+[]
+```
+
+#### 💡 Explanation:
+
+Starting from Python 3.3+ it became possible to use return statement 
+with values inside generators ([PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official doc](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) says that "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator." 
+
+So, to get `["A string..."]` from the generator `func` we need to catch `StopIteration`, e.g.:
+
+```py
+try:
+    next(func(3))
+except StopIteration as e:
+    string = e.value
+```
+
+```py
+>>> string
+['A string...']
+```
+
+Note that `list(...)` automatically catches `StopIteration`. In case of `func(3)` `StopIteration` raises at the beginning because of `return` statement. Therefore, `list(func(3))` results in an empty list.
+
+---
+
 ---
 
 

From c5665da81d583b92868218bc2a1f07436fd0456d Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 13 Sep 2019 15:01:45 +0530
Subject: [PATCH 044/146] Nitpicks in the new example

---
 README.md | 55 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/README.md b/README.md
index 47bf681..be27847 100644
--- a/README.md
+++ b/README.md
@@ -1888,57 +1888,60 @@ tuple()
 
 1\.
 ```py
-def func(k):
-    if k == 3:
-        return ["A string..."]
+def some_func(x):
+    if x == 3:
+        return ["wtf"]
     else:
-        yield from range(k)
+        yield from range(x)
 ```
 
 **Output:**
 ```py
->>> list(func(3))  # expected: ["A string..."]
+>>> list(some_func(3))
 []
 ```
 
-The same behavior is true if we rewrite `yield from` as a for loop.
+Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
 
 2\.
 ```py
-def func(k):
-    if k == 3:
-        return ["A string..."]
+def some_func(x):
+    if x == 3:
+        return ["wtf"]
     else:
-        for j in range(k):
-            yield j
+        for i in range(x):
+          yield i
 ```
 
 **Output:**
 ```py
->>> list(func(3))  # expected: ["A string..."]
+>>> list(some_func(3))
 []
 ```
 
+Same result, that didn't work either.
+
 #### 💡 Explanation:
 
-Starting from Python 3.3+ it became possible to use return statement 
-with values inside generators ([PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official doc](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) says that "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator." 
++ 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,
 
-So, to get `["A string..."]` from the generator `func` we need to catch `StopIteration`, e.g.:
+> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
 
-```py
-try:
-    next(func(3))
-except StopIteration as e:
-    string = e.value
-```
++ In case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically catched inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
 
-```py
->>> string
-['A string...']
-```
++ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
+  ```py
+  try:
+      next(some_func(3))
+  except StopIteration as e:
+      some_string = e.value
+  ```
+
+  ```py
+  >>> some_string
+  ["wtf"]
+  ```
 
-Note that `list(...)` automatically catches `StopIteration`. In case of `func(3)` `StopIteration` raises at the beginning because of `return` statement. Therefore, `list(func(3))` results in an empty list.
 
 ---
 

From 03719dea4584ac2237b4ed0c9274afb063e3dd70 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 13 Sep 2019 15:15:31 +0530
Subject: [PATCH 045/146] Add few pointers for contributing well

---
 CONTRIBUTING.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 13a5a0d..e9c43db 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -36,3 +36,10 @@ Probably unexpected output
   ```
 ```
 </pre>
+
+
+Few things that you can consider while writing an example, 
+
+- Try to be consistent with the namings and the values you use with the variables. For instance, most variable names in the project are along the lines of `some_string`, `some_list`, `some_dict`, etc. You'd see a lot of `x`s for single letter variable names, and `"wtf"` as values for strings. There's strictly enforced scheme in the project, 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, please don't forget to add your name to the [contributors list](/CONTRIBUTING.md).
\ No newline at end of file

From 290921fe12091a2364a2ff0a876c557baad19ec1 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Wed, 1 May 2019 19:12:17 +0530
Subject: [PATCH 046/146] Add json generator

---
 irrelevant/json_generator.py | 156 +++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 irrelevant/json_generator.py

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
new file mode 100644
index 0000000..86820f1
--- /dev/null
+++ b/irrelevant/json_generator.py
@@ -0,0 +1,156 @@
+import pprint
+fname = "/Users/300041709/code/self/wtfpython/README.md"
+examples = []
+
+# The globals
+current_example = 1
+current_section_name = ""
+
+
+def parse_example_parts(lines):
+    parts = {
+        "build_up": [],
+        "explanation": []
+    }
+    next_line = next(lines)
+    sequence_num = 1
+    content = []
+    # store build_up till an H4 (explanation) is encountered
+    while not next_line.startswith("#### "):
+        # Watching out for the snippets
+        if next_line.startswith("```"):
+            # It's a snippet, whatever found until now is text
+            if content:
+                parts["build_up"].append(
+                    {
+                        "type": "text",
+                        "sequence_num": sequence_num,
+                        "value": content
+                    }
+                )
+                sequence_num += 1
+                content = []
+
+            next_line = next(lines)
+            while not next_line.startswith("```"):
+                content.append(next_line)
+                next_line = next(lines)
+            # Snippet is over
+            parts["build_up"].append(
+                {
+                    "type": "code",
+                    "sequence_num": sequence_num,
+                    "value": content
+                }
+            )
+            sequence_num += 1
+            content = []
+            next_line = next(lines)
+            continue
+        else:
+            # It's a text, go on.
+            content.append(next_line)
+            next_line = next(lines)
+
+    # Explanation encountered, save any content till now (if any)
+    if content:
+        parts["build_up"].append(
+            {
+                "type": "text",
+                "sequence_num": sequence_num,
+                "value": content
+            }
+        )
+
+    # Reset stuff
+    sequence_num = 1
+    content = []
+
+    # store lines again until --- or another H3 is encountered
+    while not (next_line.startswith("---") or
+               next_line.startswith("### ")):
+
+        if next_line.startswith("```"):
+            # It's a snippet, whatever found until now is text
+            if content:
+                parts["explanation"].append(
+                    {
+                        "type": "text",
+                        "sequence_num": sequence_num,
+                        "value": content
+                    }
+                )
+                sequence_num += 1
+                content = []
+
+            next_line = next(lines)
+            while not next_line.startswith("```"):
+                content.append(next_line)
+                next_line = next(lines)
+            # Snippet is over
+            parts["explanation"].append(
+                {
+                    "type": "code",
+                    "sequence_num": sequence_num,
+                    "value": content
+                }
+            )
+            sequence_num += 1
+            content = []
+            next_line = next(lines)
+            continue
+        else:
+            # It's a text, go on.
+            content.append(next_line)
+            next_line = next(lines)
+
+    # All done
+    if content:
+        parts["explanation"].append(
+            {
+                "type": "text",
+                "sequence_num": sequence_num,
+                "value": content
+            }
+        )
+
+    return next_line, parts
+
+
+with open(fname, 'r+', encoding="utf-8") as f:
+    lines = iter(f.readlines())
+    line = next(lines)
+    result = []
+    try:
+        while True:
+            if line.startswith("## "):
+                # A section is encountered
+                current_section_name = line.replace("## ", "").strip()
+                line = next(lines)
+                # Until a new section is encountered
+                while not (line.startswith("## " )):
+                    # check if it's a H3
+                    if line.startswith("### "):
+                        # An example is encountered
+                        title = line.replace("### ", "")
+                        example_details = {
+                            "id": current_example,
+                            "title": line.replace("### ", ""),
+                            "section": current_section_name
+                        }
+                        line, example_details["parts"] = parse_example_parts(lines)
+                        result.append(example_details)
+                        current_example += 1
+                    else:
+                        # todo catch section text
+                        line = next(lines)
+            else:
+                line = next(lines)
+
+    except StopIteration:
+        pprint.pprint(result, indent=2)
+        print(len(result))
+
+
+
+

From 3479b2befb884ce8a14d087f5febe5b445016c5a Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Wed, 1 May 2019 19:55:46 +0530
Subject: [PATCH 047/146] Use absolute path for the pager.

Fixes https://github.com/satwikkansal/wtfpython/issues/119
---
 wtfpython-pypi/wtf_python/main.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/wtfpython-pypi/wtf_python/main.py b/wtfpython-pypi/wtf_python/main.py
index 5799178..bf76815 100644
--- a/wtfpython-pypi/wtf_python/main.py
+++ b/wtfpython-pypi/wtf_python/main.py
@@ -1,3 +1,5 @@
+from os.path import dirname, join, realpath
+
 import pydoc
 try:
     from urllib.request import urlretrieve
@@ -6,13 +8,14 @@ except ImportError:
 
 url = ("http://raw.githubusercontent.com/satwikkansal/"
        "wtfpython/master/README.md")
-file_name = "content.md"
+
+file_path = join(dirname(dirname(realpath(__file__))), "content.md")
 
 
 def fetch_updated_doc():
     try:
         print("Fetching the latest version...")
-        urlretrieve(url, file_name)
+        urlretrieve(url, file_path)
         print("Done!")
     except Exception as e:
         print(e)
@@ -21,7 +24,7 @@ def fetch_updated_doc():
 
 
 def render_doc():
-    with open(file_name, 'r', encoding='utf-8') as f:
+    with open(file_path, 'r', encoding="utf-8") as f:
         content = f.read()
         pydoc.pager(content)
 

From efdac8f9caf82336d6c13686a7a9c393fa3ccbab Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 6 May 2019 23:47:24 +0530
Subject: [PATCH 048/146] Get the generator in a working state

---
 irrelevant/json_generator.py | 239 +++++++++++++++++++++++++----------
 1 file changed, 175 insertions(+), 64 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index 86820f1..ea75cb5 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -1,52 +1,85 @@
+import json
 import pprint
 fname = "/Users/300041709/code/self/wtfpython/README.md"
 examples = []
 
 # The globals
 current_example = 1
+sequence_num = 1
 current_section_name = ""
 
 
-def parse_example_parts(lines):
+STATEMENT_PREFIXES = ["...", ">>> ", "$ "]
+
+
+def generate_code_block(statements, output):
+    global sequence_num
+    result = {
+        "type": "code",
+        "sequence_num": sequence_num,
+        "statements": statements,
+        "output": output
+    }
+    sequence_num += 1
+    return result
+
+
+def generate_markdown_block(lines):
+    global sequence_num
+    result = {
+        "type": "markdown",
+        "sequence_num": sequence_num,
+        "value": lines
+    }
+    sequence_num += 1
+    return result
+
+def is_interactive_statement(line):
+    for prefix in STATEMENT_PREFIXES:
+        if line.startswith(prefix):
+            return True
+    return False
+
+def parse_example_parts(lines, example_title_line):
     parts = {
         "build_up": [],
         "explanation": []
     }
-    next_line = next(lines)
-    sequence_num = 1
     content = []
+    statements_so_far = []
+    output_so_far = []
+    next_line = example_title_line
     # store build_up till an H4 (explanation) is encountered
     while not next_line.startswith("#### "):
         # Watching out for the snippets
         if next_line.startswith("```"):
             # It's a snippet, whatever found until now is text
+            is_interactive = False
             if content:
-                parts["build_up"].append(
-                    {
-                        "type": "text",
-                        "sequence_num": sequence_num,
-                        "value": content
-                    }
-                )
-                sequence_num += 1
+                parts["build_up"].append(generate_markdown_block(content))
                 content = []
 
             next_line = next(lines)
+
             while not next_line.startswith("```"):
-                content.append(next_line)
+                if is_interactive_statement(next_line):
+                    is_interactive = True
+                    if (output_so_far):
+                        parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+                        statements_so_far, output_so_far = [], []
+                    statements_so_far.append(next_line)
+                else:
+                    # can be either output or normal code
+                    if is_interactive:
+                        output_so_far.append(next_line)
+                    else:
+                        statements_so_far.append(next_line)
                 next_line = next(lines)
+
             # Snippet is over
-            parts["build_up"].append(
-                {
-                    "type": "code",
-                    "sequence_num": sequence_num,
-                    "value": content
-                }
-            )
-            sequence_num += 1
-            content = []
+            parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+            statements_so_far, output_so_far = [], []
             next_line = next(lines)
-            continue
         else:
             # It's a text, go on.
             content.append(next_line)
@@ -54,51 +87,43 @@ def parse_example_parts(lines):
 
     # Explanation encountered, save any content till now (if any)
     if content:
-        parts["build_up"].append(
-            {
-                "type": "text",
-                "sequence_num": sequence_num,
-                "value": content
-            }
-        )
+        parts["build_up"].append(generate_markdown_block(content))
 
     # Reset stuff
-    sequence_num = 1
     content = []
+    statements_so_far, output_so_far = [], []
 
     # store lines again until --- or another H3 is encountered
     while not (next_line.startswith("---") or
                next_line.startswith("### ")):
-
         if next_line.startswith("```"):
             # It's a snippet, whatever found until now is text
+            is_interactive = False
             if content:
-                parts["explanation"].append(
-                    {
-                        "type": "text",
-                        "sequence_num": sequence_num,
-                        "value": content
-                    }
-                )
-                sequence_num += 1
+                parts["build_up"].append(generate_markdown_block(content))
                 content = []
 
             next_line = next(lines)
+
             while not next_line.startswith("```"):
-                content.append(next_line)
+                if is_interactive_statement(next_line):
+                    is_interactive = True
+                    if (output_so_far):
+                        parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+                        statements_so_far, output_so_far = [], []
+                    statements_so_far.append(next_line)
+                else:
+                    # can be either output or normal code
+                    if is_interactive:
+                        output_so_far.append(next_line)
+                    else:
+                        statements_so_far.append(next_line)
                 next_line = next(lines)
+
             # Snippet is over
-            parts["explanation"].append(
-                {
-                    "type": "code",
-                    "sequence_num": sequence_num,
-                    "value": content
-                }
-            )
-            sequence_num += 1
-            content = []
+            parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+            statements_so_far, output_so_far = [], []
             next_line = next(lines)
-            continue
         else:
             # It's a text, go on.
             content.append(next_line)
@@ -106,16 +131,105 @@ def parse_example_parts(lines):
 
     # All done
     if content:
-        parts["explanation"].append(
-            {
-                "type": "text",
-                "sequence_num": sequence_num,
-                "value": content
-            }
-        )
+        parts["explanation"].append(generate_markdown_block(content))
 
     return next_line, parts
 
+def remove_from_beginning(tokens, line):
+    for token in tokens:
+        if line.startswith(token):
+            line = line.replace(token, "")
+    return line
+
+
+def inspect_and_sanitize_code_lines(lines):
+    tokens_to_remove = STATEMENT_PREFIXES
+    result = []
+    is_print_present = False
+    for line in lines:
+        line = remove_from_beginning(tokens_to_remove, line)
+        if line.startswith("print ") or line.startswith("print("):
+            is_print_present = True
+        result.append(line)
+    return is_print_present, result
+
+def convert_to_cells(cell_contents):
+    cells = []
+    for stuff in cell_contents:
+        if stuff["type"] == "markdown":
+            # todo add metadata later
+            cells.append(
+                {
+                    "cell_type": "markdown",
+                    "metadata": {},
+                    "source": stuff["value"]
+                }
+            )
+        elif stuff["type"] == "code":
+            is_print_present, sanitized_code = inspect_and_sanitize_code_lines(stuff["statements"])
+            if is_print_present:
+                cells.append(
+                    {
+                        "cell_type": "code",
+                        "metadata": {
+                            "collapsed": True
+                        },
+                        "execution_count": None,
+                        "outputs": [{
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": stuff["output"]
+                        }],
+                        "source": sanitized_code
+                    }
+                )
+            else:
+                cells.append(
+                    {
+                        "cell_type": "code",
+                        "execution_count": None,
+                        "metadata": {
+                            "collapsed": True
+                        },
+                        "outputs": [{
+                            "data": {
+                                "text/plain": stuff["output"]
+                            },
+                            "output_type": "execute_result",
+                            "metadata": {},
+                            "execution_count": None
+                        }],
+                        "source": sanitized_code
+                    }
+                )
+
+    return cells
+
+
+def convert_to_notebook(parsed_json):
+    result = {
+        "cells": [],
+        "metadata": {},
+        "nbformat": 4,
+        "nbformat_minor": 2
+    }
+    for example in parsed_json:
+        parts = example["parts"]
+        build_up = parts.get("build_up")
+        explanation = parts.get("explanation")
+        notebook_path = "test.ipynb"
+
+        if(build_up):
+            result["cells"] += convert_to_cells(build_up)
+
+        if(explanation):
+            result["cells"] += convert_to_cells(explanation)
+
+    pprint.pprint(result, indent=2)
+    with open(notebook_path, "w") as f:
+        json.dump(result, f)
+
+
 
 with open(fname, 'r+', encoding="utf-8") as f:
     lines = iter(f.readlines())
@@ -126,6 +240,7 @@ with open(fname, 'r+', encoding="utf-8") as f:
             if line.startswith("## "):
                 # A section is encountered
                 current_section_name = line.replace("## ", "").strip()
+                section_text = []
                 line = next(lines)
                 # Until a new section is encountered
                 while not (line.startswith("## " )):
@@ -138,19 +253,15 @@ with open(fname, 'r+', encoding="utf-8") as f:
                             "title": line.replace("### ", ""),
                             "section": current_section_name
                         }
-                        line, example_details["parts"] = parse_example_parts(lines)
+                        line, example_details["parts"] = parse_example_parts(lines, line)
                         result.append(example_details)
                         current_example += 1
                     else:
-                        # todo catch section text
+                        section_text.append(line)
                         line = next(lines)
             else:
                 line = next(lines)
 
     except StopIteration:
         pprint.pprint(result, indent=2)
-        print(len(result))
-
-
-
-
+        convert_to_notebook(result)

From a5e7cd7cf83c3dc8522b9e5889758cf993967c2e Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 6 May 2019 23:49:57 +0530
Subject: [PATCH 049/146] Add todos

---
 irrelevant/json_generator.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index ea75cb5..cfebf4f 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -1,3 +1,15 @@
+"""
+An inefficient monolithic piece of code that'll generate jupyter notebook
+from the projects main README.
+
+TODO
+
+- CLI arguments for running this thing.
+- Add it to prepush hook
+- Use templates?
+
+"""
+
 import json
 import pprint
 fname = "/Users/300041709/code/self/wtfpython/README.md"

From 810dbe15822ff0393dd29746573bb950bc58220f Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Fri, 7 Jun 2019 23:48:07 +0530
Subject: [PATCH 050/146] Some hideous typora corrections and a new snippets
 added

Also closes https://github.com/satwikkansal/wtfpython/issues/73
---
 README.md | 55 +++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 47 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index be27847..7fffe0c 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<p align="center"><img src="/images/logo.png" alt=""></p>
+<p align="center"><img src="images/logo.png" alt=""></p>
 <h1 align="center">What the f*ck Python! 🐍</h1>
 <p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
 
@@ -203,11 +203,10 @@ Makes sense, right?
   * All length 0 and length 1 strings are interned.
   * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)
   * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. Cpython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
-  <img src="/images/string-intern/string_intern.png" alt="">
+  <img src="images/string-intern/string_intern.png" alt="">
 + When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
 + Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than or equal to 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 
-
 ---
 
 ### ▶ Time for some hash brownies!
@@ -248,7 +247,7 @@ some_dict[5] = "Python"
 
 ---
 
-### ▶ Return return everywhere!
+### ▶ Keep trying? *
 
 ```py
 def some_func():
@@ -256,18 +255,55 @@ def some_func():
         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 ocurred", e)
 ```
 
 **Output:**
+
 ```py
 >>> some_func()
 'from_finally'
+
+>>> another_func()
+Finally!
+Finally!
+Finally!
+
+>>> 1 / 0
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ZeroDivisionError: division by zero
+
+>>> one_more_func()
+Iteration 0
+
 ```
 
 #### 💡 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.
 
 ---
 
@@ -531,11 +567,11 @@ We didn't assign 3 "X"s or did we?
 
 When we initialize `row` variable, this visualization explains what happens in the memory
 
-![image](/images/tic-tac-toe/after_row_initialized.png)
+![image](images/tic-tac-toe/after_row_initialized.png)
 
 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`)
 
-![image](/images/tic-tac-toe/after_board_initialized.png)
+![image](images/tic-tac-toe/after_board_initialized.png)
 
 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).
 
@@ -1185,8 +1221,9 @@ a, b = a[b] = {}, 5
   (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.
-
+  
+> 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`.
@@ -1320,6 +1357,7 @@ Shouldn't that be 100?
 
 * **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.
@@ -2041,6 +2079,7 @@ 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/).
 

From f8a7d38b70ce00411c752797a3101f38c1a3c57d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Fri, 7 Jun 2019 23:48:51 +0530
Subject: [PATCH 051/146] Update content.md

---
 wtfpython-pypi/content.md | 79 ++++++++++++++++++++++-----------------
 1 file changed, 44 insertions(+), 35 deletions(-)

diff --git a/wtfpython-pypi/content.md b/wtfpython-pypi/content.md
index 486a98e..9827fc4 100644
--- a/wtfpython-pypi/content.md
+++ b/wtfpython-pypi/content.md
@@ -1,9 +1,10 @@
 <p align="center"><img src="/images/logo.png" alt=""></p>
-<h1 align="center"> What the f*ck Python! 🐍 </h1>
-<p align="center"> An interesting collection of surprising snippets and lesser-known Python features.</p>
+<h1 align="center">What the f*ck Python! 🐍</h1>
+<p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
 
 [![WTFPL 2.0][license-image]][license-url]
 
+Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
 
 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.
 
@@ -13,7 +14,7 @@ While some of the examples you see below may not be WTFs in the truest sense, bu
 
 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/).
+PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).
 
 So, here we go...
 
@@ -77,7 +78,7 @@ So, here we go...
     - [▶ Yes, it exists!](#-yes-it-exists)
     - [▶ Inpinity *](#-inpinity-)
     - [▶ Mangling time! *](#-mangling-time-)
-  - [Section: Miscallaneous](#section-miscallaneous)
+  - [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)
@@ -97,22 +98,22 @@ 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)
@@ -200,10 +201,10 @@ Makes sense, right?
 + 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 `!`.
+  * 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)
   <img src="/images/string-intern/string_intern.png" alt="">
 + When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. But since the python bytecode generated after compilation is stored in `.pyc` files, the strings greater than length of 20 are discarded for peephole optimization (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`)
++ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 
 
 ---
@@ -241,7 +242,7 @@ some_dict[5] = "Python"
   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`.
+* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
 * This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
 
 ---
@@ -296,16 +297,24 @@ True
 * 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 ")
+    def __init__(self): print("I")
+    def __del__(self): print("D")
   ```
 
   **Output:**
   ```py
   >>> WTF() is WTF()
-  I I D D
+  I
+  I
+  D
+  D
+  False
   >>> id(WTF()) == id(WTF())
-  I D I D
+  I
+  D
+  I
+  D
+  True
   ```
   As you may observe, the order in which the objects are destroyed is what made all the difference here.
 
@@ -530,7 +539,7 @@ And when the `board` is initialized by multiplying the `row`, this is what happe
 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)*3] # board = = [['']*3 for _ in range(3)]
+>>> board = [['']*3 for _ in range(3)]
 >>> board[0][0] = "X"
 >>> board
 [['X', '', ''], ['', '', ''], ['', '', '']]
@@ -547,7 +556,7 @@ 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]
 ```
@@ -766,10 +775,10 @@ for item in mixed_list:
 
 **Output:**
 ```py
->>> booleans_found_so_far
-0
 >>> integers_found_so_far
 4
+>>> booleans_found_so_far
+0
 ```
 
 2\.
@@ -830,7 +839,7 @@ class C(A):
     pass
 ```
 
-**Ouptut:**
+**Output:**
 ```py
 >>> A.x, B.x, C.x
 (1, 1, 1)
@@ -1135,7 +1144,7 @@ str
             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__
@@ -1148,7 +1157,7 @@ str
   >>> s = SomeClass('s')
   >>> some_dict[s] = 40
   >>> some_dict
-  {'s': 40}
+  {'s': 40, 's': 42}
   >>> keys = list(some_dict.keys())
   >>> type(keys[0]), type(keys[1])
   (__main__.SomeClass, str)
@@ -1313,7 +1322,7 @@ Shouldn't that be 100?
   > 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
@@ -1697,7 +1706,7 @@ a += [5, 6, 7, 8]
 
 * The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.
 
-* The expression `a + =[5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.
+* The expression `a += [5,6,7,8]` is actually mapped to an "extend" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.
 
 ---
 
@@ -1731,7 +1740,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
       a += 1
       return a
   ```
-  
+
   **Output:**
   ```py
   >>> another_func()
@@ -1895,7 +1904,7 @@ 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/).
++ 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/).
 
 ---
 
@@ -2115,7 +2124,7 @@ AttributeError: 'Yo' object has no attribute '__honey'
 True
 ```
 
-Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
+Why did `Yo()._Yo__honey` work? Only Indian readers would understand.
 
 #### 💡 Explanation:
 
@@ -2127,7 +2136,7 @@ Why did `Yo()._Yo__honey` worked? Only Indian readers would understand.
 
 ---
 
-## Section: Miscallaneous
+## Section: Miscellaneous
 
 
 ### ▶ `+=` is faster
@@ -2272,7 +2281,7 @@ nan
 ### ▶ 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.
 
@@ -2350,7 +2359,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * 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.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
 
 # 🎓 License
 
@@ -2365,12 +2374,12 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 If you have any wtfs, ideas or suggestions, please share.
 
-## Want to share wtfpython with friends?
+## Surprise your geeky pythonist friends?
 
-You can use these quick links for Twitter and Linkedin.
+You can use these quick links to recommend wtfpython to your friends,
 
-[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&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.)
 
 ## Need a pdf version?
 

From dbbabbe564d63331a364514a18b68a9dcb16c2ff Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 00:23:33 +0530
Subject: [PATCH 052/146] Update evaluation time discrepency example: Add
 another snippet

Resolves https://github.com/satwikkansal/wtfpython/issues/41
---
 README.md | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 7fffe0c..266ddcb 100644
--- a/README.md
+++ b/README.md
@@ -410,7 +410,7 @@ for i, some_dict[i] in enumerate(some_string):
 
 ---
 
-### ▶ Evaluation time discrepancy
+### ▶ Evaluation time discrepancy ^
 
 1\.
 ```py
@@ -446,6 +446,23 @@ array_2[:] = [1,2,3,4,5]
 [1,2,3,4,5]
 ```
 
+3\.
+
+```py
+array_3 = [1, 2, 3]
+array_4 = [10, 20, 30]
+g = (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(g))
+[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.
@@ -453,6 +470,9 @@ array_2[:] = [1,2,3,4,5]
 - The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.
 - In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
 - In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
+- 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)
+    > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
+ 
 
 ---
 
@@ -1223,7 +1243,7 @@ a, b = a[b] = {}, 5
   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`.

From a0832c4459087bfcad7c506a7efcef3bb587077d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 00:41:58 +0530
Subject: [PATCH 053/146] Modifying a dictionary while iterating over it: Add
 note

Resolves https://github.com/satwikkansal/wtfpython/issues/53
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 266ddcb..be6e5b0 100644
--- a/README.md
+++ b/README.md
@@ -471,8 +471,8 @@ array_4 = [400, 500, 600]
 - In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
 - In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
 - 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)
+    
     > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
- 
 
 ---
 
@@ -1425,7 +1425,7 @@ Yes, it runs for exactly **eight** times and stops.
 * Iteration over a dictionary that you edit at the same time is not supported.
 * It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
 * How deleted keys are handled and when the resize occurs might be different for different Python implementations.
-* 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.
+* 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.
 
 ---
 

From f3b96e4d7fa713b3bb27a75d3d14feb22904efd0 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 02:53:53 +0530
Subject: [PATCH 054/146] Expand strings and backslashes

Resolves https://github.com/satwikkansal/wtfpython/issues/69
---
 README.md | 51 ++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/README.md b/README.md
index be6e5b0..11405be 100644
--- a/README.md
+++ b/README.md
@@ -471,7 +471,7 @@ array_4 = [400, 500, 600]
 - In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).
 - In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).
 - 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)
-    
+  
     > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.
 
 ---
@@ -704,30 +704,47 @@ SyntaxError: invalid syntax
 
 ---
 
-### ▶ Backslashes at the end of string
+### ▶ Strings and the backslashes\
 
 **Output:**
-```
->>> print("\\ C:\\")
-\ C:\
->>> print(r"\ C:")
-\ C:
->>> print(r"\ C:\")
+```py
+>>> print("\"")
+"
 
-    File "<stdin>", line 1
-      print(r"\ C:\")
-                     ^
+>>> print(r"\"")
+\"
+
+>>> print(r"\")
+File "<stdin>", 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.
-  ```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.
+- In a normal python string, the backslash is used to escape characters that may have special meaning (like single-quote, double-quote and the backslash itself).
+    ```py
+    >>> 'wt\"f'
+    'wt"f'
+    ```
+- In a raw string literal (as indicated by the prefix `r`),  the backslashes pass themselves as is along with the behavior of escaping the following character.
+    ```py
+    >>> r'wt\"f' == 'wt\\"f'
+    True
+    >>> print(repr(r'wt\"f')
+    'wt\\"f'
+
+    >>> print("\n")
+
+
+    >>> print(r"\\n")
+    '\\\\n'
+    ```
+- This means when a parser encounters a backslash in a raw string, it expects another character following it. And in our case (`print(r"\")`), the backslash escaped the trailing quote, leaving the parser without a terminating quote (hence the `SyntaxError`). That's why backslashes don't work at the end of a raw string.
 
 ---
 

From e3118ed4dacd6f189a599f77866e09d7bfa88098 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 14:21:19 +0530
Subject: [PATCH 055/146] Add new snippet: Splitsies

Resolves https://github.com/satwikkansal/wtfpython/issues/80
---
 README.md | 40 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 11405be..877a5a2 100644
--- a/README.md
+++ b/README.md
@@ -209,6 +209,44 @@ Makes sense, right?
 
 ---
 
+### ▶ Splitsies ^
+
+```py
+>>> 'a'.split()
+['a']
+
+# is same as
+>>> 'a'.split(' ')
+['a']
+
+# but
+>>> len(''.split())
+0
+
+# isn't the same as
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Explanation:
+
+- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split),
+    > If sep is not specified or is None, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
+    > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
+- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
+    ```py
+    >>> ' a '.split(' ')
+    ['', 'a', '']
+    >>> ' a '.split()
+    ['a']
+    >>> ''.split(' ')
+    ['']
+    ```
+
+---
+
+
+
 ### ▶ Time for some hash brownies!
 
 1\.
@@ -704,7 +742,7 @@ SyntaxError: invalid syntax
 
 ---
 
-### ▶ Strings and the backslashes\
+### ▶ Strings and the backslashes\ ^
 
 **Output:**
 ```py

From 89c56c236616c363343862e04a1324fe1a921e1e Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 14:49:59 +0530
Subject: [PATCH 056/146] Let's meet Friendly Language Uncle For Life: Add
 notes for non-interactive evn

Resolves https://github.com/satwikkansal/wtfpython/issues/94
---
 README.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 877a5a2..a2e5e38 100644
--- a/README.md
+++ b/README.md
@@ -2134,7 +2134,7 @@ Braces? No way! If you think that's disappointing, use Java.
 
 ---
 
-### ▶ Let's meet Friendly Language Uncle For Life *
+### ▶ Let's meet Friendly Language Uncle For Life ^
 
 **Output (Python 3.x)**
 ```py
@@ -2157,6 +2157,11 @@ There we go.
   
   > 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 on 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"'))
+    ```
 
 ---
 

From 5373d0f1844fcf72e7350a37335cb74e53d49048 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 16:30:53 +0530
Subject: [PATCH 057/146] Add example: Ellipsis

Resolves https://github.com/satwikkansal/wtfpython/issues/96
---
 README.md | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/README.md b/README.md
index a2e5e38..f05f91d 100644
--- a/README.md
+++ b/README.md
@@ -2266,6 +2266,66 @@ Try block executed successfully...
 - `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.
 
 ---
+### ▶ Ellipsis ^
+
+```py
+def some_func():
+    Ellipsis
+```
+
+**Output**
+```py
+>>> some_func()
+# No output, No Error
+
+>>> SomeRandomString
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'SomeRandomString' is not defined
+
+>>> Ellipsis
+Ellipsis
+```
+
+#### 💡 Explanation
+- In Python, `Ellipsis` is a globally available builtin object which is equivalent to `...`.
+    ```py
+    >>> ...
+    Ellipsis
+    ```
+- Eliipsis 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 *
 

From 9b3b367b450e1de567cd21d9850958a999d06a99 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 8 Jun 2019 23:25:37 +0530
Subject: [PATCH 058/146] Update example "is is not what it is"

Related to https://github.com/satwikkansal/wtfpython/issues/100
---
 README.md | 49 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 42 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index f05f91d..888a676 100644
--- a/README.md
+++ b/README.md
@@ -181,7 +181,7 @@ True
 >>> a is b
 False
 
->>> a, b = "wtf!", "wtf!"
+>>> a = "wtf!"; b = "wtf!";
 >>> a is b
 True
 ```
@@ -514,10 +514,11 @@ array_4 = [400, 500, 600]
 
 ---
 
-### ▶ `is` is not what it is!
+### ▶ Messing around with `is` operator^
 
 The following is a very famous example present all over the internet.
 
+1\.
 ```py
 >>> a = 256
 >>> b = 256
@@ -528,6 +529,37 @@ 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 (< Python 3.7)**
+```
+>>> a, b = 257, 257
+True
+
+>>> a = 257; b = 257
+>>> a is b
+True
+```
+
+**Output (Python 3.7)**
+```
+>>> a, b = 257, 257
+False
 
 >>> a = 257; b = 257
 >>> a is b
@@ -542,9 +574,8 @@ True
 * `==` 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
   ```
 
@@ -576,8 +607,11 @@ 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 (< Python 3.7)**
 ```py
 >>> a, b = 257, 257
 >>> id(a)
@@ -594,6 +628,7 @@ Here the interpreter isn't smart enough while executing `y = 257` to recognize t
 
 * 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.
+* 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.
 
 ---
 
@@ -777,6 +812,7 @@ True
     'wt\\"f'
 
     >>> print("\n")
+    ```
 
 
     >>> print(r"\\n")
@@ -2324,8 +2360,7 @@ Ellipsis
     + 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 *
 

From f365271df3363fc503ba59c33fd7157caa860a8c Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 00:07:02 +0530
Subject: [PATCH 059/146] New example: The chicken-egg problem

Closes https://github.com/satwikkansal/wtfpython/issues/101
---
 README.md | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/README.md b/README.md
index 888a676..6777d95 100644
--- a/README.md
+++ b/README.md
@@ -731,6 +731,54 @@ Even when the values of `x` were different in every iteration prior to appending
 
 ---
 
+### ▶ The chicken-egg problem ^
+
+1\.
+```py
+>>> isinstance(3, int)
+True
+>>> isinstance(type, object)
+True
+>>> isinstance(object, type)
+True
+```
+
+2\. So which is the ultimate, base class? And wait, there's more to the confusion
+
+```py
+>>> class A: pass
+>>> isinstance(A, A)
+False
+>>> isinstance(type, type)
+True
+>>> isinstance(object, object)
+True
+```
+
+3\.
+
+```py
+>>> issubclass(int, object)
+True
+>>> issubclass(type, object)
+True
+>>> issubclass(object, type)
+False
+```
+
+
+#### 💡 Explanation
+
+- `type` is a [metaclass](https://realpython.com/python-metaclasses/) in Python.
+- **Everything** is an `object` in Python, which includes classes as well as their objects (instances).
+- class `type` is the metaclass of class `object`, and every class (including `type`) has inherited directly or indirectly from `object`.
+- There is no real base class among `object` and `type`. The confusion in the above snippets is arising because we're thinking 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 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 eachother as well as themselves) exist in Python because of "cheating" at implementation level.
+
+---
+
 ### ▶ `is not ...` is not `is (not ...)`
 
 ```py

From 2295fb24b700a78c9b3d87a98d7393c193c92e5c Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 03:59:09 +0530
Subject: [PATCH 060/146] Let's make a giant string: Use %timeit for measuring
 time

Fixes https://github.com/satwikkansal/wtfpython/issues/106
---
 README.md | 63 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 28 deletions(-)

diff --git a/README.md b/README.md
index 6777d95..6f262a4 100644
--- a/README.md
+++ b/README.md
@@ -2512,40 +2512,47 @@ 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 readablity 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.
   ```py
@@ -2555,10 +2562,10 @@ 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)
   ```
 
 ---

From ae05101d705420001d6698d98f4ac7995acf2fef Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 17:34:50 +0530
Subject: [PATCH 061/146] Brace yourself: Add to explanation

Resolves https://github.com/satwikkansal/wtfpython/issues/114
---
 README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 6f262a4..c2af07f 100644
--- a/README.md
+++ b/README.md
@@ -2210,11 +2210,13 @@ 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.
++ 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.
 
 ---
 

From 330f7da1d349c289edf6517cd3788f66cc0e8253 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 17:56:36 +0530
Subject: [PATCH 062/146] String can be tricky: Remove outdated snippet

Related to https://github.com/satwikkansal/wtfpython/issues/120
---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index c2af07f..ab387d1 100644
--- a/README.md
+++ b/README.md
@@ -180,13 +180,12 @@ True
 >>> b = "wtf!"
 >>> a is b
 False
-
->>> a = "wtf!"; b = "wtf!";
->>> a is b
-True
 ```
 
 3\.
+
+**Output (< Python3.7 )**
+
 ```py
 >>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
 True
@@ -204,8 +203,9 @@ Makes sense, right?
   * 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)
   <img src="images/string-intern/string_intern.png" alt="">
-+ When `a` and `b` are set to `"wtf!"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already `wtf!` as an object (because `"wtf!"` is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment.
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than or equal to 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
+>>>>>>> String can be tricky: Remove outdated snippet
 
 ---
 

From 055bd0246dfedf84752bf5eb6d4fb80b4e38538b Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 9 Jun 2019 19:45:13 +0530
Subject: [PATCH 063/146] New example: Lossy zip of iterators

Resolves https://github.com/satwikkansal/wtfpython/issues/121
---
 README.md | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/README.md b/README.md
index ab387d1..d70ff8a 100644
--- a/README.md
+++ b/README.md
@@ -1253,6 +1253,55 @@ I've lost faith in truth!
 
 ---
 
+### ▶ Lossy zip of iterators
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three)) 
+[(0, 0), (1, 1), (2, 2)]
+# so far so good, let's zip the remaining
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Where did element `3` go from the `numbers` list?
+
+#### 💡 Explanation:
+
+- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,
+    ```py
+    def zip(*iterables):
+        sentinel = object()
+        iterators = [iter(it) for it in iterables]
+        while iterators:
+            result = []
+            for it in iterators:
+                elem = next(it, sentinel)
+                if elem is sentinel:
+                    return
+                result.append(elem)
+            yield tuple(result)
+    ```
+- So the function takes in arbitrary number of itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. 
+- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.
+- The correct way to do the above using `zip` would be,
+    ```py
+    >>> numbers = list(range(7))
+    >>> numbers_iter = iter(numbers)
+    >>> list(zip(first_three, numbers_iter))
+    [(0, 0), (1, 1), (2, 2)]
+    >>> list(zip(remaining, numbers_iter))
+    [(3, 3), (4, 4), (5, 5), (6, 6)]
+    ```
+    The first argument of zip should be the one with fewest elements.
+
+---
+
 ### ▶ From filled to None in one instruction...
 
 ```py

From 7b22f84f97723b5b8b49435a5810c37bcbbbd582 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 10 Jun 2019 00:14:01 +0530
Subject: [PATCH 064/146] Add new example: Disorder within order

Resolves https://github.com/satwikkansal/wtfpython/issues/77
---
 README.md | 115 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 109 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index d70ff8a..7392235 100644
--- a/README.md
+++ b/README.md
@@ -263,26 +263,131 @@ some_dict[5] = "Python"
 "Ruby"
 >>> some_dict[5.0]
 "Python"
->>> some_dict[5]
+>>> some_dict[5] # "Python" destroyed the existence of "JavaScript"?
+"Python"
+
+>>> complex_five = 5 + 0j
+>>> type(complex_five)
+complex
+>>> some_dict[complex_five]
 "Python"
 ```
 
-"Python" destroyed the existence of "JavaScript"?
+So, why is Python all over the place?
+
 
 #### 💡 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
+  >>> 5 == 5.0 == 5 + 0j
   True
-  >>> hash(5) == hash(5.0)
+  >>> hash(5) == hash(5.0) == hash(5 + 0j)
   True
   ```
   **Note:** Objects with different values may also have same hash (known as hash collision).
 * When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
 * This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
 
+---
+
+### ▶ The 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):
+    """
+    A dict 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 # the 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 "<stdin>", line 1, in <module>
+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 is 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 lenght 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? *
@@ -860,8 +965,6 @@ True
     'wt\\"f'
 
     >>> print("\n")
-    ```
-
 
     >>> print(r"\\n")
     '\\\\n'

From 6934d942221ccb5bc723e847554ca7cfa021bf6d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 10 Jun 2019 23:22:08 +0530
Subject: [PATCH 065/146] Some minor changes, and add assertion example

---
 README.md | 51 +++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 43 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 7392235..8202d25 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Python, being a beautifully designed high-level and interpreter-based programmin
 
 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!
+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 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:
 
@@ -105,10 +105,10 @@ All the examples are structured like below:
 > # 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.
 >
@@ -119,7 +119,7 @@ All the examples are structured like below:
 >   ```py
 >   Setting up examples for clarification (if necessary)
 >   ```
->   **Output:**
+>   **Output Output (Python version(s)):**
 >   ```py
 >   >>> trigger # some example that makes it easy to unveil the magic
 >   # some justified output
@@ -129,15 +129,15 @@ All the examples are structured like below:
 
 # 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:
+A nice way to get the most out of these examples, in my opinion, will be to just read them 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 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)).
     - 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.
+PS: You can also read WTFPython at the command line. There's a pypi package and an npm package (which supports colored formatting) for the same.
 
 To install the npm package [`wtfpython`](https://www.npmjs.com/package/wtfpython)
 ```sh
@@ -2187,7 +2187,10 @@ class SomeClass:
 
 ---
 
-### ▶ Needle in a Haystack
+
+---
+
+### ▶ Needles in a Haystack
 
 1\.
 ```py
@@ -2226,10 +2229,40 @@ e
 tuple()
 ```
 
+3\. Not asserting strongly enough
+
+```py
+a = "python"
+b = "javascript"
+```
+**Output:**
+```py
+# An assert statement with an assertion failure message.
+>>> assert(a == b, "Both languages are different")
+# No AssertionError is raised
+```
+
 #### 💡 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`.
+* For 3, no `AssertionError` was raised because we're asserting entire tuple, instead of asserting the individual expression `a == b`. The following snippet will clear things up,
+    ```py
+    >>> a = "python"
+    >>> b = "javascript"
+    >>> assert a == b
+    Traceback (most recent call last):
+        File "<stdin>", line 1, in <module>
+    AssertionError
+
+    >>> assert (a == b, "Values are not equal")
+    <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+
+    >>> assert a == b, "Values are not equal"
+    Traceback (most recent call last):
+        File "<stdin>", line 1, in <module>
+    AssertionError: Values aren not equal
+    ```
 
 ---
 
@@ -2721,6 +2754,8 @@ Let's increase the number of iterations by a factor of 10.
   >>> %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.
 
 ---
 

From 9939ff6a1f7f375a25153ea16007828f966bcebf Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Tue, 11 Jun 2019 00:43:32 +0530
Subject: [PATCH 066/146] Add new example: Wild imports

---
 README.md | 117 +++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 102 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 8202d25..9cc27ba 100644
--- a/README.md
+++ b/README.md
@@ -1858,21 +1858,22 @@ print(x, ': x in global')
 ```
 
 3\.
-```
-x = 1
-print([x for x in range(5)])
-print(x, ': x in global')
-```
 
-**Output (on Python 2.x):**
+**Output (Python 2.x):**
 ```
+>>> x = 1
+>>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
+>>> print(x, ': x in global')
 (4, ': x in global')
 ```
 
-**Output (on Python 3.x):**
+**Output (Python 3.x):**
 ```
+>>> x = 1
+>>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
+>>> print(x, ': x in global')
 1 : x in global
 ```
 
@@ -2185,12 +2186,10 @@ class SomeClass:
 - A generator expression has its own scope.
 - Starting from Python 3.X, list comprehensions also have their own scope.
 
----
-
 
 ---
 
-### ▶ Needles in a Haystack
+### ▶ Needles in a Haystack ^
 
 1\.
 ```py
@@ -2229,7 +2228,31 @@ e
 tuple()
 ```
 
-3\. Not asserting strongly enough
+3\.
+
+```
+ten_words_list = [
+    "some",
+    "very",
+    "big",
+    "list",
+    "that"
+    "consists",
+    "of",
+    "exactly",
+    "ten",
+    "words"
+]
+```
+
+**Output**
+
+```py
+>>> len(ten_words_list)
+9
+```
+
+4\. Not asserting strongly enough
 
 ```py
 a = "python"
@@ -2246,7 +2269,12 @@ b = "javascript"
 * 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`.
-* For 3, no `AssertionError` was raised because we're asserting entire tuple, instead of asserting the individual expression `a == b`. The following snippet will clear things up,
+* In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation,
+    ```py
+    >>> ten_words_list
+    ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
+    ```
+* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,
     ```py
     >>> a = "python"
     >>> b = "javascript"
@@ -2324,7 +2352,62 @@ Same result, that didn't work either.
   ["wtf"]
   ```
 
+---
 
+### ▶ Wild imports
+
+```py
+# File: module.py
+
+def some_weird_name_func_():
+    print("works!")
+
+def _another_weird_name_func():
+    print("works!")
+
+```
+
+**Output**
+
+```py
+>>> from module import *
+>>> some_weird_name_func_()
+"works!"
+>>> _another_weird_name_func()
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name '_another_weird_name_func' is not defined
+```
+
+#### 💡 Explanation:
+
+- It if often adivsable to not use wildcard imports. In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
+- Had we used `from ... import a, b, c` syntax, the above `NameError` won'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 "<stdin>", line 1, in <module>
+NameError: name 'some_weird_name_func_' is not defined
+```
 ---
 
 ---
@@ -2622,12 +2705,12 @@ The spelling is intended. Please, don't submit a patch for this.
 class Yo(object):
     def __init__(self):
         self.__honey = True
-        self.bitch = True
+        self.bro = True
 ```
 
 **Output:**
 ```py
->>> Yo().bitch
+>>> Yo().bro
 True
 >>> Yo().__honey
 AttributeError: 'Yo' object has no attribute '__honey'
@@ -2635,7 +2718,7 @@ AttributeError: 'Yo' object has no attribute '__honey'
 True
 ```
 
-Why did `Yo()._Yo__honey` work? Only Indian readers would understand.
+Why did `Yo()._Yo__honey` work?
 
 #### 💡 Explanation:
 
@@ -2645,6 +2728,10 @@ Why did `Yo()._Yo__honey` work? Only Indian readers would understand.
 
 ---
 
+
+
+
+
 ---
 
 ## Section: Miscellaneous

From edeb98f40618623d8db50141a8c9fff648aa42d2 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 7 Jul 2019 22:17:33 +0530
Subject: [PATCH 067/146] Update the booleans example

Fix some technically incorrect terminologies and snippets.
---
 README.md | 96 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 71 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index 9cc27ba..13835af 100644
--- a/README.md
+++ b/README.md
@@ -1059,7 +1059,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 
 1\.
 ```py
-# A simple example to count the number of boolean and
+# A simple example to count the number of booleans and
 # integers in an iterable of mixed data types.
 mixed_list = [False, 1.0, "some_string", 3, True, [], False]
 integers_found_so_far = 0
@@ -1080,33 +1080,27 @@ for item in mixed_list:
 0
 ```
 
+
 2\.
 ```py
-another_dict = {}
-another_dict[True] = "JavaScript"
-another_dict[1] = "Ruby"
-another_dict[1.0] = "Python"
-```
-
-**Output:**
-```py
->>> another_dict[True]
-"Python"
-```
-
-3\.
-```py
 >>> some_bool = True
->>> "wtf"*some_bool
+>>> "wtf" * some_bool
 'wtf'
 >>> some_bool = False
->>> "wtf"*some_bool
+>>> "wtf" * some_bool
 ''
 ```
 
 #### 💡 Explanation:
 
-* Booleans are a subclass of `int`
+* `bool` is a subclass of `int` in Python
+    ```py
+    >>> issubclass(bool, int)
+    True
+    >>> issubclass(int, bool)
+    False
+    ```
+* And thus, `True` and `False` are instances of `int`
   ```py
   >>> isinstance(True, int)
   True
@@ -1116,8 +1110,10 @@ another_dict[1.0] = "Python"
 
 * The integer value of `True` is `1` and that of `False` is `0`.
   ```py
-  >>> True == 1 == 1.0 and False == 0 == 0.0
-  True
+  >>> int(True)
+  1
+  >>> int(False)
+  0
   ```
 
 * See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.
@@ -1720,7 +1716,7 @@ Yes, it runs for exactly **eight** times and stops.
 
 ---
 
-### ▶ Stubborn `del` operator *
+### ▶ Stubborn `del` operation *
 
 ```py
 class SomeClass:
@@ -2381,7 +2377,7 @@ NameError: name '_another_weird_name_func' is not defined
 
 #### 💡 Explanation:
 
-- It if often adivsable to not use wildcard imports. In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
+- It if often adivsable to not use wildcard imports. The first obvious reason for this is In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
 - Had we used `from ... import a, b, c` syntax, the above `NameError` won't have occurred.
     ```py
     >>> from module import some_weird_name_func_, _another_weird_name_func
@@ -2699,8 +2695,9 @@ The spelling is intended. Please, don't submit a patch for this.
 
 ---
 
-### ▶ Mangling time! *
+### ▶ Let's mangle ^
 
+1\.
 ```py
 class Yo(object):
     def __init__(self):
@@ -2718,13 +2715,62 @@ AttributeError: 'Yo' object has no attribute '__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 "<stdin>", line 1, in <module>
+AttributeError: 'Yo' object has no attribute '_Yo__honey__'
+```
+
 Why did `Yo()._Yo__honey` work?
 
+2\.
+
+```py
+_A__variable = "Some value"
+
+class A(object):
+    def some_func(self):
+        return __variable # not initiatlized anywhere yet
+```
+
+**Output:**
+```py
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+AttributeError: 'A' object has no attribute '__variable'
+
+>>> >>> A().some_func()
+'Some value'
+```
+
+3\.
+
+```py
+
+```
+
+
 #### 💡 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.
+* 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 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 outer scope.
 
 ---
 

From 162458c88e3790e73b3e11d44c1f8d863333929d Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 7 Jul 2019 22:18:35 +0530
Subject: [PATCH 068/146] Update TOC

---
 README.md | 168 +++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 116 insertions(+), 52 deletions(-)

diff --git a/README.md b/README.md
index 13835af..7f3a354 100644
--- a/README.md
+++ b/README.md
@@ -28,67 +28,131 @@ So, here we go...
 - [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-)
-    - [▶ 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)
+    - [▶ Strings can be tricky sometimes *](#%E2%96%B6-strings-can-be-tricky-sometimes-)
+      - [💡 Explanation:](#-explanation)
+    - [▶ Splitsies ^](#%E2%96%B6-splitsies-%5E)
+      - [💡 Explanation:](#-explanation-1)
+    - [▶ Time for some hash brownies!](#%E2%96%B6-time-for-some-hash-brownies)
+      - [💡 Explanation](#-explanation)
+    - [▶ The disorder within order ^](#%E2%96%B6-the-disorder-within-order-%5E)
+      - [💡 Explanation:](#-explanation-2)
+    - [▶ Keep trying? *](#%E2%96%B6-keep-trying-)
+      - [💡 Explanation:](#-explanation-3)
+    - [▶ Deep down, we're all the same. *](#%E2%96%B6-deep-down-were-all-the-same-)
+      - [💡 Explanation:](#-explanation-4)
+    - [▶ For what?](#%E2%96%B6-for-what)
+      - [💡 Explanation:](#-explanation-5)
+    - [▶ Evaluation time discrepancy ^](#%E2%96%B6-evaluation-time-discrepancy-%5E)
+      - [💡 Explanation](#-explanation-1)
+    - [▶ Messing around with `is` operator^](#%E2%96%B6-messing-around-with-is-operator%5E)
+      - [💡 Explanation:](#-explanation-6)
+    - [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+      - [💡 Explanation:](#-explanation-7)
+    - [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
+      - [💡 Explanation](#-explanation-2)
+    - [▶ The chicken-egg problem ^](#%E2%96%B6-the-chicken-egg-problem-%5E)
+      - [💡 Explanation](#-explanation-3)
+    - [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
+      - [💡 Explanation](#-explanation-4)
+    - [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
+      - [💡 Explanation:](#-explanation-8)
+    - [▶ Strings and the backslashes\ ^](#%E2%96%B6-strings-and-the-backslashes%5C-%5E)
+      - [💡 Explanation](#-explanation-5)
+    - [▶ not knot!](#%E2%96%B6-not-knot)
+      - [💡 Explanation:](#-explanation-9)
+    - [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
+      - [💡 Explanation:](#-explanation-10)
+    - [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
+      - [💡 Explanation:](#-explanation-11)
+    - [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
+      - [💡 Explanation:](#-explanation-12)
+    - [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
+      - [💡 Explanation:](#-explanation-13)
+    - [▶ yielding None](#%E2%96%B6-yielding-none)
+      - [💡 Explanation:](#-explanation-14)
+    - [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
+      - [💡 Explanation:](#-explanation-15)
+    - [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
+      - [💡 Explanation:](#-explanation-16)
+    - [▶ When True is actually False](#%E2%96%B6-when-true-is-actually-false)
+      - [💡 Explanation:](#-explanation-17)
+    - [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
+      - [💡 Explanation:](#-explanation-18)
+    - [▶ From filled to None in one instruction...](#%E2%96%B6-from-filled-to-none-in-one-instruction)
+      - [💡 Explanation](#-explanation-6)
+    - [▶ Subclass relationships *](#%E2%96%B6-subclass-relationships-)
+      - [💡 Explanation:](#-explanation-19)
+    - [▶ The mysterious key type conversion *](#%E2%96%B6-the-mysterious-key-type-conversion-)
+      - [💡 Explanation:](#-explanation-20)
+    - [▶ Let's see if you can guess this?](#%E2%96%B6-lets-see-if-you-can-guess-this)
+      - [💡 Explanation:](#-explanation-21)
   - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
-    - [▶ Skipping lines?](#-skipping-lines)
-    - [▶ Teleportation *](#-teleportation-)
-    - [▶ Well, something is fishy...](#-well-something-is-fishy)
+    - [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
+      - [💡 Explanation](#-explanation-7)
+    - [▶ Teleportation *](#%E2%96%B6-teleportation-)
+      - [💡 Explanation:](#-explanation-22)
+    - [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
+      - [💡 Explanation](#-explanation-8)
   - [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)
+    - [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
+      - [💡 Explanation:](#-explanation-23)
+    - [▶ Stubborn `del` operation *](#%E2%96%B6-stubborn-del-operation-)
+      - [💡 Explanation:](#-explanation-24)
+    - [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
+      - [💡 Explanation:](#-explanation-25)
+    - [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
+      - [💡 Explanation:](#-explanation-26)
+    - [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
+      - [💡 Explanation:](#-explanation-27)
+    - [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
+      - [💡 Explanation](#-explanation-9)
+    - [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
+      - [💡 Explanation:](#-explanation-28)
+    - [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
+      - [💡 Explanation:](#-explanation-29)
+    - [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
+      - [💡 Explanation:](#-explanation-30)
+    - [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
+      - [💡 Explanation](#-explanation-10)
+    - [▶ Needles in a Haystack ^](#%E2%96%B6-needles-in-a-haystack-%5E)
+      - [💡 Explanation:](#-explanation-31)
     - [▶ Yielding from... return!](#-yielding-from-return)
+      - [💡 Explanation:](#-explanation-31)
+    - [▶ Wild imports](#%E2%96%B6-wild-imports)
+      - [💡 Explanation:](#-explanation-32)
   - [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-)
+    - [▶ Okay Python, Can you make me fly? *](#%E2%96%B6-okay-python-can-you-make-me-fly-)
+      - [💡 Explanation:](#-explanation-33)
+    - [▶ `goto`, but why? *](#%E2%96%B6-goto-but-why-)
+      - [💡 Explanation:](#-explanation-34)
+    - [▶ Brace yourself! *](#%E2%96%B6-brace-yourself-)
+      - [💡 Explanation:](#-explanation-35)
+    - [▶ Let's meet Friendly Language Uncle For Life ^](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life-%5E)
+      - [💡 Explanation:](#-explanation-36)
+    - [▶ Even Python understands that love is complicated *](#%E2%96%B6-even-python-understands-that-love-is-complicated-)
+      - [💡 Explanation:](#-explanation-37)
+    - [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
+      - [💡 Explanation:](#-explanation-38)
+    - [▶ Ellipsis ^](#%E2%96%B6-ellipsis-%5E)
+      - [💡 Explanation](#-explanation-11)
+    - [▶ Inpinity *](#%E2%96%B6-inpinity-)
+      - [💡 Explanation:](#-explanation-39)
+    - [▶ Let's mangle ^](#%E2%96%B6-lets-mangle-%5E)
+      - [💡 Explanation:](#-explanation-40)
   - [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)
+    - [▶ `+=` is faster](#%E2%96%B6--is-faster)
+      - [💡 Explanation:](#-explanation-41)
+    - [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
+      - [💡 Explanation](#-explanation-12)
+    - [▶ Explicit typecast of strings](#%E2%96%B6-explicit-typecast-of-strings)
+      - [💡 Explanation:](#-explanation-42)
+    - [▶ Minor Ones](#%E2%96%B6-minor-ones)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
+      - [Some nice Links!](#some-nice-links)
 - [🎓 License](#-license)
   - [Help](#help)
-  - [Want to share wtfpython with friends?](#want-to-share-wtfpython-with-friends)
+  - [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
   - [Need a pdf version?](#need-a-pdf-version)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->

From 45638fa6b1cde184dba3acf0da97d56d2147b0c0 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 02:54:49 +0530
Subject: [PATCH 069/146] Add uuids to examples

---
 README.md | 114 +++++++++++++++++++++++++++---------------------------
 1 file changed, 57 insertions(+), 57 deletions(-)

diff --git a/README.md b/README.md
index 7f3a354..5b9977b 100644
--- a/README.md
+++ b/README.md
@@ -223,7 +223,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 ## Section: Strain your brain!
 
 ### ▶ Strings can be tricky sometimes *
-
+<!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --!>
 1\.
 ```py
 >>> a = "some_string"
@@ -274,7 +274,7 @@ Makes sense, right?
 ---
 
 ### ▶ Splitsies ^
-
+<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --!>
 ```py
 >>> 'a'.split()
 ['a']
@@ -312,7 +312,7 @@ Makes sense, right?
 
 
 ### ▶ Time for some hash brownies!
-
+<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --!>
 1\.
 ```py
 some_dict = {}
@@ -357,7 +357,7 @@ So, why is Python all over the place?
 ---
 
 ### ▶ The disorder within order ^
-
+<!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --!>
 ```py
 from collections import OrderedDict
 
@@ -455,7 +455,7 @@ What is going on here?
 ---
 
 ### ▶ Keep trying? *
-
+<!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --!>
 ```py
 def some_func():
     try:
@@ -515,7 +515,7 @@ Iteration 0
 ---
 
 ### ▶ Deep down, we're all the same. *
-
+<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --!>
 ```py
 class WTF:
   pass
@@ -565,7 +565,7 @@ True
 ---
 
 ### ▶ For what?
-
+<!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --!>
 ```py
 some_string = "wtf"
 some_dict = {}
@@ -618,7 +618,7 @@ for i, some_dict[i] in enumerate(some_string):
 ---
 
 ### ▶ Evaluation time discrepancy ^
-
+<!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --!>
 1\.
 ```py
 array = [1, 8, 15]
@@ -684,7 +684,7 @@ array_4 = [400, 500, 600]
 ---
 
 ### ▶ Messing around with `is` operator^
-
+<!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --!>
 The following is a very famous example present all over the internet.
 
 1\.
@@ -802,7 +802,7 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 ---
 
 ### ▶ A tic-tac-toe where X wins in the first attempt!
-
+<!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --!>
 ```py
 # Let's initialize a row
 row = [""]*3 #row i['', '', '']
@@ -847,7 +847,7 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
 ---
 
 ### ▶ The sticky output function
-
+<!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --!>
 ```py
 funcs = []
 results = []
@@ -901,7 +901,7 @@ Even when the values of `x` were different in every iteration prior to appending
 ---
 
 ### ▶ The chicken-egg problem ^
-
+<!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --!>
 1\.
 ```py
 >>> isinstance(3, int)
@@ -949,7 +949,7 @@ False
 ---
 
 ### ▶ `is not ...` is not `is (not ...)`
-
+<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --!>
 ```py
 >>> 'something' is not None
 True
@@ -965,7 +965,7 @@ False
 ---
 
 ### ▶ The surprising comma
-
+<!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --!>
 **Output:**
 ```py
 >>> def f(x, y,):
@@ -995,7 +995,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Strings and the backslashes\ ^
-
+<!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --!>
 **Output:**
 ```py
 >>> print("\"")
@@ -1038,7 +1038,7 @@ True
 ---
 
 ### ▶ not knot!
-
+<!-- Example ID: 7034deb1-7443-417d-94ee-29a800524de8 --!>
 ```py
 x = True
 y = False
@@ -1065,7 +1065,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Half triple-quoted strings
-
+<!-- Example ID: c55da3e2-1034-43b9-abeb-a7a970a2ad9e --!>
 **Output:**
 ```py
 >>> print('wtfpython''')
@@ -1090,7 +1090,7 @@ wtfpython
 ---
 
 ### ▶ Midnight time doesn't exist?
-
+<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --!>
 ```py
 from datetime import datetime
 
@@ -1120,7 +1120,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 ---
 
 ### ▶ What's wrong with booleans?
-
+<!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --!>
 1\.
 ```py
 # A simple example to count the number of booleans and
@@ -1185,7 +1185,7 @@ for item in mixed_list:
 ---
 
 ### ▶ Class attributes and instance attributes
-
+<!-- Example ID: 6f332208-33bd-482d-8106-42863b739ed9 --!>
 1\.
 ```py
 class A:
@@ -1255,7 +1255,7 @@ True
 ---
 
 ### ▶ yielding None
-
+<!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --!>
 ```py
 some_iterable = ('a', 'b')
 
@@ -1284,7 +1284,7 @@ def some_func(val):
 ---
 
 ### ▶ Mutating the immutable!
-
+<!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --!>
 ```py
 some_tuple = ("A", "tuple", "with", "values")
 another_tuple = ([1, 2], [3, 4], [5, 6])
@@ -1317,7 +1317,7 @@ But I thought tuples were immutable...
 ---
 
 ### ▶ The disappearing variable from outer scope
-
+<!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --!>
 ```py
 e = 7
 try:
@@ -1397,7 +1397,7 @@ NameError: name 'e' is not defined
 ---
 
 ### ▶ When True is actually False
-
+<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --!>
 ```py
 True = False
 if True == False:
@@ -1417,7 +1417,7 @@ I've lost faith in truth!
 ---
 
 ### ▶ Lossy zip of iterators
-
+<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --!>
 ```py
 >>> numbers = list(range(7))
 >>> numbers
@@ -1466,7 +1466,7 @@ Where did element `3` go from the `numbers` list?
 ---
 
 ### ▶ From filled to None in one instruction...
-
+<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --!>
 ```py
 some_list = [1, 2, 3]
 some_dict = {
@@ -1494,7 +1494,7 @@ Most methods that modify the items of sequence/mapping objects like `list.append
 ---
 
 ### ▶ Subclass relationships *
-
+<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --!>
 **Output:**
 ```py
 >>> from collections import Hashable
@@ -1518,7 +1518,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 ---
 
 ### ▶ The mysterious key type conversion *
-
+<!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --!>
 ```py
 class SomeClass(str):
     pass
@@ -1574,7 +1574,7 @@ str
 ---
 
 ### ▶ Let's see if you can guess this?
-
+<!-- Example ID: 81aa9fbe-bd63-4283-b56d-6fdd14c9105e --!>
 ```py
 a, b = a[b] = {}, 5
 ```
@@ -1635,7 +1635,7 @@ a, b = a[b] = {}, 5
 ## Section: Appearances are deceptive!
 
 ### ▶ Skipping lines?
-
+<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --!>
 **Output:**
 ```py
 >>> value = 11
@@ -1671,7 +1671,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 ---
 
 ### ▶ Teleportation *
-
+<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --!>
 ```py
 import numpy as np
 
@@ -1701,7 +1701,7 @@ Where's the Nobel Prize?
 ---
 
 ### ▶ Well, something is fishy...
-
+<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --!>
 ```py
 def square(x):
     """
@@ -1746,7 +1746,7 @@ Shouldn't that be 100?
 
 
 ### ▶ Modifying a dictionary while iterating over it
-
+<!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --!>
 ```py
 x = {0: None}
 
@@ -1781,7 +1781,7 @@ Yes, it runs for exactly **eight** times and stops.
 ---
 
 ### ▶ Stubborn `del` operation *
-
+<!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --!>
 ```py
 class SomeClass:
     def __del__(self):
@@ -1824,7 +1824,7 @@ Okay, now it's deleted :confused:
 ---
 
 ### ▶ Deleting a list item while iterating
-
+<!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --!>
 ```py
 list_1 = [1, 2, 3, 4]
 list_2 = [1, 2, 3, 4]
@@ -1884,7 +1884,7 @@ Can you guess why the output is `[2, 4]`?
 ---
 
 ### ▶ Loop variables leaking out!
-
+<!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --!>
 1\.
 ```py
 for x in range(7):
@@ -1948,7 +1948,7 @@ print(x, ': x in global')
 ---
 
 ### ▶ Beware of default mutable arguments!
-
+<!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --!>
 ```py
 def some_func(default_arg=[]):
     default_arg.append("some_string")
@@ -2005,7 +2005,7 @@ def some_func(default_arg=[]):
 ---
 
 ### ▶ Catching the Exceptions
-
+<!-- Example ID: b5ca5e6a-47b9-4f69-9375-cda0f8c6755d --!>
 ```py
 some_list = [1, 2, 3]
 try:
@@ -2080,7 +2080,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Same operands, different story!
-
+<!-- Example ID: ca052cdf-dd2d-4105-b936-65c28adc18a0 --!>
 1\.
 ```py
 a = [1, 2, 3, 4]
@@ -2122,7 +2122,7 @@ a += [5, 6, 7, 8]
 ---
 
 ### ▶ The out of scope variable
-
+<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --!>
 ```py
 a = 1
 def some_func():
@@ -2161,7 +2161,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
 ---
 
 ### ▶ Be careful with chained operations
-
+<!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --!>
 ```py
 >>> (False == False) in [False] # makes sense
 False
@@ -2206,7 +2206,7 @@ While such behavior might seem silly to you in the above examples, it's fantasti
 ---
 
 ### ▶ Name resolution ignoring class scope
-
+<!-- Example ID: 03f73d96-151c-4929-b0a8-f74430788324 --!>
 1\.
 ```py
 x = 5
@@ -2250,7 +2250,7 @@ class SomeClass:
 ---
 
 ### ▶ Needles in a Haystack ^
-
+<!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --!>
 1\.
 ```py
 x, y = (0, 1) if True else None, None
@@ -2415,7 +2415,7 @@ Same result, that didn't work either.
 ---
 
 ### ▶ Wild imports
-
+<!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --!>
 ```py
 # File: module.py
 
@@ -2478,7 +2478,7 @@ NameError: name 'some_weird_name_func_' is not defined
 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? *
-
+<!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --!>
 Well, here you go
 
 ```py
@@ -2496,7 +2496,7 @@ Sshh.. It's a super secret.
 ---
 
 ### ▶ `goto`, but why? *
-
+<!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --!>
 ```py
 from goto import goto, label
 for i in range(9):
@@ -2524,7 +2524,7 @@ Freedom!
 ---
 
 ### ▶ Brace yourself! *
-
+<!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --!>
 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
@@ -2549,7 +2549,7 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr
 ---
 
 ### ▶ Let's meet Friendly Language Uncle For Life ^
-
+<!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --!>
 **Output (Python 3.x)**
 ```py
 >>> from __future__ import barry_as_FLUFL
@@ -2580,7 +2580,7 @@ There we go.
 ---
 
 ### ▶ Even Python understands that love is complicated *
-
+<!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --!>
 ```py
 import this
 ```
@@ -2637,7 +2637,7 @@ True
 ---
 
 ### ▶ Yes, it exists!
-
+<!-- Example ID: 4286db3d-1ea7-47c9-8fb6-a9a04cac6e49 --!>
 **The `else` clause for loops.** One typical example might be:
 
 ```py
@@ -2681,7 +2681,7 @@ Try block executed successfully...
 
 ---
 ### ▶ Ellipsis ^
-
+<!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --!>
 ```py
 def some_func():
     Ellipsis
@@ -2741,7 +2741,7 @@ Ellipsis
 ---
 
 ### ▶ Inpinity *
-
+<!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --!>
 The spelling is intended. Please, don't submit a patch for this.
 
 **Output (Python 3.x):**
@@ -2760,7 +2760,7 @@ The spelling is intended. Please, don't submit a patch for this.
 ---
 
 ### ▶ Let's mangle ^
-
+<!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --!>
 1\.
 ```py
 class Yo(object):
@@ -2848,7 +2848,7 @@ AttributeError: 'A' object has no attribute '__variable'
 
 
 ### ▶ `+=` is faster
-
+<!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --!>
 ```py
 # using "+", three strings:
 >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
@@ -2864,7 +2864,7 @@ AttributeError: 'A' object has no attribute '__variable'
 ---
 
 ### ▶ Let's make a giant string!
-
+<!-- Example ID: c7a07424-63fe-4504-9842-8f3d334f28fc --!>
 ```py
 def add_string_with_plus(iters):
     s = ""
@@ -2957,7 +2957,7 @@ Let's increase the number of iterations by a factor of 10.
 ---
 
 ### ▶ Explicit typecast of strings
-
+<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --!>
 ```py
 a = float('inf')
 b = float('nan')
@@ -2996,7 +2996,7 @@ nan
 ---
 
 ### ▶ Minor Ones
-
+<!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --!>
 * `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
 
   **💡 Explanation:**

From e8fcce27c28f8bb956ec542daa5b3e9f33ad3a2a Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 03:00:33 +0530
Subject: [PATCH 070/146] Fix uuid comments

---
 README.md | 114 +++++++++++++++++++++++++++---------------------------
 1 file changed, 57 insertions(+), 57 deletions(-)

diff --git a/README.md b/README.md
index 5b9977b..07f1a5c 100644
--- a/README.md
+++ b/README.md
@@ -223,7 +223,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 ## Section: Strain your brain!
 
 ### ▶ Strings can be tricky sometimes *
-<!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --!>
+<!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --->
 1\.
 ```py
 >>> a = "some_string"
@@ -274,7 +274,7 @@ Makes sense, right?
 ---
 
 ### ▶ Splitsies ^
-<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --!>
+<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
 ```py
 >>> 'a'.split()
 ['a']
@@ -312,7 +312,7 @@ Makes sense, right?
 
 
 ### ▶ Time for some hash brownies!
-<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --!>
+<!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --->
 1\.
 ```py
 some_dict = {}
@@ -357,7 +357,7 @@ So, why is Python all over the place?
 ---
 
 ### ▶ The disorder within order ^
-<!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --!>
+<!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
 from collections import OrderedDict
 
@@ -455,7 +455,7 @@ What is going on here?
 ---
 
 ### ▶ Keep trying? *
-<!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --!>
+<!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --->
 ```py
 def some_func():
     try:
@@ -515,7 +515,7 @@ Iteration 0
 ---
 
 ### ▶ Deep down, we're all the same. *
-<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --!>
+<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
 ```py
 class WTF:
   pass
@@ -565,7 +565,7 @@ True
 ---
 
 ### ▶ For what?
-<!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --!>
+<!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --->
 ```py
 some_string = "wtf"
 some_dict = {}
@@ -618,7 +618,7 @@ for i, some_dict[i] in enumerate(some_string):
 ---
 
 ### ▶ Evaluation time discrepancy ^
-<!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --!>
+<!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --->
 1\.
 ```py
 array = [1, 8, 15]
@@ -684,7 +684,7 @@ array_4 = [400, 500, 600]
 ---
 
 ### ▶ Messing around with `is` operator^
-<!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --!>
+<!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --->
 The following is a very famous example present all over the internet.
 
 1\.
@@ -802,7 +802,7 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 ---
 
 ### ▶ A tic-tac-toe where X wins in the first attempt!
-<!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --!>
+<!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --->
 ```py
 # Let's initialize a row
 row = [""]*3 #row i['', '', '']
@@ -847,7 +847,7 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
 ---
 
 ### ▶ The sticky output function
-<!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --!>
+<!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --->
 ```py
 funcs = []
 results = []
@@ -901,7 +901,7 @@ Even when the values of `x` were different in every iteration prior to appending
 ---
 
 ### ▶ The chicken-egg problem ^
-<!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --!>
+<!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --->
 1\.
 ```py
 >>> isinstance(3, int)
@@ -949,7 +949,7 @@ False
 ---
 
 ### ▶ `is not ...` is not `is (not ...)`
-<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --!>
+<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --->
 ```py
 >>> 'something' is not None
 True
@@ -965,7 +965,7 @@ False
 ---
 
 ### ▶ The surprising comma
-<!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --!>
+<!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --->
 **Output:**
 ```py
 >>> def f(x, y,):
@@ -995,7 +995,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Strings and the backslashes\ ^
-<!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --!>
+<!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --->
 **Output:**
 ```py
 >>> print("\"")
@@ -1038,7 +1038,7 @@ True
 ---
 
 ### ▶ not knot!
-<!-- Example ID: 7034deb1-7443-417d-94ee-29a800524de8 --!>
+<!-- Example ID: 7034deb1-7443-417d-94ee-29a800524de8 --->
 ```py
 x = True
 y = False
@@ -1065,7 +1065,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Half triple-quoted strings
-<!-- Example ID: c55da3e2-1034-43b9-abeb-a7a970a2ad9e --!>
+<!-- Example ID: c55da3e2-1034-43b9-abeb-a7a970a2ad9e --->
 **Output:**
 ```py
 >>> print('wtfpython''')
@@ -1090,7 +1090,7 @@ wtfpython
 ---
 
 ### ▶ Midnight time doesn't exist?
-<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --!>
+<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --->
 ```py
 from datetime import datetime
 
@@ -1120,7 +1120,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 ---
 
 ### ▶ What's wrong with booleans?
-<!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --!>
+<!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --->
 1\.
 ```py
 # A simple example to count the number of booleans and
@@ -1185,7 +1185,7 @@ for item in mixed_list:
 ---
 
 ### ▶ Class attributes and instance attributes
-<!-- Example ID: 6f332208-33bd-482d-8106-42863b739ed9 --!>
+<!-- Example ID: 6f332208-33bd-482d-8106-42863b739ed9 --->
 1\.
 ```py
 class A:
@@ -1255,7 +1255,7 @@ True
 ---
 
 ### ▶ yielding None
-<!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --!>
+<!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --->
 ```py
 some_iterable = ('a', 'b')
 
@@ -1284,7 +1284,7 @@ def some_func(val):
 ---
 
 ### ▶ Mutating the immutable!
-<!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --!>
+<!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --->
 ```py
 some_tuple = ("A", "tuple", "with", "values")
 another_tuple = ([1, 2], [3, 4], [5, 6])
@@ -1317,7 +1317,7 @@ But I thought tuples were immutable...
 ---
 
 ### ▶ The disappearing variable from outer scope
-<!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --!>
+<!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --->
 ```py
 e = 7
 try:
@@ -1397,7 +1397,7 @@ NameError: name 'e' is not defined
 ---
 
 ### ▶ When True is actually False
-<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --!>
+<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --->
 ```py
 True = False
 if True == False:
@@ -1417,7 +1417,7 @@ I've lost faith in truth!
 ---
 
 ### ▶ Lossy zip of iterators
-<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --!>
+<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --->
 ```py
 >>> numbers = list(range(7))
 >>> numbers
@@ -1466,7 +1466,7 @@ Where did element `3` go from the `numbers` list?
 ---
 
 ### ▶ From filled to None in one instruction...
-<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --!>
+<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --->
 ```py
 some_list = [1, 2, 3]
 some_dict = {
@@ -1494,7 +1494,7 @@ Most methods that modify the items of sequence/mapping objects like `list.append
 ---
 
 ### ▶ Subclass relationships *
-<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --!>
+<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
 **Output:**
 ```py
 >>> from collections import Hashable
@@ -1518,7 +1518,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 ---
 
 ### ▶ The mysterious key type conversion *
-<!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --!>
+<!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --->
 ```py
 class SomeClass(str):
     pass
@@ -1574,7 +1574,7 @@ str
 ---
 
 ### ▶ Let's see if you can guess this?
-<!-- Example ID: 81aa9fbe-bd63-4283-b56d-6fdd14c9105e --!>
+<!-- Example ID: 81aa9fbe-bd63-4283-b56d-6fdd14c9105e --->
 ```py
 a, b = a[b] = {}, 5
 ```
@@ -1635,7 +1635,7 @@ a, b = a[b] = {}, 5
 ## Section: Appearances are deceptive!
 
 ### ▶ Skipping lines?
-<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --!>
+<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --->
 **Output:**
 ```py
 >>> value = 11
@@ -1671,7 +1671,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 ---
 
 ### ▶ Teleportation *
-<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --!>
+<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
 ```py
 import numpy as np
 
@@ -1701,7 +1701,7 @@ Where's the Nobel Prize?
 ---
 
 ### ▶ Well, something is fishy...
-<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --!>
+<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --->
 ```py
 def square(x):
     """
@@ -1746,7 +1746,7 @@ Shouldn't that be 100?
 
 
 ### ▶ Modifying a dictionary while iterating over it
-<!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --!>
+<!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --->
 ```py
 x = {0: None}
 
@@ -1781,7 +1781,7 @@ Yes, it runs for exactly **eight** times and stops.
 ---
 
 ### ▶ Stubborn `del` operation *
-<!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --!>
+<!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --->
 ```py
 class SomeClass:
     def __del__(self):
@@ -1824,7 +1824,7 @@ Okay, now it's deleted :confused:
 ---
 
 ### ▶ Deleting a list item while iterating
-<!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --!>
+<!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --->
 ```py
 list_1 = [1, 2, 3, 4]
 list_2 = [1, 2, 3, 4]
@@ -1884,7 +1884,7 @@ Can you guess why the output is `[2, 4]`?
 ---
 
 ### ▶ Loop variables leaking out!
-<!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --!>
+<!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --->
 1\.
 ```py
 for x in range(7):
@@ -1948,7 +1948,7 @@ print(x, ': x in global')
 ---
 
 ### ▶ Beware of default mutable arguments!
-<!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --!>
+<!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --->
 ```py
 def some_func(default_arg=[]):
     default_arg.append("some_string")
@@ -2005,7 +2005,7 @@ def some_func(default_arg=[]):
 ---
 
 ### ▶ Catching the Exceptions
-<!-- Example ID: b5ca5e6a-47b9-4f69-9375-cda0f8c6755d --!>
+<!-- Example ID: b5ca5e6a-47b9-4f69-9375-cda0f8c6755d --->
 ```py
 some_list = [1, 2, 3]
 try:
@@ -2080,7 +2080,7 @@ SyntaxError: invalid syntax
 ---
 
 ### ▶ Same operands, different story!
-<!-- Example ID: ca052cdf-dd2d-4105-b936-65c28adc18a0 --!>
+<!-- Example ID: ca052cdf-dd2d-4105-b936-65c28adc18a0 --->
 1\.
 ```py
 a = [1, 2, 3, 4]
@@ -2122,7 +2122,7 @@ a += [5, 6, 7, 8]
 ---
 
 ### ▶ The out of scope variable
-<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --!>
+<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --->
 ```py
 a = 1
 def some_func():
@@ -2161,7 +2161,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
 ---
 
 ### ▶ Be careful with chained operations
-<!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --!>
+<!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --->
 ```py
 >>> (False == False) in [False] # makes sense
 False
@@ -2206,7 +2206,7 @@ While such behavior might seem silly to you in the above examples, it's fantasti
 ---
 
 ### ▶ Name resolution ignoring class scope
-<!-- Example ID: 03f73d96-151c-4929-b0a8-f74430788324 --!>
+<!-- Example ID: 03f73d96-151c-4929-b0a8-f74430788324 --->
 1\.
 ```py
 x = 5
@@ -2250,7 +2250,7 @@ class SomeClass:
 ---
 
 ### ▶ Needles in a Haystack ^
-<!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --!>
+<!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
 1\.
 ```py
 x, y = (0, 1) if True else None, None
@@ -2415,7 +2415,7 @@ Same result, that didn't work either.
 ---
 
 ### ▶ Wild imports
-<!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --!>
+<!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
 ```py
 # File: module.py
 
@@ -2478,7 +2478,7 @@ NameError: name 'some_weird_name_func_' is not defined
 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? *
-<!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --!>
+<!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --->
 Well, here you go
 
 ```py
@@ -2496,7 +2496,7 @@ Sshh.. It's a super secret.
 ---
 
 ### ▶ `goto`, but why? *
-<!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --!>
+<!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --->
 ```py
 from goto import goto, label
 for i in range(9):
@@ -2524,7 +2524,7 @@ Freedom!
 ---
 
 ### ▶ Brace yourself! *
-<!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --!>
+<!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --->
 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
@@ -2549,7 +2549,7 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr
 ---
 
 ### ▶ Let's meet Friendly Language Uncle For Life ^
-<!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --!>
+<!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --->
 **Output (Python 3.x)**
 ```py
 >>> from __future__ import barry_as_FLUFL
@@ -2580,7 +2580,7 @@ There we go.
 ---
 
 ### ▶ Even Python understands that love is complicated *
-<!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --!>
+<!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --->
 ```py
 import this
 ```
@@ -2637,7 +2637,7 @@ True
 ---
 
 ### ▶ Yes, it exists!
-<!-- Example ID: 4286db3d-1ea7-47c9-8fb6-a9a04cac6e49 --!>
+<!-- Example ID: 4286db3d-1ea7-47c9-8fb6-a9a04cac6e49 --->
 **The `else` clause for loops.** One typical example might be:
 
 ```py
@@ -2681,7 +2681,7 @@ Try block executed successfully...
 
 ---
 ### ▶ Ellipsis ^
-<!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --!>
+<!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --->
 ```py
 def some_func():
     Ellipsis
@@ -2741,7 +2741,7 @@ Ellipsis
 ---
 
 ### ▶ Inpinity *
-<!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --!>
+<!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --->
 The spelling is intended. Please, don't submit a patch for this.
 
 **Output (Python 3.x):**
@@ -2760,7 +2760,7 @@ The spelling is intended. Please, don't submit a patch for this.
 ---
 
 ### ▶ Let's mangle ^
-<!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --!>
+<!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --->
 1\.
 ```py
 class Yo(object):
@@ -2848,7 +2848,7 @@ AttributeError: 'A' object has no attribute '__variable'
 
 
 ### ▶ `+=` is faster
-<!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --!>
+<!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --->
 ```py
 # using "+", three strings:
 >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
@@ -2864,7 +2864,7 @@ AttributeError: 'A' object has no attribute '__variable'
 ---
 
 ### ▶ Let's make a giant string!
-<!-- Example ID: c7a07424-63fe-4504-9842-8f3d334f28fc --!>
+<!-- Example ID: c7a07424-63fe-4504-9842-8f3d334f28fc --->
 ```py
 def add_string_with_plus(iters):
     s = ""
@@ -2957,7 +2957,7 @@ Let's increase the number of iterations by a factor of 10.
 ---
 
 ### ▶ Explicit typecast of strings
-<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --!>
+<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --->
 ```py
 a = float('inf')
 b = float('nan')
@@ -2996,7 +2996,7 @@ nan
 ---
 
 ### ▶ Minor Ones
-<!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --!>
+<!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --->
 * `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
 
   **💡 Explanation:**

From d6b735768c24c7d7c3cee31f68810a3b84d899b6 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 22:01:41 +0530
Subject: [PATCH 071/146] Remove asterisks and carets from titles

---
 README.md | 145 +++++++++++++++++-------------------------------------
 1 file changed, 44 insertions(+), 101 deletions(-)

diff --git a/README.md b/README.md
index 07f1a5c..27d2f44 100644
--- a/README.md
+++ b/README.md
@@ -28,128 +28,72 @@ So, here we go...
 - [Usage](#usage)
 - [👀 Examples](#-examples)
   - [Section: Strain your brain!](#section-strain-your-brain)
-    - [▶ Strings can be tricky sometimes *](#%E2%96%B6-strings-can-be-tricky-sometimes-)
-      - [💡 Explanation:](#-explanation)
-    - [▶ Splitsies ^](#%E2%96%B6-splitsies-%5E)
-      - [💡 Explanation:](#-explanation-1)
+    - [▶ Strings can be tricky sometimes](#%E2%96%B6-strings-can-be-tricky-sometimes)
+    - [▶ Splitsies](#%E2%96%B6-splitsies)
+- [is same as](#is-same-as)
+- [but](#but)
+- [isn't the same as](#isnt-the-same-as)
     - [▶ Time for some hash brownies!](#%E2%96%B6-time-for-some-hash-brownies)
-      - [💡 Explanation](#-explanation)
-    - [▶ The disorder within order ^](#%E2%96%B6-the-disorder-within-order-%5E)
-      - [💡 Explanation:](#-explanation-2)
-    - [▶ Keep trying? *](#%E2%96%B6-keep-trying-)
-      - [💡 Explanation:](#-explanation-3)
-    - [▶ Deep down, we're all the same. *](#%E2%96%B6-deep-down-were-all-the-same-)
-      - [💡 Explanation:](#-explanation-4)
+    - [▶ The disorder within order](#%E2%96%B6-the-disorder-within-order)
+    - [▶ Keep trying?](#%E2%96%B6-keep-trying)
+    - [▶ Deep down, we're all the same](#%E2%96%B6-deep-down-were-all-the-same)
     - [▶ For what?](#%E2%96%B6-for-what)
-      - [💡 Explanation:](#-explanation-5)
-    - [▶ Evaluation time discrepancy ^](#%E2%96%B6-evaluation-time-discrepancy-%5E)
-      - [💡 Explanation](#-explanation-1)
+    - [▶ Evaluation time discrepancy](#%E2%96%B6-evaluation-time-discrepancy)
     - [▶ Messing around with `is` operator^](#%E2%96%B6-messing-around-with-is-operator%5E)
-      - [💡 Explanation:](#-explanation-6)
     - [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
-      - [💡 Explanation:](#-explanation-7)
     - [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
-      - [💡 Explanation](#-explanation-2)
-    - [▶ The chicken-egg problem ^](#%E2%96%B6-the-chicken-egg-problem-%5E)
-      - [💡 Explanation](#-explanation-3)
+    - [▶ The chicken-egg problem](#%E2%96%B6-the-chicken-egg-problem)
     - [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
-      - [💡 Explanation](#-explanation-4)
     - [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
-      - [💡 Explanation:](#-explanation-8)
-    - [▶ Strings and the backslashes\ ^](#%E2%96%B6-strings-and-the-backslashes%5C-%5E)
-      - [💡 Explanation](#-explanation-5)
+    - [▶ Strings and the backslashes](#%E2%96%B6-strings-and-the-backslashes)
     - [▶ not knot!](#%E2%96%B6-not-knot)
-      - [💡 Explanation:](#-explanation-9)
     - [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
-      - [💡 Explanation:](#-explanation-10)
     - [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
-      - [💡 Explanation:](#-explanation-11)
     - [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
-      - [💡 Explanation:](#-explanation-12)
     - [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
-      - [💡 Explanation:](#-explanation-13)
     - [▶ yielding None](#%E2%96%B6-yielding-none)
-      - [💡 Explanation:](#-explanation-14)
     - [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
-      - [💡 Explanation:](#-explanation-15)
     - [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
-      - [💡 Explanation:](#-explanation-16)
     - [▶ When True is actually False](#%E2%96%B6-when-true-is-actually-false)
-      - [💡 Explanation:](#-explanation-17)
     - [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
-      - [💡 Explanation:](#-explanation-18)
     - [▶ From filled to None in one instruction...](#%E2%96%B6-from-filled-to-none-in-one-instruction)
-      - [💡 Explanation](#-explanation-6)
-    - [▶ Subclass relationships *](#%E2%96%B6-subclass-relationships-)
-      - [💡 Explanation:](#-explanation-19)
-    - [▶ The mysterious key type conversion *](#%E2%96%B6-the-mysterious-key-type-conversion-)
-      - [💡 Explanation:](#-explanation-20)
+    - [▶ Subclass relationships](#%E2%96%B6-subclass-relationships)
+    - [▶ The mysterious key type conversion](#%E2%96%B6-the-mysterious-key-type-conversion)
     - [▶ Let's see if you can guess this?](#%E2%96%B6-lets-see-if-you-can-guess-this)
-      - [💡 Explanation:](#-explanation-21)
   - [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
     - [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
-      - [💡 Explanation](#-explanation-7)
-    - [▶ Teleportation *](#%E2%96%B6-teleportation-)
-      - [💡 Explanation:](#-explanation-22)
+    - [▶ Teleportation](#%E2%96%B6-teleportation)
     - [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
-      - [💡 Explanation](#-explanation-8)
   - [Section: Watch out for the landmines!](#section-watch-out-for-the-landmines)
     - [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
-      - [💡 Explanation:](#-explanation-23)
-    - [▶ Stubborn `del` operation *](#%E2%96%B6-stubborn-del-operation-)
-      - [💡 Explanation:](#-explanation-24)
     - [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
-      - [💡 Explanation:](#-explanation-25)
     - [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
-      - [💡 Explanation:](#-explanation-26)
     - [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
-      - [💡 Explanation:](#-explanation-27)
     - [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
-      - [💡 Explanation](#-explanation-9)
     - [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
-      - [💡 Explanation:](#-explanation-28)
     - [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
-      - [💡 Explanation:](#-explanation-29)
     - [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
-      - [💡 Explanation:](#-explanation-30)
     - [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
-      - [💡 Explanation](#-explanation-10)
     - [▶ Needles in a Haystack ^](#%E2%96%B6-needles-in-a-haystack-%5E)
-      - [💡 Explanation:](#-explanation-31)
     - [▶ Yielding from... return!](#-yielding-from-return)
-      - [💡 Explanation:](#-explanation-31)
     - [▶ Wild imports](#%E2%96%B6-wild-imports)
-      - [💡 Explanation:](#-explanation-32)
   - [Section: The Hidden treasures!](#section-the-hidden-treasures)
-    - [▶ Okay Python, Can you make me fly? *](#%E2%96%B6-okay-python-can-you-make-me-fly-)
-      - [💡 Explanation:](#-explanation-33)
-    - [▶ `goto`, but why? *](#%E2%96%B6-goto-but-why-)
-      - [💡 Explanation:](#-explanation-34)
-    - [▶ Brace yourself! *](#%E2%96%B6-brace-yourself-)
-      - [💡 Explanation:](#-explanation-35)
-    - [▶ Let's meet Friendly Language Uncle For Life ^](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life-%5E)
-      - [💡 Explanation:](#-explanation-36)
-    - [▶ Even Python understands that love is complicated *](#%E2%96%B6-even-python-understands-that-love-is-complicated-)
-      - [💡 Explanation:](#-explanation-37)
+    - [▶ Okay Python, Can you make me fly?](#%E2%96%B6-okay-python-can-you-make-me-fly)
+    - [▶ `goto`, but why?](#%E2%96%B6-goto-but-why)
+    - [▶ Brace yourself!](#%E2%96%B6-brace-yourself)
+    - [▶ Let's meet Friendly Language Uncle For Life](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life)
+    - [▶ Even Python understands that love is complicated](#%E2%96%B6-even-python-understands-that-love-is-complicated)
     - [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
-      - [💡 Explanation:](#-explanation-38)
-    - [▶ Ellipsis ^](#%E2%96%B6-ellipsis-%5E)
-      - [💡 Explanation](#-explanation-11)
-    - [▶ Inpinity *](#%E2%96%B6-inpinity-)
-      - [💡 Explanation:](#-explanation-39)
-    - [▶ Let's mangle ^](#%E2%96%B6-lets-mangle-%5E)
-      - [💡 Explanation:](#-explanation-40)
+    - [▶ Ellipsis](#%E2%96%B6-ellipsis)
+    - [▶ Inpinity](#%E2%96%B6-inpinity)
+    - [▶ Let's mangle](#%E2%96%B6-lets-mangle)
   - [Section: Miscellaneous](#section-miscellaneous)
     - [▶ `+=` is faster](#%E2%96%B6--is-faster)
-      - [💡 Explanation:](#-explanation-41)
     - [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
-      - [💡 Explanation](#-explanation-12)
     - [▶ Explicit typecast of strings](#%E2%96%B6-explicit-typecast-of-strings)
-      - [💡 Explanation:](#-explanation-42)
     - [▶ Minor Ones](#%E2%96%B6-minor-ones)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
-      - [Some nice Links!](#some-nice-links)
 - [🎓 License](#-license)
   - [Help](#help)
   - [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
@@ -161,8 +105,7 @@ So, here we go...
 
 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.
+> ### ▶ Some fancy Title
 >
 > ```py
 > # Setting up the code.
@@ -222,7 +165,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 
 ## Section: Strain your brain!
 
-### ▶ Strings can be tricky sometimes *
+### ▶ Strings can be tricky sometimes
 <!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --->
 1\.
 ```py
@@ -273,7 +216,7 @@ Makes sense, right?
 
 ---
 
-### ▶ Splitsies ^
+### ▶ Splitsies
 <!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
 ```py
 >>> 'a'.split()
@@ -356,7 +299,7 @@ So, why is Python all over the place?
 
 ---
 
-### ▶ The disorder within order ^
+### ▶ The disorder within order
 <!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
 from collections import OrderedDict
@@ -454,7 +397,7 @@ What is going on here?
 
 ---
 
-### ▶ Keep trying? *
+### ▶ Keep trying?
 <!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --->
 ```py
 def some_func():
@@ -514,7 +457,7 @@ Iteration 0
 
 ---
 
-### ▶ Deep down, we're all the same. *
+### ▶ Deep down, we're all the same
 <!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
 ```py
 class WTF:
@@ -617,7 +560,7 @@ for i, some_dict[i] in enumerate(some_string):
 
 ---
 
-### ▶ Evaluation time discrepancy ^
+### ▶ Evaluation time discrepancy
 <!-- Example ID: 6aa11a4b-4cf1-467a-b43a-810731517e98 --->
 1\.
 ```py
@@ -900,7 +843,7 @@ Even when the values of `x` were different in every iteration prior to appending
 
 ---
 
-### ▶ The chicken-egg problem ^
+### ▶ The chicken-egg problem
 <!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --->
 1\.
 ```py
@@ -994,7 +937,7 @@ SyntaxError: invalid syntax
 
 ---
 
-### ▶ Strings and the backslashes\ ^
+### ▶ Strings and the backslashes
 <!-- Example ID: 6ae622c3-6d99-4041-9b33-507bd1a4407b --->
 **Output:**
 ```py
@@ -1493,7 +1436,7 @@ Most methods that modify the items of sequence/mapping objects like `list.append
 
 ---
 
-### ▶ Subclass relationships *
+### ▶ Subclass relationships
 <!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
 **Output:**
 ```py
@@ -1517,7 +1460,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 
 ---
 
-### ▶ The mysterious key type conversion *
+### ▶ The mysterious key type conversion
 <!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --->
 ```py
 class SomeClass(str):
@@ -1670,7 +1613,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 
 ---
 
-### ▶ Teleportation *
+### ▶ Teleportation
 <!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
 ```py
 import numpy as np
@@ -1780,7 +1723,7 @@ Yes, it runs for exactly **eight** times and stops.
 
 ---
 
-### ▶ Stubborn `del` operation *
+### ▶ Stubborn `del` operation
 <!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --->
 ```py
 class SomeClass:
@@ -2249,7 +2192,7 @@ class SomeClass:
 
 ---
 
-### ▶ Needles in a Haystack ^
+### ▶ Needles in a Haystack
 <!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
 1\.
 ```py
@@ -2477,7 +2420,7 @@ NameError: name 'some_weird_name_func_' is not defined
 
 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? *
+### ▶ Okay Python, Can you make me fly?
 <!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --->
 Well, here you go
 
@@ -2495,7 +2438,7 @@ Sshh.. It's a super secret.
 
 ---
 
-### ▶ `goto`, but why? *
+### ▶ `goto`, but why?
 <!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --->
 ```py
 from goto import goto, label
@@ -2523,7 +2466,7 @@ Freedom!
 
 ---
 
-### ▶ Brace yourself! *
+### ▶ Brace yourself!
 <!-- Example ID: 5c0c75f2-ddd9-4da3-ba49-c4be7ec39acf --->
 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,
 
@@ -2548,7 +2491,7 @@ Braces? No way! If you think that's disappointing, use Java. Okay, another surpr
 
 ---
 
-### ▶ Let's meet Friendly Language Uncle For Life ^
+### ▶ Let's meet Friendly Language Uncle For Life
 <!-- Example ID: 6427fae6-e959-462d-85da-ce4c94ce41be --->
 **Output (Python 3.x)**
 ```py
@@ -2579,7 +2522,7 @@ There we go.
 
 ---
 
-### ▶ Even Python understands that love is complicated *
+### ▶ Even Python understands that love is complicated
 <!-- Example ID: b93cad9e-d341-45d1-999c-fcdce65bed25 --->
 ```py
 import this
@@ -2680,7 +2623,7 @@ Try block executed successfully...
 - `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.
 
 ---
-### ▶ Ellipsis ^
+### ▶ Ellipsis
 <!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --->
 ```py
 def some_func():
@@ -2740,7 +2683,7 @@ Ellipsis
 
 ---
 
-### ▶ Inpinity *
+### ▶ Inpinity
 <!-- Example ID: ff473ea8-a3b1-4876-a6f0-4378aff790c1 --->
 The spelling is intended. Please, don't submit a patch for this.
 
@@ -2759,7 +2702,7 @@ The spelling is intended. Please, don't submit a patch for this.
 
 ---
 
-### ▶ Let's mangle ^
+### ▶ Let's mangle
 <!-- Example ID: 37146d2d-9e67-43a9-8729-3c17934b910c --->
 1\.
 ```py

From 2a1c28ee4d850b10f15b6bff7a805b6cb875923f Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Mon, 8 Jul 2019 22:22:04 +0530
Subject: [PATCH 072/146] Fix toc

---
 README.md | 80 +++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 69 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 27d2f44..e9cd41b 100644
--- a/README.md
+++ b/README.md
@@ -20,19 +20,15 @@ So, here we go...
 
 # Table of Contents
 
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-
+<!-- toc -->
 
 - [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](#%E2%96%B6-strings-can-be-tricky-sometimes)
     - [▶ Splitsies](#%E2%96%B6-splitsies)
-- [is same as](#is-same-as)
-- [but](#but)
-- [isn't the same as](#isnt-the-same-as)
     - [▶ Time for some hash brownies!](#%E2%96%B6-time-for-some-hash-brownies)
     - [▶ The disorder within order](#%E2%96%B6-the-disorder-within-order)
     - [▶ Keep trying?](#%E2%96%B6-keep-trying)
@@ -92,14 +88,76 @@ So, here we go...
     - [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
     - [▶ Explicit typecast of strings](#%E2%96%B6-explicit-typecast-of-strings)
     - [▶ Minor Ones](#%E2%96%B6-minor-ones)
+  * [Section: Strain your brain!](#section-strain-your-brain)
+    + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
+    + [▶ Splitsies](#-splitsies)
+    + [▶ Time for some hash brownies!](#-time-for-some-hash-brownies)
+    + [▶ The disorder within order](#-the-disorder-within-order)
+    + [▶ Keep trying?](#-keep-trying)
+    + [▶ Deep down, we're all the same](#-deep-down-were-all-the-same)
+    + [▶ For what?](#-for-what)
+    + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
+    + [▶ Messing around with `is` operator](#-messing-around-with-is-operator)
+    + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+    + [▶ The sticky output function](#-the-sticky-output-function)
+    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)
+    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+    + [▶ The surprising comma](#-the-surprising-comma)
+    + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
+    + [▶ not knot!](#-not-knot)
+    + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
+    + [▶ 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)
+    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)
+    + [▶ 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: 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)
+    + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
+    + [▶ Stubborn `del` operation](#-stubborn-del-operation)
+    + [▶ 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)
+    + [▶ Needles in a Haystack](#-needles-in-a-haystack)
+    + [▶ Wild imports](#-wild-imports)
+  * [Section: The Hidden treasures!](#section-the-hidden-treasures)
+    + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
+    + [▶ `goto`, but why?](#-goto-but-why)
+    + [▶ Brace yourself!](#-brace-yourself)
+    + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
+    + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
+    + [▶ Yes, it exists!](#-yes-it-exists)
+    + [▶ Ellipsis](#-ellipsis)
+    + [▶ Inpinity](#-inpinity)
+    + [▶ Let's mangle](#-lets-mangle)
+  * [Section: 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)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
 - [🎓 License](#-license)
-  - [Help](#help)
-  - [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
-  - [Need a pdf version?](#need-a-pdf-version)
+  * [Help](#help)
+  * [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
+  * [Need a pdf version?](#need-a-pdf-version)
 
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+<!-- tocstop -->
 
 # Structure of the Examples
 
@@ -626,7 +684,7 @@ array_4 = [400, 500, 600]
 
 ---
 
-### ▶ Messing around with `is` operator^
+### ▶ Messing around with `is` operator
 <!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --->
 The following is a very famous example present all over the internet.
 

From 62237157251d68aef0a3a3ae16b285bbc4dd2383 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sat, 13 Jul 2019 22:41:27 +0530
Subject: [PATCH 073/146] change order

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index e9cd41b..70d73d4 100644
--- a/README.md
+++ b/README.md
@@ -326,9 +326,9 @@ some_dict[5] = "Python"
 ```py
 >>> some_dict[5.5]
 "Ruby"
->>> some_dict[5.0]
+>>> some_dict[5.0] # "Python" destroyed the existence of "JavaScript"?
 "Python"
->>> some_dict[5] # "Python" destroyed the existence of "JavaScript"?
+>>> some_dict[5] 
 "Python"
 
 >>> complex_five = 5 + 0j

From fc491c5dd637c1bce61fca254def98cf8f6410b5 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Sun, 21 Jul 2019 18:57:01 +0530
Subject: [PATCH 074/146] Commit insert_ids script

---
 irrelevant/insert_ids.py | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 irrelevant/insert_ids.py

diff --git a/irrelevant/insert_ids.py b/irrelevant/insert_ids.py
new file mode 100644
index 0000000..a16bf5f
--- /dev/null
+++ b/irrelevant/insert_ids.py
@@ -0,0 +1,24 @@
+import uuid
+
+new_file = []
+original_file = []
+
+fname = "../README.md"
+
+
+def generate_random_id_comment():
+    random_id = uuid.uuid4()
+    return f"<!-- Example ID: {random_id} --!>"
+
+
+with open(fname, "r") as f:
+    original_file = f.readlines()
+
+
+for line in original_file:
+    new_file.append(line)
+    if line.strip().startswith("### "):
+        new_file.append(generate_random_id_comment())
+
+with open(fname, "w") as f:
+    f.write("".join(new_file))

From d143f972b8a6a43b0e16c3ca4b26bd965e94a2d4 Mon Sep 17 00:00:00 2001
From: mitcom <pawel@burniak.pl>
Date: Sun, 6 Oct 2019 13:06:38 +0200
Subject: [PATCH 075/146] Add space-invader operator case

---
 README.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/README.md b/README.md
index be27847..27940e5 100644
--- a/README.md
+++ b/README.md
@@ -2368,6 +2368,24 @@ nan
   + `++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.
 
+* There is a lack of incrementation operator known from different languages, but have you ever heard about _the space-invader operator_?
+  ```py
+  >>> a = 42
+  >>> a -=- 1
+  >>> a
+  43
+  ```
+
+  + together with another:
+    ```py
+    >>> a +=+ 1
+    >>> a
+    >>> 44
+    ```
+
+  **💡 Explanation:**
+  This prank comes from [Raymond Hettinger's twit](https://twitter.com/raymondh/status/1131103570856632321?lang=en) and it is actually just malformatted `a -= (-1)`. Which is eqivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
+
 * 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

From f8acf49d0544108684d3fa66337e14a11bf9c6f1 Mon Sep 17 00:00:00 2001
From: Satwik Kansal <satwikkansal@gmail.com>
Date: Wed, 9 Oct 2019 18:48:41 +0530
Subject: [PATCH 076/146] Update README.md

---
 README.md | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 27940e5..c31017e 100644
--- a/README.md
+++ b/README.md
@@ -2368,23 +2368,21 @@ nan
   + `++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.
 
-* There is a lack of incrementation operator known from different languages, but have you ever heard about _the space-invader operator_?
+* Have you ever heard about _the space-invader operator_ in Python?
   ```py
   >>> a = 42
   >>> a -=- 1
   >>> a
   43
   ```
-
-  + together with another:
-    ```py
-    >>> a +=+ 1
-    >>> a
-    >>> 44
-    ```
-
+  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 twit](https://twitter.com/raymondh/status/1131103570856632321?lang=en) and it is actually just malformatted `a -= (-1)`. Which is eqivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
+  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 eqivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
 
 * 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

From bef3f2a33db59a65b159dec661c13c36850501f0 Mon Sep 17 00:00:00 2001
From: monujee <monujee@users.noreply.github.com>
Date: Fri, 25 Oct 2019 14:28:25 +0530
Subject: [PATCH 077/146] Update README.md

Typo corrected.
---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index c31017e..b1354cc 100644
--- a/README.md
+++ b/README.md
@@ -2336,7 +2336,7 @@ nan
 
 #### 💡 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.
+`'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.
 
 ---
 
@@ -2382,7 +2382,7 @@ nan
   >>> 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 eqivalent to `a = a - (- 1)`. Similar for the `a += (+ 1)` case.
+  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 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
@@ -2390,7 +2390,7 @@ nan
      exec("""
      def f():
          """ + """
-         """.join(["X"+str(x)+"=" + str(x) for x in range(65539)]))
+         """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
 
      f()
 

From d823aa922055a9c299092cb428f99282f64c03a3 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 28 Oct 2019 19:23:06 +0530
Subject: [PATCH 078/146] Ignore DS_Store

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 523a028..a252b5a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+.DS_Store
+
 node_modules
 npm-debug.log
 wtfpython-pypi/build/

From 82c37ccb32588ccf74592d541e43c14e71d98531 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 28 Oct 2019 22:17:12 +0530
Subject: [PATCH 079/146] Perhaps some editing

---
 README.md | 266 +++++++++++++++++++++++++++++++++---------------------
 1 file changed, 165 insertions(+), 101 deletions(-)

diff --git a/README.md b/README.md
index 907ebdf..f2743e8 100644
--- a/README.md
+++ b/README.md
@@ -6,13 +6,13 @@
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
 
-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.
+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 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!
+Here is 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 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 an experienced Python programmer, you can take it as a challenge to get most of them right in 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/).
 
@@ -104,11 +104,12 @@ All the examples are structured like below:
 > ### ▶ Some fancy Title
 >
 > ```py
-> # Setting up the code.
+> # Set up the code.
 > # Preparation for the magic...
 > ```
 >
 > **Output (Python version(s)):**
+>
 > ```py
 > >>> triggering_statement
 > Some unexpected output
@@ -119,16 +120,18 @@ All the examples are structured like below:
 > #### 💡 Explanation:
 >
 > * Brief explanation of what's happening and why is it happening.
->   ```py
->   Setting up examples for clarification (if necessary)
->   ```
->   **Output Output (Python version(s)):**
->   ```py
->   >>> trigger # some example that makes it easy to unveil the magic
->   # some justified output
->   ```
+> ```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 in the description.
+**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
 
@@ -199,14 +202,14 @@ 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:
++ 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)
   <img src="images/string-intern/string_intern.png" alt="">
-+ Constant folding is a technique for [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) in Python. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ The abrupt change in output of the third 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 length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 + Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
 
 ---
@@ -232,8 +235,8 @@ Makes sense, right?
 
 #### 💡 Explanation:
 
-- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/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 `[]`.
+- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)
+    >  If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
     > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
 - Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
     ```py
@@ -249,21 +252,22 @@ Makes sense, right?
 
 
 
-### ▶ Time for some hash brownies!
+### ▶ Hash brownies
 <!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --->
 1\.
 ```py
 some_dict = {}
-some_dict[5.5] = "Ruby"
-some_dict[5.0] = "JavaScript"
+some_dict[5.5] = "JavaScript"
+some_dict[5.0] = "Ruby"
 some_dict[5] = "Python"
 ```
 
 **Output:**
+
 ```py
 >>> some_dict[5.5]
 "Ruby"
->>> some_dict[5.0] # "Python" destroyed the existence of "JavaScript"?
+>>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"?
 "Python"
 >>> some_dict[5] 
 "Python"
@@ -288,13 +292,13 @@ So, why is Python all over the place?
   >>> hash(5) == hash(5.0) == hash(5 + 0j)
   True
   ```
-  **Note:** Objects with different values may also have same hash (known as hash collision).
-* When the statement `some_dict[5] = "Python"` is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
-* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains beautifully the rationale behind it.
+  **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).
+* When the statement `some_dict[5] = "Python"` is executed, the existing value "Ruby" is overwritten with "Python" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.
+* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.
 
 ---
 
-### ▶ The disorder within order
+### ▶ Disorder within order
 <!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
 from collections import OrderedDict
@@ -316,7 +320,7 @@ class DictWithHash(dict):
 
 class OrderedDictWithHash(OrderedDict):
     """
-    A dict that also implements __hash__ magic.
+    An OrderedDict that also implements __hash__ magic.
     """
     __hash__ = lambda self: 0
 ```
@@ -357,6 +361,7 @@ 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 is 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 lenght 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,
@@ -387,12 +392,11 @@ What is going on here?
     >>> 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`.
-
+    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?
+### ▶ Keep trying...
 <!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --->
 ```py
 def some_func():
@@ -446,13 +450,13 @@ 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.
+- 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.
 
 ---
 
-### ▶ Deep down, we're all the same
+### ▶ Deep down, we're all the same.
 <!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
 ```py
 class WTF:
@@ -508,12 +512,12 @@ True
 some_string = "wtf"
 some_dict = {}
 for i, some_dict[i] in enumerate(some_string):
-    pass
+    i = 10
 ```
 
 **Output:**
 ```py
->>> some_dict # An indexed dict is created.
+>>> some_dict # An indexed dict appears.
 {0: 'w', 1: 't', 2: 'f'}
 ```
 
@@ -545,7 +549,7 @@ for i, some_dict[i] in enumerate(some_string):
 
   - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).
 
-* The `enumerate(some_string)` function yields a new value `i` (A counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:
+* 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')
@@ -560,13 +564,15 @@ for i, some_dict[i] in enumerate(some_string):
 1\.
 ```py
 array = [1, 8, 15]
-g = (x for x in array if array.count(x) > 0)
+# A typical generator expresion
+gen = (x for x in array if array.count(x) > 0)
 array = [2, 8, 22]
 ```
 
 **Output:**
+
 ```py
->>> print(list(g))
+>>> print(list(gen)) # Where did the other values go?
 [8]
 ```
 
@@ -574,20 +580,20 @@ array = [2, 8, 22]
 
 ```py
 array_1 = [1,2,3,4]
-g1 = (x for x in array_1)
+gen_1 = (x for x in array_1)
 array_1 = [1,2,3,4,5]
 
 array_2 = [1,2,3,4]
-g2 = (x for x in array_2)
+gen_2 = (x for x in array_2)
 array_2[:] = [1,2,3,4,5]
 ```
 
 **Output:**
 ```py
->>> print(list(g1))
+>>> print(list(gen_1))
 [1,2,3,4]
 
->>> print(list(g2))
+>>> print(list(gen_2))
 [1,2,3,4,5]
 ```
 
@@ -596,7 +602,7 @@ array_2[:] = [1,2,3,4,5]
 ```py
 array_3 = [1, 2, 3]
 array_4 = [10, 20, 30]
-g = (i + j for i in array_3 for j in array_4)
+gen = (i + j for i in array_3 for j in array_4)
 
 array_3 = [4, 5, 6]
 array_4 = [400, 500, 600]
@@ -604,7 +610,7 @@ array_4 = [400, 500, 600]
 
 **Output:**
 ```py
->>> print(list(g))
+>>> print(list(gen))
 [401, 501, 601, 402, 502, 602, 403, 503, 603]
 ```
 
@@ -621,11 +627,12 @@ array_4 = [400, 500, 600]
 
 ---
 
-### ▶ Messing around with `is` operator
+### ▶ How not to use `is` operator
 <!-- Example ID: 230fa2ac-ab36-4ad1-b675-5f5a1c1a6217 --->
 The following is a very famous example present all over the internet.
 
 1\.
+
 ```py
 >>> a = 256
 >>> b = 256
@@ -741,14 +748,16 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 
 ### ▶ A tic-tac-toe where X wins in the first attempt!
 <!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --->
+
 ```py
 # Let's initialize a row
-row = [""]*3 #row i['', '', '']
+row = [""] * 3 #row i['', '', '']
 # Let's make a board
-board = [row]*3
+board = [row] * 3
 ```
 
 **Output:**
+
 ```py
 >>> board
 [['', '', ''], ['', '', ''], ['', '', '']]
@@ -761,7 +770,7 @@ 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:
 
@@ -786,6 +795,9 @@ We can avoid this scenario here by not using `row` variable to generate `board`.
 
 ### ▶ The sticky output function
 <!-- Example ID: 4dc42f77-94cb-4eb5-a120-8203d3ed7604 --->
+
+1\.
+
 ```py
 funcs = []
 results = []
@@ -799,6 +811,7 @@ funcs_results = [func() for func in funcs]
 ```
 
 **Output:**
+
 ```py
 >>> results
 [0, 1, 2, 3, 4, 5, 6]
@@ -807,7 +820,7 @@ funcs_results = [func() for func in funcs]
 ```
 Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.
 
-//OR
+2\.
 
 ```py
 >>> powers_of_x = [lambda x: x**i for i in range(10)]
@@ -850,7 +863,9 @@ True
 True
 ```
 
-2\. So which is the ultimate, base class? And wait, there's more to the confusion
+So which is the "ultimate" base class? There's more to the confusion by the way,
+
+2\. 
 
 ```py
 >>> class A: pass
@@ -904,7 +919,8 @@ False
 
 ### ▶ The surprising comma
 <!-- Example ID: 31a819c8-ed73-4dcc-84eb-91bedbb51e58 --->
-**Output:**
+**Output (< 3.6):**
+
 ```py
 >>> def f(x, y,):
 ...     print(x, y)
@@ -917,6 +933,7 @@ False
     def h(x, **kwargs,):
                      ^
 SyntaxError: invalid syntax
+
 >>> def h(*args,):
   File "<stdin>", line 1
     def h(*args,):
@@ -1045,7 +1062,8 @@ if noon_time:
     print("Time at noon is", noon_time)
 ```
 
-**Output:**
+**Output (< 3.5):**
+
 ```sh
 ('Time at noon is', datetime.time(12, 0))
 ```
@@ -1202,6 +1220,7 @@ def some_func(val):
 ```
 
 **Output:**
+
 ```py
 >>> [x for x in some_iterable]
 ['a', 'b']
@@ -1216,6 +1235,7 @@ def some_func(val):
 ```
 
 #### 💡 Explanation:
+- This is bug in CPython's handling of `yield` in generators and comprehensions.
 - Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
 - Related bug report: http://bugs.python.org/issue10544
 
@@ -1223,6 +1243,9 @@ def some_func(val):
 
 ### ▶ Mutating the immutable!
 <!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --->
+
+This might seem trivial if you know how references works in Python.
+
 ```py
 some_tuple = ("A", "tuple", "with", "values")
 another_tuple = ([1, 2], [3, 4], [5, 6])
@@ -1342,7 +1365,8 @@ if True == False:
     print("I've lost faith in truth!")
 ```
 
-**Output:**
+**Output (< 3.x):**
+
 ```
 I've lost faith in truth!
 ```
@@ -1403,34 +1427,6 @@ Where did element `3` go from the `numbers` list?
 
 ---
 
-### ▶ From filled to None in one instruction...
-<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --->
-```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
 <!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
 **Output:**
@@ -2184,24 +2180,60 @@ class SomeClass:
 - A generator expression has its own scope.
 - Starting from Python 3.X, list comprehensions also have their own scope.
 
+---
+
+### ▶ From full to None in one instruction
+
+<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --->
+
+```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
+
+
 
 ---
 
+
+
 ### ▶ Needles in a Haystack
+
 <!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
+
+I haven't met even a single experience Pythonist till date who has not came across one or more of the following scenarios,
+
 1\.
+
 ```py
 x, y = (0, 1) if True else None, None
 ```
 
 **Output:**
+
 ```py
 >>> x, y  # expected (0, 1)
 ((0, 1), None)
 ```
 
-Almost every Python programmer has faced a similar situation.
-
 2\.
 ```py
 t = ('one', 'two')
@@ -2263,15 +2295,45 @@ b = "javascript"
 # No AssertionError is raised
 ```
 
+5\.
+
+```py
+some_list = [1, 2, 3]
+some_dict = {
+  "key_1": 1,
+  "key_2": 2,
+  "key_3": 3
+}
+
+some_list = some_list.append(4)
+some_dict = some_dict.update({"key_4": 4})
+```
+
+**Output:**
+
+```py
+>>> print(some_list)
+None
+>>> print(some_dict)
+None
+```
+
+
+
 #### 💡 Explanation:
+
 * For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.
+
 * For 2, the correct statement for expected behavior is `t = ('one',)` or `t = 'one',` (missing comma) otherwise the interpreter considers `t` to be a `str` and iterates over it character by character.
+
 * `()` is a special token and denotes empty `tuple`.
+
 * In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation,
     ```py
     >>> ten_words_list
     ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
     ```
+    
 * No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,
     ```py
     >>> a = "python"
@@ -2289,15 +2351,17 @@ b = "javascript"
         File "<stdin>", line 1, in <module>
     AssertionError: Values aren not equal
     ```
+    
+* As for the last snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+
+* Being aware of these knitpicks can save you hours of degugging effort in long run. 
 
 ---
 
-```
-
-
 ### ▶ Yielding from... return!
 
 1\.
+
 ```py
 def some_func(x):
     if x == 3:
@@ -2307,6 +2371,7 @@ def some_func(x):
 ```
 
 **Output:**
+
 ```py
 >>> list(some_func(3))
 []
@@ -2315,6 +2380,7 @@ def some_func(x):
 Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
 
 2\.
+
 ```py
 def some_func(x):
     if x == 3:
@@ -2324,7 +2390,8 @@ def some_func(x):
           yield i
 ```
 
-**Output:**
+**Output (> 3.3):**
+
 ```py
 >>> list(some_func(3))
 []
@@ -2573,7 +2640,7 @@ True
 
 * `this` module in Python is an easter egg for The Zen Of Python ([PEP 20](https://www.python.org/dev/peps/pep-0020)).
 * And if you think that's already interesting enough, check out the implementation of [this.py](https://hg.python.org/cpython/file/c3896275c0f6/Lib/this.py). Interestingly, the code for the Zen violates itself (and that's probably the only place where this happens).
-* Regarding the statement `love is not True or False; love is love`, ironic but it's self-explanatory.
+* 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).
 
 ---
 
@@ -2781,8 +2848,6 @@ AttributeError: 'A' object has no attribute '__variable'
 
 
 
-
-
 ---
 
 ## Section: Miscellaneous
@@ -2790,6 +2855,7 @@ AttributeError: 'A' object has no attribute '__variable'
 
 ### ▶ `+=` is faster
 <!-- Example ID: bfd19c60-a807-4a26-9598-4912b86ddb36 --->
+
 ```py
 # using "+", three strings:
 >>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
@@ -2893,6 +2959,7 @@ Let's increase the number of iterations by a factor of 10.
   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.
 
 ---
@@ -3016,11 +3083,13 @@ nan
 
 ---
 
+<center>~~~ That's all folks! ~~~</center>
+
+---
+
 # Contributing
 
-All patches are Welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details.
-
-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)
+All patches are welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details. 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).
 
 # Acknowledgements
 
@@ -3044,16 +3113,11 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 [license-url]: http://www.wtfpl.net
 [license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
 
-## Help
+## Surprise your friends too?
 
-If you have any wtfs, ideas or suggestions, please share.
+If you liked the project, you can use these quick links to recommend wtfpython to your friends,
 
-## Surprise your geeky pythonist friends?
-
-You can use these quick links to recommend wtfpython to your friends,
-
-[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&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.)
 
 ## Need a pdf version?
 

From 28bcbfd311a6f5314bc1159c022eff5cc53e2f2e Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 28 Oct 2019 22:40:32 +0530
Subject: [PATCH 080/146] More changes to order and aesthetics

---
 README.md | 228 ++++++++++++++++++++++++------------------------------
 1 file changed, 103 insertions(+), 125 deletions(-)

diff --git a/README.md b/README.md
index f2743e8..5ac7462 100644
--- a/README.md
+++ b/README.md
@@ -1303,7 +1303,7 @@ NameError: name 'e' is not defined
 
 * Source: https://docs.python.org/3/reference/compound_stmts.html#except
 
-  When an exception has been assigned using `as` target, it is cleared at the end of the except clause. This is as if
+  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:
@@ -1378,8 +1378,75 @@ I've lost faith in truth!
 
 ---
 
+### ▶ Yielding from... return!
+
+1\.
+
+```py
+def some_func(x):
+    if x == 3:
+        return ["wtf"]
+    else:
+        yield from range(x)
+```
+
+**Output:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
+
+2\.
+
+```py
+def some_func(x):
+    if x == 3:
+        return ["wtf"]
+    else:
+        for i in range(x):
+          yield i
+```
+
+**Output (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Same result, that didn't work either.
+
+#### 💡 Explanation:
+
++ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that,
+
+> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
+
++ In case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically catched inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
+
++ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
+
+  ```py
+  try:
+      next(some_func(3))
+  except StopIteration as e:
+      some_string = e.value
+  ```
+
+  ```py
+  >>> some_string
+  ["wtf"]
+  ```
+
+---
+
 ### ▶ Lossy zip of iterators
+
 <!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --->
+
 ```py
 >>> numbers = list(range(7))
 >>> numbers
@@ -1407,8 +1474,7 @@ Where did element `3` go from the `numbers` list?
             result = []
             for it in iterators:
                 elem = next(it, sentinel)
-                if elem is sentinel:
-                    return
+                if elem is sentinel: return
                 result.append(elem)
             yield tuple(result)
     ```
@@ -1605,7 +1671,9 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 ---
 
 ### ▶ Teleportation
+
 <!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
+
 ```py
 import numpy as np
 
@@ -1858,8 +1926,8 @@ print(x, ': x in global')
 >>> x = 1
 >>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
->>> print(x, ': x in global')
-(4, ': x in global')
+>>> print(x)
+4
 ```
 
 **Output (Python 3.x):**
@@ -1867,15 +1935,15 @@ print(x, ': x in global')
 >>> x = 1
 >>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
->>> print(x, ': x in global')
-1 : x in global
+>>> print(x)
+1
 ```
 
 #### 💡 Explanation:
 
 - In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable.
 
-- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) documentation:
+- 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) change log:
 
     > "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."
 
@@ -1883,6 +1951,7 @@ print(x, ': x in global')
 
 ### ▶ Beware of default mutable arguments!
 <!-- Example ID: 7d42dade-e20d-4a7b-9ed7-16fb58505fe9 --->
+
 ```py
 def some_func(default_arg=[]):
     default_arg.append("some_string")
@@ -2182,39 +2251,6 @@ class SomeClass:
 
 ---
 
-### ▶ From full to None in one instruction
-
-<!-- Example ID: 9a0d5335-efe5-4eae-af44-584d15233066 --->
-
-```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
-
-
-
----
-
-
-
 ### ▶ Needles in a Haystack
 
 <!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
@@ -2235,6 +2271,7 @@ x, y = (0, 1) if True else None, None
 ```
 
 2\.
+
 ```py
 t = ('one', 'two')
 for i in t:
@@ -2249,6 +2286,7 @@ print(t)
 ```
 
 **Output:**
+
 ```py
 one
 two
@@ -2288,7 +2326,9 @@ ten_words_list = [
 a = "python"
 b = "javascript"
 ```
+
 **Output:**
+
 ```py
 # An assert statement with an assertion failure message.
 >>> assert(a == b, "Both languages are different")
@@ -2329,99 +2369,37 @@ None
 * `()` is a special token and denotes empty `tuple`.
 
 * In 3, as you might have already figured out, there's a missing comma after 5th element (`"that"`) in the list. So by implicit string literal concatenation,
-    ```py
-    >>> ten_words_list
-    ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
-    ```
-    
+
+  ```py
+  >>> ten_words_list
+  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']
+  ```
+
 * No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,
-    ```py
-    >>> a = "python"
-    >>> b = "javascript"
-    >>> assert a == b
-    Traceback (most recent call last):
-        File "<stdin>", line 1, in <module>
-    AssertionError
 
-    >>> assert (a == b, "Values are not equal")
-    <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+  ```py
+  >>> a = "python"
+  >>> b = "javascript"
+  >>> assert a == b
+  Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+  AssertionError
+  
+  >>> assert (a == b, "Values are not equal")
+  <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?
+  
+  >>> assert a == b, "Values are not equal"
+  Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+  AssertionError: Values aren not equal
+  ```
 
-    >>> assert a == b, "Values are not equal"
-    Traceback (most recent call last):
-        File "<stdin>", line 1, in <module>
-    AssertionError: Values aren not equal
-    ```
-    
 * As for the last snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
 
 * Being aware of these knitpicks can save you hours of degugging effort in long run. 
 
 ---
 
-### ▶ Yielding from... return!
-
-1\.
-
-```py
-def some_func(x):
-    if x == 3:
-        return ["wtf"]
-    else:
-        yield from range(x)
-```
-
-**Output:**
-
-```py
->>> list(some_func(3))
-[]
-```
-
-Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
-
-2\.
-
-```py
-def some_func(x):
-    if x == 3:
-        return ["wtf"]
-    else:
-        for i in range(x):
-          yield i
-```
-
-**Output (> 3.3):**
-
-```py
->>> list(some_func(3))
-[]
-```
-
-Same result, that didn't work either.
-
-#### 💡 Explanation:
-
-+ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that,
-
-> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
-
-+ In case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically catched inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
-
-+ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
-  ```py
-  try:
-      next(some_func(3))
-  except StopIteration as e:
-      some_string = e.value
-  ```
-
-  ```py
-  >>> some_string
-  ["wtf"]
-  ```
-
----
-
 ### ▶ Wild imports
 <!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
 ```py

From ce8adb0417b6821f95747c2e4cf81b931da4b547 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 28 Oct 2019 22:48:15 +0530
Subject: [PATCH 081/146] Update TOC

---
 README.md | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 5ac7462..5033a90 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,6 @@
 <p align="center"><img src="images/logo.png" alt=""></p>
 <h1 align="center">What the f*ck Python! 🐍</h1>
 <p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
-
 [![WTFPL 2.0][license-image]][license-url]
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
@@ -20,22 +19,22 @@ So, here we go...
 
 # Table of Contents
 
-<!-- toc -->
+<!-- toc generated using "markdown-toc -i README.md --maxdepth 3"-->
 
 - [Structure of the Examples](#structure-of-the-examples)
     + [▶ Some fancy Title](#-some-fancy-title)
 - [Usage](#usage)
-- [👀 Examples](#-examples)
+- [👀 Examples](#%F0%9F%91%80-examples)
   * [Section: Strain your brain!](#section-strain-your-brain)
     + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
     + [▶ Splitsies](#-splitsies)
-    + [▶ Time for some hash brownies!](#-time-for-some-hash-brownies)
-    + [▶ The disorder within order](#-the-disorder-within-order)
-    + [▶ Keep trying?](#-keep-trying)
-    + [▶ Deep down, we're all the same](#-deep-down-were-all-the-same)
+    + [▶ Hash brownies](#-hash-brownies)
+    + [▶ Disorder within order](#-disorder-within-order)
+    + [▶ Keep trying...](#-keep-trying)
+    + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)
     + [▶ For what?](#-for-what)
     + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
-    + [▶ Messing around with `is` operator](#-messing-around-with-is-operator)
+    + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
     + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
     + [▶ The sticky output function](#-the-sticky-output-function)
     + [▶ The chicken-egg problem](#-the-chicken-egg-problem)
@@ -51,8 +50,8 @@ So, here we go...
     + [▶ 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)
+    + [▶ Yielding from... return!](#-yielding-from-return)
     + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)
-    + [▶ 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)
@@ -88,11 +87,11 @@ So, here we go...
     + [▶ Let's make a giant string!](#-lets-make-a-giant-string)
     + [▶ Explicit typecast of strings](#-explicit-typecast-of-strings)
     + [▶ Minor Ones](#-minor-ones)
+  * [~~~ That's all folks! ~~~](#-thats-all-folks-)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
-- [🎓 License](#-license)
-  * [Help](#help)
-  * [Surprise your geeky pythonist friends?](#surprise-your-geeky-pythonist-friends)
+- [🎓 License](#%F0%9F%8E%93-license)
+  * [Surprise your friends too?](#surprise-your-friends-too)
   * [Need a pdf version?](#need-a-pdf-version)
 
 <!-- tocstop -->
@@ -361,7 +360,7 @@ 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 is 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 lenght 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,
@@ -2937,7 +2936,7 @@ Let's increase the number of iterations by a factor of 10.
   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.
 
 ---
@@ -3062,7 +3061,6 @@ nan
 ---
 
 <center>~~~ That's all folks! ~~~</center>
-
 ---
 
 # Contributing

From bd798f2966b7c3be801fbb3ed868bea7fe97d24f Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 28 Oct 2019 22:51:03 +0530
Subject: [PATCH 082/146] Update alignment

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5033a90..dcafc44 100644
--- a/README.md
+++ b/README.md
@@ -3060,7 +3060,8 @@ nan
 
 ---
 
-<center>~~~ That's all folks! ~~~</center>
+<p align="center">~~~ That's all folks! ~~~</p>
+
 ---
 
 # Contributing

From 34e97d53fb12970945d05a2853a7102c980f1e20 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Tue, 29 Oct 2019 01:07:28 +0530
Subject: [PATCH 083/146] Add example related to the Walrus operator

Closes https://github.com/satwikkansal/wtfpython/issues/145
---
 README.md | 118 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 115 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index dcafc44..58bbdb7 100644
--- a/README.md
+++ b/README.md
@@ -160,12 +160,124 @@ Now, just run `wtfpython` at the command line which will open this collection in
 
 # 👀 Examples
 
-
 ## Section: Strain your brain!
 
+### ▶ First things first!
+
+<!-- Example ID: d3d73936-3cf1-4632-b5ab-817981338863 -->
+
+For some reasons, "Walrus" operator (`:=`) has become a very popular feature in the language. Let's check it out,
+
+1\.
+
+```py
+>>> a = "wtf_walrus"
+>>> a
+'wtf_walrus'
+>>> a := "wtf_walrus"
+File "<ipython-input-20-14e95425e0a2>", line 1
+    a := "wtf_walrus"
+      ^
+SyntaxError: invalid syntax
+
+>>> (a := "wtf_walrus") # This works though
+>>> a
+'wtf_walrus'
+```
+
+2 \.
+
+```py
+>>> a = 6, 9
+>>> a
+(6, 9)
+
+>>> (a := 6, 9)
+>>> a
+6
+
+>>> a, b = 6, 9 # Typcial unpacking
+>>> a, b
+(6, 9)
+>>> (a, b = 16, 19) # Oops
+  File "<ipython-input-67-f4339673d0d4>", line 1
+    (a, b = 6, 9)
+          ^
+SyntaxError: invalid syntax
+
+>>> (a, b := 16, 19) # This prints out a weird 3-tuple
+(6, 16, 19)
+
+>>> a # a is still unchanged?
+6
+16
+```
+
+
+
+💡 Explanation
+
+**Quick walrus operator refresher**
+
+The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situatitions where you'd want to assing values to variables within an expression.
+
+```py
+def some_func():
+		# Assume some expensive computation here
+		# time.sleep(1000)
+		return 5
+
+# So instead of,
+if some_func():
+		print(some_func()) # Which is bad practice since computation is happening twice
+
+# or
+a = some_func()
+if a:
+	print(a)
+
+# Now you can concisely write
+if a := some_func():
+		print(a)
+```
+
+**Output (> 3.8):**
+
+```py
+5
+5
+5
+```
+
+This helped save one line of code, and implicitly prevented invoking `some_func` twice.
+
+- Unparenthesized "assignment expression" (use of walrus operator), is restricted at top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of first snippet. Parenthesizing it worked as expected and assigned `a`.  
+
+- As usual, parenthesizing of expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. 
+
+- The syntax of the Walrus operator is of the form `NAME: expr`, where `NAME` is a valid identifier and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means, 
+
+  - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6')
+
+    ```py
+    >>> (a := 6, 9) == ((a := 6), 9)
+    True
+    >>> x = (a := 696, 9)
+    >>> x
+    (696, 9)
+    >>> x[0] is a # Both reference same memory location
+    True
+    ```
+
+  - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple. 
+
+---
+
 ### ▶ Strings can be tricky sometimes
+
 <!-- Example ID: 30f1d3fc-e267-4b30-84ef-4d9e7091ac1a --->
 1\.
+
 ```py
 >>> a = "some_string"
 >>> id(a)
@@ -3066,7 +3178,7 @@ nan
 
 # Contributing
 
-All patches are welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details. 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).
+All patches are welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details. 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)
 
 # Acknowledgements
 
@@ -3092,7 +3204,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 ## Surprise your friends too?
 
-If you liked the project, you can use these quick links to recommend wtfpython to your friends,
+If you liked wtfpython, you can use these quick links to share it with your friends,
 
 [Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&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.)
 

From 133baac11c7c1f4edf591c22966219897de9308f Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Tue, 29 Oct 2019 21:45:41 +0530
Subject: [PATCH 084/146] Add minor snippet related to output buffer flushing

Closes https://github.com/satwikkansal/wtfpython/issues/140
---
 README.md | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 58bbdb7..1c927bf 100644
--- a/README.md
+++ b/README.md
@@ -3120,7 +3120,7 @@ nan
   + `++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.
 
-* Have you ever heard about _the space-invader operator_ 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
@@ -3151,6 +3151,18 @@ nan
 
 * 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.
 
+* Sometimes the `print` method might not print values immediately. For example,
+
+     ```py
+     # File some_file.py
+     import time
+     
+     print("wtfpython", end="_")
+     time.sleep(3)
+     ```
+
+     This will print the `wtfpython` after 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.
+
 * List slicing with out of the bounds indices throws no errors
   ```py
   >>> some_list = [1, 2, 3, 4, 5]

From b10b3ad346548bbe18b95fe5e4f33442c0329231 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Tue, 29 Oct 2019 22:31:37 +0530
Subject: [PATCH 085/146] Add another needle-like example

Closes https://github.com/satwikkansal/wtfpython/issues/137
---
 README.md | 39 +++++++++++++++++++++++++++++++--------
 1 file changed, 31 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 1c927bf..7d9b277 100644
--- a/README.md
+++ b/README.md
@@ -2469,6 +2469,33 @@ None
 None
 ```
 
+6\.
+
+```py
+def some_recursive_func(a):
+    if a[0] == 0:
+        return 
+    a[0] -= 1
+    some_func(a)
+    return a
+
+def similar_recursive_func(a):
+		if a == 0:
+				return a
+		a -= 1
+		another_func()
+		return a
+```
+
+**Output:**
+
+```py
+>>> some_recursive_func([5, 0])
+[0, 0]
+>>> similar_recursive_func(5)
+4
+```
+
 
 
 #### 💡 Explanation:
@@ -2505,7 +2532,9 @@ None
   AssertionError: Values aren not equal
   ```
 
-* As for the last snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
+
+* Last one should be fairly obvious, passing mutable object (like  `list` ) results in call by reference, whereas an immutable object (like `int`)  results in call by value.
 
 * Being aware of these knitpicks can save you hours of degugging effort in long run. 
 
@@ -2898,7 +2927,7 @@ AttributeError: 'Yo' object has no attribute '_Yo__honey__'
 
 Why did `Yo()._Yo__honey` work?
 
-2\.
+3\.
 
 ```py
 _A__variable = "Some value"
@@ -2918,12 +2947,6 @@ AttributeError: 'A' object has no attribute '__variable'
 'Some value'
 ```
 
-3\.
-
-```py
-
-```
-
 
 #### 💡 Explanation:
 

From 4af4f9debf9d95fdcb992e027c4ba2e964dd5869 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Tue, 29 Oct 2019 23:53:42 +0530
Subject: [PATCH 086/146] Add more examples

---
 README.md | 103 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 102 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7d9b277..d4075de 100644
--- a/README.md
+++ b/README.md
@@ -2598,6 +2598,92 @@ NameError: name 'some_weird_name_func_' is not defined
 
 ---
 
+## Section: Read the docs
+
+### ▶ All sorted?
+
+<!-- Example ID: e5ff1eaf-8823-4738-b4ce-b73f7c9d5511 -->
+
+```py
+>>> x = 7, 8, 9
+>>> sorted(x) == x
+False
+>>> sorted(x) == sorted(x)
+True
+
+>>> y = reversed(x)
+>>> sorted(y) == sorted(y)
+False
+```
+
+#### 💡 Explanation:
+
+- The `sorted` method always returns a list, and comparing list and tuples always returns `False` in Python. 
+
+- ```py
+  >>> [] == tuple()
+  False
+  >>> x = 7, 8, 9
+  >>> type(x), type(sorted(x))
+  (tuple, list)
+  ```
+
+- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use extra container (a list), whereas reversing can simple work by iterating from the last index to the first.
+
+- So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list.
+
+  ```py
+  >>> x = 7, 8, 9
+  >>> y = reversed(x)
+  >>> sorted(y), sorted(y)
+  ([7, 8, 9], [])
+  ```
+
+  
+
+---
+
+### ▶ All-true-ation
+
+<!-- Example ID: dfe6d845-e452-48fe-a2da-0ed3869a8042 -->
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+Why's this True-False alteration?
+
+#### 💡 Explanation:
+
+- The implementation of `all` function is equivalent to
+
+- ```py
+  def all(iterable):
+      for element in iterable:
+          if not element:
+              return False
+      return True
+  ```
+
+- `all([])` returns `True` since the iterable is empty. 
+- `all([[]])` returns `False` because `not []` is `True` is equivalent to `not False` as the list inside the iterable is empty.
+- `all([[[]]])` and higher recursive variants are always `True` since `not [[]]`, `not [[[]]]`, and so on are equivalent to `not True`.
+
+---
+
+---
+
+
 
 ## Section: The Hidden treasures!
 
@@ -3195,6 +3281,21 @@ nan
 
 * `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.
 
+* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator. 
+
+     ```py
+     >>> False ** False == True
+     True
+     >>> False ** True == False
+     True
+     >>> True ** False == True
+     True
+     >>> True ** True == True
+     True
+     ```
+
+     If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)).
+
 * `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
   ```py
   def count(s, sub):
@@ -3208,7 +3309,6 @@ nan
 ---
 
 <p align="center">~~~ That's all folks! ~~~</p>
-
 ---
 
 # Contributing
@@ -3226,6 +3326,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * 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
 
 # 🎓 License

From 312c5d542c875056de6ad595eca0ee47765a27fa Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Wed, 30 Oct 2019 01:03:07 +0530
Subject: [PATCH 087/146] Add non reflexive class method and the matmul
 operator examples

---
 README.md | 110 +++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 80 insertions(+), 30 deletions(-)

diff --git a/README.md b/README.md
index d4075de..3bc4b24 100644
--- a/README.md
+++ b/README.md
@@ -1321,6 +1321,48 @@ True
 
 ---
 
+### ▶ Non-reflexive class methods
+
+<!-- Example ID: 3649771a-f733-413c-8060-3f9f167b83fd -->
+
+```py
+class SomeClass:
+		def instance_method(self):
+				pass
+		
+		@classmethod
+		def class_method(cls):
+				pass
+```
+
+**Output:**
+
+```py
+>>> SomeClass.instance_method is SomeClass.instance_method
+True
+>>> SomeClass.class_method is SomeClass.class_method
+False
+>>> id(SomeClass.class_method) == id(SomeClass.class_method)
+True
+```
+
+#### 💡 Explanation:
+
+- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. 
+
+  ```py
+  >>> SomeClass.instance_method
+  <function __main__.SomeClass.instance_method(self)>
+  >>> SomeClass.class_method
+  <bound method SomeClass.class_method of <class '__main__.SomeClass'>
+  ```
+
+  A new bound method everytime `SomeClass.class_method` is accessed.
+
+-  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). 
+
+---
+
 ### ▶ yielding None
 <!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --->
 ```py
@@ -2843,7 +2885,7 @@ 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).
+* 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).
 
 ---
@@ -2888,7 +2930,7 @@ Try block executed successfully...
 ```
 
 #### 💡 Explanation:
-- The `else` clause after a loop is executed only when there's no explicit `break` after all the iterations.
+- 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 try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
 
 ---
@@ -3041,11 +3083,10 @@ AttributeError: 'A' object has no attribute '__variable'
 * So, to access `__honey` attribute in 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 outer scope.
+* Also, if the mangled name is longer than 255 characters truncation will happen.
 
 ---
 
-
-
 ---
 
 ## Section: Miscellaneous
@@ -3205,9 +3246,8 @@ nan
 <!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --->
 * `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.
-
+  **💡 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 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.
@@ -3242,22 +3282,47 @@ nan
   >>> 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.
+  **💡 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 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 scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
 
 * 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()
-
+    """.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/2/library/multiprocessing.html) module.
 
 * Sometimes the `print` method might not print values immediately. For example,
@@ -3281,21 +3346,6 @@ nan
 
 * `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.
 
-* Python has an undocumented [converse implication](https://en.wikipedia.org/wiki/Converse_implication) operator. 
-
-     ```py
-     >>> False ** False == True
-     True
-     >>> False ** True == False
-     True
-     >>> True ** False == True
-     True
-     >>> True ** True == True
-     True
-     ```
-
-     If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator)).
-
 * `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
   ```py
   def count(s, sub):

From 5bf46f66af9f308eda3a9fbc37c07172eaa41f68 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Wed, 30 Oct 2019 23:04:50 +0530
Subject: [PATCH 088/146] Bring compiler optimisation stuff back, and add minor
 updates.

---
 README.md | 81 ++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index 3bc4b24..992810f 100644
--- a/README.md
+++ b/README.md
@@ -297,6 +297,10 @@ True
 >>> b = "wtf!"
 >>> a is b
 False
+
+>>> a, b = "wtf!", "wtf!"
+>>> a is b
+True
 ```
 
 3\.
@@ -320,6 +324,7 @@ Makes sense, right?
   * 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)
   <img src="images/string-intern/string_intern.png" alt="">
++ 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. 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).
 + The abrupt change in output of the third 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 length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 + Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
 
@@ -771,7 +776,8 @@ True
 ```
 
 3\.
-**Output (< Python 3.7)**
+**Output**
+
 ```
 >>> a, b = 257, 257
 True
@@ -781,7 +787,8 @@ True
 True
 ```
 
-**Output (Python 3.7)**
+**Output (Python 3.7.x specifically)**
+
 ```
 >>> a, b = 257, 257
 False
@@ -836,7 +843,8 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 
 **Both `a` and `b` refer to the same object when initialized with same value in the same line.**
 
-**Output (< Python 3.7)**
+**Output**
+
 ```py
 >>> a, b = 257, 257
 >>> id(a)
@@ -852,7 +860,17 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 ```
 
 * 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.
+
+* 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 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.
 
 ---
@@ -1189,6 +1207,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 ### ▶ What's wrong with booleans?
 <!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --->
 1\.
+
 ```py
 # A simple example to count the number of booleans and
 # integers in an iterable of mixed data types.
@@ -1222,15 +1241,33 @@ for item in mixed_list:
 ''
 ```
 
+3\.
+
+```py
+True = False
+if True == False:
+    print("I've lost faith in truth!")
+```
+
+**Output (< 3.x):**
+
+```
+I've lost faith in truth!
+```
+
+
+
 #### 💡 Explanation:
 
 * `bool` is a subclass of `int` in Python
+    
     ```py
     >>> issubclass(bool, int)
     True
     >>> issubclass(int, bool)
     False
     ```
+    
 * And thus, `True` and `False` are instances of `int`
   ```py
   >>> isinstance(True, int)
@@ -1249,6 +1286,10 @@ for item in mixed_list:
 
 * See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.
 
+* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true).  `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them
+
+* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!
+
 ---
 
 ### ▶ Class attributes and instance attributes
@@ -1510,27 +1551,6 @@ NameError: name 'e' is not defined
 
 ---
 
-### ▶ When True is actually False
-<!-- Example ID: c8317047-48ae-4306-af5a-04c6d8b7c2b9 --->
-```py
-True = False
-if True == False:
-    print("I've lost faith in truth!")
-```
-
-**Output (< 3.x):**
-
-```
-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!
-
----
-
 ### ▶ Yielding from... return!
 
 1\.
@@ -3346,6 +3366,17 @@ f()
 
 * `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.
 
+* You can seperate numeric literals with underscores (for better readablity) from Python 3 onwards.
+
+     ```py
+     >>> six_million = 6_000_000
+     >>> six_million
+     6000000
+     >>> hex_address = 0xF00D_CAFE
+     >>> hex_address
+     4027435774
+     ```
+
 * `'abc'.count('') == 4`. Here's an approximate implementation of `count` method, which would make the things more clear
   ```py
   def count(s, sub):

From af6d1799d9800d7acd0c628ffe46685027737775 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Wed, 30 Oct 2019 23:24:07 +0530
Subject: [PATCH 089/146] Add more details to compile time optimisation
 snippets.

---
 README.md | 33 +++++++++++++++++++++++++--------
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 992810f..bfbd48d 100644
--- a/README.md
+++ b/README.md
@@ -298,13 +298,31 @@ True
 >>> a is b
 False
 
->>> a, b = "wtf!", "wtf!"
->>> a is b
-True
 ```
 
 3\.
 
+```py
+>>> a, b = "wtf!", "wtf!"
+>>> a is b # All versions except 3.7.x
+True
+
+>>> a = "wtf!"; b = "wtf!"
+>>> a is b
+False
+```
+
+```py
+# This time in file some_file.py
+a = "wtf!"
+b = "wtf!"
+print(a is b)
+
+# prints True when the module is invoked!
+```
+
+4\.
+
 **Output (< Python3.7 )**
 
 ```py
@@ -324,8 +342,9 @@ Makes sense, right?
   * 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)
   <img src="images/string-intern/string_intern.png" alt="">
-+ 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. 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).
-+ The abrupt change in output of the third 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 length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ 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 an 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).
++ The compile unit in interactive environment consists of 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 2 statements in 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 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 length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 + Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
 
 ---
@@ -861,7 +880,7 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 
 * 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 and floats as well.
+* 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
@@ -869,8 +888,6 @@ Similar optimization applies to other **immutable** objects like empty tuples as
   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.
 
 ---

From 7df49cd8184956023ca18db6d840f721bc1371d6 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 00:51:48 +0530
Subject: [PATCH 090/146] Change section name to Slippery Slopes and modify
 nan-reflexivity example

---
 README.md | 116 +++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 76 insertions(+), 40 deletions(-)

diff --git a/README.md b/README.md
index bfbd48d..c80f3ff 100644
--- a/README.md
+++ b/README.md
@@ -1452,7 +1452,82 @@ def some_func(val):
 
 ---
 
+### ▶ Nan-reflexivity 
+
+<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --->
+
+1\.
+
+```py
+a = float('inf')
+b = float('nan')
+c = float('-iNf')  # These strings are case-insensitive
+d = float('nan')
+```
+
+**Output:**
+
+```py
+>>> a
+inf
+>>> b
+nan
+>>> c
+-inf
+>>> float('some_other_string')
+ValueError: could not convert string to float: some_other_string
+>>> a == -c # inf==inf
+True
+>>> None == None # None == None
+True
+>>> b == d # but nan!=nan
+False
+>>> 50 / a
+0.0
+>>> a / a
+nan
+>>> 23 + b
+nan
+```
+
+2\.
+
+```py
+>>> x = float('nan')
+>>> y = x / x
+>>> y is y # identity holds
+True
+>>> y == y # equality fails of y
+False
+>>> [y] == [y] # but the equality succeeds for the list containing y
+True
+```
+
+
+
+#### 💡 Explanation:
+
+- `'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
+
+- Since according to standards ` NaN != NaN`, implementing this breaks the reflexivity assumption of a collection element in Python i.e if `x` is a part of 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) whlie comparing two elements, and the values are compared only when the identities mismatch. Following snippet will make things clearer
+
+  ```py
+  >>> x = float('nan')
+  >>> x == x, [x] == [x]
+  (False, True)
+  >>> y = float('nan')
+  >>> y == y, [y] == [y]
+  (False, True)
+  >>> x == y, [x] == [y]
+  (False, False)
+  ```
+
+  Since the identities of `x` and `y` are different, the values are considered, which are also different, hence the comparison returns `False` this time.
+
+---
+
 ### ▶ Mutating the immutable!
+
 <!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --->
 
 This might seem trivial if you know how references works in Python.
@@ -1934,7 +2009,7 @@ Shouldn't that be 100?
 
 ---
 
-## Section: Watch out for the landmines!
+## Section: Slippery Slopes
 
 
 ### ▶ Modifying a dictionary while iterating over it
@@ -2575,8 +2650,6 @@ def similar_recursive_func(a):
 4
 ```
 
-
-
 #### 💡 Explanation:
 
 * For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.
@@ -3238,44 +3311,7 @@ Let's increase the number of iterations by a factor of 10.
   
     > There should be one-- and preferably only one --obvious way to do it.
 
----
 
-### ▶ Explicit typecast of strings
-<!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --->
-```py
-a = float('inf')
-b = float('nan')
-c = float('-iNf')  #These strings are case-insensitive
-d = float('nan')
-```
-
-**Output:**
-```py
->>> a
-inf
->>> b
-nan
->>> c
--inf
->>> float('some_other_string')
-ValueError: could not convert string to float: some_other_string
->>> a == -c #inf==inf
-True
->>> None == None # None==None
-True
->>> b == d #but nan!=nan
-False
->>> 50/a
-0.0
->>> a/a
-nan
->>> 23 + b
-nan
-```
-
-#### 💡 Explanation:
-
-`'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
 
 ---
 

From a5593c42e0b6d37caed49667197c0060cd9169c2 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 00:59:57 +0530
Subject: [PATCH 091/146] Update comments

---
 irrelevant/json_generator.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index cfebf4f..11eab86 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -2,12 +2,19 @@
 An inefficient monolithic piece of code that'll generate jupyter notebook
 from the projects main README.
 
-TODO
+PS: If you are a recruiter, please don't judge me by this piece of code. I wrote it
+in hurry. I know this is messy and can be simplified, but I don't want to change it
+much because it just works. 
 
-- CLI arguments for running this thing.
+Simplifictions and improvements through patches are more than welcome however :)
+
+
+#TODOs
+
+- CLI arguments for running this thing
 - Add it to prepush hook
+- Add support for skip comments, to skip examples that are not meant for notebook environment.
 - Use templates?
-
 """
 
 import json

From 0160d5019b6c724af81ebd94a4a05fd67c94308e Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 01:01:45 +0530
Subject: [PATCH 092/146] Remove un-necessary file

---
 irrelevant/generated.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 irrelevant/generated.md

diff --git a/irrelevant/generated.md b/irrelevant/generated.md
deleted file mode 100644
index e69de29..0000000

From 1d467287ef3e9d379a80c28f6f91cc8da1f26737 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 01:05:23 +0530
Subject: [PATCH 093/146] Move stuff to obsolete package.

Not deleting it for quick future reference for contributors and myself.
---
 irrelevant/{ => obsolete}/add_categories            | 0
 irrelevant/{ => obsolete}/generate_contributions.py | 0
 irrelevant/{ => obsolete}/initial.md                | 0
 irrelevant/{ => obsolete}/parse_readme.py           | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename irrelevant/{ => obsolete}/add_categories (100%)
 rename irrelevant/{ => obsolete}/generate_contributions.py (100%)
 rename irrelevant/{ => obsolete}/initial.md (100%)
 rename irrelevant/{ => obsolete}/parse_readme.py (100%)

diff --git a/irrelevant/add_categories b/irrelevant/obsolete/add_categories
similarity index 100%
rename from irrelevant/add_categories
rename to irrelevant/obsolete/add_categories
diff --git a/irrelevant/generate_contributions.py b/irrelevant/obsolete/generate_contributions.py
similarity index 100%
rename from irrelevant/generate_contributions.py
rename to irrelevant/obsolete/generate_contributions.py
diff --git a/irrelevant/initial.md b/irrelevant/obsolete/initial.md
similarity index 100%
rename from irrelevant/initial.md
rename to irrelevant/obsolete/initial.md
diff --git a/irrelevant/parse_readme.py b/irrelevant/obsolete/parse_readme.py
similarity index 100%
rename from irrelevant/parse_readme.py
rename to irrelevant/obsolete/parse_readme.py

From d4021862f060c231847db801da219e5137cfb477 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 01:07:04 +0530
Subject: [PATCH 094/146] Add no longer working note.

---
 irrelevant/obsolete/generate_contributions.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/irrelevant/obsolete/generate_contributions.py b/irrelevant/obsolete/generate_contributions.py
index f396f32..1394e0e 100644
--- a/irrelevant/obsolete/generate_contributions.py
+++ b/irrelevant/obsolete/generate_contributions.py
@@ -1,6 +1,8 @@
 """
-Parses the README.md and generated the table
+This script parses the README.md and generates the table
 `CONTRIBUTORS.md`.
+
+No longer works since we've moved on contributors to CONTRIBUTORS.md entirely.
 """
 
 import pprint

From a553ea00706f2988723c3a92b2b0319a5c4bf0cb Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 23:50:23 +0530
Subject: [PATCH 095/146] Some meta tags and corrections after running on
 Python 3.8

---
 README.md | 74 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 45 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index c80f3ff..e2111cc 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ Python, being a beautifully designed high-level and interpreter-based programmin
 
 Here is 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!
+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 beliereve 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 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:
 
@@ -175,7 +175,7 @@ For some reasons, "Walrus" operator (`:=`) has become a very popular feature in
 >>> a
 'wtf_walrus'
 >>> a := "wtf_walrus"
-File "<ipython-input-20-14e95425e0a2>", line 1
+File "<stdin>", line 1
     a := "wtf_walrus"
       ^
 SyntaxError: invalid syntax
@@ -200,7 +200,7 @@ SyntaxError: invalid syntax
 >>> a, b
 (6, 9)
 >>> (a, b = 16, 19) # Oops
-  File "<ipython-input-67-f4339673d0d4>", line 1
+  File "<stdin>", line 1
     (a, b = 6, 9)
           ^
 SyntaxError: invalid syntax
@@ -210,6 +210,8 @@ SyntaxError: invalid syntax
 
 >>> a # a is still unchanged?
 6
+
+>>> b
 16
 ```
 
@@ -308,7 +310,7 @@ False
 True
 
 >>> a = "wtf!"; b = "wtf!"
->>> a is b
+>>> a is b # This will print True or False depending on where you're invoking it (python shell / ipython / as a script)
 False
 ```
 
@@ -343,7 +345,7 @@ Makes sense, right?
   * 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)
   <img src="images/string-intern/string_intern.png" alt="">
 + 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 an 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).
-+ The compile unit in interactive environment consists of 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 2 statements in 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 compile unit in interactive environment like ipython consists of 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 2 statements in 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 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 length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 + Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
 
@@ -401,7 +403,7 @@ some_dict[5] = "Python"
 
 ```py
 >>> some_dict[5.5]
-"Ruby"
+"JavaScript"
 >>> some_dict[5.0] # "Python" destroyed the existence of "Ruby"?
 "Python"
 >>> some_dict[5] 
@@ -726,10 +728,10 @@ array_2[:] = [1,2,3,4,5]
 **Output:**
 ```py
 >>> print(list(gen_1))
-[1,2,3,4]
+[1, 2, 3, 4]
 
 >>> print(list(gen_2))
-[1,2,3,4,5]
+[1, 2, 3, 4, 5]
 ```
 
 3\.
@@ -797,24 +799,18 @@ True
 3\.
 **Output**
 
-```
+```py
 >>> a, b = 257, 257
-True
-
->>> a = 257; b = 257
 >>> a is b
 True
 ```
 
 **Output (Python 3.7.x specifically)**
 
-```
+```py
 >>> a, b = 257, 257
+>> a is b
 False
-
->>> a = 257; b = 257
->>> a is b
-True
 ```
 
 #### 💡 Explanation:
@@ -1176,6 +1172,10 @@ wtfpython
 >>> # The following statements raise `SyntaxError`
 >>> # print('''wtfpython')
 >>> # print("""wtfpython")
+  File "<input>", line 3
+    print("""wtfpython")
+                        ^
+SyntaxError: EOF while scanning triple-quoted string literal
 ```
 
 #### 💡 Explanation:
@@ -1261,15 +1261,17 @@ for item in mixed_list:
 3\.
 
 ```py
-True = False
-if True == False:
-    print("I've lost faith in truth!")
+def tell_truth():
+    True = False
+    if True == False:
+        print("I have lost faith in truth!")
 ```
 
 **Output (< 3.x):**
 
-```
-I've lost faith in truth!
+```py
+>>> tell_truth()
+I have lost faith in truth!
 ```
 
 
@@ -1331,7 +1333,7 @@ class C(A):
 >>> A.x, B.x, C.x
 (1, 2, 1)
 >>> A.x = 3
->>> A.x, B.x, C.x
+>>> A.x, B.x, C.x # C.x changed, but B.x didn't
 (3, 2, 3)
 >>> a = A()
 >>> a.x, A.x
@@ -1379,7 +1381,7 @@ True
 
 ---
 
-### ▶ Non-reflexive class methods
+### ▶ Non-reflexive class method
 
 <!-- Example ID: 3649771a-f733-413c-8060-3f9f167b83fd -->
 
@@ -1430,7 +1432,7 @@ def some_func(val):
     return "something"
 ```
 
-**Output:**
+**Output (<= 3.7.x):**
 
 ```py
 >>> [x for x in some_iterable]
@@ -1449,6 +1451,7 @@ def some_func(val):
 - This is bug in CPython's handling of `yield` in generators and comprehensions.
 - Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
 - Related bug report: http://bugs.python.org/issue10544
+- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.
 
 ---
 
@@ -1509,7 +1512,7 @@ True
 
 - `'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
 
-- Since according to standards ` NaN != NaN`, implementing this breaks the reflexivity assumption of a collection element in Python i.e if `x` is a part of 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) whlie comparing two elements, and the values are compared only when the identities mismatch. Following snippet will make things clearer
+- 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 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) whlie comparing two elements, and the values are compared only when the identities mismatch. Following snippet will make things clearer
 
   ```py
   >>> x = float('nan')
@@ -1524,6 +1527,8 @@ True
 
   Since the identities of `x` and `y` are different, the values are considered, which are also different, hence the comparison returns `False` this time.
 
+- Interesting read: [Reflexivity, and other pilliars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+
 ---
 
 ### ▶ Mutating the immutable!
@@ -1565,6 +1570,8 @@ But I thought tuples were immutable...
 
 ### ▶ The disappearing variable from outer scope
 <!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --->
+<!-- version-specific: True -->
+
 ```py
 e = 7
 try:
@@ -1788,7 +1795,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 class SomeClass(str):
     pass
 
-some_dict = {'s':42}
+some_dict = {'s': 42}
 ```
 
 **Output:**
@@ -2014,6 +2021,7 @@ Shouldn't that be 100?
 
 ### ▶ Modifying a dictionary while iterating over it
 <!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --->
+<!-- version-specific: True -->
 ```py
 x = {0: None}
 
@@ -2044,11 +2052,14 @@ Yes, it runs for exactly **eight** times and stops.
 * It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
 * How deleted keys are handled and when the resize occurs might be different for different Python implementations.
 * So for Python versions other than Python 2.7 - Python 3.5 the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread.
+* Python 3.8 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.
 
 ---
 
 ### ▶ Stubborn `del` operation
 <!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --->
+<!-- read-only: True -->
+
 ```py
 class SomeClass:
     def __del__(self):
@@ -2152,6 +2163,7 @@ Can you guess why the output is `[2, 4]`?
 
 ### ▶ Loop variables leaking out!
 <!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --->
+<!-- version-specific: True -->
 1\.
 ```py
 for x in range(7):
@@ -2630,14 +2642,14 @@ def some_recursive_func(a):
     if a[0] == 0:
         return 
     a[0] -= 1
-    some_func(a)
+    some_recursive_func(a)
     return a
 
 def similar_recursive_func(a):
 		if a == 0:
 				return a
 		a -= 1
-		another_func()
+		similar_recursive_func(a)
 		return a
 ```
 
@@ -2694,6 +2706,8 @@ def similar_recursive_func(a):
 
 ### ▶ Wild imports
 <!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
+<!-- read-only: True -->
+
 ```py
 # File: module.py
 
@@ -2861,6 +2875,8 @@ Sshh.. It's a super secret.
 
 ### ▶ `goto`, but why?
 <!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --->
+<!-- version-specific: True -->
+
 ```py
 from goto import goto, label
 for i in range(9):

From 2160dad717fcd56cb159af795e28f04f03167a28 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 23:50:50 +0530
Subject: [PATCH 096/146] Use dynamic path instead of fixed one

---
 irrelevant/json_generator.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index 11eab86..c62499a 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -18,8 +18,10 @@ Simplifictions and improvements through patches are more than welcome however :)
 """
 
 import json
+import os
 import pprint
-fname = "/Users/300041709/code/self/wtfpython/README.md"
+
+fpath = os.path.join(os.path.dirname( __file__ ), '..', 'README.md')
 examples = []
 
 # The globals
@@ -250,7 +252,7 @@ def convert_to_notebook(parsed_json):
 
 
 
-with open(fname, 'r+', encoding="utf-8") as f:
+with open(fpath, 'r+', encoding="utf-8") as f:
     lines = iter(f.readlines())
     line = next(lines)
     result = []

From 08302ba0c89ffab3dcb1cb5890049bead3fceb9f Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 31 Oct 2019 23:51:47 +0530
Subject: [PATCH 097/146] Ignore environment and checkpoint files

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index a252b5a..36f9a1f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,7 @@ wtfpython-pypi/wtfpython.egg-info
 __pycache__/
 *.py[cod]
 *$py.class
+
+irrelevant/.ipynb_checkpoints/
+
+irrelevant/.python-version

From 321e7196d06e7df601ca7eab334a12d6dc5668d9 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 2 Nov 2019 23:02:47 +0530
Subject: [PATCH 098/146] Some change of example orders

---
 README.md | 1060 ++++++++++++++++++++++++++---------------------------
 1 file changed, 529 insertions(+), 531 deletions(-)

diff --git a/README.md b/README.md
index e2111cc..04a0d1b 100644
--- a/README.md
+++ b/README.md
@@ -19,74 +19,79 @@ So, here we go...
 
 # Table of Contents
 
-<!-- toc generated using "markdown-toc -i README.md --maxdepth 3"-->
+<!-- Generated using "markdown-toc -i README.md --maxdepth 3"-->
+<!-- toc -->
 
 - [Structure of the Examples](#structure-of-the-examples)
-    + [▶ Some fancy Title](#-some-fancy-title)
+    + [▶ Some fancy Title](#%E2%96%B6-some-fancy-title)
 - [Usage](#usage)
 - [👀 Examples](#%F0%9F%91%80-examples)
   * [Section: Strain your brain!](#section-strain-your-brain)
-    + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
-    + [▶ Splitsies](#-splitsies)
-    + [▶ Hash brownies](#-hash-brownies)
-    + [▶ Disorder within order](#-disorder-within-order)
-    + [▶ Keep trying...](#-keep-trying)
-    + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)
-    + [▶ For what?](#-for-what)
-    + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
-    + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
-    + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
-    + [▶ The sticky output function](#-the-sticky-output-function)
-    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)
-    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
-    + [▶ The surprising comma](#-the-surprising-comma)
-    + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
-    + [▶ not knot!](#-not-knot)
-    + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
-    + [▶ 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)
-    + [▶ Yielding from... return!](#-yielding-from-return)
-    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)
-    + [▶ 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)
+    + [▶ First things first!](#%E2%96%B6-first-things-first)
+    + [▶ Strings can be tricky sometimes](#%E2%96%B6-strings-can-be-tricky-sometimes)
+    + [▶ Splitsies](#%E2%96%B6-splitsies)
+    + [▶ Hash brownies](#%E2%96%B6-hash-brownies)
+    + [▶ Disorder within order](#%E2%96%B6-disorder-within-order)
+    + [▶ Keep trying...](#%E2%96%B6-keep-trying)
+    + [▶ Deep down, we're all the same.](#%E2%96%B6-deep-down-were-all-the-same)
+    + [▶ For what?](#%E2%96%B6-for-what)
+    + [▶ Evaluation time discrepancy](#%E2%96%B6-evaluation-time-discrepancy)
+    + [▶ How not to use `is` operator](#%E2%96%B6-how-not-to-use-is-operator)
+    + [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+    + [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
+    + [▶ The chicken-egg problem](#%E2%96%B6-the-chicken-egg-problem)
+    + [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
+    + [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
+    + [▶ Strings and the backslashes](#%E2%96%B6-strings-and-the-backslashes)
+    + [▶ not knot!](#%E2%96%B6-not-knot)
+    + [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
+    + [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
+    + [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
+    + [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
+    + [▶ Non-reflexive class method](#%E2%96%B6-non-reflexive-class-method)
+    + [▶ yielding None](#%E2%96%B6-yielding-none)
+    + [▶ Nan-reflexivity](#%E2%96%B6-nan-reflexivity)
+    + [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
+    + [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
+    + [▶ Yielding from... return!](#%E2%96%B6-yielding-from-return)
+    + [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
+    + [▶ Subclass relationships](#%E2%96%B6-subclass-relationships)
+    + [▶ The mysterious key type conversion](#%E2%96%B6-the-mysterious-key-type-conversion)
+    + [▶ Let's see if you can guess this?](#%E2%96%B6-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)
-    + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
-    + [▶ Stubborn `del` operation](#-stubborn-del-operation)
-    + [▶ 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)
-    + [▶ Needles in a Haystack](#-needles-in-a-haystack)
-    + [▶ Wild imports](#-wild-imports)
+    + [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
+    + [▶ Teleportation](#%E2%96%B6-teleportation)
+    + [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
+  * [Section: Slippery Slopes](#section-slippery-slopes)
+    + [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
+    + [▶ Stubborn `del` operation](#%E2%96%B6-stubborn-del-operation)
+    + [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
+    + [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
+    + [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
+    + [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
+    + [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
+    + [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
+    + [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
+    + [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
+    + [▶ Needles in a Haystack](#%E2%96%B6-needles-in-a-haystack)
+    + [▶ Wild imports](#%E2%96%B6-wild-imports)
+  * [Section: Read the docs](#section-read-the-docs)
+    + [▶ All sorted?](#%E2%96%B6-all-sorted)
+    + [▶ All-true-ation](#%E2%96%B6-all-true-ation)
   * [Section: The Hidden treasures!](#section-the-hidden-treasures)
-    + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
-    + [▶ `goto`, but why?](#-goto-but-why)
-    + [▶ Brace yourself!](#-brace-yourself)
-    + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
-    + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
-    + [▶ Yes, it exists!](#-yes-it-exists)
-    + [▶ Ellipsis](#-ellipsis)
-    + [▶ Inpinity](#-inpinity)
-    + [▶ Let's mangle](#-lets-mangle)
+    + [▶ Okay Python, Can you make me fly?](#%E2%96%B6-okay-python-can-you-make-me-fly)
+    + [▶ `goto`, but why?](#%E2%96%B6-goto-but-why)
+    + [▶ Brace yourself!](#%E2%96%B6-brace-yourself)
+    + [▶ Let's meet Friendly Language Uncle For Life](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life)
+    + [▶ Even Python understands that love is complicated](#%E2%96%B6-even-python-understands-that-love-is-complicated)
+    + [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
+    + [▶ Ellipsis](#%E2%96%B6-ellipsis)
+    + [▶ Inpinity](#%E2%96%B6-inpinity)
+    + [▶ Let's mangle](#%E2%96%B6-lets-mangle)
   * [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)
+    + [▶ `+=` is faster](#%E2%96%B6--is-faster)
+    + [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
+    + [▶ Minor Ones](#%E2%96%B6-minor-ones)
   * [~~~ That's all folks! ~~~](#-thats-all-folks-)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
@@ -351,44 +356,6 @@ Makes sense, right?
 
 ---
 
-### ▶ Splitsies
-<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
-```py
->>> 'a'.split()
-['a']
-
-# is same as
->>> 'a'.split(' ')
-['a']
-
-# but
->>> len(''.split())
-0
-
-# isn't the same as
->>> len(''.split(' '))
-1
-```
-
-#### 💡 Explanation:
-
-- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)
-    >  If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
-    > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
-- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
-    ```py
-    >>> ' a '.split(' ')
-    ['', 'a', '']
-    >>> ' a '.split()
-    ['a']
-    >>> ''.split(' ')
-    ['']
-    ```
-
----
-
-
-
 ### ▶ Hash brownies
 <!-- Example ID: eb17db53-49fd-4b61-85d6-345c5ca213ff --->
 1\.
@@ -435,6 +402,56 @@ So, why is Python all over the place?
 
 ---
 
+### ▶ Deep down, we're all the same.
+<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
+```py
+class WTF:
+  pass
+```
+
+**Output:**
+```py
+>>> WTF() == WTF() # two different instances can't be equal
+False
+>>> WTF() is WTF() # identities are also different
+False
+>>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
+True
+>>> id(WTF()) == id(WTF())
+True
+```
+
+#### 💡 Explanation:
+
+* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.
+* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.
+* So, object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
+* But why did the `is` operator evaluated to `False`? Let's see with this snippet.
+  ```py
+  class WTF(object):
+    def __init__(self): print("I")
+    def __del__(self): print("D")
+  ```
+
+  **Output:**
+  ```py
+  >>> WTF() is WTF()
+  I
+  I
+  D
+  D
+  False
+  >>> id(WTF()) == id(WTF())
+  I
+  D
+  I
+  D
+  True
+  ```
+  As you may observe, the order in which the objects are destroyed is what made all the difference here.
+
+---
+
 ### ▶ Disorder within order
 <!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
@@ -500,7 +517,7 @@ What is going on here?
 - 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 is behavior  is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.
+- The reason for this equality is 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 lenght 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()
@@ -593,55 +610,6 @@ Iteration 0
 
 ---
 
-### ▶ Deep down, we're all the same.
-<!-- Example ID: 8f99a35f-1736-43e2-920d-3b78ec35da9b --->
-```py
-class WTF:
-  pass
-```
-
-**Output:**
-```py
->>> WTF() == WTF() # two different instances can't be equal
-False
->>> WTF() is WTF() # identities are also different
-False
->>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well
-True
->>> id(WTF()) == id(WTF())
-True
-```
-
-#### 💡 Explanation:
-
-* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.
-* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.
-* So, object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
-* But why did the `is` operator evaluated to `False`? Let's see with this snippet.
-  ```py
-  class WTF(object):
-    def __init__(self): print("I")
-    def __del__(self): print("D")
-  ```
-
-  **Output:**
-  ```py
-  >>> WTF() is WTF()
-  I
-  I
-  D
-  D
-  False
-  >>> id(WTF()) == id(WTF())
-  I
-  D
-  I
-  D
-  True
-  ```
-  As you may observe, the order in which the objects are destroyed is what made all the difference here.
-
----
 
 ### ▶ For what?
 <!-- Example ID: 64a9dccf-5083-4bc9-98aa-8aeecde4f210 --->
@@ -888,6 +856,22 @@ Similar optimization applies to other **immutable** objects like empty tuples as
 
 ---
 
+### ▶ `is not ...` is not `is (not ...)`
+<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --->
+```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.
+
+---
+
 ### ▶ A tic-tac-toe where X wins in the first attempt!
 <!-- Example ID: 69329249-bdcb-424f-bd09-cca2e6705a7a --->
 
@@ -1043,19 +1027,65 @@ False
 
 ---
 
-### ▶ `is not ...` is not `is (not ...)`
-<!-- Example ID: b26fb1ed-0c7d-4b9c-8c6d-94a58a055c0d --->
+### ▶ Subclass relationships
+<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
+**Output:**
 ```py
->>> 'something' is not None
+>>> from collections import Hashable
+>>> issubclass(list, object)
 True
->>> 'something' is (not None)
+>>> issubclass(object, Hashable)
+True
+>>> issubclass(list, Hashable)
 False
 ```
 
-#### 💡 Explanation
+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`)
 
-- `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:
+
+* 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/).
+
+---
+
+### ▶ All-true-ation
+
+<!-- Example ID: dfe6d845-e452-48fe-a2da-0ed3869a8042 -->
+
+```py
+>>> all([True, True, True])
+True
+>>> all([True, True, False])
+False
+
+>>> all([])
+True
+>>> all([[]])
+False
+>>> all([[[]]])
+True
+```
+
+Why's this True-False alteration?
+
+#### 💡 Explanation:
+
+- The implementation of `all` function is equivalent to
+
+- ```py
+  def all(iterable):
+      for element in iterable:
+          if not element:
+              return False
+      return True
+  ```
+
+- `all([])` returns `True` since the iterable is empty. 
+- `all([[]])` returns `False` because `not []` is `True` is equivalent to `not False` as the list inside the iterable is empty.
+- `all([[[]]])` and higher recursive variants are always `True` since `not [[]]`, `not [[[]]]`, and so on are equivalent to `not True`.
 
 ---
 
@@ -1190,37 +1220,6 @@ SyntaxError: EOF while scanning triple-quoted string literal
 
 ---
 
-### ▶ Midnight time doesn't exist?
-<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --->
-```py
-from datetime import datetime
-
-midnight = datetime(2018, 1, 1, 0, 0)
-midnight_time = midnight.time()
-
-noon = datetime(2018, 1, 1, 12, 0)
-noon_time = noon.time()
-
-if midnight_time:
-    print("Time at midnight is", midnight_time)
-
-if noon_time:
-    print("Time at noon is", noon_time)
-```
-
-**Output (< 3.5):**
-
-```sh
-('Time at noon is', datetime.time(12, 0))
-```
-The midnight time is not printed.
-
-#### 💡 Explanation:
-
-Before Python 3.5, the boolean value for `datetime.time` object was considered to be `False` if it represented midnight in UTC. It is error-prone when using the `if obj:` syntax to check if the `obj` is null or some equivalent of "empty."
-
----
-
 ### ▶ What's wrong with booleans?
 <!-- Example ID: 0bba5fa7-9e6d-4cd2-8b94-952d061af5dd --->
 1\.
@@ -1423,6 +1422,7 @@ True
 
 ---
 
+
 ### ▶ yielding None
 <!-- Example ID: 5a40c241-2c30-40d0-8ba9-cf7e097b3b53 --->
 ```py
@@ -1455,6 +1455,72 @@ def some_func(val):
 
 ---
 
+
+### ▶ Yielding from... return!
+
+1\.
+
+```py
+def some_func(x):
+    if x == 3:
+        return ["wtf"]
+    else:
+        yield from range(x)
+```
+
+**Output (> 3.3):**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
+
+2\.
+
+```py
+def some_func(x):
+    if x == 3:
+        return ["wtf"]
+    else:
+        for i in range(x):
+          yield i
+```
+
+**Output:**
+
+```py
+>>> list(some_func(3))
+[]
+```
+
+Same result, that didn't work either.
+
+#### 💡 Explanation:
+
++ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that,
+
+> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
+
++ In case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically catched inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
+
++ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
+
+  ```py
+  try:
+      next(some_func(3))
+  except StopIteration as e:
+      some_string = e.value
+  ```
+
+  ```py
+  >>> some_string
+  ["wtf"]
+  ```
+
+---
+
 ### ▶ Nan-reflexivity 
 
 <!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --->
@@ -1650,144 +1716,6 @@ NameError: name 'e' is not defined
 
 ---
 
-### ▶ Yielding from... return!
-
-1\.
-
-```py
-def some_func(x):
-    if x == 3:
-        return ["wtf"]
-    else:
-        yield from range(x)
-```
-
-**Output:**
-
-```py
->>> list(some_func(3))
-[]
-```
-
-Where did the `"wtf"` go? Is it due to some special effect of `yield from`? Let's validate that,
-
-2\.
-
-```py
-def some_func(x):
-    if x == 3:
-        return ["wtf"]
-    else:
-        for i in range(x):
-          yield i
-```
-
-**Output (> 3.3):**
-
-```py
->>> list(some_func(3))
-[]
-```
-
-Same result, that didn't work either.
-
-#### 💡 Explanation:
-
-+ From Python 3.3 onwards, it became possible to use `return` statement with values inside generators (See [PEP380](https://www.python.org/dev/peps/pep-0380/)). The [official docs](https://www.python.org/dev/peps/pep-0380/#enhancements-to-stopiteration) say that,
-
-> "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
-
-+ In case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically catched inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
-
-+ To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
-
-  ```py
-  try:
-      next(some_func(3))
-  except StopIteration as e:
-      some_string = e.value
-  ```
-
-  ```py
-  >>> some_string
-  ["wtf"]
-  ```
-
----
-
-### ▶ Lossy zip of iterators
-
-<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --->
-
-```py
->>> numbers = list(range(7))
->>> numbers
-[0, 1, 2, 3, 4, 5, 6]
->>> first_three, remaining = numbers[:3], numbers[3:]
->>> first_three, remaining
-([0, 1, 2], [3, 4, 5, 6])
->>> numbers_iter = iter(numbers)
->>> list(zip(numbers_iter, first_three)) 
-[(0, 0), (1, 1), (2, 2)]
-# so far so good, let's zip the remaining
->>> list(zip(numbers_iter, remaining))
-[(4, 3), (5, 4), (6, 5)]
-```
-Where did element `3` go from the `numbers` list?
-
-#### 💡 Explanation:
-
-- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,
-    ```py
-    def zip(*iterables):
-        sentinel = object()
-        iterators = [iter(it) for it in iterables]
-        while iterators:
-            result = []
-            for it in iterators:
-                elem = next(it, sentinel)
-                if elem is sentinel: return
-                result.append(elem)
-            yield tuple(result)
-    ```
-- So the function takes in arbitrary number of itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. 
-- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.
-- The correct way to do the above using `zip` would be,
-    ```py
-    >>> numbers = list(range(7))
-    >>> numbers_iter = iter(numbers)
-    >>> list(zip(first_three, numbers_iter))
-    [(0, 0), (1, 1), (2, 2)]
-    >>> list(zip(remaining, numbers_iter))
-    [(3, 3), (4, 4), (5, 5), (6, 6)]
-    ```
-    The first argument of zip should be the one with fewest elements.
-
----
-
-### ▶ Subclass relationships
-<!-- Example ID: 9f6d8cf0-e1b5-42d0-84a0-4cfab25a0bc0 --->
-**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
 <!-- Example ID: 00f42dd0-b9ef-408d-9e39-1bc209ce3f36 --->
@@ -1901,124 +1829,10 @@ a, b = a[b] = {}, 5
   ```
 
 ---
-
----
-
-## Section: Appearances are deceptive!
-
-### ▶ Skipping lines?
-<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --->
-**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
-
-<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
-
-```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...
-<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --->
-```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: Slippery Slopes
 
-
 ### ▶ Modifying a dictionary while iterating over it
 <!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --->
 <!-- version-specific: True -->
@@ -2101,6 +1915,45 @@ Okay, now it's deleted :confused:
 
 ---
 
+### ▶ The out of scope variable
+<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --->
+```py
+a = 1
+def some_func():
+    return a
+
+def another_func():
+    a += 1
+    return a
+```
+
+**Output:**
+```py
+>>> some_func()
+1
+>>> another_func()
+UnboundLocalError: local variable 'a' referenced before assignment
+```
+
+#### 💡 Explanation:
+* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`,  but it has not been initialized previously in the same scope which throws an error.
+* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.
+* To modify the outer scope variable `a` in `another_func`, use `global` keyword.
+  ```py
+  def another_func()
+      global a
+      a += 1
+      return a
+  ```
+
+  **Output:**
+  ```py
+  >>> another_func()
+  2
+  ```
+
+---
+
 ### ▶ Deleting a list item while iterating
 <!-- Example ID: 4cc52d4e-d42b-4e09-b25f-fbf5699b7d4e --->
 ```py
@@ -2161,6 +2014,57 @@ Can you guess why the output is `[2, 4]`?
 
 ---
 
+
+### ▶ Lossy zip of iterators
+
+<!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --->
+
+```py
+>>> numbers = list(range(7))
+>>> numbers
+[0, 1, 2, 3, 4, 5, 6]
+>>> first_three, remaining = numbers[:3], numbers[3:]
+>>> first_three, remaining
+([0, 1, 2], [3, 4, 5, 6])
+>>> numbers_iter = iter(numbers)
+>>> list(zip(numbers_iter, first_three)) 
+[(0, 0), (1, 1), (2, 2)]
+# so far so good, let's zip the remaining
+>>> list(zip(numbers_iter, remaining))
+[(4, 3), (5, 4), (6, 5)]
+```
+Where did element `3` go from the `numbers` list?
+
+#### 💡 Explanation:
+
+- From Python [docs](https://docs.python.org/3.3/library/functions.html#zip), here's an approximate implementation of zip function,
+    ```py
+    def zip(*iterables):
+        sentinel = object()
+        iterators = [iter(it) for it in iterables]
+        while iterators:
+            result = []
+            for it in iterators:
+                elem = next(it, sentinel)
+                if elem is sentinel: return
+                result.append(elem)
+            yield tuple(result)
+    ```
+- So the function takes in arbitrary number of itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. 
+- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.
+- The correct way to do the above using `zip` would be,
+    ```py
+    >>> numbers = list(range(7))
+    >>> numbers_iter = iter(numbers)
+    >>> list(zip(first_three, numbers_iter))
+    [(0, 0), (1, 1), (2, 2)]
+    >>> list(zip(remaining, numbers_iter))
+    [(3, 3), (4, 4), (5, 5), (6, 6)]
+    ```
+    The first argument of zip should be the one with fewest elements.
+
+---
+
 ### ▶ Loop variables leaking out!
 <!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --->
 <!-- version-specific: True -->
@@ -2199,7 +2103,7 @@ print(x, ': x in global')
 3\.
 
 **Output (Python 2.x):**
-```
+```py
 >>> x = 1
 >>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
@@ -2208,7 +2112,7 @@ print(x, ': x in global')
 ```
 
 **Output (Python 3.x):**
-```
+```py
 >>> x = 1
 >>> print([x for x in range(5)])
 [0, 1, 2, 3, 4]
@@ -2401,44 +2305,6 @@ a += [5, 6, 7, 8]
 
 ---
 
-### ▶ The out of scope variable
-<!-- Example ID: 75c03015-7be9-4289-9e22-4f5fdda056f7 --->
-```py
-a = 1
-def some_func():
-    return a
-
-def another_func():
-    a += 1
-    return a
-```
-
-**Output:**
-```py
->>> some_func()
-1
->>> another_func()
-UnboundLocalError: local variable 'a' referenced before assignment
-```
-
-#### 💡 Explanation:
-* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`,  but it has not been initialized previously in the same scope which throws an error.
-* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.
-* To modify the outer scope variable `a` in `another_func`, use `global` keyword.
-  ```py
-  def another_func()
-      global a
-      a += 1
-      return a
-  ```
-
-  **Output:**
-  ```py
-  >>> another_func()
-  2
-  ```
-
----
 
 ### ▶ Be careful with chained operations
 <!-- Example ID: 07974979-9c86-4720-80bd-467aa19470d9 --->
@@ -2622,7 +2488,7 @@ some_dict = {
   "key_3": 3
 }
 
-some_list = some_list.append(4)
+some_list = some_list.append(4) 
 some_dict = some_dict.update({"key_4": 4})
 ```
 
@@ -2704,6 +2570,43 @@ def similar_recursive_func(a):
 
 ---
 
+
+### ▶ Splitsies
+<!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
+```py
+>>> 'a'.split()
+['a']
+
+# is same as
+>>> 'a'.split(' ')
+['a']
+
+# but
+>>> len(''.split())
+0
+
+# isn't the same as
+>>> len(''.split(' '))
+1
+```
+
+#### 💡 Explanation:
+
+- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)
+    >  If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.
+    > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.
+- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,
+    ```py
+    >>> ' a '.split(' ')
+    ['', 'a', '']
+    >>> ' a '.split()
+    ['a']
+    >>> ''.split(' ')
+    ['']
+    ```
+
+---
+
 ### ▶ Wild imports
 <!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
 <!-- read-only: True -->
@@ -2741,31 +2644,28 @@ NameError: name '_another_weird_name_func' is not defined
     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']
+    ```py
+    __all__ = ['_another_weird_name_func']
 
-def some_weird_name_func_():
-    print("works!")
+    def some_weird_name_func_():
+        print("works!")
 
-def _another_weird_name_func():
-    print("works!")
-```
-**Output**
+    def _another_weird_name_func():
+        print("works!")
+    ```
+    **Output**
 
-```py
->>> _another_weird_name_func()
-"works!"
->>> some_weird_name_func_()
-Traceback (most recent call last):
-  File "<stdin>", line 1, in <module>
-NameError: name 'some_weird_name_func_' is not defined
-```
----
+    ```py
+    >>> _another_weird_name_func()
+    "works!"
+    >>> some_weird_name_func_()
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    NameError: name 'some_weird_name_func_' is not defined
+    ```
 
 ---
 
-## Section: Read the docs
-
 ### ▶ All sorted?
 
 <!-- Example ID: e5ff1eaf-8823-4738-b4ce-b73f7c9d5511 -->
@@ -2805,48 +2705,38 @@ False
   ([7, 8, 9], [])
   ```
 
-  
-
 ---
 
-### ▶ All-true-ation
-
-<!-- Example ID: dfe6d845-e452-48fe-a2da-0ed3869a8042 -->
-
+### ▶ Midnight time doesn't exist?
+<!-- Example ID: 1bce8294-5619-4d70-8ce3-fe0bade690d1 --->
 ```py
->>> all([True, True, True])
-True
->>> all([True, True, False])
-False
+from datetime import datetime
 
->>> all([])
-True
->>> all([[]])
-False
->>> all([[[]]])
-True
+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)
 ```
 
-Why's this True-False alteration?
+**Output (< 3.5):**
+
+```sh
+('Time at noon is', datetime.time(12, 0))
+```
+The midnight time is not printed.
 
 #### 💡 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 `not []` is `True` is equivalent to `not False` as the list inside the iterable is empty.
-- `all([[[]]])` and higher recursive variants are always `True` since `not [[]]`, `not [[[]]]`, and so on are equivalent to `not True`.
+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."
 
 ---
-
 ---
 
 
@@ -3211,8 +3101,118 @@ AttributeError: 'A' object has no attribute '__variable'
 * 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 outer scope.
 * Also, if the mangled name is longer than 255 characters truncation will happen.
 
+---
 ---
 
+## Section: Appearances are deceptive!
+
+### ▶ Skipping lines?
+<!-- Example ID: d50bbde1-fb9d-4735-9633-3444b9d2f417 --->
+**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
+
+<!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
+
+```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...
+<!-- Example ID: cb6a37c5-74f7-44ca-b58c-3b902419b362 --->
+```py
+def square(x):
+    """
+    A simple function to calculate the square of a number by addition.
+    """
+    sum_so_far = 0
+    for counter in range(x):
+        sum_so_far = sum_so_far + x
+  return sum_so_far
+```
+
+**Output (Python 2.x):**
+
+```py
+>>> square(10)
+10
+```
+
+Shouldn't that be 100?
+
+**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.
+
+#### 💡 Explanation
+
+* **Don't mix tabs and spaces!** The character just preceding return is a "tab",  and the code is indented by multiple of "4 spaces" elsewhere in the example.
+* This is how Python handles tabs:
+  
+  > First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
+* So the "tab" at the last line of `square` function is replaced with eight spaces, and it gets into the loop.
+* Python 3 is kind enough to throw an error for such cases automatically.
+
+    **Output (Python 3.x):**
+    ```py
+    TabError: inconsistent use of tabs and spaces in indentation
+    ```
+
+---
 ---
 
 ## Section: Miscellaneous
@@ -3327,8 +3327,6 @@ Let's increase the number of iterations by a factor of 10.
   
     > There should be one-- and preferably only one --obvious way to do it.
 
-
-
 ---
 
 ### ▶ Minor Ones

From 2161c48e8e56dd545c97848bb202e1274097879b Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 2 Nov 2019 23:25:58 +0530
Subject: [PATCH 099/146] Parse nested examples

---
 irrelevant/json_generator.py | 34 +++++++++++++++++++++++-----------
 1 file changed, 23 insertions(+), 11 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index c62499a..6d4a32e 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -21,7 +21,7 @@ import json
 import os
 import pprint
 
-fpath = os.path.join(os.path.dirname( __file__ ), '..', 'README.md')
+fpath = os.path.join(os.path.dirname( __file__ ), '..', 'test_nb.md')
 examples = []
 
 # The globals
@@ -55,12 +55,14 @@ def generate_markdown_block(lines):
     sequence_num += 1
     return result
 
+
 def is_interactive_statement(line):
     for prefix in STATEMENT_PREFIXES:
-        if line.startswith(prefix):
+        if line.lstrip().startswith(prefix):
             return True
     return False
 
+
 def parse_example_parts(lines, example_title_line):
     parts = {
         "build_up": [],
@@ -117,20 +119,20 @@ def parse_example_parts(lines, example_title_line):
     # store lines again until --- or another H3 is encountered
     while not (next_line.startswith("---") or
                next_line.startswith("### ")):
-        if next_line.startswith("```"):
+        if next_line.lstrip().startswith("```"):
             # It's a snippet, whatever found until now is text
             is_interactive = False
             if content:
-                parts["build_up"].append(generate_markdown_block(content))
+                parts["explanation"].append(generate_markdown_block(content))
                 content = []
 
             next_line = next(lines)
 
-            while not next_line.startswith("```"):
+            while not next_line.lstrip().startswith("```"):
                 if is_interactive_statement(next_line):
                     is_interactive = True
                     if (output_so_far):
-                        parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+                        parts["explanation"].append(generate_code_block(statements_so_far, output_so_far))
                         statements_so_far, output_so_far = [], []
                     statements_so_far.append(next_line)
                 else:
@@ -142,7 +144,7 @@ def parse_example_parts(lines, example_title_line):
                 next_line = next(lines)
 
             # Snippet is over
-            parts["build_up"].append(generate_code_block(statements_so_far, output_so_far))
+            parts["explanation"].append(generate_code_block(statements_so_far, output_so_far))
             statements_so_far, output_so_far = [], []
             next_line = next(lines)
         else:
@@ -156,9 +158,10 @@ def parse_example_parts(lines, example_title_line):
 
     return next_line, parts
 
+
 def remove_from_beginning(tokens, line):
     for token in tokens:
-        if line.startswith(token):
+        if line.lstrip().startswith(token):
             line = line.replace(token, "")
     return line
 
@@ -174,6 +177,7 @@ def inspect_and_sanitize_code_lines(lines):
         result.append(line)
     return is_print_present, result
 
+
 def convert_to_cells(cell_contents):
     cells = []
     for stuff in cell_contents:
@@ -240,10 +244,10 @@ def convert_to_notebook(parsed_json):
         explanation = parts.get("explanation")
         notebook_path = "test.ipynb"
 
-        if(build_up):
+        if build_up:
             result["cells"] += convert_to_cells(build_up)
 
-        if(explanation):
+        if explanation:
             result["cells"] += convert_to_cells(explanation)
 
     pprint.pprint(result, indent=2)
@@ -251,14 +255,17 @@ def convert_to_notebook(parsed_json):
         json.dump(result, f)
 
 
-
 with open(fpath, 'r+', encoding="utf-8") as f:
     lines = iter(f.readlines())
     line = next(lines)
     result = []
+    pre_examples_phase = True
+    pre_stuff = []
+    post_stuff = []
     try:
         while True:
             if line.startswith("## "):
+                pre_examples_phase = False
                 # A section is encountered
                 current_section_name = line.replace("## ", "").strip()
                 section_text = []
@@ -281,8 +288,13 @@ with open(fpath, 'r+', encoding="utf-8") as f:
                         section_text.append(line)
                         line = next(lines)
             else:
+                if pre_examples_phase:
+                    pre_stuff.append(line)
+                else:
+                    post_stuff.append(line)
                 line = next(lines)
 
     except StopIteration:
         pprint.pprint(result, indent=2)
+        print("POST", post_stuff)
         convert_to_notebook(result)

From 2cd7e3fccd81543a056151ac04eef9c080dcca52 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sun, 3 Nov 2019 00:54:04 +0530
Subject: [PATCH 100/146] Fix broken links

---
 README.md | 125 +++++++++++++++++++++++++++---------------------------
 1 file changed, 62 insertions(+), 63 deletions(-)

diff --git a/README.md b/README.md
index 04a0d1b..05f336f 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,6 @@
 <p align="center"><img src="images/logo.png" alt=""></p>
 <h1 align="center">What the f*ck Python! 🐍</h1>
 <p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
-[![WTFPL 2.0][license-image]][license-url]
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
 
@@ -23,75 +22,75 @@ So, here we go...
 <!-- toc -->
 
 - [Structure of the Examples](#structure-of-the-examples)
-    + [▶ Some fancy Title](#%E2%96%B6-some-fancy-title)
+    + [▶ Some fancy Title](#-some-fancy-title)
 - [Usage](#usage)
 - [👀 Examples](#%F0%9F%91%80-examples)
   * [Section: Strain your brain!](#section-strain-your-brain)
-    + [▶ First things first!](#%E2%96%B6-first-things-first)
-    + [▶ Strings can be tricky sometimes](#%E2%96%B6-strings-can-be-tricky-sometimes)
-    + [▶ Splitsies](#%E2%96%B6-splitsies)
-    + [▶ Hash brownies](#%E2%96%B6-hash-brownies)
-    + [▶ Disorder within order](#%E2%96%B6-disorder-within-order)
-    + [▶ Keep trying...](#%E2%96%B6-keep-trying)
-    + [▶ Deep down, we're all the same.](#%E2%96%B6-deep-down-were-all-the-same)
-    + [▶ For what?](#%E2%96%B6-for-what)
-    + [▶ Evaluation time discrepancy](#%E2%96%B6-evaluation-time-discrepancy)
-    + [▶ How not to use `is` operator](#%E2%96%B6-how-not-to-use-is-operator)
-    + [▶ A tic-tac-toe where X wins in the first attempt!](#%E2%96%B6-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
-    + [▶ The sticky output function](#%E2%96%B6-the-sticky-output-function)
-    + [▶ The chicken-egg problem](#%E2%96%B6-the-chicken-egg-problem)
-    + [▶ `is not ...` is not `is (not ...)`](#%E2%96%B6-is-not--is-not-is-not-)
-    + [▶ The surprising comma](#%E2%96%B6-the-surprising-comma)
-    + [▶ Strings and the backslashes](#%E2%96%B6-strings-and-the-backslashes)
-    + [▶ not knot!](#%E2%96%B6-not-knot)
-    + [▶ Half triple-quoted strings](#%E2%96%B6-half-triple-quoted-strings)
-    + [▶ Midnight time doesn't exist?](#%E2%96%B6-midnight-time-doesnt-exist)
-    + [▶ What's wrong with booleans?](#%E2%96%B6-whats-wrong-with-booleans)
-    + [▶ Class attributes and instance attributes](#%E2%96%B6-class-attributes-and-instance-attributes)
-    + [▶ Non-reflexive class method](#%E2%96%B6-non-reflexive-class-method)
-    + [▶ yielding None](#%E2%96%B6-yielding-none)
-    + [▶ Nan-reflexivity](#%E2%96%B6-nan-reflexivity)
-    + [▶ Mutating the immutable!](#%E2%96%B6-mutating-the-immutable)
-    + [▶ The disappearing variable from outer scope](#%E2%96%B6-the-disappearing-variable-from-outer-scope)
-    + [▶ Yielding from... return!](#%E2%96%B6-yielding-from-return)
-    + [▶ Lossy zip of iterators](#%E2%96%B6-lossy-zip-of-iterators)
-    + [▶ Subclass relationships](#%E2%96%B6-subclass-relationships)
-    + [▶ The mysterious key type conversion](#%E2%96%B6-the-mysterious-key-type-conversion)
-    + [▶ Let's see if you can guess this?](#%E2%96%B6-lets-see-if-you-can-guess-this)
+    + [▶ First things first!](#-first-things-first)
+    + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
+    + [▶ Splitsies](#-splitsies)
+    + [▶ Hash brownies](#-hash-brownies)
+    + [▶ Disorder within order](#-disorder-within-order)
+    + [▶ Keep trying...](#-keep-trying)
+    + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)
+    + [▶ For what?](#-for-what)
+    + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)
+    + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
+    + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
+    + [▶ The sticky output function](#-the-sticky-output-function)
+    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)
+    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+    + [▶ The surprising comma](#-the-surprising-comma)
+    + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
+    + [▶ not knot!](#-not-knot)
+    + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
+    + [▶ 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)
+    + [▶ Non-reflexive class method](#-non-reflexive-class-method)
+    + [▶ yielding None](#-yielding-none)
+    + [▶ Nan-reflexivity](#-nan-reflexivity)
+    + [▶ Mutating the immutable!](#-mutating-the-immutable)
+    + [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)
+    + [▶ Yielding from... return!](#-yielding-from-return)
+    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)
+    + [▶ 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: Appearances are deceptive!](#section-appearances-are-deceptive)
-    + [▶ Skipping lines?](#%E2%96%B6-skipping-lines)
-    + [▶ Teleportation](#%E2%96%B6-teleportation)
-    + [▶ Well, something is fishy...](#%E2%96%B6-well-something-is-fishy)
+    + [▶ Skipping lines?](#-skipping-lines)
+    + [▶ Teleportation](#-teleportation)
+    + [▶ Well, something is fishy...](#-well-something-is-fishy)
   * [Section: Slippery Slopes](#section-slippery-slopes)
-    + [▶ Modifying a dictionary while iterating over it](#%E2%96%B6-modifying-a-dictionary-while-iterating-over-it)
-    + [▶ Stubborn `del` operation](#%E2%96%B6-stubborn-del-operation)
-    + [▶ Deleting a list item while iterating](#%E2%96%B6-deleting-a-list-item-while-iterating)
-    + [▶ Loop variables leaking out!](#%E2%96%B6-loop-variables-leaking-out)
-    + [▶ Beware of default mutable arguments!](#%E2%96%B6-beware-of-default-mutable-arguments)
-    + [▶ Catching the Exceptions](#%E2%96%B6-catching-the-exceptions)
-    + [▶ Same operands, different story!](#%E2%96%B6-same-operands-different-story)
-    + [▶ The out of scope variable](#%E2%96%B6-the-out-of-scope-variable)
-    + [▶ Be careful with chained operations](#%E2%96%B6-be-careful-with-chained-operations)
-    + [▶ Name resolution ignoring class scope](#%E2%96%B6-name-resolution-ignoring-class-scope)
-    + [▶ Needles in a Haystack](#%E2%96%B6-needles-in-a-haystack)
-    + [▶ Wild imports](#%E2%96%B6-wild-imports)
+    + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
+    + [▶ Stubborn `del` operation](#-stubborn-del-operation)
+    + [▶ 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)
+    + [▶ Needles in a Haystack](#-needles-in-a-haystack)
+    + [▶ Wild imports](#-wild-imports)
   * [Section: Read the docs](#section-read-the-docs)
-    + [▶ All sorted?](#%E2%96%B6-all-sorted)
-    + [▶ All-true-ation](#%E2%96%B6-all-true-ation)
+    + [▶ All sorted?](#-all-sorted)
+    + [▶ All-true-ation](#-all-true-ation)
   * [Section: The Hidden treasures!](#section-the-hidden-treasures)
-    + [▶ Okay Python, Can you make me fly?](#%E2%96%B6-okay-python-can-you-make-me-fly)
-    + [▶ `goto`, but why?](#%E2%96%B6-goto-but-why)
-    + [▶ Brace yourself!](#%E2%96%B6-brace-yourself)
-    + [▶ Let's meet Friendly Language Uncle For Life](#%E2%96%B6-lets-meet-friendly-language-uncle-for-life)
-    + [▶ Even Python understands that love is complicated](#%E2%96%B6-even-python-understands-that-love-is-complicated)
-    + [▶ Yes, it exists!](#%E2%96%B6-yes-it-exists)
-    + [▶ Ellipsis](#%E2%96%B6-ellipsis)
-    + [▶ Inpinity](#%E2%96%B6-inpinity)
-    + [▶ Let's mangle](#%E2%96%B6-lets-mangle)
+    + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)
+    + [▶ `goto`, but why?](#-goto-but-why)
+    + [▶ Brace yourself!](#-brace-yourself)
+    + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
+    + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
+    + [▶ Yes, it exists!](#-yes-it-exists)
+    + [▶ Ellipsis](#-ellipsis)
+    + [▶ Inpinity](#-inpinity)
+    + [▶ Let's mangle](#-lets-mangle)
   * [Section: Miscellaneous](#section-miscellaneous)
-    + [▶ `+=` is faster](#%E2%96%B6--is-faster)
-    + [▶ Let's make a giant string!](#%E2%96%B6-lets-make-a-giant-string)
-    + [▶ Minor Ones](#%E2%96%B6-minor-ones)
+    + [▶ `+=` is faster](#--is-faster)
+    + [▶ Let's make a giant string!](#-lets-make-a-giant-string)
+    + [▶ Minor Ones](#-minor-ones)
   * [~~~ That's all folks! ~~~](#-thats-all-folks-)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
@@ -3479,7 +3478,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 # 🎓 License
 
-[![CC 4.0][license-image]][license-url]
+[![WTFPL 2.0][license-image]][license-url]
 
 &copy; [Satwik Kansal](https://satwikkansal.xyz)
 

From e18e56eba341d51d0f5dc4d517dfb4eebc05997b Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sun, 3 Nov 2019 00:54:27 +0530
Subject: [PATCH 101/146] Working experimental notebook generator

---
 irrelevant/json_generator.py | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index 6d4a32e..73be981 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -21,7 +21,7 @@ import json
 import os
 import pprint
 
-fpath = os.path.join(os.path.dirname( __file__ ), '..', 'test_nb.md')
+fpath = os.path.join(os.path.dirname( __file__ ), '..', 'README.md')
 examples = []
 
 # The globals
@@ -73,11 +73,12 @@ def parse_example_parts(lines, example_title_line):
     output_so_far = []
     next_line = example_title_line
     # store build_up till an H4 (explanation) is encountered
-    while not next_line.startswith("#### "):
+    while not (next_line.startswith("#### ")or next_line.startswith('---')):
         # Watching out for the snippets
-        if next_line.startswith("```"):
+        if next_line.startswith("```py"):
             # It's a snippet, whatever found until now is text
             is_interactive = False
+            output_encountered = False
             if content:
                 parts["build_up"].append(generate_markdown_block(content))
                 content = []
@@ -95,6 +96,8 @@ def parse_example_parts(lines, example_title_line):
                     # can be either output or normal code
                     if is_interactive:
                         output_so_far.append(next_line)
+                    elif output_encountered:
+                        output_so_far.append(next_line)
                     else:
                         statements_so_far.append(next_line)
                 next_line = next(lines)
@@ -119,7 +122,7 @@ def parse_example_parts(lines, example_title_line):
     # store lines again until --- or another H3 is encountered
     while not (next_line.startswith("---") or
                next_line.startswith("### ")):
-        if next_line.lstrip().startswith("```"):
+        if next_line.lstrip().startswith("```py"):
             # It's a snippet, whatever found until now is text
             is_interactive = False
             if content:
@@ -231,18 +234,22 @@ def convert_to_cells(cell_contents):
     return cells
 
 
-def convert_to_notebook(parsed_json):
+def convert_to_notebook(pre_examples_content, parsed_json, post_examples_content):
     result = {
         "cells": [],
         "metadata": {},
         "nbformat": 4,
         "nbformat_minor": 2
     }
+
+    notebook_path = "test.ipynb"
+
+    result["cells"] += convert_to_cells([generate_markdown_block(pre_examples_content)])
+
     for example in parsed_json:
         parts = example["parts"]
         build_up = parts.get("build_up")
         explanation = parts.get("explanation")
-        notebook_path = "test.ipynb"
 
         if build_up:
             result["cells"] += convert_to_cells(build_up)
@@ -250,6 +257,8 @@ def convert_to_notebook(parsed_json):
         if explanation:
             result["cells"] += convert_to_cells(explanation)
 
+    result["cells"] += convert_to_cells([generate_markdown_block(post_examples_content)])
+
     pprint.pprint(result, indent=2)
     with open(notebook_path, "w") as f:
         json.dump(result, f)
@@ -271,7 +280,7 @@ with open(fpath, 'r+', encoding="utf-8") as f:
                 section_text = []
                 line = next(lines)
                 # Until a new section is encountered
-                while not (line.startswith("## " )):
+                while not (line.startswith("## ") or line.startswith("# ")):
                     # check if it's a H3
                     if line.startswith("### "):
                         # An example is encountered
@@ -294,7 +303,6 @@ with open(fpath, 'r+', encoding="utf-8") as f:
                     post_stuff.append(line)
                 line = next(lines)
 
-    except StopIteration:
+    except StopIteration as e:
         pprint.pprint(result, indent=2)
-        print("POST", post_stuff)
-        convert_to_notebook(result)
+        convert_to_notebook(pre_stuff, result, post_stuff)

From 888c9e126106300a20a3fcfbb6f0d11605a092c0 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 4 Nov 2019 23:18:52 +0530
Subject: [PATCH 102/146] Fix indenting, add a minor example, and update
 contributing message

---
 README.md | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 05f336f..1313bf3 100644
--- a/README.md
+++ b/README.md
@@ -3377,9 +3377,9 @@ Let's increase the number of iterations by a factor of 10.
      True
      >>> False ** True == False
      True
->>> True ** False == True
+     >>> True ** False == True
      True
->>> True ** True == True
+     >>> True ** True == True
      True
      ```
 
@@ -3395,6 +3395,13 @@ Let's increase the number of iterations by a factor of 10.
 
      **💡 Explanation:**  The `@` operator was added in Python 3.5 keeping 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=}'
+    "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
@@ -3454,17 +3461,25 @@ f()
   The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.
 
 ---
-
-<p align="center">~~~ That's all folks! ~~~</p>
 ---
 
 # Contributing
 
-All patches are welcome! Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for further details. 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)
+Here are a few ways that you can contribute to wtfpython,
+
+- Suggesting new examples
+- Helping with translation (See issues labeled translation)
+- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc
+- Identifying gaps (things inadequate explanation, redundancy, etc)
+- Suggestions in general for making this project more fun and useful
+
+Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new).
+
+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 the community gave it the shape it is in right now. 
 
 #### Some nice Links!
 * https://www.youtube.com/watch?v=sH4XF6pKKmk

From 65c8a9ef8c97376c59fa048a4251546cfc39c233 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 4 Nov 2019 23:19:13 +0530
Subject: [PATCH 103/146] Update contributors list.

---
 CONTRIBUTORS.md | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index a5e440e..313c024 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,4 +1,4 @@
-I'm really grateful 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 |
 |-------------|--------|--------|
@@ -10,5 +10,19 @@ I'm really grateful to all the contributors. Following are the wonderful people
 | 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) |
 
-Thank you all for taking out the time to make this project more awesome! :smile:
+
+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.

From d9e71224e2dfb36c20d696e0ef3d0ae8280f8538 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 7 Nov 2019 17:27:52 +0530
Subject: [PATCH 104/146] Add minor example

---
 README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/README.md b/README.md
index 1313bf3..3985612 100644
--- a/README.md
+++ b/README.md
@@ -3437,6 +3437,16 @@ f()
   []
   ```
 
+* 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](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.
 
 * You can seperate numeric literals with underscores (for better readablity) from Python 3 onwards.

From e899e385530b1bcfb29e71f94c74648f23553574 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Sun, 1 Dec 2019 15:51:18 +0300
Subject: [PATCH 105/146] Adds wemake-python-styleguide

Link: https://github.com/wemake-services/wemake-python-styleguide
Docs: https://wemake-python-stylegui.de/en/latest/
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index b1354cc..17a7487 100644
--- a/README.md
+++ b/README.md
@@ -2438,6 +2438,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
 * https://www.python.org/doc/humor/
 * https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
+* https://github.com/wemake-services/wemake-python-styleguide
 
 # 🎓 License
 

From d7c8b73731eb0eeb8f660d244017c6d8b3e03d9e Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 19 Dec 2019 15:49:40 +0530
Subject: [PATCH 106/146] Remove lobby link

---
 CONTRIBUTING.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e9c43db..e89821d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 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.
 
-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.
+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, 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.
 
@@ -42,4 +42,4 @@ Few things that you can consider while writing an example,
 
 - Try to be consistent with the namings and the values you use with the variables. For instance, most variable names in the project are along the lines of `some_string`, `some_list`, `some_dict`, etc. You'd see a lot of `x`s for single letter variable names, and `"wtf"` as values for strings. There's strictly enforced scheme in the project, 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, please don't forget to add your name to the [contributors list](/CONTRIBUTING.md).
\ No newline at end of file
+- Also, please don't forget to add your name to the [contributors list](/CONTRIBUTING.md).

From f3c7afebd7e04fc4db2243bbec906fb7319fb4e5 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 19 Dec 2019 15:49:52 +0530
Subject: [PATCH 107/146] Minor corrections

---
 README.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 3985612..9695385 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 <h1 align="center">What the f*ck Python! 🐍</h1>
 <p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
 
-Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn)
+Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
 
 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.
 
@@ -24,7 +24,7 @@ So, here we go...
 - [Structure of the Examples](#structure-of-the-examples)
     + [▶ Some fancy Title](#-some-fancy-title)
 - [Usage](#usage)
-- [👀 Examples](#%F0%9F%91%80-examples)
+- [👀 Examples](#-examples)
   * [Section: Strain your brain!](#section-strain-your-brain)
     + [▶ First things first!](#-first-things-first)
     + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
@@ -91,7 +91,6 @@ So, here we go...
     + [▶ `+=` is faster](#--is-faster)
     + [▶ Let's make a giant string!](#-lets-make-a-giant-string)
     + [▶ Minor Ones](#-minor-ones)
-  * [~~~ That's all folks! ~~~](#-thats-all-folks-)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
 - [🎓 License](#%F0%9F%8E%93-license)
@@ -221,7 +220,7 @@ SyntaxError: invalid syntax
 
 
 
-💡 Explanation
+####💡 Explanation
 
 **Quick walrus operator refresher**
 
@@ -3355,7 +3354,7 @@ Let's increase the number of iterations by a factor of 10.
   + `++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_?
+* 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
@@ -3470,26 +3469,28 @@ f()
   ```
   The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.
 
+**That's all folks!**
+
 ---
 ---
 
 # Contributing
 
-Here are a few ways that you can contribute to wtfpython,
+A few ways that you can contribute to wtfpython,
 
 - Suggesting new examples
-- Helping with translation (See issues labeled translation)
-- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc
-- Identifying gaps (things inadequate explanation, redundancy, etc)
-- Suggestions in general for making this project more fun and useful
+- Helping with translation (See [issues labeled translation](https://github.com/satwikkansal/wtfpython/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation))
+- Minor corrections like pointing out outdated snippets, typos, formatting errors, etc.
+- Identifying gaps (things like inadequate explanation, redundant examples, etc.)
+- Any creative suggestions to make this project more fun and useful
 
-Please see [CONTRIBUTING.md](/CONTRIBUTING.md) for more details. Feel free to create a new [issue](https://github.com/satwikkansal/wtfpython/issues/new).
+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
@@ -3510,7 +3511,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 [license-url]: http://www.wtfpl.net
 [license-image]: https://img.shields.io/badge/License-WTFPL%202.0-lightgrey.svg?style=flat-square
 
-## Surprise your friends too?
+## Surprise your friends as well!
 
 If you liked wtfpython, you can use these quick links to share it with your friends,
 

From 8522964105057162c144db30211090c598c69f9a Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Thu, 19 Dec 2019 21:47:20 +0530
Subject: [PATCH 108/146] Read only meta tag, and minor fixes

---
 README.md | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 9695385..2e846cf 100644
--- a/README.md
+++ b/README.md
@@ -168,6 +168,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 ### ▶ First things first!
 
 <!-- Example ID: d3d73936-3cf1-4632-b5ab-817981338863 -->
+<!-- read-only -->
 
 For some reasons, "Walrus" operator (`:=`) has become a very popular feature in the language. Let's check it out,
 
@@ -220,7 +221,7 @@ SyntaxError: invalid syntax
 
 
 
-####💡 Explanation
+#### 💡 Explanation
 
 **Quick walrus operator refresher**
 
@@ -1455,7 +1456,7 @@ def some_func(val):
 
 
 ### ▶ Yielding from... return!
-
+<!-- Example ID: 5626d8ef-8802-49c2-adbc-7cda5c550816 --->
 1\.
 
 ```py
@@ -1634,7 +1635,6 @@ But I thought tuples were immutable...
 
 ### ▶ The disappearing variable from outer scope
 <!-- Example ID: 7f1e71b6-cb3e-44fb-aa47-87ef1b7decc8 --->
-<!-- version-specific: True -->
 
 ```py
 e = 7
@@ -1833,7 +1833,6 @@ a, b = a[b] = {}, 5
 
 ### ▶ Modifying a dictionary while iterating over it
 <!-- Example ID: b4e5cdfb-c3a8-4112-bd38-e2356d801c41 --->
-<!-- version-specific: True -->
 ```py
 x = {0: None}
 
@@ -1870,7 +1869,7 @@ Yes, it runs for exactly **eight** times and stops.
 
 ### ▶ Stubborn `del` operation
 <!-- Example ID: 777ed4fd-3a2d-466f-95e7-c4058e61d78e --->
-<!-- read-only: True -->
+<!-- read-only -->
 
 ```py
 class SomeClass:
@@ -2065,7 +2064,6 @@ Where did element `3` go from the `numbers` list?
 
 ### ▶ Loop variables leaking out!
 <!-- Example ID: ccec7bf6-7679-4963-907a-1cd8587be9ea --->
-<!-- version-specific: True -->
 1\.
 ```py
 for x in range(7):
@@ -2607,7 +2605,7 @@ def similar_recursive_func(a):
 
 ### ▶ Wild imports
 <!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
-<!-- read-only: True -->
+<!-- read-only -->
 
 ```py
 # File: module.py
@@ -2725,7 +2723,7 @@ if noon_time:
 
 **Output (< 3.5):**
 
-```sh
+```py
 ('Time at noon is', datetime.time(12, 0))
 ```
 The midnight time is not printed.
@@ -2763,7 +2761,6 @@ Sshh.. It's a super secret.
 
 ### ▶ `goto`, but why?
 <!-- Example ID: 2aff961e-7fa5-4986-a18a-9e5894bd89fe --->
-<!-- version-specific: True -->
 
 ```py
 from goto import goto, label

From ef68d1b482af9ba826d5206bb8fd19fc9cb84171 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 00:27:21 +0530
Subject: [PATCH 109/146] Add markers for new content

---
 README.md | 39 +++++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index 2e846cf..57b8987 100644
--- a/README.md
+++ b/README.md
@@ -165,7 +165,7 @@ Now, just run `wtfpython` at the command line which will open this collection in
 
 ## Section: Strain your brain!
 
-### ▶ First things first!
+### ▶ First things first! *
 
 <!-- Example ID: d3d73936-3cf1-4632-b5ab-817981338863 -->
 <!-- read-only -->
@@ -451,7 +451,7 @@ True
 
 ---
 
-### ▶ Disorder within order
+### ▶ Disorder within order *
 <!-- Example ID: 91bff1f8-541d-455a-9de4-6cd8ff00ea66 --->
 ```py
 from collections import OrderedDict
@@ -549,7 +549,7 @@ What is going on here?
 
 ---
 
-### ▶ Keep trying...
+### ▶ Keep trying... *
 <!-- Example ID: b4349443-e89f-4d25-a109-82616be9d41a --->
 ```py
 def some_func():
@@ -976,7 +976,7 @@ Even when the values of `x` were different in every iteration prior to appending
 
 ---
 
-### ▶ The chicken-egg problem
+### ▶ The chicken-egg problem *
 <!-- Example ID: 60730dc2-0d79-4416-8568-2a63323b3ce8 --->
 1\.
 ```py
@@ -1050,7 +1050,7 @@ The Subclass relationships were expected to be transitive, right? (i.e., if `A`
 
 ---
 
-### ▶ All-true-ation
+### ▶ All-true-ation *
 
 <!-- Example ID: dfe6d845-e452-48fe-a2da-0ed3869a8042 -->
 
@@ -1379,7 +1379,7 @@ True
 
 ---
 
-### ▶ Non-reflexive class method
+### ▶ Non-reflexive class method *
 
 <!-- Example ID: 3649771a-f733-413c-8060-3f9f167b83fd -->
 
@@ -1455,7 +1455,7 @@ def some_func(val):
 ---
 
 
-### ▶ Yielding from... return!
+### ▶ Yielding from... return! *
 <!-- Example ID: 5626d8ef-8802-49c2-adbc-7cda5c550816 --->
 1\.
 
@@ -1520,7 +1520,7 @@ Same result, that didn't work either.
 
 ---
 
-### ▶ Nan-reflexivity 
+### ▶ Nan-reflexivity *
 
 <!-- Example ID: 59bee91a-36e0-47a4-8c7d-aa89bf1d3976 --->
 
@@ -2012,8 +2012,7 @@ Can you guess why the output is `[2, 4]`?
 ---
 
 
-### ▶ Lossy zip of iterators
-
+### ▶ Lossy zip of iterators *
 <!-- Example ID: c28ed154-e59f-4070-8eb6-8967a4acac6d --->
 
 ```py
@@ -2390,7 +2389,7 @@ class SomeClass:
 
 ---
 
-### ▶ Needles in a Haystack
+### ▶ Needles in a Haystack *
 
 <!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
 
@@ -2567,7 +2566,7 @@ def similar_recursive_func(a):
 ---
 
 
-### ▶ Splitsies
+### ▶ Splitsies *
 <!-- Example ID: ec3168ba-a81a-4482-afb0-691f1cc8d65a --->
 ```py
 >>> 'a'.split()
@@ -2603,7 +2602,7 @@ def similar_recursive_func(a):
 
 ---
 
-### ▶ Wild imports
+### ▶ Wild imports *
 <!-- Example ID: 83deb561-bd55-4461-bb5e-77dd7f411e1c --->
 <!-- read-only -->
 
@@ -2662,7 +2661,7 @@ NameError: name '_another_weird_name_func' is not defined
 
 ---
 
-### ▶ All sorted?
+### ▶ All sorted? *
 
 <!-- Example ID: e5ff1eaf-8823-4738-b4ce-b73f7c9d5511 -->
 
@@ -2767,7 +2766,7 @@ 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
@@ -2776,8 +2775,8 @@ 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!
 ```
 
@@ -2945,7 +2944,7 @@ Try block executed successfully...
 - `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.
 
 ---
-### ▶ Ellipsis
+### ▶ Ellipsis *
 <!-- Example ID: 969b7100-ab3d-4a7d-ad7d-a6be16181b2b --->
 ```py
 def some_func():
@@ -3324,7 +3323,7 @@ Let's increase the number of iterations by a factor of 10.
 
 ---
 
-### ▶ Minor Ones
+### ▶ Minor Ones *
 <!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --->
 * `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)
 
@@ -3512,7 +3511,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 If you liked wtfpython, you can use these quick links to share it with your friends,
 
-[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&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&hastags=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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
 
 ## Need a pdf version?
 

From b96e2fb6a981528522477fdc330a1976005eb2b5 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 00:31:42 +0530
Subject: [PATCH 110/146] Respect the read_only rule

---
 irrelevant/json_generator.py | 53 ++++++++++++++++++++++++++----------
 1 file changed, 38 insertions(+), 15 deletions(-)

diff --git a/irrelevant/json_generator.py b/irrelevant/json_generator.py
index 73be981..2c77a6e 100644
--- a/irrelevant/json_generator.py
+++ b/irrelevant/json_generator.py
@@ -63,15 +63,15 @@ def is_interactive_statement(line):
     return False
 
 
-def parse_example_parts(lines, example_title_line):
+def parse_example_parts(lines, title, current_line):
     parts = {
         "build_up": [],
         "explanation": []
     }
-    content = []
+    content = [title]
     statements_so_far = []
     output_so_far = []
-    next_line = example_title_line
+    next_line = current_line
     # store build_up till an H4 (explanation) is encountered
     while not (next_line.startswith("#### ")or next_line.startswith('---')):
         # Watching out for the snippets
@@ -181,7 +181,7 @@ def inspect_and_sanitize_code_lines(lines):
     return is_print_present, result
 
 
-def convert_to_cells(cell_contents):
+def convert_to_cells(cell_contents, read_only):
     cells = []
     for stuff in cell_contents:
         if stuff["type"] == "markdown":
@@ -194,13 +194,26 @@ def convert_to_cells(cell_contents):
                 }
             )
         elif stuff["type"] == "code":
+            if read_only:
+                # Skip read only
+                # TODO: Fix
+                cells.append(
+                {
+                    "cell_type": "markdown",
+                    "metadata": {},
+                    "source": ["```py\n"] + stuff["statements"] + ["```\n"] + ["```py\n"] + stuff['output'] + ["```\n"]
+                    }
+                )
+                continue
+
             is_print_present, sanitized_code = inspect_and_sanitize_code_lines(stuff["statements"])
             if is_print_present:
                 cells.append(
                     {
                         "cell_type": "code",
                         "metadata": {
-                            "collapsed": True
+                            "collapsed": True,
+
                         },
                         "execution_count": None,
                         "outputs": [{
@@ -244,22 +257,23 @@ def convert_to_notebook(pre_examples_content, parsed_json, post_examples_content
 
     notebook_path = "test.ipynb"
 
-    result["cells"] += convert_to_cells([generate_markdown_block(pre_examples_content)])
+    result["cells"] += convert_to_cells([generate_markdown_block(pre_examples_content)], False)
 
     for example in parsed_json:
         parts = example["parts"]
         build_up = parts.get("build_up")
         explanation = parts.get("explanation")
+        read_only = example.get("read_only")
 
         if build_up:
-            result["cells"] += convert_to_cells(build_up)
+            result["cells"] += convert_to_cells(build_up, read_only)
 
         if explanation:
-            result["cells"] += convert_to_cells(explanation)
+            result["cells"] += convert_to_cells(explanation, read_only)
 
-    result["cells"] += convert_to_cells([generate_markdown_block(post_examples_content)])
+    result["cells"] += convert_to_cells([generate_markdown_block(post_examples_content)], False)
 
-    pprint.pprint(result, indent=2)
+    #pprint.pprint(result, indent=2)
     with open(notebook_path, "w") as f:
         json.dump(result, f)
 
@@ -284,13 +298,22 @@ with open(fpath, 'r+', encoding="utf-8") as f:
                     # check if it's a H3
                     if line.startswith("### "):
                         # An example is encountered
-                        title = line.replace("### ", "")
+                        title_line = line
+                        line = next(lines)
+                        read_only = False
+                        while line.strip() == "" or line.startswith('<!--'):
+                            #TODO: Capture example ID here using regex.
+                            if '<!-- read-only -->' in line:
+                                read_only = True
+                            line = next(lines)
+
                         example_details = {
                             "id": current_example,
-                            "title": line.replace("### ", ""),
-                            "section": current_section_name
+                            "title": title_line.replace("### ", ""),
+                            "section": current_section_name,
+                            "read_only": read_only
                         }
-                        line, example_details["parts"] = parse_example_parts(lines, line)
+                        line, example_details["parts"] = parse_example_parts(lines, title_line, line)
                         result.append(example_details)
                         current_example += 1
                     else:
@@ -304,5 +327,5 @@ with open(fpath, 'r+', encoding="utf-8") as f:
                 line = next(lines)
 
     except StopIteration as e:
-        pprint.pprint(result, indent=2)
+        #pprint.pprint(result, indent=2)
         convert_to_notebook(pre_stuff, result, post_stuff)

From 0c461ee66af878553c072d2ca3d94cf05f492aa4 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 00:36:19 +0530
Subject: [PATCH 111/146] Ignore IDE files

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 36f9a1f..057dcb0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,5 @@ __pycache__/
 irrelevant/.ipynb_checkpoints/
 
 irrelevant/.python-version
+
+.idea/

From 68904d3f6fe2e474c10af27b9d96616cbd7b9cab Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:13:18 +0530
Subject: [PATCH 112/146] Remove mention of npm package

---
 README.md | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 445755c..482f7b1 100644
--- a/README.md
+++ b/README.md
@@ -145,20 +145,11 @@ A nice way to get the most out of these examples, in my opinion, will be to just
     - 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)).
     - 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 (which 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)
+PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),
 ```sh
 $ pip install wtfpython -U
+$ wtfpython
 ```
-
-Now, just run `wtfpython` at the command line which will open this collection in your selected `$PAGER`.
-
 ---
 
 # 👀 Examples
@@ -3497,7 +3488,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * 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
+* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
 
 # 🎓 License
 

From dd3c62d49d155093753a4bc3e35b4fca7ca6e9a6 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:14:09 +0530
Subject: [PATCH 113/146] Remove npm related stuff

---
 .npmignore   |  1 -
 package.json | 41 -----------------------------------------
 2 files changed, 42 deletions(-)
 delete mode 100644 .npmignore
 delete mode 100644 package.json

diff --git a/.npmignore b/.npmignore
deleted file mode 100644
index 9b7aaab..0000000
--- a/.npmignore
+++ /dev/null
@@ -1 +0,0 @@
-irrelevant/
diff --git a/package.json b/package.json
deleted file mode 100644
index f617091..0000000
--- 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 <satwikkansal@gmail.com> (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"
-  }
-}

From 44e885a09c18209b152d3ff82749d1cf5dfd9204 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:19:31 +0530
Subject: [PATCH 114/146] Ignore unnecessary stuff in npm package

---
 .npmignore | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.npmignore b/.npmignore
index 9b7aaab..42ef728 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1 +1,9 @@
 irrelevant/
+wtfpython-pypi/build/
+wtfpython-pypi/dist/
+wtfpython-pypi/wtfpython.egg-info
+
+# Python-specific byte-compiled files should be ignored
+__pycache__/
+*.py[cod]
+*$py.class

From 176bcc8a253de967c62d33c0604d4d154ca79794 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:19:49 +0530
Subject: [PATCH 115/146] Bump npm version

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index f617091..68472df 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "wtfpython",
-  "version": "2.1.0",
-  "description": "A collection of surprising Python snippets and lesser known features.",
+  "version": "2.2.0",
+  "description": "A collection of surprising Python snippets and lesser known features. [ARCHIVED]",
   "bin": "wtfpython",
   "scripts": {
     "postpublish": "git push origin master",

From 8e798af4fcf5e1c20cb18ce75267496e7f7fb5b6 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:20:48 +0530
Subject: [PATCH 116/146] Ignore IDE files and Bump npm version

---
 .npmignore   | 2 ++
 package.json | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.npmignore b/.npmignore
index 42ef728..5b48b06 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1,3 +1,5 @@
+.idea/
+
 irrelevant/
 wtfpython-pypi/build/
 wtfpython-pypi/dist/
diff --git a/package.json b/package.json
index 68472df..bdfa76f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "wtfpython",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "A collection of surprising Python snippets and lesser known features. [ARCHIVED]",
   "bin": "wtfpython",
   "scripts": {

From 6e5278e30a59b6cfcf2ea1484c73cce49523e9a5 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:23:20 +0530
Subject: [PATCH 117/146] More cleanup and another version bump

---
 .npmignore   | 5 ++---
 package.json | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/.npmignore b/.npmignore
index 5b48b06..57de941 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1,9 +1,8 @@
+.DS_Store
 .idea/
 
 irrelevant/
-wtfpython-pypi/build/
-wtfpython-pypi/dist/
-wtfpython-pypi/wtfpython.egg-info
+wtfpython-pypi/**
 
 # Python-specific byte-compiled files should be ignored
 __pycache__/
diff --git a/package.json b/package.json
index bdfa76f..eae9e95 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "wtfpython",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "A collection of surprising Python snippets and lesser known features. [ARCHIVED]",
   "bin": "wtfpython",
   "scripts": {

From 264b93a633af0d29d6dca7637ca2e7779dd262cb Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 01:27:34 +0530
Subject: [PATCH 118/146] Remove every existence of npm

---
 .npmignore   | 10 -------
 package.json | 41 -------------------------
 wtfpython    | 85 ----------------------------------------------------
 3 files changed, 136 deletions(-)
 delete mode 100644 .npmignore
 delete mode 100644 package.json
 delete mode 100644 wtfpython

diff --git a/.npmignore b/.npmignore
deleted file mode 100644
index 57de941..0000000
--- a/.npmignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.DS_Store
-.idea/
-
-irrelevant/
-wtfpython-pypi/**
-
-# Python-specific byte-compiled files should be ignored
-__pycache__/
-*.py[cod]
-*$py.class
diff --git a/package.json b/package.json
deleted file mode 100644
index eae9e95..0000000
--- a/package.json
+++ /dev/null
@@ -1,41 +0,0 @@
-{
-  "name": "wtfpython",
-  "version": "2.2.2",
-  "description": "A collection of surprising Python snippets and lesser known features. [ARCHIVED]",
-  "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 <satwikkansal@gmail.com> (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/wtfpython b/wtfpython
deleted file mode 100644
index b8a3fa6..0000000
--- 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());
-});

From 9fb381c4f3064d304654c5d046698ceb13a262e8 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 02:05:53 +0530
Subject: [PATCH 119/146] Fix soo many typos, sigh.

---
 README.md | 176 +++++++++++++++++++++++++++---------------------------
 1 file changed, 88 insertions(+), 88 deletions(-)

diff --git a/README.md b/README.md
index 482f7b1..974359a 100644
--- a/README.md
+++ b/README.md
@@ -8,9 +8,9 @@ Python, being a beautifully designed high-level and interpreter-based programmin
 
 Here is 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 beliereve that you'll find it interesting too!
+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 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:
+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/).
 
@@ -137,8 +137,8 @@ All the examples are structured like below:
 
 # Usage
 
-A nice way to get the most out of these examples, in my opinion, will be to just read them 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 chronologically, 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.
@@ -161,7 +161,7 @@ $ wtfpython
 <!-- Example ID: d3d73936-3cf1-4632-b5ab-817981338863 -->
 <!-- read-only -->
 
-For some reasons, "Walrus" operator (`:=`) has become a very popular feature in the language. Let's check it out,
+For some reason, the "Walrus" operator (`:=`) has become a popular feature in the language. Let's check it out,
 
 1\.
 
@@ -216,26 +216,26 @@ SyntaxError: invalid syntax
 
 **Quick walrus operator refresher**
 
-The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situatitions where you'd want to assing values to variables within an expression.
+The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situations where you'd want to assign values to variables within an expression.
 
 ```py
 def some_func():
-		# Assume some expensive computation here
-		# time.sleep(1000)
-		return 5
+        # 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
+        print(some_func()) # Which is bad practice since computation is happening twice
 
 # or
 a = some_func()
 if a:
-	print(a)
+    print(a)
 
 # Now you can concisely write
 if a := some_func():
-		print(a)
+        print(a)
 ```
 
 **Output (> 3.8):**
@@ -246,13 +246,13 @@ if a := some_func():
 5
 ```
 
-This helped save one line of code, and implicitly prevented invoking `some_func` twice.
+This saved one line of code, and implicitly prevented invoking `some_func` twice.
 
-- Unparenthesized "assignment expression" (use of walrus operator), is restricted at top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of first snippet. Parenthesizing it worked as expected and assigned `a`.  
+- 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 expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. 
+- 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, 
+- 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')
 
@@ -333,15 +333,15 @@ Makes sense, right?
 
 #### 💡 Explanation:
 + The behavior in first and second snippets is due to a CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.
-+ After being "interned", many variables may reference the same string object in memory (saving memory thereby).
-+ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some rules that can be used to guess if a string will be interned or not:
++ 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)
+  * 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)
   <img src="images/string-intern/string_intern.png" alt="">
-+ 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 an 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).
-+ The compile unit in interactive environment like ipython consists of 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 2 statements in 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 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 length less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
++ 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 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
 + Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). 
 
 ---
@@ -379,7 +379,7 @@ So, why is Python all over the place?
 #### 💡 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.
+* Immutable objects with the same value always have the same hash in Python.
   ```py
   >>> 5 == 5.0 == 5 + 0j
   True
@@ -415,7 +415,7 @@ True
 
 * When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.
 * When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.
-* So, 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.
+* So, the object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
 * But why did the `is` operator evaluated to `False`? Let's see with this snippet.
   ```py
   class WTF(object):
@@ -1010,10 +1010,10 @@ False
 - `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 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 instance of class B, and class B is an instance of class A.
+- 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 eachother as well as themselves) exist in Python because of "cheating" at implementation level.
+- 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.
 
 ---
 
@@ -1133,7 +1133,7 @@ True
 
 #### 💡 Explanation
 
-- In a normal python string, the backslash is used to escape characters that may have special meaning (like single-quote, double-quote and the backslash itself).
+- In a usual python string, the backslash is used to escape characters that may have a special meaning (like single-quote, double-quote, and the backslash itself).
     ```py
     >>> 'wt\"f'
     'wt"f'
@@ -1376,12 +1376,12 @@ True
 
 ```py
 class SomeClass:
-		def instance_method(self):
-				pass
-		
-		@classmethod
-		def class_method(cls):
-				pass
+        def instance_method(self):
+                pass
+        
+        @classmethod
+        def class_method(cls):
+                pass
 ```
 
 **Output:**
@@ -1406,7 +1406,7 @@ True
   <bound method SomeClass.class_method of <class '__main__.SomeClass'>
   ```
 
-  A new bound method everytime `SomeClass.class_method` is accessed.
+  A new bound method every time `SomeClass.class_method` is accessed.
 
 -  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). 
 
@@ -1438,7 +1438,7 @@ def some_func(val):
 ```
 
 #### 💡 Explanation:
-- This is bug in CPython's handling of `yield` in generators and comprehensions.
+- This is a bug in CPython's handling of `yield` in generators and comprehensions.
 - Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
 - Related bug report: http://bugs.python.org/issue10544
 - Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.
@@ -1485,7 +1485,7 @@ def some_func(x):
 []
 ```
 
-Same result, that didn't work either.
+The same result, this didn't work either.
 
 #### 💡 Explanation:
 
@@ -1493,7 +1493,7 @@ Same result, that didn't work either.
 
 > "... `return expr` in a generator causes `StopIteration(expr)` to be raised upon exit from the generator."
 
-+ In case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically catched inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
++ In the case of `some_func(3)`, `StopIteration` is raised at the beginning because of `return` statement. The `StopIteration` exception is automatically caught inside the `list(...)` wrapper and the `for` loop. Therefore, the above two snippets result in an empty list.
 
 + To get `["wtf"]` from the generator `some_func` we need to catch the `StopIteration` exception,
 
@@ -1566,9 +1566,9 @@ True
 
 #### 💡 Explanation:
 
-- `'inf'` and `'nan'` are special strings (case-insensitive), which when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
+- `'inf'` and `'nan'` are special strings (case-insensitive), which, when explicitly typecast-ed to `float` type, are used to represent mathematical "infinity" and "not a number" respectively.
 
-- Since according to IEEE standards ` NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e if `x` is a part of 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) whlie comparing two elements, and the values are compared only when the identities mismatch. Following snippet will make things clearer
+- Since according to IEEE standards ` NaN != NaN`, obeying this rule breaks the reflexivity assumption of a collection element in Python i.e. if `x` is a part of a collection like `list`, the implementations like comparison are based on the assumption that `x == x`.  Because of this assumption, the identity is compared first (since it's faster) while comparing two elements, and the values are compared only when the identities mismatch. The following snippet will make things clearer,
 
   ```py
   >>> x = float('nan')
@@ -1581,9 +1581,9 @@ True
   (False, False)
   ```
 
-  Since the identities of `x` and `y` are different, the values are considered, which are also different, hence the comparison returns `False` this time.
+  Since the identities of `x` and `y` are different, the values are considered, which are also different; hence the comparison returns `False` this time.
 
-- Interesting read: [Reflexivity, and other pilliars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
+- Interesting read: [Reflexivity, and other pillars of civilization](https://bertrandmeyer.com/2010/02/06/reflexivity-and-other-pillars-of-civilization/)
 
 ---
 
@@ -1591,7 +1591,7 @@ True
 
 <!-- Example ID: 15a9e782-1695-43ea-817a-a9208f6bb33d --->
 
-This might seem trivial if you know how references works in Python.
+This might seem trivial if you know how references work in Python.
 
 ```py
 some_tuple = ("A", "tuple", "with", "values")
@@ -1670,7 +1670,7 @@ NameError: name 'e' is not defined
 
   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:
+* The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable `e` got removed due to the execution of the `except` clause. The same is not the case with functions that have their separate inner-scopes. The example below illustrates this:
 
      ```py
      def f(x):
@@ -1693,7 +1693,7 @@ NameError: name 'e' is not defined
      [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.
+* 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
@@ -1786,9 +1786,9 @@ a, b = a[b] = {}, 5
 
 * 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`.
+* After the expression list is evaluated, its value is unpacked to the target lists from **left to right**. So, in our case, first the `{}, 5` tuple is unpacked to `a, b` and we now have `a = {}` and `b = 5`.
 
-* `a` is now assigned to `{}` which is a mutable object.
+* `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`).
 
@@ -1853,7 +1853,7 @@ Yes, it runs for exactly **eight** times and stops.
 * Iteration over a dictionary that you edit at the same time is not supported.
 * It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
 * How deleted keys are handled and when the resize occurs might be different for different Python implementations.
-* So for Python versions other than Python 2.7 - Python 3.5 the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread.
+* So for Python versions other than Python 2.7 - Python 3.5, the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread.
 * Python 3.8 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.
 
 ---
@@ -1878,7 +1878,7 @@ class SomeClass:
 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.
+Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twists to the example.
 
 2\.
 ```py
@@ -1898,8 +1898,8 @@ 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!).
++ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.
++ Calling `globals` caused the existing reference to be destroyed, and hence we can see "Deleted!" being printed (finally!).
 
 ---
 
@@ -1924,7 +1924,7 @@ UnboundLocalError: local variable 'a' referenced before assignment
 ```
 
 #### 💡 Explanation:
-* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`,  but it has not been initialized previously in the same scope which throws an error.
+* 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.
 * Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.
 * To modify the outer scope variable `a` in `another_func`, use `global` keyword.
   ```py
@@ -2110,9 +2110,9 @@ print(x, ': x in global')
 
 - 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) change log:
+- The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) changelog:
 
-    > "List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular the loop control variables are no longer leaked into the surrounding scope."
+    > "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."
 
 ---
 
@@ -2384,7 +2384,7 @@ class SomeClass:
 
 <!-- Example ID: 52a199b1-989a-4b28-8910-dff562cebba9 --->
 
-I haven't met even a single experience Pythonist till date who has not came across one or more of the following scenarios,
+I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,
 
 1\.
 
@@ -2498,11 +2498,11 @@ def some_recursive_func(a):
     return a
 
 def similar_recursive_func(a):
-		if a == 0:
-				return a
-		a -= 1
-		similar_recursive_func(a)
-		return a
+        if a == 0:
+                return a
+        a -= 1
+        similar_recursive_func(a)
+        return a
 ```
 
 **Output:**
@@ -2550,9 +2550,9 @@ def similar_recursive_func(a):
 
 * As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).
 
-* Last one should be fairly obvious, passing mutable object (like  `list` ) results in call by reference, whereas an immutable object (like `int`)  results in call by value.
+* Last one should be fairly obvious, passing mutable object (like  `list` ) results in a call by reference, whereas an immutable object (like `int`)  results in a call by value.
 
-* Being aware of these knitpicks can save you hours of degugging effort in long run. 
+* Being aware of these nitpicks can save you hours of debugging effort in the long run. 
 
 ---
 
@@ -2578,7 +2578,7 @@ def similar_recursive_func(a):
 
 #### 💡 Explanation:
 
-- It might appear at first that the default seperator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)
+- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)
     >  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,
@@ -2622,8 +2622,8 @@ NameError: name '_another_weird_name_func' is not defined
 
 #### 💡 Explanation:
 
-- It if often adivsable to not use wildcard imports. The first obvious reason for this is In wildcard imports, the names with leading underscore are be imported. This may lead to errors in runtime.
-- Had we used `from ... import a, b, c` syntax, the above `NameError` won't have occurred.
+- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore get imported. This may lead to errors during runtime.
+- 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()
@@ -2670,7 +2670,7 @@ False
 
 #### 💡 Explanation:
 
-- The `sorted` method always returns a list, and comparing list and tuples always returns `False` in Python. 
+- The `sorted` method always returns a list, and comparing lists and tuples always returns `False` in Python. 
 
 - ```py
   >>> [] == tuple()
@@ -2680,7 +2680,7 @@ False
   (tuple, list)
   ```
 
-- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use extra container (a list), whereas reversing can simple work by iterating from the last index to the first.
+- Unlike `sorted`, the `reversed` method returns an iterator. Why? Because sorting requires the iterator to be either modified in-place or use an extra container (a list), whereas reversing can simply work by iterating from the last index to the first.
 
 - So during comparison `sorted(y) == sorted(y)`, the first call to `sorted()` will consume the iterator `y`, and the next call will just return an empty list.
 
@@ -2729,7 +2729,7 @@ Before Python 3.5, the boolean value for `datetime.time` object was considered t
 
 ## 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?
 <!-- Example ID: a92f3645-1899-4d50-9721-0031be4aec3f --->
@@ -2740,7 +2740,7 @@ 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.
@@ -2796,7 +2796,7 @@ SyntaxError: not a chance
 Braces? No way! If you think that's disappointing, use Java. Okay, another surprising thing, can you find where's the `SyntaxError` raised in `__future__` module [code](https://github.com/python/cpython/blob/master/Lib/__future__.py)?
 
 #### 💡 Explanation:
-+ The `__future__` module is normally used to provide features from future versions of Python. The "future" in this specific context is however ironic.
++ 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.
@@ -2824,9 +2824,9 @@ There we go.
 - 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 on 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,
+- 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"'))
@@ -2932,7 +2932,7 @@ 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 try block is also called "completion clause" as reaching the `else` clause in a `try` statement means that the try block actually completed successfully.
+- `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 *
@@ -2957,7 +2957,7 @@ Ellipsis
 ```
 
 #### 💡 Explanation
-- In Python, `Ellipsis` is a globally available builtin object which is equivalent to `...`.
+- In Python, `Ellipsis` is a globally available built-in object which is equivalent to `...`.
     ```py
     >>> ...
     Ellipsis
@@ -3081,10 +3081,10 @@ AttributeError: 'A' object has no attribute '__variable'
 
 * [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 first snippet, we had to append `_Yo` to the front which would prevent conflicts with the same name attribute defined in any other class.
+* 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 outer scope.
-* Also, if the mangled name is longer than 255 characters truncation will happen.
+* 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.
 
 ---
 ---
@@ -3295,7 +3295,7 @@ Let's increase the number of iterations by a factor of 10.
 - Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases (justified with the execution times of `add_bytes_with_plus` function)
 - Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for very short strings).
 - Or better, if already you've contents available in the form of an iterable object, then use `''.join(iterable_object)` which is much faster.
-- `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 = ""
@@ -3318,14 +3318,14 @@ Let's increase the number of iterations by a factor of 10.
 <!-- Example ID: f885cb82-f1e4-4daa-9ff3-972b14cb1324 --->
 * `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.
+  **💡 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 a semantically correct statement as strings are [sequences](https://docs.python.org/3/glossary.html#term-sequence)(iterables supporting element access using integer indices) in Python.
   + `3 --0-- 5 == 8` and `--5 == 5` are both semantically correct statements and evaluate to `True`.
 
-* Given that `a` is a number, `++a` and `--a` are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++ or Java.
+* 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
@@ -3369,7 +3369,7 @@ Let's increase the number of iterations by a factor of 10.
      True
      ```
 
-     **💡 Explanation:** If you replace `False` and `True` by 0 and 1 and do the maths, the truth table is equivalent to converse implication operator. ([Source](https://github.com/cosmologicon/pywat/blob/master/explanation.md#the-undocumented-converse-implication-operator))
+     **💡 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).
 
@@ -3379,7 +3379,7 @@ Let's increase the number of iterations by a factor of 10.
      46
      ```
 
-     **💡 Explanation:**  The `@` operator was added in Python 3.5 keeping scientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
+     **💡 Explanation:**  The `@` operator was added in Python 3.5 keeping sthe cientific 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
@@ -3402,9 +3402,9 @@ 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/2/library/multiprocessing.html) module.
+* 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.
 
-* Sometimes the `print` method might not print values immediately. For example,
+* Sometimes, the `print` method might not print values immediately. For example,
 
      ```py
      # File some_file.py
@@ -3477,7 +3477,7 @@ PS: Please don't reach out with backlinking requests, no links will be added unl
 
 # Acknowledgements
 
-The idea and design for this collection were initially inspired by Denys Dovhan's awesome project [wtfjs](https://github.com/denysdovhan/wtfjs). The overwhelming support by pythonistas gave it the shape it is in right now.
+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
@@ -3501,10 +3501,10 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 ## Surprise your friends as well!
 
-If you liked wtfpython, you can use these quick links to share it with your friends,
+If you like wtfpython, you can use these quick links to share it with your friends,
 
 [Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hastags=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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
 
-## Need a pdf version?
+## More content like this?
 
-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.
+If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/wtfpython-pdf/).

From a9cbcdd95a691ee09bbf4404098b2c2e17057f50 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 23:27:25 +0530
Subject: [PATCH 120/146] Rename json_generator to notebook_generator

---
 irrelevant/{json_generator.py => notebook_generator.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename irrelevant/{json_generator.py => notebook_generator.py} (100%)

diff --git a/irrelevant/json_generator.py b/irrelevant/notebook_generator.py
similarity index 100%
rename from irrelevant/json_generator.py
rename to irrelevant/notebook_generator.py

From 7006084c120ef1fb317969b1643437920182f21e Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 23:39:10 +0530
Subject: [PATCH 121/146] Fix URLs

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 974359a..67957cc 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<p align="center"><img src="images/logo.png" alt=""></p>
+<p align="center"><img src="/images/logo.png" alt=""></p>
 <h1 align="center">What the f*ck Python! 🐍</h1>
 <p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
 
@@ -338,7 +338,7 @@ Makes sense, right?
   * All length 0 and length 1 strings are interned.
   * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)
   * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. CPython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)
-  <img src="images/string-intern/string_intern.png" alt="">
+  ![image](/images/string-intern/string_intern.png)
 + 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 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.
@@ -892,11 +892,11 @@ We didn't assign three `"X"`s, did we?
 
 When we initialize `row` variable, this visualization explains what happens in the memory
 
-![image](images/tic-tac-toe/after_row_initialized.png)
+![image](/images/tic-tac-toe/after_row_initialized.png)
 
 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`)
 
-![image](images/tic-tac-toe/after_board_initialized.png)
+![image](/images/tic-tac-toe/after_board_initialized.png)
 
 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).
 
@@ -3507,4 +3507,4 @@ If you like wtfpython, you can use these quick links to share it with your frien
 
 ## More content like this?
 
-If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/wtfpython-pdf/).
+If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/content-like-wtfpython/).

From 56c0347dd1596bf3f96d294e22ade14fe6004e12 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 20 Dec 2019 23:56:35 +0530
Subject: [PATCH 122/146] Minor correction

---
 README.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 67957cc..a068090 100644
--- a/README.md
+++ b/README.md
@@ -161,14 +161,17 @@ $ wtfpython
 <!-- Example ID: d3d73936-3cf1-4632-b5ab-817981338863 -->
 <!-- read-only -->
 
-For some reason, the "Walrus" operator (`:=`) has become a popular feature in the language. Let's check it out,
+For some reason, the Python 3.8's "Walrus" operator (`:=`) has become quite popular. Let's check it out,
 
 1\.
 
 ```py
+# Python version 3.8+
+
 >>> a = "wtf_walrus"
 >>> a
 'wtf_walrus'
+
 >>> a := "wtf_walrus"
 File "<stdin>", line 1
     a := "wtf_walrus"
@@ -183,6 +186,8 @@ SyntaxError: invalid syntax
 2 \.
 
 ```py
+# Python version 3.8+
+
 >>> a = 6, 9
 >>> a
 (6, 9)

From 49ed35e0996f2c5af725970a0499807fe4697299 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 00:16:19 +0530
Subject: [PATCH 123/146] Add hosted notebook instructions

---
 irrelevant/notebook_generator.py | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/irrelevant/notebook_generator.py b/irrelevant/notebook_generator.py
index 2c77a6e..d9818b3 100644
--- a/irrelevant/notebook_generator.py
+++ b/irrelevant/notebook_generator.py
@@ -32,6 +32,27 @@ current_section_name = ""
 
 STATEMENT_PREFIXES = ["...", ">>> ", "$ "]
 
+HOSTED_NOTEBOOK_INSTRUCTIONS = """
+
+# Hosted notebook instructions
+
+This is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, 
+- they either require a version of Python that's not supported in the hosted runtime.
+- or they can't be reproduced in the notebook envrinonment.
+
+The 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
+
+```py
+>>> import sys
+>>> sys.version
+# Prints out Python version here.
+```
+
+That being said, most of tbe 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!
+
+---
+"""
+
 
 def generate_code_block(statements, output):
     global sequence_num
@@ -255,7 +276,7 @@ def convert_to_notebook(pre_examples_content, parsed_json, post_examples_content
         "nbformat_minor": 2
     }
 
-    notebook_path = "test.ipynb"
+    notebook_path = "wtf.ipynb"
 
     result["cells"] += convert_to_cells([generate_markdown_block(pre_examples_content)], False)
 
@@ -328,4 +349,5 @@ with open(fpath, 'r+', encoding="utf-8") as f:
 
     except StopIteration as e:
         #pprint.pprint(result, indent=2)
+        pre_stuff.append(HOSTED_NOTEBOOK_INSTRUCTIONS)
         convert_to_notebook(pre_stuff, result, post_stuff)

From 1b1a5bc10d869163f8e3089146f1f4aa1acdc629 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 00:16:34 +0530
Subject: [PATCH 124/146] Add generated notebook

---
 irrelevant/wtf.ipynb | 12427 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 12427 insertions(+)
 create mode 100644 irrelevant/wtf.ipynb

diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb
new file mode 100644
index 0000000..64e315b
--- /dev/null
+++ b/irrelevant/wtf.ipynb
@@ -0,0 +1,12427 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<p align=\"center\"><img src=\"/images/logo.png\" alt=\"\"></p>\n",
+    "<h1 align=\"center\">What the f*ck Python! 🐍</h1>\n",
+    "<p align=\"center\">An interesting collection of surprising snippets and lesser-known Python features.</p>\n",
+    "\n",
+    "Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n",
+    "\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 is 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/).\n",
+    "\n",
+    "So, here we go...\n",
+    "\n",
+    "# Table of Contents\n",
+    "\n",
+    "<!-- Generated using \"markdown-toc -i README.md --maxdepth 3\"-->\n",
+    "<!-- toc -->\n",
+    "\n",
+    "- [Structure of the Examples](#structure-of-the-examples)\n",
+    "    + [▶ Some fancy Title](#-some-fancy-title)\n",
+    "- [Usage](#usage)\n",
+    "- [👀 Examples](#-examples)\n",
+    "  * [Section: Strain your brain!](#section-strain-your-brain)\n",
+    "    + [▶ First things first!](#-first-things-first)\n",
+    "    + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)\n",
+    "    + [▶ Splitsies](#-splitsies)\n",
+    "    + [▶ Hash brownies](#-hash-brownies)\n",
+    "    + [▶ Disorder within order](#-disorder-within-order)\n",
+    "    + [▶ Keep trying...](#-keep-trying)\n",
+    "    + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)\n",
+    "    + [▶ For what?](#-for-what)\n",
+    "    + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)\n",
+    "    + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)\n",
+    "    + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)\n",
+    "    + [▶ The sticky output function](#-the-sticky-output-function)\n",
+    "    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)\n",
+    "    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)\n",
+    "    + [▶ The surprising comma](#-the-surprising-comma)\n",
+    "    + [▶ Strings and the backslashes](#-strings-and-the-backslashes)\n",
+    "    + [▶ not knot!](#-not-knot)\n",
+    "    + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)\n",
+    "    + [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)\n",
+    "    + [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)\n",
+    "    + [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes)\n",
+    "    + [▶ Non-reflexive class method](#-non-reflexive-class-method)\n",
+    "    + [▶ yielding None](#-yielding-none)\n",
+    "    + [▶ Nan-reflexivity](#-nan-reflexivity)\n",
+    "    + [▶ Mutating the immutable!](#-mutating-the-immutable)\n",
+    "    + [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)\n",
+    "    + [▶ Yielding from... return!](#-yielding-from-return)\n",
+    "    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)\n",
+    "    + [▶ Subclass relationships](#-subclass-relationships)\n",
+    "    + [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion)\n",
+    "    + [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this)\n",
+    "  * [Section: Appearances are deceptive!](#section-appearances-are-deceptive)\n",
+    "    + [▶ Skipping lines?](#-skipping-lines)\n",
+    "    + [▶ Teleportation](#-teleportation)\n",
+    "    + [▶ Well, something is fishy...](#-well-something-is-fishy)\n",
+    "  * [Section: Slippery Slopes](#section-slippery-slopes)\n",
+    "    + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)\n",
+    "    + [▶ Stubborn `del` operation](#-stubborn-del-operation)\n",
+    "    + [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)\n",
+    "    + [▶ Loop variables leaking out!](#-loop-variables-leaking-out)\n",
+    "    + [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)\n",
+    "    + [▶ Catching the Exceptions](#-catching-the-exceptions)\n",
+    "    + [▶ Same operands, different story!](#-same-operands-different-story)\n",
+    "    + [▶ The out of scope variable](#-the-out-of-scope-variable)\n",
+    "    + [▶ Be careful with chained operations](#-be-careful-with-chained-operations)\n",
+    "    + [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope)\n",
+    "    + [▶ Needles in a Haystack](#-needles-in-a-haystack)\n",
+    "    + [▶ Wild imports](#-wild-imports)\n",
+    "  * [Section: Read the docs](#section-read-the-docs)\n",
+    "    + [▶ All sorted?](#-all-sorted)\n",
+    "    + [▶ All-true-ation](#-all-true-ation)\n",
+    "  * [Section: The Hidden treasures!](#section-the-hidden-treasures)\n",
+    "    + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)\n",
+    "    + [▶ `goto`, but why?](#-goto-but-why)\n",
+    "    + [▶ Brace yourself!](#-brace-yourself)\n",
+    "    + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)\n",
+    "    + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)\n",
+    "    + [▶ Yes, it exists!](#-yes-it-exists)\n",
+    "    + [▶ Ellipsis](#-ellipsis)\n",
+    "    + [▶ Inpinity](#-inpinity)\n",
+    "    + [▶ Let's mangle](#-lets-mangle)\n",
+    "  * [Section: Miscellaneous](#section-miscellaneous)\n",
+    "    + [▶ `+=` is faster](#--is-faster)\n",
+    "    + [▶ Let's make a giant string!](#-lets-make-a-giant-string)\n",
+    "    + [▶ Minor Ones](#-minor-ones)\n",
+    "- [Contributing](#contributing)\n",
+    "- [Acknowledgements](#acknowledgements)\n",
+    "- [🎓 License](#%F0%9F%8E%93-license)\n",
+    "  * [Surprise your friends too?](#surprise-your-friends-too)\n",
+    "  * [Need a pdf version?](#need-a-pdf-version)\n",
+    "\n",
+    "<!-- tocstop -->\n",
+    "\n",
+    "# Structure of the Examples\n",
+    "\n",
+    "All the examples are structured like below:\n",
+    "\n",
+    "> ### ▶ 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",
+    "> #### 💡 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)).\n",
+    "    - If yes, give a gentle pat on your back, and you may skip to the next example.\n",
+    "\n",
+    "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n",
+    "```sh\n",
+    "$ pip install wtfpython -U\n",
+    "$ wtfpython\n",
+    "```\n",
+    "---\n",
+    "\n",
+    "# 👀 Examples\n",
+    "\n",
+    "\n",
+    "\n",
+    "# Hosted notebook instructions\n",
+    "\n",
+    "This 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",
+    "\n",
+    "The 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",
+    "\n",
+    "That being said, most of tbe 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": [
+    "### ▶ 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 \"<stdin>\", 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",
+    ">>> 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",
+    ">>> a\n",
+    "```\n",
+    "```py\n",
+    "6\n",
+    "\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```py\n",
+    ">>> a, b = 6, 9 # Typcial 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 \"<stdin>\", 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": [
+    "#### 💡 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": [
+    "### ▶ Strings can be tricky sometimes\n",
+    "1\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "140420665652016\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = \"some_string\"\n",
+    "id(a)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "140420665652016\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Makes sense, right?\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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",
+    "  ![image](/images/string-intern/string_intern.png)\n",
+    "+ When `a` and `b` are set to `\"wtf!\"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't \"know\" that there's already `wtf!` as an object (because `\"wtf!\"` is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).\n",
+    "+ A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. `a, b = \"wtf!\", \"wtf!\"` is single statement, whereas `a = \"wtf!\"; b = \"wtf!\"` are two statements in a single line. This explains why the identities are different in `a = \"wtf!\"; b = \"wtf!\"`, and also explain why they are same when invoked in `some_file.py`\n",
+    "+ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a  few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.\n",
+    "+ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Hash brownies\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_dict[5.5]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Python\"\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_dict[5] \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "complex\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 Explanation\n",
+    "\n",
+    "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n",
+    "* Immutable objects with the same value always have the same hash in Python.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  5 == 5.0 == 5 + 0j\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  hash(5) == hash(5.0) == hash(5 + 0j)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "  **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n",
+    "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n",
+    "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Deep down, we're all the same.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "WTF() is WTF() # identities are also different\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(WTF()) == id(WTF())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Disorder within order *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dictionary == ordered_dict # If a == b\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ordered_dict == another_ordered_dict # the why isn't c == a ??\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Traceback (most recent call last):\n",
+       "  File \"<stdin>\", line 1, in <module>\n",
+       "TypeError: unhashable type: 'dict'\n",
+       "\n",
+       "# Makes sense since dict don't have __hash__ implemented, let's use\n",
+       "# our wrapper classes.\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len({dictionary, ordered_dict, another_ordered_dict})\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n",
+    "  \n",
+    "    > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n",
+    "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n",
+    "- Okay, so why did changing the order affect the lenght 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    another_ordered_dict in some_set\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    1\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    dictionary in another_set\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    2\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Keep trying... *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 ocurred\", 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_func()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Finally!\n",
+       "Finally!\n",
+       "Finally!\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_func()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Traceback (most recent call last):\n",
+       "  File \"<stdin>\", line 1, in <module>\n",
+       "ZeroDivisionError: division by zero\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1 / 0\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Iteration 0\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "one_more_func()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "- 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.\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": [
+    "### ▶ For what?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_dict # An indexed dict appears.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "####  💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+    "  **💡 Explanation:**\n",
+    "\n",
+    "  - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).\n",
+    "\n",
+    "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Evaluation time discrepancy\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "array = [1, 8, 15]\n",
+    "# A typical generator expresion\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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 2, 3, 4]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(list(gen_1))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": [
+    "#### 💡 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": [
+    "### ▶ 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = []\n",
+    "b = []\n",
+    "a is b\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a, b = 257, 257\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(256)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10922528\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(b)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "140084850247312\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(257)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "140084850247440\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a, b = 257, 257\n",
+    "id(a)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "140640774013296\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(b)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "140640774013392\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ `is not ...` is not `is (not ...)`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'something' is not None\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'something' is (not None)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "board\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['', '', '']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "board[0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "''\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "board[0][0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[['X', '', ''], ['X', '', ''], ['X', '', '']]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "When we initialize `row` variable, this visualization explains what happens in the memory\n",
+    "\n",
+    "![image](/images/tic-tac-toe/after_row_initialized.png)\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",
+    "![image](/images/tic-tac-toe/after_board_initialized.png)\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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ The sticky output function\n",
+    "1\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 1, 2, 3, 4, 5, 6]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[6, 6, 6, 6, 6, 6, 6]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "funcs_results\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n",
+    "\n",
+    "2\\.\n",
+    "\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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 Explanation\n",
+    "\n",
+    "- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.\n",
+    "\n",
+    "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    [0, 1, 2, 3, 4, 5, 6]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    funcs_results = [func() for func in funcs]\n",
+    "    funcs_results\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ The chicken-egg problem *\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(3, int)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(type, object)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class A: pass\n",
+    "isinstance(A, A)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "isinstance(type, type)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "issubclass(int, object)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "issubclass(type, object)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "issubclass(object, type)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": [
+    "### ▶ Subclass relationships\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "issubclass(object, Hashable)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ All-true-ation *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all([True, True, True])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all([True, True, False])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all([])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all([[]])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all([[[]]])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Why's this True-False alteration?\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": [
+    "### ▶ The surprising comma\n",
+    "**Output (< 3.6):**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  File \"<stdin>\", line 1\n",
+       "    def h(x, **kwargs,):\n",
+       "                     ^\n",
+       "SyntaxError: invalid syntax\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 \"<stdin>\", line 1\n",
+       "    def h(*args,):\n",
+       "                ^\n",
+       "SyntaxError: invalid syntax\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def h(*args,):\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": [
+    "### ▶ Strings and the backslashes\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\\\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(r\"\\\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "File \"<stdin>\", 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r'\\'' == \"\\\\'\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    r'wt\\\"f' == 'wt\\\\\"f'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    'wt\\\\\"f'\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    print(repr(r'wt\\\"f')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    print(\"\\n\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    '\\\\\\\\n'\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ not knot!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "not x == y\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  File \"<input>\", line 1\n",
+       "    x == not y\n",
+       "           ^\n",
+       "SyntaxError: invalid syntax\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x == not y\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.\n",
+    "* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.\n",
+    "* 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.\n",
+    "* 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`.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Half triple-quoted strings\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "wtfpython\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('wtfpython''')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "wtfpython\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"wtfpython\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  File \"<input>\", line 3\n",
+       "    print(\"\"\"wtfpython\")\n",
+       "                        ^\n",
+       "SyntaxError: EOF while scanning triple-quoted string literal\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The following statements raise `SyntaxError`\n",
+    "# print('''wtfpython')\n",
+    "# print(\"\"\"wtfpython\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n",
+    "  ```\n",
+    "  >>> print(\"wtf\" \"python\")\n",
+    "  wtfpython\n",
+    "  >>> print(\"wtf\" \"\") # or \"wtf\"\"\"\n",
+    "  wtf\n",
+    "  ```\n",
+    "+ `'''` and `\"\"\"` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ What's wrong with booleans?\n",
+    "1\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# A simple example to count the number of booleans and\n",
+    "# integers in an iterable of mixed data types.\n",
+    "mixed_list = [False, 1.0, \"some_string\", 3, True, [], False]\n",
+    "integers_found_so_far = 0\n",
+    "booleans_found_so_far = 0\n",
+    "\n",
+    "for item in mixed_list:\n",
+    "    if isinstance(item, int):\n",
+    "        integers_found_so_far += 1\n",
+    "    elif isinstance(item, bool):\n",
+    "        booleans_found_so_far += 1\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "integers_found_so_far\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "booleans_found_so_far\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "2\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'wtf'\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_bool = True\n",
+    "\"wtf\" * some_bool\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "''\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_bool = False\n",
+    "\"wtf\" * some_bool\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "3\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def tell_truth():\n",
+    "    True = False\n",
+    "    if True == False:\n",
+    "        print(\"I have lost faith in truth!\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output (< 3.x):**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "I have lost faith in truth!\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tell_truth()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "* `bool` is a subclass of `int` in Python\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    issubclass(bool, int)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    issubclass(int, bool)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "    \n",
+    "* And thus, `True` and `False` are instances of `int`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  isinstance(True, int)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  isinstance(False, int)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "* The integer value of `True` is `1` and that of `False` is `0`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  1\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  int(True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  0\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  int(False)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.\n",
+    "\n",
+    "* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true).  `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them\n",
+    "\n",
+    "* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Class attributes and instance attributes\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class A:\n",
+    "    x = 1\n",
+    "\n",
+    "class B(A):\n",
+    "    pass\n",
+    "\n",
+    "class C(A):\n",
+    "    pass\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 1, 1)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A.x, B.x, C.x\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 2, 1)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "B.x = 2\n",
+    "A.x, B.x, C.x\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3, 2, 3)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A.x = 3\n",
+    "A.x, B.x, C.x # C.x changed, but B.x didn't\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3, 3)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = A()\n",
+    "a.x, A.x\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(4, 3)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.x += 1\n",
+    "a.x, A.x\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "2\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class SomeClass:\n",
+    "    some_var = 15\n",
+    "    some_list = [5]\n",
+    "    another_list = [5]\n",
+    "    def __init__(self, x):\n",
+    "        self.some_var = x + 1\n",
+    "        self.some_list = self.some_list + [x]\n",
+    "        self.another_list += [x]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[5, 420]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_obj = SomeClass(420)\n",
+    "some_obj.some_list\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[5, 420]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_obj.another_list\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[5, 111]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_obj = SomeClass(111)\n",
+    "another_obj.some_list\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[5, 420, 111]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_obj.another_list\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_obj.another_list is SomeClass.another_list\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_obj.another_list is some_obj.another_list\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.\n",
+    "* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Non-reflexive class method *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class SomeClass:\n",
+    "        def instance_method(self):\n",
+    "                pass\n",
+    "        \n",
+    "        @classmethod\n",
+    "        def class_method(cls):\n",
+    "                pass\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SomeClass.instance_method is SomeClass.instance_method\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SomeClass.class_method is SomeClass.class_method\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "id(SomeClass.class_method) == id(SomeClass.class_method)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  <function __main__.SomeClass.instance_method(self)>\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  SomeClass.instance_method\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  <bound method SomeClass.class_method of <class '__main__.SomeClass'>\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  SomeClass.class_method\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "  A new bound method every time `SomeClass.class_method` is accessed.\n",
+    "\n",
+    "-  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ yielding None\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_iterable = ('a', 'b')\n",
+    "\n",
+    "def some_func(val):\n",
+    "    return \"something\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output (<= 3.7.x):**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['a', 'b']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[x for x in some_iterable]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<generator object <listcomp> at 0x7f70b0a4ad58>\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(some_func((yield x)) for x in some_iterable)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "- This is a bug in CPython's handling of `yield` in generators and comprehensions.\n",
+    "- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions\n",
+    "- Related bug report: http://bugs.python.org/issue10544\n",
+    "- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Yielding from... return! *\n",
+    "1\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  some_string\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Nan-reflexivity *\n",
+    "1\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "nan\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-inf\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "float('some_other_string')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a == -c # inf==inf\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "None == None # None == None\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b == d # but nan!=nan\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.0\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "50 / a\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "nan\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a / a\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "nan\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y == y # equality fails of y\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_tuple\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "But I thought tuples were immutable...\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "* Quoting from https://docs.python.org/2/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",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ The disappearing variable from outer scope\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    e\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    # Nothing is printed!\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    print e\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ The mysterious key type conversion\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(list(some_dict.keys())[0])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'s': 40}\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(list(some_dict.keys())[0])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Let's see if you can guess this?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form\n",
+    "  ```\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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  some_list[0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  some_list is some_list[0]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  a[b][0] is a\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Modifying a dictionary while iterating over it\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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.8 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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": [
+    "#### 💡 Explanation:\n",
+    "+ `del x` doesn’t directly call `x.__del__()`.\n",
+    "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero.\n",
+    "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n",
+    "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ The out of scope variable\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "another_func()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`,  but it has not been initialized previously in the same scope, which throws an error.\n",
+    "* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n",
+    "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  another_func()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Deleting a list item while iterating\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list_1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 4]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list_2\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list_3\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 4]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n",
+    "- 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Loop variables leaking out!\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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’s 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": [
+    "### ▶ Beware of default mutable arguments!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_func()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['some_string', 'some_string']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_func()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['some_string']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_func([])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['some_string', 'some_string', 'some_string']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_func()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    def some_func(default_arg=None):\n",
+    "        if not default_arg:\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": [
+    "### ▶ Catching the Exceptions\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  File \"<input>\", line 3\n",
+    "    except IndexError, ValueError:\n",
+    "                     ^\n",
+    "SyntaxError: invalid syntax\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation\n",
+    "\n",
+    "* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  some_list = [1, 2, 3]\n",
+    "  try:\n",
+    "     # This should raise a ``ValueError``\n",
+    "     some_list.remove(4)\n",
+    "  except (IndexError, ValueError), e:\n",
+    "     print(\"Caught again!\")\n",
+    "     print(e)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "  **Output (Python 2.x):**\n",
+    "  ```\n",
+    "  Caught again!\n",
+    "  list.remove(x): x not in list\n",
+    "  ```\n",
+    "  **Output (Python 3.x):**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    File \"<input>\", line 4\n",
+    "      except (IndexError, ValueError), e:\n",
+    "                                       ^\n",
+    "  IndentationError: unindent does not match any outer indentation level\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  some_list = [1, 2, 3]\n",
+    "  try:\n",
+    "      some_list.remove(4)\n",
+    "\n",
+    "  except (IndexError, ValueError) as e:\n",
+    "      print(\"Caught again!\")\n",
+    "      print(e)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "  **Output:**\n",
+    "  ```\n",
+    "  Caught again!\n",
+    "  list.remove(x): x not in list\n",
+    "  ```\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Same operands, different story!\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = [1, 2, 3, 4]\n",
+    "b = a\n",
+    "a = a + [5, 6, 7, 8]\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, 5, 6, 7, 8]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1, 2, 3, 4]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "2\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = [1, 2, 3, 4]\n",
+    "b = a\n",
+    "a += [5, 6, 7, 8]\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, 5, 6, 7, 8]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1, 2, 3, 4, 5, 6, 7, 8]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "*  `a += b` doesn't always behave the same way as `a = a + b`.  Classes *may* implement the *`op=`* operators differently, and lists do this.\n",
+    "\n",
+    "* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.\n",
+    "\n",
+    "* The expression `a += [5,6,7,8]` is actually mapped to an \"extend\" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Be careful with chained operations\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(False == False) in [False] # makes sense\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "False == (False in [False]) # makes sense\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "False == False in [False] # now what?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "True is False == False\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "False is False is False\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1 > 0 < 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(1 > 0) < 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1 > (0 < 1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "As per https://docs.python.org/2/reference/expressions.html#not-in\n",
+    "\n",
+    "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n",
+    "\n",
+    "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n",
+    "\n",
+    "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n",
+    "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n",
+    "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n",
+    "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  1\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  int(True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  2\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Name resolution ignoring class scope\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = 5\n",
+    "class SomeClass:\n",
+    "    x = 17\n",
+    "    y = (x for i in range(10))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(SomeClass.y)[0]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "2\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = 5\n",
+    "class SomeClass:\n",
+    "    x = 17\n",
+    "    y = [x for i in range(10)]\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": [
+       "17\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SomeClass.y[0]\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": [
+       "5\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SomeClass.y[0]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation\n",
+    "- Scopes nested inside class definition ignore names bound at the class level.\n",
+    "- A generator expression has its own scope.\n",
+    "- Starting from Python 3.X, list comprehensions also have their own scope.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Needles in a Haystack *\n",
+    "I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,\n",
+    "\n",
+    "1\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x, y = (0, 1) if True else None, None\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), None)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x, y  # expected (0, 1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "2\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": []
+    }
+   ],
+   "source": [
+    "t = ('one', 'two')\n",
+    "for i in t:\n",
+    "    print(i)\n",
+    "\n",
+    "t = ('one')\n",
+    "for i in t:\n",
+    "    print(i)\n",
+    "\n",
+    "t = ()\n",
+    "print(t)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "one\n",
+    "two\n",
+    "o\n",
+    "n\n",
+    "e\n",
+    "tuple()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "3\\.\n",
+    "\n",
+    "```\n",
+    "ten_words_list = [\n",
+    "    \"some\",\n",
+    "    \"very\",\n",
+    "    \"big\",\n",
+    "    \"list\",\n",
+    "    \"that\"\n",
+    "    \"consists\",\n",
+    "    \"of\",\n",
+    "    \"exactly\",\n",
+    "    \"ten\",\n",
+    "    \"words\"\n",
+    "]\n",
+    "```\n",
+    "\n",
+    "**Output**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(ten_words_list)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "4\\. Not asserting strongly enough\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = \"python\"\n",
+    "b = \"javascript\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "# No AssertionError is raised\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# An assert statement with an assertion failure message.\n",
+    "assert(a == b, \"Both languages are different\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "5\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_list = [1, 2, 3]\n",
+    "some_dict = {\n",
+    "  \"key_1\": 1,\n",
+    "  \"key_2\": 2,\n",
+    "  \"key_3\": 3\n",
+    "}\n",
+    "\n",
+    "some_list = some_list.append(4) \n",
+    "some_dict = some_dict.update({\"key_4\": 4})\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(some_list)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(some_dict)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "6\\.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def some_recursive_func(a):\n",
+    "    if a[0] == 0:\n",
+    "        return \n",
+    "    a[0] -= 1\n",
+    "    some_recursive_func(a)\n",
+    "    return a\n",
+    "\n",
+    "def similar_recursive_func(a):\n",
+    "        if a == 0:\n",
+    "                return a\n",
+    "        a -= 1\n",
+    "        similar_recursive_func(a)\n",
+    "        return a\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 0]\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_recursive_func([5, 0])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "similar_recursive_func(5)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.\n",
+    "\n",
+    "* 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.\n",
+    "\n",
+    "* `()` is a special token and denotes empty `tuple`.\n",
+    "\n",
+    "* In 3, as you might have already figured out, there's a missing comma after 5th element (`\"that\"`) in the list. So by implicit string literal concatenation,\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  ten_words_list\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  Traceback (most recent call last):\n",
+       "      File \"<stdin>\", line 1, in <module>\n",
+       "  AssertionError\n",
+       "  \n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "  a = \"python\"\n",
+    "  b = \"javascript\"\n",
+    "  assert a == b\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "  <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n",
+       "  \n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 \"<stdin>\", line 1, in <module>\n",
+       "  AssertionError: Values aren not equal\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n",
+    "\n",
+    "* Last one should be fairly obvious, passing mutable object (like  `list` ) results in a call by reference, whereas an immutable object (like `int`)  results in a call by value.\n",
+    "\n",
+    "* Being aware of these nitpicks can save you hours of debugging effort in the long run. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Splitsies *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['a']\n",
+       "\n",
+       "# is same as\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'a'.split()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['a']\n",
+       "\n",
+       "# but\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(''.split())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(''.split(' '))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)\n",
+    "    >  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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    ' a '.split(' ')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    ['a']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    ' a '.split()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "    ['']\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    ''.split(' ')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ 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 \"<stdin>\", line 1, in <module>\n",
+    "NameError: name '_another_weird_name_func' is not defined\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore get imported. This may lead to errors during runtime.\n",
+    "- 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 \"<stdin>\", line 1, in <module>\n",
+    "    NameError: name 'some_weird_name_func_' is not defined\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ All sorted? *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sorted(x) == sorted(x)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y = reversed(x)\n",
+    "sorted(y) == sorted(y)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Midnight time doesn't exist?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 Explanation:\n",
+    "+ `antigravity` module is one of the few easter eggs released by Python developers.\n",
+    "+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python.\n",
+    "+ 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": [
+    "### ▶ `goto`, but why?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"Ruby\" <> \"Python\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "There we go.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    from __future__ import barry_as_FLUFL\n",
+    "    print(eval('\"Ruby\" <> \"Python\"'))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Even Python understands that love is complicated\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "love = this\n",
+    "this is love\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "love is True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "love is False\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "love is not True or False\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Try block executed successfully...\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": [
+    "### ▶ Ellipsis *\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_func()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Traceback (most recent call last):\n",
+       "  File \"<stdin>\", line 1, in <module>\n",
+       "NameError: name 'SomeRandomString' is not defined\n",
+       "\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SomeRandomString\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Ellipsis\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Ellipsis\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "infinity = float('infinity')\n",
+    "hash(infinity)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-314159\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "hash(float('-inf'))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "- Hash of infinity is 10⁵ x π.\n",
+    "- Interestingly, the hash of `float('-inf')` is \"-10⁵ x π\" in Python 3, whereas \"-10⁵ x e\" in Python 2.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ Let's mangle\n",
+    "1\\.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Yo().__honey\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Yo().bro\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Traceback (most recent call last):\n",
+       "  File \"<stdin>\", line 1, in <module>\n",
+       "AttributeError: 'Yo' object has no attribute '_Yo__honey__'\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "_A__variable = \"Some value\"\n",
+    "\n",
+    "class A(object):\n",
+    "    def some_func(self):\n",
+    "        return __variable # not initiatlized anywhere yet\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Some value'\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Traceback (most recent call last):\n",
+    "  File \"<stdin>\", line 1, in <module>\n",
+    "AttributeError: 'A' object has no attribute '__variable'\n",
+    "\n",
+    "A().some_func()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 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": [
+    "### ▶ Skipping lines?\n",
+    "**Output:**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "11\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "value = 11\n",
+    "valuе = 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": [
+    "#### 💡 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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ord('е') # cyrillic 'e' (Ye)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "101\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'е' == 'e'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "value = 42 # latin e\n",
+    "valuе = 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": [
+    "### ▶ Teleportation\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ Well, something is fishy...\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "    TabError: inconsistent use of tabs and spaces in indentation\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ `+=` is faster\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.25748300552368164\n",
+       "# using \"+=\", three strings:\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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": [
+    "### ▶ Let's make a giant string!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Executed in ipython shell using %timeit for better readablity 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 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%timeit -n1000 add_bytes_with_plus(NUM_ITERS)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%timeit -n1000 add_string_with_format(NUM_ITERS)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "#### 💡 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 — 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": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "339 µs ± 28.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+     ]
+    }
+   ],
+   "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 ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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": [
+    "### ▶ Minor Ones *\n",
+    "* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)\n",
+    "\n",
+    "  **💡 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",
+    "  **💡 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",
+    "  **💡 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",
+    "     **💡 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",
+    "     **💡 Explanation:**  The `@` operator was added in Python 3.5 keeping sthe cientific 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",
+    "    \"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/2/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 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n",
+    "\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('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n",
+    "\n",
+    "* You can seperate numeric literals with underscores (for better readablity) 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",
+    "**That's all folks!**\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Contributing\n",
+    "\n",
+    "A few ways that 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",
+    "\n",
+    "# 🎓 License\n",
+    "\n",
+    "[![WTFPL 2.0][license-image]][license-url]\n",
+    "\n",
+    "&copy; [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": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.0+"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 12b2fc008ecc60ed2abd293c3fbc12f4489db520 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 19:39:28 +0530
Subject: [PATCH 125/146] Fix TOC and links

---
 README.md | 56 +++++++++++++++++++++++++++----------------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/README.md b/README.md
index a068090..57a26e9 100644
--- a/README.md
+++ b/README.md
@@ -19,6 +19,7 @@ So, here we go...
 # Table of Contents
 
 <!-- Generated using "markdown-toc -i README.md --maxdepth 3"-->
+
 <!-- toc -->
 
 - [Structure of the Examples](#structure-of-the-examples)
@@ -26,57 +27,52 @@ So, here we go...
 - [Usage](#usage)
 - [👀 Examples](#-examples)
   * [Section: Strain your brain!](#section-strain-your-brain)
-    + [▶ First things first!](#-first-things-first)
+    + [▶ First things first! *](#-first-things-first-)
     + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)
-    + [▶ Splitsies](#-splitsies)
     + [▶ Hash brownies](#-hash-brownies)
-    + [▶ Disorder within order](#-disorder-within-order)
-    + [▶ Keep trying...](#-keep-trying)
     + [▶ 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)
     + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)
+    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
     + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)
     + [▶ The sticky output function](#-the-sticky-output-function)
-    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)
-    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)
+    + [▶ The chicken-egg problem *](#-the-chicken-egg-problem-)
+    + [▶ Subclass relationships](#-subclass-relationships)
+    + [▶ All-true-ation *](#-all-true-ation-)
     + [▶ The surprising comma](#-the-surprising-comma)
     + [▶ Strings and the backslashes](#-strings-and-the-backslashes)
     + [▶ not knot!](#-not-knot)
     + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)
-    + [▶ 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)
-    + [▶ Non-reflexive class method](#-non-reflexive-class-method)
+    + [▶ Non-reflexive class method *](#-non-reflexive-class-method-)
     + [▶ yielding None](#-yielding-none)
-    + [▶ Nan-reflexivity](#-nan-reflexivity)
+    + [▶ 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)
-    + [▶ Yielding from... return!](#-yielding-from-return)
-    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)
-    + [▶ 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: Appearances are deceptive!](#section-appearances-are-deceptive)
-    + [▶ Skipping lines?](#-skipping-lines)
-    + [▶ Teleportation](#-teleportation)
-    + [▶ Well, something is fishy...](#-well-something-is-fishy)
   * [Section: Slippery Slopes](#section-slippery-slopes)
     + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)
     + [▶ Stubborn `del` operation](#-stubborn-del-operation)
+    + [▶ The out of scope variable](#-the-out-of-scope-variable)
     + [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)
+    + [▶ Lossy zip of iterators *](#-lossy-zip-of-iterators-)
     + [▶ Loop variables leaking out!](#-loop-variables-leaking-out)
     + [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)
     + [▶ Catching the Exceptions](#-catching-the-exceptions)
     + [▶ Same operands, different story!](#-same-operands-different-story)
-    + [▶ 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)
-    + [▶ Needles in a Haystack](#-needles-in-a-haystack)
-    + [▶ Wild imports](#-wild-imports)
-  * [Section: Read the docs](#section-read-the-docs)
-    + [▶ All sorted?](#-all-sorted)
-    + [▶ All-true-ation](#-all-true-ation)
+    + [▶ 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)
@@ -84,18 +80,22 @@ So, here we go...
     + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)
     + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)
     + [▶ Yes, it exists!](#-yes-it-exists)
-    + [▶ Ellipsis](#-ellipsis)
+    + [▶ Ellipsis *](#-ellipsis-)
     + [▶ Inpinity](#-inpinity)
     + [▶ Let's mangle](#-lets-mangle)
+  * [Section: Appearances are deceptive!](#section-appearances-are-deceptive)
+    + [▶ Skipping lines?](#-skipping-lines)
+    + [▶ Teleportation](#-teleportation)
+    + [▶ Well, something is fishy...](#-well-something-is-fishy)
   * [Section: Miscellaneous](#section-miscellaneous)
     + [▶ `+=` is faster](#--is-faster)
     + [▶ Let's make a giant string!](#-lets-make-a-giant-string)
-    + [▶ Minor Ones](#-minor-ones)
+    + [▶ Minor Ones *](#-minor-ones-)
 - [Contributing](#contributing)
 - [Acknowledgements](#acknowledgements)
-- [🎓 License](#%F0%9F%8E%93-license)
-  * [Surprise your friends too?](#surprise-your-friends-too)
-  * [Need a pdf version?](#need-a-pdf-version)
+- [🎓 License](#-license)
+  * [Surprise your friends as well!](#surprise-your-friends-as-well)
+  * [More content like this?](#more-content-like-this)
 
 <!-- tocstop -->
 
@@ -3508,7 +3508,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 If you like wtfpython, you can use these quick links to share it with your friends,
 
-[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hastags=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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)
+[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&hastags=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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)  
 
 ## More content like this?
 

From f914194a875294cba1791afbbc0e86ed723588b7 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 19:39:49 +0530
Subject: [PATCH 126/146] Add instructions

---
 irrelevant/notebook_generator.py    |    5 +-
 irrelevant/notebook_instructions.md |   26 +
 irrelevant/wtf.ipynb                | 1137 ++++++++++++++-------------
 3 files changed, 599 insertions(+), 569 deletions(-)
 create mode 100644 irrelevant/notebook_instructions.md

diff --git a/irrelevant/notebook_generator.py b/irrelevant/notebook_generator.py
index d9818b3..17551df 100644
--- a/irrelevant/notebook_generator.py
+++ b/irrelevant/notebook_generator.py
@@ -34,7 +34,7 @@ STATEMENT_PREFIXES = ["...", ">>> ", "$ "]
 
 HOSTED_NOTEBOOK_INSTRUCTIONS = """
 
-# Hosted notebook instructions
+## Hosted notebook instructions
 
 This is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, 
 - they either require a version of Python that's not supported in the hosted runtime.
@@ -48,7 +48,7 @@ The expected outputs are already present in collapsed cells following the code c
 # Prints out Python version here.
 ```
 
-That being said, most of tbe 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!
+That 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!
 
 ---
 """
@@ -350,4 +350,5 @@ with open(fpath, 'r+', encoding="utf-8") as f:
     except StopIteration as e:
         #pprint.pprint(result, indent=2)
         pre_stuff.append(HOSTED_NOTEBOOK_INSTRUCTIONS)
+        result.sort(key = lambda x: x["read_only"])
         convert_to_notebook(pre_stuff, result, post_stuff)
diff --git a/irrelevant/notebook_instructions.md b/irrelevant/notebook_instructions.md
new file mode 100644
index 0000000..891698a
--- /dev/null
+++ b/irrelevant/notebook_instructions.md
@@ -0,0 +1,26 @@
+## Generating the notebook
+
+- Expand the relative links in README.md to absolute ones
+- Remove the TOC in README.md (because Google colab generates its own anyway)
+- Reorder the examples, so that the ones that work are upfront.
+- Run the `notebook_generator.py`, it will generate a notebook named `wtf.ipynb`
+- Revert the README.md changes (optional)
+
+
+# Hosted notebook instructions
+
+This is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, 
+- they either require a version of Python that's not supported in the hosted runtime.
+- or they can't be reproduced in the notebook envrinonment.
+
+The 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
+
+```py
+>>> import sys
+>>> sys.version
+# Prints out Python version here.
+```
+
+That being said, most of tbe 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!
+
+
diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb
index 64e315b..0464b36 100644
--- a/irrelevant/wtf.ipynb
+++ b/irrelevant/wtf.ipynb
@@ -162,7 +162,7 @@
     "\n",
     "\n",
     "\n",
-    "# Hosted notebook instructions\n",
+    "## Hosted notebook instructions\n",
     "\n",
     "This 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",
@@ -176,306 +176,11 @@
     "# Prints out Python version here.\n",
     "```\n",
     "\n",
-    "That being said, most of tbe 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",
+    "That 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": [
-    "### ▶ 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 \"<stdin>\", 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",
-    ">>> 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",
-    ">>> a\n",
-    "```\n",
-    "```py\n",
-    "6\n",
-    "\n",
-    "```\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "```py\n",
-    ">>> a, b = 6, 9 # Typcial 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 \"<stdin>\", 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": [
-    "#### 💡 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": {},
@@ -1850,9 +1555,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -6926,110 +6629,6 @@
     "\n"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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": [
-    "#### 💡 Explanation:\n",
-    "+ `del x` doesn’t directly call `x.__del__()`.\n",
-    "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero.\n",
-    "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n",
-    "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n",
-    "\n"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -9750,162 +9349,6 @@
     "\n"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ 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 \"<stdin>\", line 1, in <module>\n",
-    "NameError: name '_another_weird_name_func' is not defined\n",
-    "```\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore get imported. This may lead to errors during runtime.\n",
-    "- 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 \"<stdin>\", line 1, in <module>\n",
-    "    NameError: name 'some_weird_name_func_' is not defined\n",
-    "```\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -12156,15 +11599,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "339 µs ± 28.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
-     ]
+     "data": {
+      "text/plain": [
+       "  388 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -12358,6 +11806,561 @@
     "\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ 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 \"<stdin>\", 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",
+    ">>> 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",
+    ">>> a\n",
+    "```\n",
+    "```py\n",
+    "6\n",
+    "\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```py\n",
+    ">>> a, b = 6, 9 # Typcial 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 \"<stdin>\", 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": [
+    "#### 💡 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": [
+    "### ▶ 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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": [
+    "#### 💡 Explanation:\n",
+    "+ `del x` doesn’t directly call `x.__del__()`.\n",
+    "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero.\n",
+    "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n",
+    "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ▶ 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 \"<stdin>\", line 1, in <module>\n",
+    "NameError: name '_another_weird_name_func' is not defined\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 💡 Explanation:\n",
+    "\n",
+    "- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore get imported. This may lead to errors during runtime.\n",
+    "- 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 \"<stdin>\", line 1, in <module>\n",
+    "    NameError: name 'some_weird_name_func_' is not defined\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

From 483496d97a2a0be106342efa8c20bdb58d4c1923 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 20:00:21 +0530
Subject: [PATCH 127/146] Aesthetical changes

---
 README.md | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 57a26e9..fb48b8e 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
 <p align="center"><img src="/images/logo.png" alt=""></p>
-<h1 align="center">What the f*ck Python! 🐍</h1>
-<p align="center">An interesting collection of surprising snippets and lesser-known Python features.</p>
+<h1 align="center">What the f*ck Python! 😱</h1>
+<p align="center">Exploring and understanding Python through surprising snippets.</p>
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
 
 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 is a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python.
+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!
 
@@ -3137,6 +3137,7 @@ The built-in `ord()` function returns a character's Unicode [code point](https:/
 <!-- Example ID: edafe923-0c20-4315-b6e1-0c31abfc38f5 --->
 
 ```py
+# `pip install nump` first.
 import numpy as np
 
 def energy_send(x):
@@ -3384,7 +3385,7 @@ Let's increase the number of iterations by a factor of 10.
      46
      ```
 
-     **💡 Explanation:**  The `@` operator was added in Python 3.5 keeping sthe cientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
+     **💡 Explanation:** The `@` operator was added in Python 3.5 keeping sthe cientific 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
@@ -3397,15 +3398,15 @@ Let's increase the number of iterations by a factor of 10.
      
      ```py
      import dis
-     exec("""
-     def f():
-         """ + """
-    """.join(["X" + str(x) + "=" + str(x) for x in range(65539)]))
-     
-f()
-     
-     print(dis.dis(f))
-```
+    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/2/library/multiprocessing.html) module.
 
@@ -3468,7 +3469,7 @@ f()
 
 # Contributing
 
-A few ways that you can contribute to wtfpython,
+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))

From 2fb14be424e9bd63a3f89a3913df7d7c04148b81 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 20:06:48 +0530
Subject: [PATCH 128/146] Update the  notebook

---
 irrelevant/wtf.ipynb | 12431 +----------------------------------------
 1 file changed, 1 insertion(+), 12430 deletions(-)

diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb
index 0464b36..cd824f4 100644
--- a/irrelevant/wtf.ipynb
+++ b/irrelevant/wtf.ipynb
@@ -1,12430 +1 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<p align=\"center\"><img src=\"/images/logo.png\" alt=\"\"></p>\n",
-    "<h1 align=\"center\">What the f*ck Python! 🐍</h1>\n",
-    "<p align=\"center\">An interesting collection of surprising snippets and lesser-known Python features.</p>\n",
-    "\n",
-    "Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n",
-    "\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 is 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/).\n",
-    "\n",
-    "So, here we go...\n",
-    "\n",
-    "# Table of Contents\n",
-    "\n",
-    "<!-- Generated using \"markdown-toc -i README.md --maxdepth 3\"-->\n",
-    "<!-- toc -->\n",
-    "\n",
-    "- [Structure of the Examples](#structure-of-the-examples)\n",
-    "    + [▶ Some fancy Title](#-some-fancy-title)\n",
-    "- [Usage](#usage)\n",
-    "- [👀 Examples](#-examples)\n",
-    "  * [Section: Strain your brain!](#section-strain-your-brain)\n",
-    "    + [▶ First things first!](#-first-things-first)\n",
-    "    + [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes)\n",
-    "    + [▶ Splitsies](#-splitsies)\n",
-    "    + [▶ Hash brownies](#-hash-brownies)\n",
-    "    + [▶ Disorder within order](#-disorder-within-order)\n",
-    "    + [▶ Keep trying...](#-keep-trying)\n",
-    "    + [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same)\n",
-    "    + [▶ For what?](#-for-what)\n",
-    "    + [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy)\n",
-    "    + [▶ How not to use `is` operator](#-how-not-to-use-is-operator)\n",
-    "    + [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt)\n",
-    "    + [▶ The sticky output function](#-the-sticky-output-function)\n",
-    "    + [▶ The chicken-egg problem](#-the-chicken-egg-problem)\n",
-    "    + [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-)\n",
-    "    + [▶ The surprising comma](#-the-surprising-comma)\n",
-    "    + [▶ Strings and the backslashes](#-strings-and-the-backslashes)\n",
-    "    + [▶ not knot!](#-not-knot)\n",
-    "    + [▶ Half triple-quoted strings](#-half-triple-quoted-strings)\n",
-    "    + [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist)\n",
-    "    + [▶ What's wrong with booleans?](#-whats-wrong-with-booleans)\n",
-    "    + [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes)\n",
-    "    + [▶ Non-reflexive class method](#-non-reflexive-class-method)\n",
-    "    + [▶ yielding None](#-yielding-none)\n",
-    "    + [▶ Nan-reflexivity](#-nan-reflexivity)\n",
-    "    + [▶ Mutating the immutable!](#-mutating-the-immutable)\n",
-    "    + [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope)\n",
-    "    + [▶ Yielding from... return!](#-yielding-from-return)\n",
-    "    + [▶ Lossy zip of iterators](#-lossy-zip-of-iterators)\n",
-    "    + [▶ Subclass relationships](#-subclass-relationships)\n",
-    "    + [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion)\n",
-    "    + [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this)\n",
-    "  * [Section: Appearances are deceptive!](#section-appearances-are-deceptive)\n",
-    "    + [▶ Skipping lines?](#-skipping-lines)\n",
-    "    + [▶ Teleportation](#-teleportation)\n",
-    "    + [▶ Well, something is fishy...](#-well-something-is-fishy)\n",
-    "  * [Section: Slippery Slopes](#section-slippery-slopes)\n",
-    "    + [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it)\n",
-    "    + [▶ Stubborn `del` operation](#-stubborn-del-operation)\n",
-    "    + [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating)\n",
-    "    + [▶ Loop variables leaking out!](#-loop-variables-leaking-out)\n",
-    "    + [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments)\n",
-    "    + [▶ Catching the Exceptions](#-catching-the-exceptions)\n",
-    "    + [▶ Same operands, different story!](#-same-operands-different-story)\n",
-    "    + [▶ The out of scope variable](#-the-out-of-scope-variable)\n",
-    "    + [▶ Be careful with chained operations](#-be-careful-with-chained-operations)\n",
-    "    + [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope)\n",
-    "    + [▶ Needles in a Haystack](#-needles-in-a-haystack)\n",
-    "    + [▶ Wild imports](#-wild-imports)\n",
-    "  * [Section: Read the docs](#section-read-the-docs)\n",
-    "    + [▶ All sorted?](#-all-sorted)\n",
-    "    + [▶ All-true-ation](#-all-true-ation)\n",
-    "  * [Section: The Hidden treasures!](#section-the-hidden-treasures)\n",
-    "    + [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly)\n",
-    "    + [▶ `goto`, but why?](#-goto-but-why)\n",
-    "    + [▶ Brace yourself!](#-brace-yourself)\n",
-    "    + [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life)\n",
-    "    + [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated)\n",
-    "    + [▶ Yes, it exists!](#-yes-it-exists)\n",
-    "    + [▶ Ellipsis](#-ellipsis)\n",
-    "    + [▶ Inpinity](#-inpinity)\n",
-    "    + [▶ Let's mangle](#-lets-mangle)\n",
-    "  * [Section: Miscellaneous](#section-miscellaneous)\n",
-    "    + [▶ `+=` is faster](#--is-faster)\n",
-    "    + [▶ Let's make a giant string!](#-lets-make-a-giant-string)\n",
-    "    + [▶ Minor Ones](#-minor-ones)\n",
-    "- [Contributing](#contributing)\n",
-    "- [Acknowledgements](#acknowledgements)\n",
-    "- [🎓 License](#%F0%9F%8E%93-license)\n",
-    "  * [Surprise your friends too?](#surprise-your-friends-too)\n",
-    "  * [Need a pdf version?](#need-a-pdf-version)\n",
-    "\n",
-    "<!-- tocstop -->\n",
-    "\n",
-    "# Structure of the Examples\n",
-    "\n",
-    "All the examples are structured like below:\n",
-    "\n",
-    "> ### ▶ 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",
-    "> #### 💡 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)).\n",
-    "    - If yes, give a gentle pat on your back, and you may skip to the next example.\n",
-    "\n",
-    "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n",
-    "```sh\n",
-    "$ pip install wtfpython -U\n",
-    "$ wtfpython\n",
-    "```\n",
-    "---\n",
-    "\n",
-    "# 👀 Examples\n",
-    "\n",
-    "\n",
-    "\n",
-    "## Hosted notebook instructions\n",
-    "\n",
-    "This 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",
-    "\n",
-    "The 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",
-    "\n",
-    "That 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": [
-    "### ▶ Strings can be tricky sometimes\n",
-    "1\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "140420665652016\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = \"some_string\"\n",
-    "id(a)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "140420665652016\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "Makes sense, right?\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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",
-    "  ![image](/images/string-intern/string_intern.png)\n",
-    "+ When `a` and `b` are set to `\"wtf!\"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't \"know\" that there's already `wtf!` as an object (because `\"wtf!\"` is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).\n",
-    "+ A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. `a, b = \"wtf!\", \"wtf!\"` is single statement, whereas `a = \"wtf!\"; b = \"wtf!\"` are two statements in a single line. This explains why the identities are different in `a = \"wtf!\"; b = \"wtf!\"`, and also explain why they are same when invoked in `some_file.py`\n",
-    "+ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a  few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.\n",
-    "+ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Hash brownies\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_dict[5.5]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "\"Python\"\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_dict[5] \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "complex\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 Explanation\n",
-    "\n",
-    "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n",
-    "* Immutable objects with the same value always have the same hash in Python.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  5 == 5.0 == 5 + 0j\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  hash(5) == hash(5.0) == hash(5 + 0j)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "  **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n",
-    "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n",
-    "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Deep down, we're all the same.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "WTF() is WTF() # identities are also different\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(WTF()) == id(WTF())\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Disorder within order *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dictionary == ordered_dict # If a == b\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ordered_dict == another_ordered_dict # the why isn't c == a ??\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Traceback (most recent call last):\n",
-       "  File \"<stdin>\", line 1, in <module>\n",
-       "TypeError: unhashable type: 'dict'\n",
-       "\n",
-       "# Makes sense since dict don't have __hash__ implemented, let's use\n",
-       "# our wrapper classes.\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len({dictionary, ordered_dict, another_ordered_dict})\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n",
-    "  \n",
-    "    > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n",
-    "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n",
-    "- Okay, so why did changing the order affect the lenght 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    another_ordered_dict in some_set\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    1\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    dictionary in another_set\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    2\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Keep trying... *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 ocurred\", 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_func()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Finally!\n",
-       "Finally!\n",
-       "Finally!\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_func()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Traceback (most recent call last):\n",
-       "  File \"<stdin>\", line 1, in <module>\n",
-       "ZeroDivisionError: division by zero\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "1 / 0\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Iteration 0\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "one_more_func()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "- 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.\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": [
-    "### ▶ For what?\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{0: 'w', 1: 't', 2: 'f'}\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_dict # An indexed dict appears.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "####  💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-    "  **💡 Explanation:**\n",
-    "\n",
-    "  - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).\n",
-    "\n",
-    "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Evaluation time discrepancy\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "array = [1, 8, 15]\n",
-    "# A typical generator expresion\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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1, 2, 3, 4]\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(list(gen_1))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": [
-    "#### 💡 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": [
-    "### ▶ 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = []\n",
-    "b = []\n",
-    "a is b\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a, b = 257, 257\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(256)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "10922528\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(b)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "140084850247312\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(257)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "140084850247440\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a, b = 257, 257\n",
-    "id(a)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "140640774013296\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(b)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "140640774013392\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ `is not ...` is not `is (not ...)`\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'something' is not None\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'something' is (not None)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "board\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['', '', '']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "board[0]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "''\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "board[0][0]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[['X', '', ''], ['X', '', ''], ['X', '', '']]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "When we initialize `row` variable, this visualization explains what happens in the memory\n",
-    "\n",
-    "![image](/images/tic-tac-toe/after_row_initialized.png)\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",
-    "![image](/images/tic-tac-toe/after_board_initialized.png)\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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ The sticky output function\n",
-    "1\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[0, 1, 2, 3, 4, 5, 6]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "results\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[6, 6, 6, 6, 6, 6, 6]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "funcs_results\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n",
-    "\n",
-    "2\\.\n",
-    "\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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 Explanation\n",
-    "\n",
-    "- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.\n",
-    "\n",
-    "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    [0, 1, 2, 3, 4, 5, 6]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    funcs_results = [func() for func in funcs]\n",
-    "    funcs_results\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ The chicken-egg problem *\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "isinstance(3, int)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "isinstance(type, object)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "class A: pass\n",
-    "isinstance(A, A)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "isinstance(type, type)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "issubclass(int, object)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "issubclass(type, object)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "issubclass(object, type)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": [
-    "### ▶ Subclass relationships\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "issubclass(object, Hashable)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ All-true-ation *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all([True, True, True])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all([True, True, False])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all([])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all([[]])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all([[[]]])\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "Why's this True-False alteration?\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": [
-    "### ▶ The surprising comma\n",
-    "**Output (< 3.6):**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  File \"<stdin>\", line 1\n",
-       "    def h(x, **kwargs,):\n",
-       "                     ^\n",
-       "SyntaxError: invalid syntax\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 \"<stdin>\", line 1\n",
-       "    def h(*args,):\n",
-       "                ^\n",
-       "SyntaxError: invalid syntax\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "def h(*args,):\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": [
-    "### ▶ Strings and the backslashes\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\"\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"\\\"\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\\\"\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(r\"\\\"\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "File \"<stdin>\", 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "r'\\'' == \"\\\\'\"\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    r'wt\\\"f' == 'wt\\\\\"f'\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    'wt\\\\\"f'\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    print(repr(r'wt\\\"f')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    print(\"\\n\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    '\\\\\\\\n'\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ not knot!\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "not x == y\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  File \"<input>\", line 1\n",
-       "    x == not y\n",
-       "           ^\n",
-       "SyntaxError: invalid syntax\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x == not y\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.\n",
-    "* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.\n",
-    "* 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.\n",
-    "* 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`.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Half triple-quoted strings\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "wtfpython\n"
-     ]
-    }
-   ],
-   "source": [
-    "print('wtfpython''')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "wtfpython\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"wtfpython\"\"\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  File \"<input>\", line 3\n",
-       "    print(\"\"\"wtfpython\")\n",
-       "                        ^\n",
-       "SyntaxError: EOF while scanning triple-quoted string literal\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# The following statements raise `SyntaxError`\n",
-    "# print('''wtfpython')\n",
-    "# print(\"\"\"wtfpython\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n",
-    "  ```\n",
-    "  >>> print(\"wtf\" \"python\")\n",
-    "  wtfpython\n",
-    "  >>> print(\"wtf\" \"\") # or \"wtf\"\"\"\n",
-    "  wtf\n",
-    "  ```\n",
-    "+ `'''` and `\"\"\"` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ What's wrong with booleans?\n",
-    "1\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# A simple example to count the number of booleans and\n",
-    "# integers in an iterable of mixed data types.\n",
-    "mixed_list = [False, 1.0, \"some_string\", 3, True, [], False]\n",
-    "integers_found_so_far = 0\n",
-    "booleans_found_so_far = 0\n",
-    "\n",
-    "for item in mixed_list:\n",
-    "    if isinstance(item, int):\n",
-    "        integers_found_so_far += 1\n",
-    "    elif isinstance(item, bool):\n",
-    "        booleans_found_so_far += 1\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "4\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "integers_found_so_far\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "booleans_found_so_far\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n",
-    "2\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'wtf'\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_bool = True\n",
-    "\"wtf\" * some_bool\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "''\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_bool = False\n",
-    "\"wtf\" * some_bool\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "3\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "def tell_truth():\n",
-    "    True = False\n",
-    "    if True == False:\n",
-    "        print(\"I have lost faith in truth!\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output (< 3.x):**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "I have lost faith in truth!\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tell_truth()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "* `bool` is a subclass of `int` in Python\n",
-    "    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    issubclass(bool, int)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    issubclass(int, bool)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "    \n",
-    "* And thus, `True` and `False` are instances of `int`\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  isinstance(True, int)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  isinstance(False, int)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "* The integer value of `True` is `1` and that of `False` is `0`.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  1\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  int(True)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  0\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  int(False)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.\n",
-    "\n",
-    "* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true).  `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them\n",
-    "\n",
-    "* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Class attributes and instance attributes\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "class A:\n",
-    "    x = 1\n",
-    "\n",
-    "class B(A):\n",
-    "    pass\n",
-    "\n",
-    "class C(A):\n",
-    "    pass\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(1, 1, 1)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "A.x, B.x, C.x\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(1, 2, 1)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "B.x = 2\n",
-    "A.x, B.x, C.x\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(3, 2, 3)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "A.x = 3\n",
-    "A.x, B.x, C.x # C.x changed, but B.x didn't\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(3, 3)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = A()\n",
-    "a.x, A.x\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(4, 3)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a.x += 1\n",
-    "a.x, A.x\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "2\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "class SomeClass:\n",
-    "    some_var = 15\n",
-    "    some_list = [5]\n",
-    "    another_list = [5]\n",
-    "    def __init__(self, x):\n",
-    "        self.some_var = x + 1\n",
-    "        self.some_list = self.some_list + [x]\n",
-    "        self.another_list += [x]\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[5, 420]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_obj = SomeClass(420)\n",
-    "some_obj.some_list\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[5, 420]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_obj.another_list\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[5, 111]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_obj = SomeClass(111)\n",
-    "another_obj.some_list\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[5, 420, 111]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_obj.another_list\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_obj.another_list is SomeClass.another_list\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_obj.another_list is some_obj.another_list\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.\n",
-    "* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Non-reflexive class method *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "class SomeClass:\n",
-    "        def instance_method(self):\n",
-    "                pass\n",
-    "        \n",
-    "        @classmethod\n",
-    "        def class_method(cls):\n",
-    "                pass\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SomeClass.instance_method is SomeClass.instance_method\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SomeClass.class_method is SomeClass.class_method\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "id(SomeClass.class_method) == id(SomeClass.class_method)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  <function __main__.SomeClass.instance_method(self)>\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  SomeClass.instance_method\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  <bound method SomeClass.class_method of <class '__main__.SomeClass'>\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  SomeClass.class_method\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "  A new bound method every time `SomeClass.class_method` is accessed.\n",
-    "\n",
-    "-  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ yielding None\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_iterable = ('a', 'b')\n",
-    "\n",
-    "def some_func(val):\n",
-    "    return \"something\"\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output (<= 3.7.x):**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['a', 'b']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "[x for x in some_iterable]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<generator object <listcomp> at 0x7f70b0a4ad58>\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list(some_func((yield x)) for x in some_iterable)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "- This is a bug in CPython's handling of `yield` in generators and comprehensions.\n",
-    "- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions\n",
-    "- Related bug report: http://bugs.python.org/issue10544\n",
-    "- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Yielding from... return! *\n",
-    "1\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  some_string\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Nan-reflexivity *\n",
-    "1\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "nan\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "b\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-inf\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "float('some_other_string')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a == -c # inf==inf\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "None == None # None == None\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "b == d # but nan!=nan\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.0\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "50 / a\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "nan\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a / a\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "nan\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "y == y # equality fails of y\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_tuple\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "But I thought tuples were immutable...\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "* Quoting from https://docs.python.org/2/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",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ The disappearing variable from outer scope\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    e\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    # Nothing is printed!\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    print e\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ The mysterious key type conversion\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "type(list(some_dict.keys())[0])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'s': 40}\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "type(list(some_dict.keys())[0])\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Let's see if you can guess this?\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form\n",
-    "  ```\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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  some_list[0]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  some_list is some_list[0]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  a[b][0] is a\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Modifying a dictionary while iterating over it\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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.8 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ The out of scope variable\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "another_func()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`,  but it has not been initialized previously in the same scope, which throws an error.\n",
-    "* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n",
-    "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  another_func()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Deleting a list item while iterating\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list_1\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[2, 4]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list_2\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list_3\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[2, 4]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n",
-    "- 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Loop variables leaking out!\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(x)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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’s 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": [
-    "### ▶ Beware of default mutable arguments!\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_func()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['some_string', 'some_string']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_func()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['some_string']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_func([])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['some_string', 'some_string', 'some_string']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_func()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    def some_func(default_arg=None):\n",
-    "        if not default_arg:\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": [
-    "### ▶ Catching the Exceptions\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  File \"<input>\", line 3\n",
-    "    except IndexError, ValueError:\n",
-    "                     ^\n",
-    "SyntaxError: invalid syntax\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation\n",
-    "\n",
-    "* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  some_list = [1, 2, 3]\n",
-    "  try:\n",
-    "     # This should raise a ``ValueError``\n",
-    "     some_list.remove(4)\n",
-    "  except (IndexError, ValueError), e:\n",
-    "     print(\"Caught again!\")\n",
-    "     print(e)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "  **Output (Python 2.x):**\n",
-    "  ```\n",
-    "  Caught again!\n",
-    "  list.remove(x): x not in list\n",
-    "  ```\n",
-    "  **Output (Python 3.x):**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    File \"<input>\", line 4\n",
-    "      except (IndexError, ValueError), e:\n",
-    "                                       ^\n",
-    "  IndentationError: unindent does not match any outer indentation level\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  some_list = [1, 2, 3]\n",
-    "  try:\n",
-    "      some_list.remove(4)\n",
-    "\n",
-    "  except (IndexError, ValueError) as e:\n",
-    "      print(\"Caught again!\")\n",
-    "      print(e)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "  **Output:**\n",
-    "  ```\n",
-    "  Caught again!\n",
-    "  list.remove(x): x not in list\n",
-    "  ```\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Same operands, different story!\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = [1, 2, 3, 4]\n",
-    "b = a\n",
-    "a = a + [5, 6, 7, 8]\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, 5, 6, 7, 8]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[1, 2, 3, 4]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "b\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "2\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = [1, 2, 3, 4]\n",
-    "b = a\n",
-    "a += [5, 6, 7, 8]\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, 5, 6, 7, 8]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[1, 2, 3, 4, 5, 6, 7, 8]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "b\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "*  `a += b` doesn't always behave the same way as `a = a + b`.  Classes *may* implement the *`op=`* operators differently, and lists do this.\n",
-    "\n",
-    "* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.\n",
-    "\n",
-    "* The expression `a += [5,6,7,8]` is actually mapped to an \"extend\" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Be careful with chained operations\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(False == False) in [False] # makes sense\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "False == (False in [False]) # makes sense\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "False == False in [False] # now what?\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "True is False == False\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "False is False is False\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "1 > 0 < 1\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(1 > 0) < 1\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "1 > (0 < 1)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "As per https://docs.python.org/2/reference/expressions.html#not-in\n",
-    "\n",
-    "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n",
-    "\n",
-    "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n",
-    "\n",
-    "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n",
-    "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n",
-    "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n",
-    "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  1\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  int(True)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  2\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Name resolution ignoring class scope\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x = 5\n",
-    "class SomeClass:\n",
-    "    x = 17\n",
-    "    y = (x for i in range(10))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "5\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list(SomeClass.y)[0]\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "2\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x = 5\n",
-    "class SomeClass:\n",
-    "    x = 17\n",
-    "    y = [x for i in range(10)]\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": [
-       "17\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SomeClass.y[0]\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": [
-       "5\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SomeClass.y[0]\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation\n",
-    "- Scopes nested inside class definition ignore names bound at the class level.\n",
-    "- A generator expression has its own scope.\n",
-    "- Starting from Python 3.X, list comprehensions also have their own scope.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Needles in a Haystack *\n",
-    "I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,\n",
-    "\n",
-    "1\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x, y = (0, 1) if True else None, None\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), None)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "x, y  # expected (0, 1)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "2\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": []
-    }
-   ],
-   "source": [
-    "t = ('one', 'two')\n",
-    "for i in t:\n",
-    "    print(i)\n",
-    "\n",
-    "t = ('one')\n",
-    "for i in t:\n",
-    "    print(i)\n",
-    "\n",
-    "t = ()\n",
-    "print(t)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "one\n",
-    "two\n",
-    "o\n",
-    "n\n",
-    "e\n",
-    "tuple()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "3\\.\n",
-    "\n",
-    "```\n",
-    "ten_words_list = [\n",
-    "    \"some\",\n",
-    "    \"very\",\n",
-    "    \"big\",\n",
-    "    \"list\",\n",
-    "    \"that\"\n",
-    "    \"consists\",\n",
-    "    \"of\",\n",
-    "    \"exactly\",\n",
-    "    \"ten\",\n",
-    "    \"words\"\n",
-    "]\n",
-    "```\n",
-    "\n",
-    "**Output**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "9\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(ten_words_list)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "4\\. Not asserting strongly enough\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "a = \"python\"\n",
-    "b = \"javascript\"\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "# No AssertionError is raised\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An assert statement with an assertion failure message.\n",
-    "assert(a == b, \"Both languages are different\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "5\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_list = [1, 2, 3]\n",
-    "some_dict = {\n",
-    "  \"key_1\": 1,\n",
-    "  \"key_2\": 2,\n",
-    "  \"key_3\": 3\n",
-    "}\n",
-    "\n",
-    "some_list = some_list.append(4) \n",
-    "some_dict = some_dict.update({\"key_4\": 4})\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(some_list)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "None\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(some_dict)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "6\\.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "def some_recursive_func(a):\n",
-    "    if a[0] == 0:\n",
-    "        return \n",
-    "    a[0] -= 1\n",
-    "    some_recursive_func(a)\n",
-    "    return a\n",
-    "\n",
-    "def similar_recursive_func(a):\n",
-    "        if a == 0:\n",
-    "                return a\n",
-    "        a -= 1\n",
-    "        similar_recursive_func(a)\n",
-    "        return a\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[0, 0]\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_recursive_func([5, 0])\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "4\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "similar_recursive_func(5)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.\n",
-    "\n",
-    "* 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.\n",
-    "\n",
-    "* `()` is a special token and denotes empty `tuple`.\n",
-    "\n",
-    "* In 3, as you might have already figured out, there's a missing comma after 5th element (`\"that\"`) in the list. So by implicit string literal concatenation,\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  ten_words_list\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  Traceback (most recent call last):\n",
-       "      File \"<stdin>\", line 1, in <module>\n",
-       "  AssertionError\n",
-       "  \n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "  a = \"python\"\n",
-    "  b = \"javascript\"\n",
-    "  assert a == b\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "  <stdin>:1: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n",
-       "  \n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 \"<stdin>\", line 1, in <module>\n",
-       "  AssertionError: Values aren not equal\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n",
-    "\n",
-    "* Last one should be fairly obvious, passing mutable object (like  `list` ) results in a call by reference, whereas an immutable object (like `int`)  results in a call by value.\n",
-    "\n",
-    "* Being aware of these nitpicks can save you hours of debugging effort in the long run. \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Splitsies *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['a']\n",
-       "\n",
-       "# is same as\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'a'.split()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['a']\n",
-       "\n",
-       "# but\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(''.split())\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(''.split(' '))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)\n",
-    "    >  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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    ' a '.split(' ')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    ['a']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    ' a '.split()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "    ['']\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    ''.split(' ')\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ All sorted? *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sorted(x) == sorted(x)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "y = reversed(x)\n",
-    "sorted(y) == sorted(y)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Midnight time doesn't exist?\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 Explanation:\n",
-    "+ `antigravity` module is one of the few easter eggs released by Python developers.\n",
-    "+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python.\n",
-    "+ 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": [
-    "### ▶ `goto`, but why?\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "\"Ruby\" <> \"Python\"\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "There we go.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    from __future__ import barry_as_FLUFL\n",
-    "    print(eval('\"Ruby\" <> \"Python\"'))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Even Python understands that love is complicated\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "love = this\n",
-    "this is love\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "love is True\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "False\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "love is False\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "love is not True or False\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Try block executed successfully...\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": [
-    "### ▶ Ellipsis *\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "some_func()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Traceback (most recent call last):\n",
-       "  File \"<stdin>\", line 1, in <module>\n",
-       "NameError: name 'SomeRandomString' is not defined\n",
-       "\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "SomeRandomString\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Ellipsis\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Ellipsis\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "infinity = float('infinity')\n",
-    "hash(infinity)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-314159\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "hash(float('-inf'))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "- Hash of infinity is 10⁵ x π.\n",
-    "- Interestingly, the hash of `float('-inf')` is \"-10⁵ x π\" in Python 3, whereas \"-10⁵ x e\" in Python 2.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ Let's mangle\n",
-    "1\\.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Yo().__honey\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "True\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Yo().bro\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Traceback (most recent call last):\n",
-       "  File \"<stdin>\", line 1, in <module>\n",
-       "AttributeError: 'Yo' object has no attribute '_Yo__honey__'\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "_A__variable = \"Some value\"\n",
-    "\n",
-    "class A(object):\n",
-    "    def some_func(self):\n",
-    "        return __variable # not initiatlized anywhere yet\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Some value'\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Traceback (most recent call last):\n",
-    "  File \"<stdin>\", line 1, in <module>\n",
-    "AttributeError: 'A' object has no attribute '__variable'\n",
-    "\n",
-    "A().some_func()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 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": [
-    "### ▶ Skipping lines?\n",
-    "**Output:**\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "11\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "value = 11\n",
-    "valuе = 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": [
-    "#### 💡 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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ord('е') # cyrillic 'e' (Ye)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "101\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'е' == 'e'\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "42\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "value = 42 # latin e\n",
-    "valuе = 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": [
-    "### ▶ Teleportation\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ Well, something is fishy...\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "    TabError: inconsistent use of tabs and spaces in indentation\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ `+=` is faster\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.25748300552368164\n",
-       "# using \"+=\", three strings:\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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": [
-    "### ▶ Let's make a giant string!\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 µs ± 4.73 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Executed in ipython shell using %timeit for better readablity 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 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "%timeit -n1000 add_bytes_with_plus(NUM_ITERS)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "61 µs ± 2.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "%timeit -n1000 add_string_with_format(NUM_ITERS)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "117 µs ± 3.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 ± 76.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 ± 134 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 ± 7.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 µs ± 2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "#### 💡 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 — 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 µs ± 22.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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 ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "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": [
-    "### ▶ Minor Ones *\n",
-    "* `join()` is a string operation instead of list operation. (sort of counter-intuitive at first usage)\n",
-    "\n",
-    "  **💡 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",
-    "  **💡 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",
-    "  **💡 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",
-    "     **💡 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",
-    "     **💡 Explanation:**  The `@` operator was added in Python 3.5 keeping sthe cientific 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",
-    "    \"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/2/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 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n",
-    "\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('١٢٣٤٥٦٧٨٩')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n",
-    "\n",
-    "* You can seperate numeric literals with underscores (for better readablity) 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",
-    "**That's all folks!**\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ 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 \"<stdin>\", 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",
-    ">>> 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",
-    ">>> a\n",
-    "```\n",
-    "```py\n",
-    "6\n",
-    "\n",
-    "```\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "```py\n",
-    ">>> a, b = 6, 9 # Typcial 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 \"<stdin>\", 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": [
-    "#### 💡 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": [
-    "### ▶ 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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": [
-    "#### 💡 Explanation:\n",
-    "+ `del x` doesn’t directly call `x.__del__()`.\n",
-    "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x’s reference count reaches zero.\n",
-    "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n",
-    "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ▶ 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 \"<stdin>\", line 1, in <module>\n",
-    "NameError: name '_another_weird_name_func' is not defined\n",
-    "```\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### 💡 Explanation:\n",
-    "\n",
-    "- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore get imported. This may lead to errors during runtime.\n",
-    "- 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 \"<stdin>\", line 1, in <module>\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 that 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",
-    "\n",
-    "# 🎓 License\n",
-    "\n",
-    "[![WTFPL 2.0][license-image]][license-url]\n",
-    "\n",
-    "&copy; [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": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.0+"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
+{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["<p align=\"center\"><img src=\"https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//logo.png\" alt=\"\"></p>\n", "<h1 align=\"center\">What the f*ck Python! \ud83d\ude31</h1>\n", "<p align=\"center\">Exploring and understanding Python through surprising snippets.</p>\n", "\n", "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n", "\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/).\n", "\n", "So, here we go...\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)).\n", "    - If yes, give a gentle pat on your back, and you may skip to the next example.\n", "\n", "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n", "```sh\n", "$ pip install wtfpython -U\n", "$ wtfpython\n", "```\n", "---\n", "\n", "# \ud83d\udc40 Examples\n", "\n", "\n\n## Hosted notebook instructions\n\nThis is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, \n- they either require a version of Python that's not supported in the hosted runtime.\n- or they can't be reproduced in the notebook envrinonment.\n\nThe expected outputs are already present in collapsed cells following the code cells. The Google colab provides Python2 (2.7) and Python3 (3.6, default) runtimes. You can switch among these for Python2 specific examples. For examples specific to other minor versions, you can simply refer to collapsed outputs (it's not possible to control the minor version in hosted notebooks as of now). You can check the active version using\n\n```py\n>>> import sys\n>>> sys.version\n# Prints out Python version here.\n```\n\nThat being said, most of the examples do work as expected. If you face any trouble, feel free to consult the original content on wtfpython and create an issue in the repo. Have fun!\n\n---\n"]}, {"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", "  ![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//string-intern/string_intern.png)\n", "+ When `a` and `b` are set to `\"wtf!\"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't \"know\" that there's already `wtf!` as an object (because `\"wtf!\"` is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).\n", "+ A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. `a, b = \"wtf!\", \"wtf!\"` is single statement, whereas `a = \"wtf!\"; b = \"wtf!\"` are two statements in a single line. This explains why the identities are different in `a = \"wtf!\"; b = \"wtf!\"`, and also explain why they are same when invoked in `some_file.py`\n", "+ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a  few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.\n", "+ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n", "\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", "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n", "* Immutable objects with the same value always have the same hash in Python.\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  5 == 5.0 == 5 + 0j\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  hash(5) == hash(5.0) == hash(5 + 0j)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n", "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n", "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Deep down, we're all the same.\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["class WTF:\n", "  pass\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"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 # the why isn't c == a ??\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["Traceback (most recent call last):\n", "  File \"<stdin>\", line 1, in <module>\n", "TypeError: unhashable type: 'dict'\n", "\n", "# Makes sense since dict don't have __hash__ implemented, let's use\n", "# our wrapper classes.\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["len({dictionary, ordered_dict, another_ordered_dict})\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["1\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["dictionary = DictWithHash()\n", "dictionary[1] = 'a'; dictionary[2] = 'b';\n", "ordered_dict = OrderedDictWithHash()\n", "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n", "another_ordered_dict = OrderedDictWithHash()\n", "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n", "len({dictionary, ordered_dict, another_ordered_dict})\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["2\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "What is going on here?\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n", "  \n", "    > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n", "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n", "- Okay, so why did changing the order affect the lenght 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 ocurred\", 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 \"<stdin>\", line 1, in <module>\n", "ZeroDivisionError: division by zero\n", "\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["1 / 0\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["Iteration 0\n", "\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["one_more_func()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n", "- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.\n", "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 For what?\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_string = \"wtf\"\n", "some_dict = {}\n", "for i, some_dict[i] in enumerate(some_string):\n", "    i = 10\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["{0: 'w', 1: 't', 2: 'f'}\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_dict # An indexed dict appears.\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["####  \ud83d\udca1 Explanation:\n", "\n", "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n", "  ```\n", "  for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n", "  ```\n", "  Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n", "  An interesting example that illustrates this:\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  for i in range(4):\n", "      print(i)\n", "      i = 10\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "  **Output:**\n", "  ```\n", "  0\n", "  1\n", "  2\n", "  3\n", "  ```\n", "\n", "  Did you expect the loop to run just once?\n", "\n", "  **\ud83d\udca1 Explanation:**\n", "\n", "  - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).\n", "\n", "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  i, some_dict[i] = (0, 'w')\n", "  i, some_dict[i] = (1, 't')\n", "  i, some_dict[i] = (2, 'f')\n", "  some_dict\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Evaluation time discrepancy\n", "1\\.\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["array = [1, 8, 15]\n", "# A typical generator expresion\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 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 `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", "\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", "![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//tic-tac-toe/after_row_initialized.png)\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", "![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//tic-tac-toe/after_board_initialized.png)\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 The sticky output function\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": ["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:**\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": ["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": ["Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n", "\n", "2\\.\n", "\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", "\n", "- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.\n", "\n", "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n", "\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"]}, {"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"]}, {"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 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 \"<stdin>\", 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 \"<stdin>\", 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 \"<stdin>\", 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 \"<input>\", line 1\n", "    x == not y\n", "           ^\n", "SyntaxError: invalid syntax\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["x == not y\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.\n", "* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.\n", "* 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.\n", "* 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`.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Half triple-quoted strings\n", "**Output:**\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["wtfpython\n"]}], "source": ["print('wtfpython''')\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["wtfpython\n"]}], "source": ["print(\"wtfpython\"\"\")\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  File \"<input>\", line 3\n", "    print(\"\"\"wtfpython\")\n", "                        ^\n", "SyntaxError: EOF while scanning triple-quoted string literal\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["# The following statements raise `SyntaxError`\n", "# print('''wtfpython')\n", "# print(\"\"\"wtfpython\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n", "  ```\n", "  >>> print(\"wtf\" \"python\")\n", "  wtfpython\n", "  >>> print(\"wtf\" \"\") # or \"wtf\"\"\"\n", "  wtf\n", "  ```\n", "+ `'''` and `\"\"\"` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 What's wrong with booleans?\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 simple example to count the number of booleans and\n", "# integers in an iterable of mixed data types.\n", "mixed_list = [False, 1.0, \"some_string\", 3, True, [], False]\n", "integers_found_so_far = 0\n", "booleans_found_so_far = 0\n", "\n", "for item in mixed_list:\n", "    if isinstance(item, int):\n", "        integers_found_so_far += 1\n", "    elif isinstance(item, bool):\n", "        booleans_found_so_far += 1\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["4\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["integers_found_so_far\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["0\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["booleans_found_so_far\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "\n", "2\\.\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_bool = True\n", "\"wtf\" * some_bool\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_bool = False\n", "\"wtf\" * some_bool\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": ["def tell_truth():\n", "    True = False\n", "    if True == False:\n", "        print(\"I have lost faith in truth!\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output (< 3.x):**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["I have lost faith in truth!\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["tell_truth()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* `bool` is a subclass of `int` in 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": ["    issubclass(bool, int)\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(int, bool)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["    \n", "* And thus, `True` and `False` are instances of `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(True, 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(False, int)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* The integer value of `True` is `1` and that of `False` is `0`.\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": ["  0\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  int(False)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.\n", "\n", "* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true).  `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them\n", "\n", "* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Class attributes and instance attributes\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 A:\n", "    x = 1\n", "\n", "class B(A):\n", "    pass\n", "\n", "class C(A):\n", "    pass\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(1, 1, 1)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["A.x, B.x, C.x\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(1, 2, 1)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["B.x = 2\n", "A.x, B.x, C.x\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(3, 2, 3)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["A.x = 3\n", "A.x, B.x, C.x # C.x changed, but B.x didn't\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(3, 3)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["a = A()\n", "a.x, A.x\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(4, 3)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["a.x += 1\n", "a.x, A.x\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 SomeClass:\n", "    some_var = 15\n", "    some_list = [5]\n", "    another_list = [5]\n", "    def __init__(self, x):\n", "        self.some_var = x + 1\n", "        self.some_list = self.some_list + [x]\n", "        self.another_list += [x]\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 420]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_obj = SomeClass(420)\n", "some_obj.some_list\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 420]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_obj.another_list\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 111]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["another_obj = SomeClass(111)\n", "another_obj.some_list\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 420, 111]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["another_obj.another_list\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_obj.another_list is SomeClass.another_list\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_obj.another_list is some_obj.another_list\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.\n", "* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Non-reflexive class method *\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["class SomeClass:\n", "        def instance_method(self):\n", "                pass\n", "        \n", "        @classmethod\n", "        def class_method(cls):\n", "                pass\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.instance_method is SomeClass.instance_method\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["False\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.class_method is SomeClass.class_method\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["id(SomeClass.class_method) == id(SomeClass.class_method)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  <function __main__.SomeClass.instance_method(self)>\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  SomeClass.instance_method\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  <bound method SomeClass.class_method of <class '__main__.SomeClass'>\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  SomeClass.class_method\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "  A new bound method every time `SomeClass.class_method` is accessed.\n", "\n", "-  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 yielding None\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_iterable = ('a', 'b')\n", "\n", "def some_func(val):\n", "    return \"something\"\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output (<= 3.7.x):**\n", "\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": ["[x for x in some_iterable]\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["<generator object <listcomp> 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: http://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/2/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", "\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/2/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.8 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"]}, {"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", "**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"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["another_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", "* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n", "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n"]}, {"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": ["\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 itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n", "- 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 not default_arg:\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 \"<input>\", line 3\n", "    except IndexError, ValueError:\n", "                     ^\n", "SyntaxError: invalid syntax\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation\n", "\n", "* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,\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 a ``ValueError``\n", "     some_list.remove(4)\n", "  except (IndexError, ValueError), e:\n", "     print(\"Caught again!\")\n", "     print(e)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  **Output (Python 2.x):**\n", "  ```\n", "  Caught again!\n", "  list.remove(x): x not in list\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": ["    File \"<input>\", line 4\n", "      except (IndexError, ValueError), e:\n", "                                       ^\n", "  IndentationError: unindent does not match any outer indentation level\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,\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", "      some_list.remove(4)\n", "\n", "  except (IndexError, ValueError) as e:\n", "      print(\"Caught again!\")\n", "      print(e)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  **Output:**\n", "  ```\n", "  Caught again!\n", "  list.remove(x): x not in list\n", "  ```\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Same operands, different story!\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, 2, 3, 4]\n", "b = a\n", "a = a + [5, 6, 7, 8]\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, 5, 6, 7, 8]\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": ["[1, 2, 3, 4]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["b\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": ["a = [1, 2, 3, 4]\n", "b = a\n", "a += [5, 6, 7, 8]\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, 5, 6, 7, 8]\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": ["[1, 2, 3, 4, 5, 6, 7, 8]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["b\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "*  `a += b` doesn't always behave the same way as `a = a + b`.  Classes *may* implement the *`op=`* operators differently, and lists do this.\n", "\n", "* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.\n", "\n", "* The expression `a += [5,6,7,8]` is actually mapped to an \"extend\" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.\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/2/reference/expressions.html#not-in\n", "\n", "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n", "\n", "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n", "\n", "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n", "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n", "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n", "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  1\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  int(True)\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  2\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  True + 1 #not relevant for this example, but just for fun\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  So, `1 < 1` evaluates to `False`\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Name resolution ignoring class scope\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": ["x = 5\n", "class SomeClass:\n", "    x = 17\n", "    y = (x for i in range(10))\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": ["list(SomeClass.y)[0]\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": ["x = 5\n", "class SomeClass:\n", "    x = 17\n", "    y = [x for i in range(10)]\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": ["17\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.y[0]\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": ["5\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.y[0]\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation\n", "- Scopes nested inside class definition ignore names bound at the class level.\n", "- A generator expression has its own scope.\n", "- Starting from Python 3.X, list comprehensions also have their own scope.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Needles in a Haystack *\n", "I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,\n", "\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": ["x, y = (0, 1) if True else None, None\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), None)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["x, y  # expected (0, 1)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "2\\.\n", "\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": []}], "source": ["t = ('one', 'two')\n", "for i in t:\n", "    print(i)\n", "\n", "t = ('one')\n", "for i in t:\n", "    print(i)\n", "\n", "t = ()\n", "print(t)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["one\n", "two\n", "o\n", "n\n", "e\n", "tuple()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "3\\.\n", "\n", "```\n", "ten_words_list = [\n", "    \"some\",\n", "    \"very\",\n", "    \"big\",\n", "    \"list\",\n", "    \"that\"\n", "    \"consists\",\n", "    \"of\",\n", "    \"exactly\",\n", "    \"ten\",\n", "    \"words\"\n", "]\n", "```\n", "\n", "**Output**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["9\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["len(ten_words_list)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "4\\. Not asserting strongly enough\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 = \"python\"\n", "b = \"javascript\"\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["# No AssertionError is raised\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["# An assert statement with an assertion failure message.\n", "assert(a == b, \"Both languages are different\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "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": ["some_list = [1, 2, 3]\n", "some_dict = {\n", "  \"key_1\": 1,\n", "  \"key_2\": 2,\n", "  \"key_3\": 3\n", "}\n", "\n", "some_list = some_list.append(4) \n", "some_dict = some_dict.update({\"key_4\": 4})\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": ["None\n"]}], "source": ["print(some_list)\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["None\n"]}], "source": ["print(some_dict)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "6\\.\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_recursive_func(a):\n", "    if a[0] == 0:\n", "        return \n", "    a[0] -= 1\n", "    some_recursive_func(a)\n", "    return a\n", "\n", "def similar_recursive_func(a):\n", "        if a == 0:\n", "                return a\n", "        a -= 1\n", "        similar_recursive_func(a)\n", "        return a\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\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": ["some_recursive_func([5, 0])\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["4\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["similar_recursive_func(5)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.\n", "\n", "* 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.\n", "\n", "* `()` is a special token and denotes empty `tuple`.\n", "\n", "* In 3, as you might have already figured out, there's a missing comma after 5th element (`\"that\"`) in the list. So by implicit string literal concatenation,\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  ten_words_list\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  Traceback (most recent call last):\n", "      File \"<stdin>\", line 1, in <module>\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": ["  <stdin>: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 \"<stdin>\", line 1, in <module>\n", "  AssertionError: Values aren 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](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n", "\n", "* Last one should be fairly obvious, passing mutable object (like  `list` ) results in a call by reference, whereas an immutable object (like `int`)  results in a call by value.\n", "\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/2.7/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](http://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 \"<stdin>\", line 1, in <module>\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 \"<stdin>\", line 1, in <module>\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 initiatlized anywhere yet\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\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": ["Traceback (most recent call last):\n", "  File \"<stdin>\", line 1, in <module>\n", "AttributeError: 'A' object has no attribute '__variable'\n", "\n", "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 nump` 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 readablity 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 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 sthe cientific 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", "    \"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/2/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 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n", "\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](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n", "\n", "* You can seperate numeric literals with underscores (for better readablity) 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", "**That's all folks!**\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 \"<stdin>\", 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", ">>> 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", ">>> a\n", "```\n", "```py\n", "6\n", "\n", "```\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["```py\n", ">>> a, b = 6, 9 # Typcial 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 \"<stdin>\", 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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", "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x\u2019s reference count reaches zero.\n", "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n", "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n", "\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 \"<stdin>\", line 1, in <module>\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 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 \"<stdin>\", line 1, in <module>\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", "\n", "# \ud83c\udf93 License\n", "\n", "[![WTFPL 2.0][license-image]][license-url]\n", "\n", "&copy; [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}
\ No newline at end of file

From 734360ff599fdb11f8e22fbe8224e887ac47fadb Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 20:38:18 +0530
Subject: [PATCH 129/146] Add team trees

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index fb48b8e..f54e3a8 100644
--- a/README.md
+++ b/README.md
@@ -3514,3 +3514,4 @@ If you like wtfpython, you can use these quick links to share it with your frien
 ## More content like this?
 
 If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/content-like-wtfpython/).
+PS: On a sidenote, consider [buying me a meal](https://ko-fi.com/satwikkansal) or [planting a tree](https://teamtrees.org/).

From d59db75b4cf5ba6f9f19d8c711785f61f17bb808 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 22:11:55 +0530
Subject: [PATCH 130/146] Add link to other modes

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f54e3a8..de8e03a 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,7 @@
 <p align="center">Exploring and understanding Python through surprising snippets.</p>
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
+Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/3.0/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
 
 Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight.
 
@@ -3514,4 +3515,4 @@ If you like wtfpython, you can use these quick links to share it with your frien
 ## More content like this?
 
 If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/content-like-wtfpython/).
-PS: On a sidenote, consider [buying me a meal](https://ko-fi.com/satwikkansal) or [planting a tree](https://teamtrees.org/).
+*PS: On a sidenote, consider [buying me a meal](https://ko-fi.com/satwikkansal) or [planting a tree](https://teamtrees.org/).*

From 76d98d91385fe3c20ba553106fca496c392cacf6 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Sat, 21 Dec 2019 22:12:56 +0530
Subject: [PATCH 131/146] Fix line break

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index de8e03a..e9923f9 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,7 @@
 <p align="center">Exploring and understanding Python through surprising snippets.</p>
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
+
 Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/3.0/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
 
 Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight.

From f8aa17c8bac8dd486ec416b1759a8c71bbfa9bed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ramiro=20G=C3=B3mez?= <code@ramiro.org>
Date: Sun, 22 Dec 2019 21:11:25 +0100
Subject: [PATCH 132/146] Make hashtags in Twitter link work

Change URL parameter from `hastags` to  `hashtags`.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e9923f9..d821d04 100644
--- a/README.md
+++ b/README.md
@@ -3511,7 +3511,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 
 If you like wtfpython, you can use these quick links to share it with your friends,
 
-[Twitter](https://twitter.com/intent/tweet?url=https://github.com/satwikkansal/wtfpython&text=If%20you%20really%20think%20you%20know%20Python,%20think%20once%20more!%20Check%20out%20wtfpython&hastags=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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)  
+[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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)  
 
 ## More content like this?
 

From e35642ed0506401146a707bc626815a74a8a754f Mon Sep 17 00:00:00 2001
From: Saverio Miroddi <saverio.pub2@gmail.com>
Date: Mon, 23 Dec 2019 10:31:40 +0100
Subject: [PATCH 133/146] Correct some typos

Corrected a handful of typos.
---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index e9923f9..11c575b 100644
--- a/README.md
+++ b/README.md
@@ -198,7 +198,7 @@ SyntaxError: invalid syntax
 >>> a
 6
 
->>> a, b = 6, 9 # Typcial unpacking
+>>> a, b = 6, 9 # Typical unpacking
 >>> a, b
 (6, 9)
 >>> (a, b = 16, 19) # Oops
@@ -666,7 +666,7 @@ for i, some_dict[i] in enumerate(some_string):
 1\.
 ```py
 array = [1, 8, 15]
-# A typical generator expresion
+# A typical generator expression
 gen = (x for x in array if array.count(x) > 0)
 array = [2, 8, 22]
 ```
@@ -3070,7 +3070,7 @@ _A__variable = "Some value"
 
 class A(object):
     def some_func(self):
-        return __variable # not initiatlized anywhere yet
+        return __variable # not initialized anywhere yet
 ```
 
 **Output:**
@@ -3263,7 +3263,7 @@ def convert_list_to_string(l, iters):
 **Output:**
 
 ```py
-# Executed in ipython shell using %timeit for better readablity of results.
+# 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())
 
@@ -3387,7 +3387,7 @@ Let's increase the number of iterations by a factor of 10.
      46
      ```
 
-     **💡 Explanation:** The `@` operator was added in Python 3.5 keeping sthe cientific community in mind. Any object can overload `__matmul__` magic method to define behavior for this operator.
+     **💡 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
@@ -3443,7 +3443,7 @@ Let's increase the number of iterations by a factor of 10.
 
 * `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.
 
-* You can seperate numeric literals with underscores (for better readablity) from Python 3 onwards.
+* You can separate numeric literals with underscores (for better readability) from Python 3 onwards.
 
      ```py
      >>> six_million = 6_000_000

From b3387c9dc7b7c8c912ca0e6ca9a6350471e4f2ac Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 23 Dec 2019 15:58:25 +0530
Subject: [PATCH 134/146] Add indent to the dump for better diff

---
 irrelevant/notebook_generator.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/irrelevant/notebook_generator.py b/irrelevant/notebook_generator.py
index 17551df..d275530 100644
--- a/irrelevant/notebook_generator.py
+++ b/irrelevant/notebook_generator.py
@@ -296,7 +296,7 @@ def convert_to_notebook(pre_examples_content, parsed_json, post_examples_content
 
     #pprint.pprint(result, indent=2)
     with open(notebook_path, "w") as f:
-        json.dump(result, f)
+        json.dump(result, f, indent=2)
 
 
 with open(fpath, 'r+', encoding="utf-8") as f:

From 438f52c3e92322314b3d41d9ae82be1b32014c7a Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 23 Dec 2019 15:58:49 +0530
Subject: [PATCH 135/146] Update notebook with recent changes

---
 irrelevant/wtf.ipynb | 12318 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 12317 insertions(+), 1 deletion(-)

diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb
index cd824f4..12c7bb8 100644
--- a/irrelevant/wtf.ipynb
+++ b/irrelevant/wtf.ipynb
@@ -1 +1,12317 @@
-{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["<p align=\"center\"><img src=\"https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//logo.png\" alt=\"\"></p>\n", "<h1 align=\"center\">What the f*ck Python! \ud83d\ude31</h1>\n", "<p align=\"center\">Exploring and understanding Python through surprising snippets.</p>\n", "\n", "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n", "\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/).\n", "\n", "So, here we go...\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)).\n", "    - If yes, give a gentle pat on your back, and you may skip to the next example.\n", "\n", "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n", "```sh\n", "$ pip install wtfpython -U\n", "$ wtfpython\n", "```\n", "---\n", "\n", "# \ud83d\udc40 Examples\n", "\n", "\n\n## Hosted notebook instructions\n\nThis is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, \n- they either require a version of Python that's not supported in the hosted runtime.\n- or they can't be reproduced in the notebook envrinonment.\n\nThe expected outputs are already present in collapsed cells following the code cells. The Google colab provides Python2 (2.7) and Python3 (3.6, default) runtimes. You can switch among these for Python2 specific examples. For examples specific to other minor versions, you can simply refer to collapsed outputs (it's not possible to control the minor version in hosted notebooks as of now). You can check the active version using\n\n```py\n>>> import sys\n>>> sys.version\n# Prints out Python version here.\n```\n\nThat being said, most of the examples do work as expected. If you face any trouble, feel free to consult the original content on wtfpython and create an issue in the repo. Have fun!\n\n---\n"]}, {"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", "  ![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//string-intern/string_intern.png)\n", "+ When `a` and `b` are set to `\"wtf!\"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't \"know\" that there's already `wtf!` as an object (because `\"wtf!\"` is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).\n", "+ A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. `a, b = \"wtf!\", \"wtf!\"` is single statement, whereas `a = \"wtf!\"; b = \"wtf!\"` are two statements in a single line. This explains why the identities are different in `a = \"wtf!\"; b = \"wtf!\"`, and also explain why they are same when invoked in `some_file.py`\n", "+ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a  few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.\n", "+ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n", "\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", "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n", "* Immutable objects with the same value always have the same hash in Python.\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  5 == 5.0 == 5 + 0j\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  hash(5) == hash(5.0) == hash(5 + 0j)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n", "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n", "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Deep down, we're all the same.\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["class WTF:\n", "  pass\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"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 # the why isn't c == a ??\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["Traceback (most recent call last):\n", "  File \"<stdin>\", line 1, in <module>\n", "TypeError: unhashable type: 'dict'\n", "\n", "# Makes sense since dict don't have __hash__ implemented, let's use\n", "# our wrapper classes.\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["len({dictionary, ordered_dict, another_ordered_dict})\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["1\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["dictionary = DictWithHash()\n", "dictionary[1] = 'a'; dictionary[2] = 'b';\n", "ordered_dict = OrderedDictWithHash()\n", "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n", "another_ordered_dict = OrderedDictWithHash()\n", "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n", "len({dictionary, ordered_dict, another_ordered_dict})\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["2\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "What is going on here?\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n", "  \n", "    > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n", "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n", "- Okay, so why did changing the order affect the lenght 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 ocurred\", 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 \"<stdin>\", line 1, in <module>\n", "ZeroDivisionError: division by zero\n", "\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["1 / 0\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["Iteration 0\n", "\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["one_more_func()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n", "- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.\n", "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 For what?\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_string = \"wtf\"\n", "some_dict = {}\n", "for i, some_dict[i] in enumerate(some_string):\n", "    i = 10\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["{0: 'w', 1: 't', 2: 'f'}\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_dict # An indexed dict appears.\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["####  \ud83d\udca1 Explanation:\n", "\n", "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n", "  ```\n", "  for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n", "  ```\n", "  Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n", "  An interesting example that illustrates this:\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  for i in range(4):\n", "      print(i)\n", "      i = 10\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "  **Output:**\n", "  ```\n", "  0\n", "  1\n", "  2\n", "  3\n", "  ```\n", "\n", "  Did you expect the loop to run just once?\n", "\n", "  **\ud83d\udca1 Explanation:**\n", "\n", "  - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).\n", "\n", "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  i, some_dict[i] = (0, 'w')\n", "  i, some_dict[i] = (1, 't')\n", "  i, some_dict[i] = (2, 'f')\n", "  some_dict\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Evaluation time discrepancy\n", "1\\.\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["array = [1, 8, 15]\n", "# A typical generator expresion\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 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 `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", "\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", "![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//tic-tac-toe/after_row_initialized.png)\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", "![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images//tic-tac-toe/after_board_initialized.png)\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 The sticky output function\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": ["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:**\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": ["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": ["Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n", "\n", "2\\.\n", "\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", "\n", "- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.\n", "\n", "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n", "\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"]}, {"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"]}, {"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 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 \"<stdin>\", 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 \"<stdin>\", 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 \"<stdin>\", 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 \"<input>\", line 1\n", "    x == not y\n", "           ^\n", "SyntaxError: invalid syntax\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["x == not y\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.\n", "* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.\n", "* 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.\n", "* 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`.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Half triple-quoted strings\n", "**Output:**\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["wtfpython\n"]}], "source": ["print('wtfpython''')\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["wtfpython\n"]}], "source": ["print(\"wtfpython\"\"\")\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  File \"<input>\", line 3\n", "    print(\"\"\"wtfpython\")\n", "                        ^\n", "SyntaxError: EOF while scanning triple-quoted string literal\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["# The following statements raise `SyntaxError`\n", "# print('''wtfpython')\n", "# print(\"\"\"wtfpython\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n", "  ```\n", "  >>> print(\"wtf\" \"python\")\n", "  wtfpython\n", "  >>> print(\"wtf\" \"\") # or \"wtf\"\"\"\n", "  wtf\n", "  ```\n", "+ `'''` and `\"\"\"` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 What's wrong with booleans?\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 simple example to count the number of booleans and\n", "# integers in an iterable of mixed data types.\n", "mixed_list = [False, 1.0, \"some_string\", 3, True, [], False]\n", "integers_found_so_far = 0\n", "booleans_found_so_far = 0\n", "\n", "for item in mixed_list:\n", "    if isinstance(item, int):\n", "        integers_found_so_far += 1\n", "    elif isinstance(item, bool):\n", "        booleans_found_so_far += 1\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["4\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["integers_found_so_far\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["0\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["booleans_found_so_far\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "\n", "2\\.\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_bool = True\n", "\"wtf\" * some_bool\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_bool = False\n", "\"wtf\" * some_bool\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": ["def tell_truth():\n", "    True = False\n", "    if True == False:\n", "        print(\"I have lost faith in truth!\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output (< 3.x):**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["I have lost faith in truth!\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["tell_truth()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* `bool` is a subclass of `int` in 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": ["    issubclass(bool, int)\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(int, bool)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["    \n", "* And thus, `True` and `False` are instances of `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(True, 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(False, int)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* The integer value of `True` is `1` and that of `False` is `0`.\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": ["  0\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  int(False)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.\n", "\n", "* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true).  `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them\n", "\n", "* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Class attributes and instance attributes\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 A:\n", "    x = 1\n", "\n", "class B(A):\n", "    pass\n", "\n", "class C(A):\n", "    pass\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(1, 1, 1)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["A.x, B.x, C.x\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(1, 2, 1)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["B.x = 2\n", "A.x, B.x, C.x\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(3, 2, 3)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["A.x = 3\n", "A.x, B.x, C.x # C.x changed, but B.x didn't\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(3, 3)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["a = A()\n", "a.x, A.x\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["(4, 3)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["a.x += 1\n", "a.x, A.x\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 SomeClass:\n", "    some_var = 15\n", "    some_list = [5]\n", "    another_list = [5]\n", "    def __init__(self, x):\n", "        self.some_var = x + 1\n", "        self.some_list = self.some_list + [x]\n", "        self.another_list += [x]\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 420]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_obj = SomeClass(420)\n", "some_obj.some_list\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 420]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_obj.another_list\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 111]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["another_obj = SomeClass(111)\n", "another_obj.some_list\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["[5, 420, 111]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["another_obj.another_list\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_obj.another_list is SomeClass.another_list\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_obj.another_list is some_obj.another_list\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.\n", "* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Non-reflexive class method *\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["class SomeClass:\n", "        def instance_method(self):\n", "                pass\n", "        \n", "        @classmethod\n", "        def class_method(cls):\n", "                pass\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.instance_method is SomeClass.instance_method\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["False\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.class_method is SomeClass.class_method\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["True\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["id(SomeClass.class_method) == id(SomeClass.class_method)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  <function __main__.SomeClass.instance_method(self)>\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  SomeClass.instance_method\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  <bound method SomeClass.class_method of <class '__main__.SomeClass'>\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  SomeClass.class_method\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "  A new bound method every time `SomeClass.class_method` is accessed.\n", "\n", "-  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 yielding None\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["some_iterable = ('a', 'b')\n", "\n", "def some_func(val):\n", "    return \"something\"\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output (<= 3.7.x):**\n", "\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": ["[x for x in some_iterable]\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["<generator object <listcomp> 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: http://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/2/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", "\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/2/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.8 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"]}, {"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", "**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"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["another_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", "* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n", "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n"]}, {"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": ["\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 itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n", "- 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 not default_arg:\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 \"<input>\", line 3\n", "    except IndexError, ValueError:\n", "                     ^\n", "SyntaxError: invalid syntax\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation\n", "\n", "* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,\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 a ``ValueError``\n", "     some_list.remove(4)\n", "  except (IndexError, ValueError), e:\n", "     print(\"Caught again!\")\n", "     print(e)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  **Output (Python 2.x):**\n", "  ```\n", "  Caught again!\n", "  list.remove(x): x not in list\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": ["    File \"<input>\", line 4\n", "      except (IndexError, ValueError), e:\n", "                                       ^\n", "  IndentationError: unindent does not match any outer indentation level\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,\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", "      some_list.remove(4)\n", "\n", "  except (IndexError, ValueError) as e:\n", "      print(\"Caught again!\")\n", "      print(e)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  **Output:**\n", "  ```\n", "  Caught again!\n", "  list.remove(x): x not in list\n", "  ```\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Same operands, different story!\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, 2, 3, 4]\n", "b = a\n", "a = a + [5, 6, 7, 8]\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, 5, 6, 7, 8]\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": ["[1, 2, 3, 4]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["b\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": ["a = [1, 2, 3, 4]\n", "b = a\n", "a += [5, 6, 7, 8]\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, 5, 6, 7, 8]\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": ["[1, 2, 3, 4, 5, 6, 7, 8]\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["b\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "*  `a += b` doesn't always behave the same way as `a = a + b`.  Classes *may* implement the *`op=`* operators differently, and lists do this.\n", "\n", "* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.\n", "\n", "* The expression `a += [5,6,7,8]` is actually mapped to an \"extend\" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.\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/2/reference/expressions.html#not-in\n", "\n", "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n", "\n", "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n", "\n", "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n", "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n", "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n", "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  1\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  int(True)\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  2\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  True + 1 #not relevant for this example, but just for fun\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["  So, `1 < 1` evaluates to `False`\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Name resolution ignoring class scope\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": ["x = 5\n", "class SomeClass:\n", "    x = 17\n", "    y = (x for i in range(10))\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": ["list(SomeClass.y)[0]\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": ["x = 5\n", "class SomeClass:\n", "    x = 17\n", "    y = [x for i in range(10)]\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": ["17\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.y[0]\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": ["5\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["SomeClass.y[0]\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation\n", "- Scopes nested inside class definition ignore names bound at the class level.\n", "- A generator expression has its own scope.\n", "- Starting from Python 3.X, list comprehensions also have their own scope.\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### \u25b6 Needles in a Haystack *\n", "I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,\n", "\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": ["x, y = (0, 1) if True else None, None\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), None)\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["x, y  # expected (0, 1)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "2\\.\n", "\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": []}], "source": ["t = ('one', 'two')\n", "for i in t:\n", "    print(i)\n", "\n", "t = ('one')\n", "for i in t:\n", "    print(i)\n", "\n", "t = ()\n", "print(t)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": []}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["one\n", "two\n", "o\n", "n\n", "e\n", "tuple()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "3\\.\n", "\n", "```\n", "ten_words_list = [\n", "    \"some\",\n", "    \"very\",\n", "    \"big\",\n", "    \"list\",\n", "    \"that\"\n", "    \"consists\",\n", "    \"of\",\n", "    \"exactly\",\n", "    \"ten\",\n", "    \"words\"\n", "]\n", "```\n", "\n", "**Output**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["9\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["len(ten_words_list)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "4\\. Not asserting strongly enough\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 = \"python\"\n", "b = \"javascript\"\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["# No AssertionError is raised\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["# An assert statement with an assertion failure message.\n", "assert(a == b, \"Both languages are different\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "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": ["some_list = [1, 2, 3]\n", "some_dict = {\n", "  \"key_1\": 1,\n", "  \"key_2\": 2,\n", "  \"key_3\": 3\n", "}\n", "\n", "some_list = some_list.append(4) \n", "some_dict = some_dict.update({\"key_4\": 4})\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": ["None\n"]}], "source": ["print(some_list)\n"]}, {"cell_type": "code", "metadata": {"collapsed": true}, "execution_count": null, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["None\n"]}], "source": ["print(some_dict)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "6\\.\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_recursive_func(a):\n", "    if a[0] == 0:\n", "        return \n", "    a[0] -= 1\n", "    some_recursive_func(a)\n", "    return a\n", "\n", "def similar_recursive_func(a):\n", "        if a == 0:\n", "                return a\n", "        a -= 1\n", "        similar_recursive_func(a)\n", "        return a\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\n", "\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": ["some_recursive_func([5, 0])\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["4\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["similar_recursive_func(5)\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["#### \ud83d\udca1 Explanation:\n", "\n", "* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.\n", "\n", "* 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.\n", "\n", "* `()` is a special token and denotes empty `tuple`.\n", "\n", "* In 3, as you might have already figured out, there's a missing comma after 5th element (`\"that\"`) in the list. So by implicit string literal concatenation,\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']\n"]}, "output_type": "execute_result", "metadata": {}, "execution_count": null}], "source": ["  ten_words_list\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,\n", "\n"]}, {"cell_type": "code", "execution_count": null, "metadata": {"collapsed": true}, "outputs": [{"data": {"text/plain": ["  Traceback (most recent call last):\n", "      File \"<stdin>\", line 1, in <module>\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": ["  <stdin>: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 \"<stdin>\", line 1, in <module>\n", "  AssertionError: Values aren 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](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n", "\n", "* Last one should be fairly obvious, passing mutable object (like  `list` ) results in a call by reference, whereas an immutable object (like `int`)  results in a call by value.\n", "\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/2.7/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](http://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 \"<stdin>\", line 1, in <module>\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 \"<stdin>\", line 1, in <module>\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 initiatlized anywhere yet\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["\n", "**Output:**\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": ["Traceback (most recent call last):\n", "  File \"<stdin>\", line 1, in <module>\n", "AttributeError: 'A' object has no attribute '__variable'\n", "\n", "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 nump` 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 readablity 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 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 sthe cientific 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", "    \"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/2/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 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n", "\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](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n", "\n", "* You can seperate numeric literals with underscores (for better readablity) 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", "**That's all folks!**\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 \"<stdin>\", 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", ">>> 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", ">>> a\n", "```\n", "```py\n", "6\n", "\n", "```\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["```py\n", ">>> a, b = 6, 9 # Typcial 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 \"<stdin>\", 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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", "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x\u2019s reference count reaches zero.\n", "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n", "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n", "\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 \"<stdin>\", line 1, in <module>\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 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 \"<stdin>\", line 1, in <module>\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", "\n", "# \ud83c\udf93 License\n", "\n", "[![WTFPL 2.0][license-image]][license-url]\n", "\n", "&copy; [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}
\ No newline at end of file
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "<p align=\"center\"><img src=\"https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images/logo.png\" alt=\"\"></p>\n",
+        "<h1 align=\"center\">What the f*ck Python! \ud83d\ude31</h1>\n",
+        "<p align=\"center\">Exploring and understanding Python through surprising snippets.</p>\n",
+        "\n",
+        "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n",
+        "\n",
+        "Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/3.0/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)\n",
+        "\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/).\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)).\n",
+        "    - If yes, give a gentle pat on your back, and you may skip to the next example.\n",
+        "\n",
+        "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n",
+        "```sh\n",
+        "$ pip install wtfpython -U\n",
+        "$ wtfpython\n",
+        "```\n",
+        "---\n",
+        "\n",
+        "# \ud83d\udc40 Examples\n",
+        "\n",
+        "\n\n## Hosted notebook instructions\n\nThis is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, \n- they either require a version of Python that's not supported in the hosted runtime.\n- or they can't be reproduced in the notebook envrinonment.\n\nThe expected outputs are already present in collapsed cells following the code cells. The Google colab provides Python2 (2.7) and Python3 (3.6, default) runtimes. You can switch among these for Python2 specific examples. For examples specific to other minor versions, you can simply refer to collapsed outputs (it's not possible to control the minor version in hosted notebooks as of now). You can check the active version using\n\n```py\n>>> import sys\n>>> sys.version\n# Prints out Python version here.\n```\n\nThat being said, most of the examples do work as expected. If you face any trouble, feel free to consult the original content on wtfpython and create an issue in the repo. Have fun!\n\n---\n"
+      ]
+    },
+    {
+      "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",
+        "  ![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images/string-intern/string_intern.png)\n",
+        "+ When `a` and `b` are set to `\"wtf!\"` in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't \"know\" that there's already `wtf!` as an object (because `\"wtf!\"` is not implicitly interned as per the facts mentioned above). It's a compile-time optimization. This optimization doesn't apply to 3.7.x versions of CPython (check this [issue](https://github.com/satwikkansal/wtfpython/issues/100) for more discussion).\n",
+        "+ A compile unit in an interactive environment like IPython consists of a single statement, whereas it consists of the entire module in case of modules. `a, b = \"wtf!\", \"wtf!\"` is single statement, whereas `a = \"wtf!\"; b = \"wtf!\"` are two statements in a single line. This explains why the identities are different in `a = \"wtf!\"; b = \"wtf!\"`, and also explain why they are same when invoked in `some_file.py`\n",
+        "+ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a  few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 20. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.\n",
+        "+ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the third snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n",
+        "\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",
+        "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n",
+        "* Immutable objects with the same value always have the same hash in Python.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  True\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  5 == 5.0 == 5 + 0j\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  True\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  hash(5) == hash(5.0) == hash(5 + 0j)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "  **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n",
+        "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n",
+        "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Deep down, we're all the same.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "class WTF:\n",
+        "  pass\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "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 # the why isn't c == a ??\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "Traceback (most recent call last):\n",
+              "  File \"<stdin>\", line 1, in <module>\n",
+              "TypeError: unhashable type: 'dict'\n",
+              "\n",
+              "# Makes sense since dict don't have __hash__ implemented, let's use\n",
+              "# our wrapper classes.\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "len({dictionary, ordered_dict, another_ordered_dict})\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "1\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "dictionary = DictWithHash()\n",
+        "dictionary[1] = 'a'; dictionary[2] = 'b';\n",
+        "ordered_dict = OrderedDictWithHash()\n",
+        "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n",
+        "another_ordered_dict = OrderedDictWithHash()\n",
+        "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n",
+        "len({dictionary, ordered_dict, another_ordered_dict})\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "2\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "What is going on here?\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n",
+        "  \n",
+        "    > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n",
+        "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n",
+        "- Okay, so why did changing the order affect the lenght 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 ocurred\", 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 \"<stdin>\", line 1, in <module>\n",
+              "ZeroDivisionError: division by zero\n",
+              "\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "1 / 0\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "Iteration 0\n",
+              "\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "one_more_func()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n",
+        "- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.\n",
+        "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 For what?\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "some_string = \"wtf\"\n",
+        "some_dict = {}\n",
+        "for i, some_dict[i] in enumerate(some_string):\n",
+        "    i = 10\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{0: 'w', 1: 't', 2: 'f'}\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "some_dict # An indexed dict appears.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "####  \ud83d\udca1 Explanation:\n",
+        "\n",
+        "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n",
+        "  ```\n",
+        "  for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n",
+        "  ```\n",
+        "  Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n",
+        "  An interesting example that illustrates this:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  for i in range(4):\n",
+        "      print(i)\n",
+        "      i = 10\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "  **Output:**\n",
+        "  ```\n",
+        "  0\n",
+        "  1\n",
+        "  2\n",
+        "  3\n",
+        "  ```\n",
+        "\n",
+        "  Did you expect the loop to run just once?\n",
+        "\n",
+        "  **\ud83d\udca1 Explanation:**\n",
+        "\n",
+        "  - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).\n",
+        "\n",
+        "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  i, some_dict[i] = (0, 'w')\n",
+        "  i, some_dict[i] = (1, 't')\n",
+        "  i, some_dict[i] = (2, 'f')\n",
+        "  some_dict\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Evaluation time discrepancy\n",
+        "1\\.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "array = [1, 8, 15]\n",
+        "# A typical generator expression\n",
+        "gen = (x for x in array if array.count(x) > 0)\n",
+        "array = [2, 8, 22]\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[8]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(list(gen)) # Where did the other values go?\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "2\\.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "array_1 = [1,2,3,4]\n",
+        "gen_1 = (x for x in array_1)\n",
+        "array_1 = [1,2,3,4,5]\n",
+        "\n",
+        "array_2 = [1,2,3,4]\n",
+        "gen_2 = (x for x in array_2)\n",
+        "array_2[:] = [1,2,3,4,5]\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[1, 2, 3, 4]\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(list(gen_1))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[1, 2, 3, 4, 5]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(list(gen_2))\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "3\\.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "array_3 = [1, 2, 3]\n",
+        "array_4 = [10, 20, 30]\n",
+        "gen = (i + j for i in array_3 for j in array_4)\n",
+        "\n",
+        "array_3 = [4, 5, 6]\n",
+        "array_4 = [400, 500, 600]\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[401, 501, 601, 402, 502, 602, 403, 503, 603]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(list(gen))\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation\n",
+        "\n",
+        "- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.\n",
+        "- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`.\n",
+        "- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.\n",
+        "- In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).\n",
+        "- In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).\n",
+        "- Okay, going by the logic discussed so far, shouldn't be the value of `list(g)` in the third snippet be `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (because `array_3` and `array_4` are going to behave just like `array_1`). The reason why (only) `array_4` values got updated is explained in [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)\n",
+        "  \n",
+        "    > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.\n",
+        "\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 `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",
+        "\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",
+        "![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images/tic-tac-toe/after_row_initialized.png)\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",
+        "![image](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images/tic-tac-toe/after_board_initialized.png)\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 The sticky output function\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": [
+        "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:**\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": [
+        "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": [
+        "Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n",
+        "\n",
+        "2\\.\n",
+        "\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",
+        "\n",
+        "- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.\n",
+        "\n",
+        "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n",
+        "\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"
+      ]
+    },
+    {
+      "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"
+      ]
+    },
+    {
+      "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 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 \"<stdin>\", 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 \"<stdin>\", 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 \"<stdin>\", 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 \"<input>\", line 1\n",
+              "    x == not y\n",
+              "           ^\n",
+              "SyntaxError: invalid syntax\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "x == not y\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "* Operator precedence affects how an expression is evaluated, and `==` operator has higher precedence than `not` operator in Python.\n",
+        "* So `not x == y` is equivalent to `not (x == y)` which is equivalent to `not (True == False)` finally evaluating to `True`.\n",
+        "* 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.\n",
+        "* 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`.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Half triple-quoted strings\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "wtfpython\n"
+          ]
+        }
+      ],
+      "source": [
+        "print('wtfpython''')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "wtfpython\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"wtfpython\"\"\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  File \"<input>\", line 3\n",
+              "    print(\"\"\"wtfpython\")\n",
+              "                        ^\n",
+              "SyntaxError: EOF while scanning triple-quoted string literal\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "# The following statements raise `SyntaxError`\n",
+        "# print('''wtfpython')\n",
+        "# print(\"\"\"wtfpython\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n",
+        "  ```\n",
+        "  >>> print(\"wtf\" \"python\")\n",
+        "  wtfpython\n",
+        "  >>> print(\"wtf\" \"\") # or \"wtf\"\"\"\n",
+        "  wtf\n",
+        "  ```\n",
+        "+ `'''` and `\"\"\"` are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 What's wrong with booleans?\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 simple example to count the number of booleans and\n",
+        "# integers in an iterable of mixed data types.\n",
+        "mixed_list = [False, 1.0, \"some_string\", 3, True, [], False]\n",
+        "integers_found_so_far = 0\n",
+        "booleans_found_so_far = 0\n",
+        "\n",
+        "for item in mixed_list:\n",
+        "    if isinstance(item, int):\n",
+        "        integers_found_so_far += 1\n",
+        "    elif isinstance(item, bool):\n",
+        "        booleans_found_so_far += 1\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "4\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "integers_found_so_far\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "0\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "booleans_found_so_far\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "\n",
+        "2\\.\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_bool = True\n",
+        "\"wtf\" * some_bool\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_bool = False\n",
+        "\"wtf\" * some_bool\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": [
+        "def tell_truth():\n",
+        "    True = False\n",
+        "    if True == False:\n",
+        "        print(\"I have lost faith in truth!\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output (< 3.x):**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "I have lost faith in truth!\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "tell_truth()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "* `bool` is a subclass of `int` in 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": [
+        "    issubclass(bool, int)\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(int, bool)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "    \n",
+        "* And thus, `True` and `False` are instances of `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(True, 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(False, int)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "* The integer value of `True` is `1` and that of `False` is `0`.\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": [
+              "  0\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  int(False)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "* See this StackOverflow [answer](https://stackoverflow.com/a/8169049/4354153) for the rationale behind it.\n",
+        "\n",
+        "* Initially, Python used to have no `bool` type (people used 0 for false and non-zero value like 1 for true).  `True`, `False`, and a `bool` type was added in 2.x versions, but, for backward compatibility, `True` and `False` couldn't be made constants. They just were built-in variables, and it was possible to reassign them\n",
+        "\n",
+        "* Python 3 was backward-incompatible, the issue was finally fixed, and thus the last snippet won't work with Python 3.x!\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Class attributes and instance attributes\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 A:\n",
+        "    x = 1\n",
+        "\n",
+        "class B(A):\n",
+        "    pass\n",
+        "\n",
+        "class C(A):\n",
+        "    pass\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(1, 1, 1)\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "A.x, B.x, C.x\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(1, 2, 1)\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "B.x = 2\n",
+        "A.x, B.x, C.x\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(3, 2, 3)\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "A.x = 3\n",
+        "A.x, B.x, C.x # C.x changed, but B.x didn't\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(3, 3)\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "a = A()\n",
+        "a.x, A.x\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "(4, 3)\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "a.x += 1\n",
+        "a.x, A.x\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 SomeClass:\n",
+        "    some_var = 15\n",
+        "    some_list = [5]\n",
+        "    another_list = [5]\n",
+        "    def __init__(self, x):\n",
+        "        self.some_var = x + 1\n",
+        "        self.some_list = self.some_list + [x]\n",
+        "        self.another_list += [x]\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[5, 420]\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "some_obj = SomeClass(420)\n",
+        "some_obj.some_list\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[5, 420]\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "some_obj.another_list\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[5, 111]\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "another_obj = SomeClass(111)\n",
+        "another_obj.some_list\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "[5, 420, 111]\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "another_obj.another_list\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_obj.another_list is SomeClass.another_list\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_obj.another_list is some_obj.another_list\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.\n",
+        "* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Non-reflexive class method *\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "class SomeClass:\n",
+        "        def instance_method(self):\n",
+        "                pass\n",
+        "        \n",
+        "        @classmethod\n",
+        "        def class_method(cls):\n",
+        "                pass\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "True\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "SomeClass.instance_method is SomeClass.instance_method\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "False\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "SomeClass.class_method is SomeClass.class_method\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "True\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "id(SomeClass.class_method) == id(SomeClass.class_method)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  <function __main__.SomeClass.instance_method(self)>\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  SomeClass.instance_method\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  <bound method SomeClass.class_method of <class '__main__.SomeClass'>\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  SomeClass.class_method\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "  A new bound method every time `SomeClass.class_method` is accessed.\n",
+        "\n",
+        "-  `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 yielding None\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "some_iterable = ('a', 'b')\n",
+        "\n",
+        "def some_func(val):\n",
+        "    return \"something\"\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output (<= 3.7.x):**\n",
+        "\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": [
+        "[x for x in some_iterable]\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "<generator object <listcomp> 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: http://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/2/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",
+        "\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/2/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.8 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"
+      ]
+    },
+    {
+      "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",
+        "**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"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "another_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",
+        "* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n",
+        "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n"
+      ]
+    },
+    {
+      "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": [
+        "\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 itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n",
+        "- 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 not default_arg:\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 \"<input>\", line 3\n",
+        "    except IndexError, ValueError:\n",
+        "                     ^\n",
+        "SyntaxError: invalid syntax\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation\n",
+        "\n",
+        "* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,\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 a ``ValueError``\n",
+        "     some_list.remove(4)\n",
+        "  except (IndexError, ValueError), e:\n",
+        "     print(\"Caught again!\")\n",
+        "     print(e)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "  **Output (Python 2.x):**\n",
+        "  ```\n",
+        "  Caught again!\n",
+        "  list.remove(x): x not in list\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": [
+        "    File \"<input>\", line 4\n",
+        "      except (IndexError, ValueError), e:\n",
+        "                                       ^\n",
+        "  IndentationError: unindent does not match any outer indentation level\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "* Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use `as`. Example,\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",
+        "      some_list.remove(4)\n",
+        "\n",
+        "  except (IndexError, ValueError) as e:\n",
+        "      print(\"Caught again!\")\n",
+        "      print(e)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "  **Output:**\n",
+        "  ```\n",
+        "  Caught again!\n",
+        "  list.remove(x): x not in list\n",
+        "  ```\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Same operands, different story!\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, 2, 3, 4]\n",
+        "b = a\n",
+        "a = a + [5, 6, 7, 8]\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, 5, 6, 7, 8]\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": [
+              "[1, 2, 3, 4]\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "b\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": [
+        "a = [1, 2, 3, 4]\n",
+        "b = a\n",
+        "a += [5, 6, 7, 8]\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, 5, 6, 7, 8]\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": [
+              "[1, 2, 3, 4, 5, 6, 7, 8]\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "b\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "*  `a += b` doesn't always behave the same way as `a = a + b`.  Classes *may* implement the *`op=`* operators differently, and lists do this.\n",
+        "\n",
+        "* The expression `a = a + [5,6,7,8]` generates a new list and sets `a`'s reference to that new list, leaving `b` unchanged.\n",
+        "\n",
+        "* The expression `a += [5,6,7,8]` is actually mapped to an \"extend\" function that operates on the list such that `a` and `b` still point to the same list that has been modified in-place.\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/2/reference/expressions.html#not-in\n",
+        "\n",
+        "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n",
+        "\n",
+        "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n",
+        "\n",
+        "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n",
+        "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n",
+        "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n",
+        "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  1\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  int(True)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  2\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  True + 1 #not relevant for this example, but just for fun\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "  So, `1 < 1` evaluates to `False`\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Name resolution ignoring class scope\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": [
+        "x = 5\n",
+        "class SomeClass:\n",
+        "    x = 17\n",
+        "    y = (x for i in range(10))\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": [
+        "list(SomeClass.y)[0]\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": [
+        "x = 5\n",
+        "class SomeClass:\n",
+        "    x = 17\n",
+        "    y = [x for i in range(10)]\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": [
+              "17\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "SomeClass.y[0]\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": [
+              "5\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "SomeClass.y[0]\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation\n",
+        "- Scopes nested inside class definition ignore names bound at the class level.\n",
+        "- A generator expression has its own scope.\n",
+        "- Starting from Python 3.X, list comprehensions also have their own scope.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### \u25b6 Needles in a Haystack *\n",
+        "I haven't met even a single experience Pythonist till date who has not come across one or more of the following scenarios,\n",
+        "\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": [
+        "x, y = (0, 1) if True else None, None\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), None)\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "x, y  # expected (0, 1)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "2\\.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": []
+        }
+      ],
+      "source": [
+        "t = ('one', 'two')\n",
+        "for i in t:\n",
+        "    print(i)\n",
+        "\n",
+        "t = ('one')\n",
+        "for i in t:\n",
+        "    print(i)\n",
+        "\n",
+        "t = ()\n",
+        "print(t)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": []
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "one\n",
+        "two\n",
+        "o\n",
+        "n\n",
+        "e\n",
+        "tuple()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "3\\.\n",
+        "\n",
+        "```\n",
+        "ten_words_list = [\n",
+        "    \"some\",\n",
+        "    \"very\",\n",
+        "    \"big\",\n",
+        "    \"list\",\n",
+        "    \"that\"\n",
+        "    \"consists\",\n",
+        "    \"of\",\n",
+        "    \"exactly\",\n",
+        "    \"ten\",\n",
+        "    \"words\"\n",
+        "]\n",
+        "```\n",
+        "\n",
+        "**Output**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "9\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "len(ten_words_list)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "4\\. Not asserting strongly enough\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 = \"python\"\n",
+        "b = \"javascript\"\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "# No AssertionError is raised\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "# An assert statement with an assertion failure message.\n",
+        "assert(a == b, \"Both languages are different\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "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": [
+        "some_list = [1, 2, 3]\n",
+        "some_dict = {\n",
+        "  \"key_1\": 1,\n",
+        "  \"key_2\": 2,\n",
+        "  \"key_3\": 3\n",
+        "}\n",
+        "\n",
+        "some_list = some_list.append(4) \n",
+        "some_dict = some_dict.update({\"key_4\": 4})\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": [
+            "None\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(some_list)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "collapsed": true
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "None\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(some_dict)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "6\\.\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_recursive_func(a):\n",
+        "    if a[0] == 0:\n",
+        "        return \n",
+        "    a[0] -= 1\n",
+        "    some_recursive_func(a)\n",
+        "    return a\n",
+        "\n",
+        "def similar_recursive_func(a):\n",
+        "        if a == 0:\n",
+        "                return a\n",
+        "        a -= 1\n",
+        "        similar_recursive_func(a)\n",
+        "        return a\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "**Output:**\n",
+        "\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": [
+        "some_recursive_func([5, 0])\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "4\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "similar_recursive_func(5)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "#### \ud83d\udca1 Explanation:\n",
+        "\n",
+        "* For 1, the correct statement for expected behavior is `x, y = (0, 1) if True else (None, None)`.\n",
+        "\n",
+        "* 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.\n",
+        "\n",
+        "* `()` is a special token and denotes empty `tuple`.\n",
+        "\n",
+        "* In 3, as you might have already figured out, there's a missing comma after 5th element (`\"that\"`) in the list. So by implicit string literal concatenation,\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  ['some', 'very', 'big', 'list', 'thatconsists', 'of', 'exactly', 'ten', 'words']\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "  ten_words_list\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n",
+        "* No `AssertionError` was raised in 4th snippet because instead of asserting the individual expression `a == b`, we're asserting entire tuple. The following snippet will clear things up,\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "  Traceback (most recent call last):\n",
+              "      File \"<stdin>\", line 1, in <module>\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": [
+              "  <stdin>: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 \"<stdin>\", line 1, in <module>\n",
+              "  AssertionError: Values aren 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](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n",
+        "\n",
+        "* Last one should be fairly obvious, passing mutable object (like  `list` ) results in a call by reference, whereas an immutable object (like `int`)  results in a call by value.\n",
+        "\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/2.7/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](http://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 \"<stdin>\", line 1, in <module>\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 \"<stdin>\", line 1, in <module>\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": [
+              "'Some value'\n"
+            ]
+          },
+          "output_type": "execute_result",
+          "metadata": {},
+          "execution_count": null
+        }
+      ],
+      "source": [
+        "Traceback (most recent call last):\n",
+        "  File \"<stdin>\", line 1, in <module>\n",
+        "AttributeError: 'A' object has no attribute '__variable'\n",
+        "\n",
+        "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 nump` 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 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",
+        "    \"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/2/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 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n",
+        "\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](http://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",
+        "**That's all folks!**\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 \"<stdin>\", 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",
+        ">>> 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",
+        ">>> 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 \"<stdin>\", 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 from `__del__` 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__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__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",
+        "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x\u2019s reference count reaches zero.\n",
+        "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n",
+        "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n",
+        "\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 \"<stdin>\", line 1, in <module>\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 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 \"<stdin>\", line 1, in <module>\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",
+        "\n",
+        "# \ud83c\udf93 License\n",
+        "\n",
+        "[![WTFPL 2.0][license-image]][license-url]\n",
+        "\n",
+        "&copy; [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
+}
\ No newline at end of file

From bd451754058ef11e1487cbb42018ac39e3396fc7 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 23 Dec 2019 15:59:59 +0530
Subject: [PATCH 136/146] Point colab notebook to the master

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a8af4d8..c9fe71b 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)
 
-Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/3.0/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
+Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
 
 Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight.
 

From a39792bd4b4c945c1597fccb557b37cb8d1b4281 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 23 Dec 2019 16:27:27 +0530
Subject: [PATCH 137/146] Remove kofi link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c9fe71b..8c3f3f0 100644
--- a/README.md
+++ b/README.md
@@ -3516,4 +3516,4 @@ If you like wtfpython, you can use these quick links to share it with your frien
 ## More content like this?
 
 If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/content-like-wtfpython/).
-*PS: On a sidenote, consider [buying me a meal](https://ko-fi.com/satwikkansal) or [planting a tree](https://teamtrees.org/).*
+*PS: On a sidenote, consider [planting a tree](https://teamtrees.org/).*

From 73a1248d04791ddb2483f04913223bb4cb75fd92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?pu=C9=90lo=C9=B9=20=CA=87=C9=B9=C7=9Dq=C6=83=C7=9D?=
 =?UTF-8?q?=E1=B4=89s?= <roland@siegbert.info>
Date: Mon, 23 Dec 2019 16:31:44 +0100
Subject: [PATCH 138/146] Fix typo in dictionary section

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8c3f3f0..67f1f11 100644
--- a/README.md
+++ b/README.md
@@ -515,7 +515,7 @@ What is going on here?
   
     > 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 is 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 lenght 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,
+- 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

From a1b4f8d521b154a767d656a98e8d7a3565f99719 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Mon, 23 Dec 2019 23:13:08 +0530
Subject: [PATCH 139/146] Put the pdf link back on demand

---
 README.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 67f1f11..eab7656 100644
--- a/README.md
+++ b/README.md
@@ -3513,7 +3513,9 @@ If you like wtfpython, you can use these quick links to share it with your frien
 
 [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&quote=If%20you%20really%20think%20you%20know%20Python%2C%20think%20once%20more!)  
 
-## More content like this?
+## Need a pdf version?
 
-If you're interested in more content like this, you can share your email [here](https://satwikkansal.xyz/content-like-wtfpython/).
-*PS: On a sidenote, consider [planting a tree](https://teamtrees.org/).*
+I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get them as soon as they are finished.
+
+
+*PS: On a sidenote, consider donating a dollar to [plant a tree](https://teamtrees.org/).*

From dcc2e6a3d86ef27ddac6181626847f7c70662187 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Tue, 24 Dec 2019 20:09:12 +0530
Subject: [PATCH 140/146] Update links

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index eab7656..a59a8b8 100644
--- a/README.md
+++ b/README.md
@@ -3464,8 +3464,6 @@ Let's increase the number of iterations by a factor of 10.
   ```
   The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.
 
-**That's all folks!**
-
 ---
 ---
 
@@ -3518,4 +3516,5 @@ If you like wtfpython, you can use these quick links to share it with your frien
 I've received a few requests for the pdf (and epub) version of wtfpython. You can add your details [here](https://satwikkansal.xyz/wtfpython-pdf/) to get them as soon as they are finished.
 
 
+**That's all folks!** For upcoming content like this, you can add your email [here](https://www.satwikkansal.xyz/content-like-wtfpython/).
 *PS: On a sidenote, consider donating a dollar to [plant a tree](https://teamtrees.org/).*

From 6c0ed6e7c5935fdbc5b23e77bba7cae0dee20fd6 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Tue, 24 Dec 2019 21:47:59 +0530
Subject: [PATCH 141/146] Add discussion links

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index a59a8b8..d347e40 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,8 @@ Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [
 
 Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
 
+Discussions: [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/)
+
 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.

From e4f340281cfce44f365f3e81385e067d1ea1f74d Mon Sep 17 00:00:00 2001
From: BoppreH <boppreh@gmail.com>
Date: Tue, 24 Dec 2019 14:02:22 -0300
Subject: [PATCH 142/146] Update README.md

Fix incorrect output for f-string.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d347e40..014726b 100644
--- a/README.md
+++ b/README.md
@@ -3395,7 +3395,7 @@ Let's increase the number of iterations by a factor of 10.
     ```py
     >>> some_string = "wtfpython"
     >>> f'{some_string=}'
-    "string='wtfpython'"
+    "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!):

From 7c85a73442281a979494575d5292d1ce7a9804bf Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Wed, 25 Dec 2019 00:09:55 +0530
Subject: [PATCH 143/146] Move discussion thread links to the links section

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d347e40..2ffd07f 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,6 @@ Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [
 
 Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)
 
-Discussions: [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/)
-
 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.
@@ -3497,6 +3495,7 @@ The idea and design for this collection were initially inspired by Denys Dovhan'
 * https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator
 * https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
 * https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues
+* WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).
 
 # 🎓 License
 

From 2f2fcf87bc07ffd94b1ad1aa17062f94853ab73e Mon Sep 17 00:00:00 2001
From: Rahul Gopinath <vrthra@users.noreply.github.com>
Date: Wed, 25 Dec 2019 10:10:53 +0100
Subject: [PATCH 144/146] Make sure that default_arg is not passed rather than
 checking for falsity

```
if not default_arg:
    ...
```
fails when `default_arg` can be assigned and still be false (implementing a `__bool__` or `__len__` etc). You dont want to overwrite the passed values.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index de542ef..f2a825a 100644
--- a/README.md
+++ b/README.md
@@ -2173,7 +2173,7 @@ def some_func(default_arg=[]):
 
     ```py
     def some_func(default_arg=None):
-        if not default_arg:
+        if default_arg is not None:
             default_arg = []
         default_arg.append("some_string")
         return default_arg

From 9a2718ae3a0d2b70af07eb002077fa60207cf490 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 27 Dec 2019 20:00:59 +0530
Subject: [PATCH 145/146] Fix typo

Closes https://github.com/satwikkansal/wtfpython/issues/162
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f2a825a..7d53527 100644
--- a/README.md
+++ b/README.md
@@ -259,7 +259,7 @@ This saved one line of code, and implicitly prevented invoking `some_func` twice
 
 - 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, 
+- 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')
 

From 2c910351b7a71208562cc03b47b4ebe1a3bd60e1 Mon Sep 17 00:00:00 2001
From: Satwik <satwikkansal@gmail.com>
Date: Fri, 27 Dec 2019 20:04:34 +0530
Subject: [PATCH 146/146] Fix relevant typos detected by codespell

Closes https://github.com/satwikkansal/wtfpython/issues/161
---
 CONTRIBUTING.md                     |  2 +-
 README.md                           |  2 +-
 irrelevant/notebook_instructions.md | 19 -------------------
 irrelevant/obsolete/add_categories  |  2 +-
 irrelevant/wtf.ipynb                |  4 ++--
 5 files changed, 5 insertions(+), 24 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e89821d..5085b59 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -29,7 +29,7 @@ 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
diff --git a/README.md b/README.md
index 7d53527..8ef9d5d 100644
--- a/README.md
+++ b/README.md
@@ -575,7 +575,7 @@ def one_more_func(): # A gotcha!
                 print("Iteration", i)
                 break
     except ZeroDivisionError as e:
-        print("Zero division error ocurred", e)
+        print("Zero division error occurred", e)
 ```
 
 **Output:**
diff --git a/irrelevant/notebook_instructions.md b/irrelevant/notebook_instructions.md
index 891698a..bc267eb 100644
--- a/irrelevant/notebook_instructions.md
+++ b/irrelevant/notebook_instructions.md
@@ -5,22 +5,3 @@
 - Reorder the examples, so that the ones that work are upfront.
 - Run the `notebook_generator.py`, it will generate a notebook named `wtf.ipynb`
 - Revert the README.md changes (optional)
-
-
-# Hosted notebook instructions
-
-This is just an experimental attempt of browsing wtfpython through jupyter notebooks. Some examples are read-only because, 
-- they either require a version of Python that's not supported in the hosted runtime.
-- or they can't be reproduced in the notebook envrinonment.
-
-The 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
-
-```py
->>> import sys
->>> sys.version
-# Prints out Python version here.
-```
-
-That being said, most of tbe 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!
-
-
diff --git a/irrelevant/obsolete/add_categories b/irrelevant/obsolete/add_categories
index 7818b2c..5eed768 100644
--- a/irrelevant/obsolete/add_categories
+++ b/irrelevant/obsolete/add_categories
@@ -139,7 +139,7 @@ f*
 Half triple-quoted strings
 f
 
-Implicity key type conversion
+Implicit key type conversion
 f*
 
 Stubborn `del` operator
diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb
index 12c7bb8..de1cba2 100644
--- a/irrelevant/wtf.ipynb
+++ b/irrelevant/wtf.ipynb
@@ -1044,7 +1044,7 @@
         "  \n",
         "    > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n",
         "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n",
-        "- Okay, so why did changing the order affect the lenght 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"
+        "- 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"
       ]
     },
     {
@@ -1289,7 +1289,7 @@
         "                print(\"Iteration\", i)\n",
         "                break\n",
         "    except ZeroDivisionError as e:\n",
-        "        print(\"Zero division error ocurred\", e)\n"
+        "        print(\"Zero division error occurred\", e)\n"
       ]
     },
     {