diff --git a/irrelevant/wtf.ipynb b/irrelevant/wtf.ipynb index de1cba2..a3147e1 100644 --- a/irrelevant/wtf.ipynb +++ b/irrelevant/wtf.ipynb @@ -4,13 +4,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "

\"\"

\n", + "

\"\"

\n", "

What the f*ck Python! \ud83d\ude31

\n", "

Exploring and understanding Python through surprising snippets.

\n", "\n", - "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n", + "Translations: [Chinese \u4e2d\u6587](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Ti\u1ebfng Vi\u1ec7t](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].)\n", "\n", - "Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/3.0/irrelevant/wtf.ipynb) | [CLI](https://pypi.python.org/pypi/wtfpython)\n", + "Other modes: [Interactive](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) | [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", @@ -20,7 +20,7 @@ "\n", "If you're an experienced Python programmer, you can take it as a challenge to get most of them right in the first attempt. You may have already experienced some of them before, and I might be able to revive sweet old memories of yours! :sweat_smile:\n", "\n", - "PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/).\n", + "PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/) (the examples marked with asterisk are the ones added in the latest major revision). \n", "\n", "So, here we go...\n", "\n", @@ -68,7 +68,7 @@ "- Read the output snippets and,\n", " + Check if the outputs are the same as you'd expect.\n", " + Make sure if you know the exact reason behind the output being the way it is.\n", - " - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfPython)).\n", + " - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfpython/issues/new)).\n", " - If yes, give a gentle pat on your back, and you may skip to the next example.\n", "\n", "PS: You can also read WTFPython at the command line using the [pypi package](https://pypi.python.org/pypi/wtfpython),\n", @@ -353,13 +353,13 @@ "+ After being \"interned,\" many variables may reference the same string object in memory (saving memory thereby).\n", "+ In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation-dependent. There are some rules that can be used to guess if a string will be interned or not:\n", " * All length 0 and length 1 strings are interned.\n", - " * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f']` will not be interned)\n", + " * Strings are interned at compile time (`'wtf'` will be interned but `''.join(['w', 't', 'f'])` will not be interned)\n", " * Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why `'wtf!'` was not interned due to `!`. CPython implementation of this rule can be found [here](https://github.com/python/cpython/blob/3.6/Objects/codeobject.c#L19)\n", - " ![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", + " ![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", + "+ The abrupt change in the output of the fourth snippet is due to a [peephole optimization](https://en.wikipedia.org/wiki/Peephole_optimization) technique known as Constant folding. This means the expression `'a'*20` is replaced by `'aaaaaaaaaaaaaaaaaaaa'` during compilation to save a few clock cycles during runtime. Constant folding only occurs for strings having a length of less than 21. (Why? Imagine the size of `.pyc` file generated as a result of the expression `'a'*10**10`). [Here's](https://github.com/python/cpython/blob/3.6/Python/peephole.c#L288) the implementation source for the same.\n", + "+ Note: In Python 3.7, Constant folding was moved out from peephole optimizer to the new AST optimizer with some change in logic as well, so the fourth snippet doesn't work for Python 3.7. You can read more about the change [here](https://bugs.python.org/issue11549). \n", "\n" ] }, @@ -367,262 +367,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### \u25b6 Hash brownies\n", - "1\\.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_dict = {}\n", - "some_dict[5.5] = \"JavaScript\"\n", - "some_dict[5.0] = \"Ruby\"\n", - "some_dict[5] = \"Python\"\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"JavaScript\"\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_dict[5.5]\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Python\"\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_dict[5.0] # \"Python\" destroyed the existence of \"Ruby\"?\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Python\"\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_dict[5] \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "complex\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "complex_five = 5 + 0j\n", - "type(complex_five)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "\"Python\"\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_dict[complex_five]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "So, why is Python all over the place?\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation\n", - "\n", - "* Python dictionaries check for equality and compare the hash value to determine if two keys are the same.\n", - "* Immutable objects with the same value always have the same hash in Python.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " 5 == 5.0 == 5 + 0j\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " hash(5) == hash(5.0) == hash(5 + 0j)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " **Note:** Objects with different values may also have same hash (known as [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science))).\n", - "* When the statement `some_dict[5] = \"Python\"` is executed, the existing value \"Ruby\" is overwritten with \"Python\" because Python recognizes `5` and `5.0` as the same keys of the dictionary `some_dict`.\n", - "* This StackOverflow [answer](https://stackoverflow.com/a/32211042/4354153) explains the rationale behind it.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 Deep down, we're all the same.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "class WTF:\n", - " pass\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n" + "### \u25b6 Be careful with chained operations\n" ] }, { @@ -644,7 +389,7 @@ } ], "source": [ - "WTF() == WTF() # two different instances can't be equal\n" + "(False == False) in [False] # makes sense\n" ] }, { @@ -666,7 +411,75 @@ } ], "source": [ - "WTF() is WTF() # identities are also different\n" + "False == (False in [False]) # makes sense\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "False == False in [False] # now what?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "True is False == False\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "False is False is False\n" ] }, { @@ -688,7 +501,7 @@ } ], "source": [ - "hash(WTF()) == hash(WTF()) # hashes _should_ be different as well\n" + "1 > 0 < 1\n" ] }, { @@ -701,7 +514,7 @@ { "data": { "text/plain": [ - "True\n" + "False\n" ] }, "output_type": "execute_result", @@ -710,7 +523,29 @@ } ], "source": [ - "id(WTF()) == id(WTF())\n" + "(1 > 0) < 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "1 > (0 < 1)\n" ] }, { @@ -726,40 +561,16 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "\n", - "* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.\n", - "* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.\n", - "* So, the object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.\n", - "* But why did the `is` operator evaluated to `False`? Let's see with this snippet.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " class WTF(object):\n", - " def __init__(self): print(\"I\")\n", - " def __del__(self): print(\"D\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "As per https://docs.python.org/3/reference/expressions.html#membership-test-operations\n", "\n", - " **Output:**\n" + "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n", + "\n", + "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n", + "\n", + "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n", + "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n", + "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n", + "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n" ] }, { @@ -772,11 +583,7 @@ { "data": { "text/plain": [ - " I\n", - " I\n", - " D\n", - " D\n", - " False\n" + " 1\n" ] }, "output_type": "execute_result", @@ -785,7 +592,7 @@ } ], "source": [ - " WTF() is WTF()\n" + " int(True)\n" ] }, { @@ -798,11 +605,7 @@ { "data": { "text/plain": [ - " I\n", - " D\n", - " I\n", - " D\n", - " True\n" + " 2\n" ] }, "output_type": "execute_result", @@ -811,989 +614,14 @@ } ], "source": [ - " id(WTF()) == id(WTF())\n" + " True + 1 #not relevant for this example, but just for fun\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - " As you may observe, the order in which the objects are destroyed is what made all the difference here.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 Disorder within order *\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "from collections import OrderedDict\n", - "\n", - "dictionary = dict()\n", - "dictionary[1] = 'a'; dictionary[2] = 'b';\n", - "\n", - "ordered_dict = OrderedDict()\n", - "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n", - "\n", - "another_ordered_dict = OrderedDict()\n", - "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n", - "\n", - "class DictWithHash(dict):\n", - " \"\"\"\n", - " A dict that also implements __hash__ magic.\n", - " \"\"\"\n", - " __hash__ = lambda self: 0\n", - "\n", - "class OrderedDictWithHash(OrderedDict):\n", - " \"\"\"\n", - " An OrderedDict that also implements __hash__ magic.\n", - " \"\"\"\n", - " __hash__ = lambda self: 0\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output**\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "dictionary == ordered_dict # If a == b\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "dictionary == another_ordered_dict # and b == c\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n", - "\n", - "# We all know that a set consists of only unique elements,\n", - "# let's try making a set of these dictionaries and see what happens...\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "ordered_dict == another_ordered_dict # the why isn't c == a ??\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Traceback (most recent call last):\n", - " File \"\", line 1, in \n", - "TypeError: unhashable type: 'dict'\n", - "\n", - "# Makes sense since dict don't have __hash__ implemented, let's use\n", - "# our wrapper classes.\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "len({dictionary, ordered_dict, another_ordered_dict})\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "dictionary = DictWithHash()\n", - "dictionary[1] = 'a'; dictionary[2] = 'b';\n", - "ordered_dict = OrderedDictWithHash()\n", - "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n", - "another_ordered_dict = OrderedDictWithHash()\n", - "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n", - "len({dictionary, ordered_dict, another_ordered_dict})\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "What is going on here?\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation:\n", - "\n", - "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n", - " \n", - " > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n", - "- The reason for this equality is behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n", - "- Okay, so why did changing the order affect the length of the generated `set` object? The answer is the lack of intransitive equality only. Since sets are \"unordered\" collections of unique elements, the order in which elements are inserted shouldn't matter. But in this case, it does matter. Let's break it down a bit,\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " some_set = set()\n", - " some_set.add(dictionary) # these are the mapping objects from the snippets above\n", - " ordered_dict in some_set\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " 1\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " some_set.add(ordered_dict)\n", - " len(some_set)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " another_ordered_dict in some_set\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " 1\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " some_set.add(another_ordered_dict)\n", - " len(some_set)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " another_set = set()\n", - " another_set.add(ordered_dict)\n", - " another_ordered_dict in another_set\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " 2\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " another_set.add(another_ordered_dict)\n", - " len(another_set)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " dictionary in another_set\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " 2\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " another_set.add(another_ordered_dict)\n", - " len(another_set)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " So the inconsistency is due to `another_ordered_dict in another_set` being `False` because `ordered_dict` was already present in `another_set` and as observed before, `ordered_dict == another_ordered_dict` is `False`.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 Keep trying... *\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "def some_func():\n", - " try:\n", - " return 'from_try'\n", - " finally:\n", - " return 'from_finally'\n", - "\n", - "def another_func(): \n", - " for _ in range(3):\n", - " try:\n", - " continue\n", - " finally:\n", - " print(\"Finally!\")\n", - "\n", - "def one_more_func(): # A gotcha!\n", - " try:\n", - " for i in range(3):\n", - " try:\n", - " 1 / i\n", - " except ZeroDivisionError:\n", - " # Let's throw it here and handle it outside for loop\n", - " raise ZeroDivisionError(\"A trivial divide by zero error\")\n", - " finally:\n", - " print(\"Iteration\", i)\n", - " break\n", - " except ZeroDivisionError as e:\n", - " print(\"Zero division error occurred\", e)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "'from_finally'\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_func()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Finally!\n", - "Finally!\n", - "Finally!\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "another_func()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Traceback (most recent call last):\n", - " File \"\", line 1, in \n", - "ZeroDivisionError: division by zero\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "1 / 0\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Iteration 0\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "one_more_func()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation:\n", - "\n", - "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n", - "- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.\n", - "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 For what?\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_string = \"wtf\"\n", - "some_dict = {}\n", - "for i, some_dict[i] in enumerate(some_string):\n", - " i = 10\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 'w', 1: 't', 2: 'f'}\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "some_dict # An indexed dict appears.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation:\n", - "\n", - "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n", - " ```\n", - " for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n", - " ```\n", - " Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n", - " An interesting example that illustrates this:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " for i in range(4):\n", - " print(i)\n", - " i = 10\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - " **Output:**\n", - " ```\n", - " 0\n", - " 1\n", - " 2\n", - " 3\n", - " ```\n", - "\n", - " Did you expect the loop to run just once?\n", - "\n", - " **\ud83d\udca1 Explanation:**\n", - "\n", - " - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` this case) is unpacked and assigned the target list variables (`i` in this case).\n", - "\n", - "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " i, some_dict[i] = (0, 'w')\n", - " i, some_dict[i] = (1, 't')\n", - " i, some_dict[i] = (2, 'f')\n", - " some_dict\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 Evaluation time discrepancy\n", - "1\\.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "array = [1, 8, 15]\n", - "# A typical generator expression\n", - "gen = (x for x in array if array.count(x) > 0)\n", - "array = [2, 8, 22]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n", - "\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "collapsed": true - }, - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[8]\n" - ] - } - ], - "source": [ - "print(list(gen)) # Where did the other values go?\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "2\\.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "array_1 = [1,2,3,4]\n", - "gen_1 = (x for x in array_1)\n", - "array_1 = [1,2,3,4,5]\n", - "\n", - "array_2 = [1,2,3,4]\n", - "gen_2 = (x for x in array_2)\n", - "array_2[:] = [1,2,3,4,5]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "collapsed": true - }, - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 2, 3, 4]\n", - "\n" - ] - } - ], - "source": [ - "print(list(gen_1))\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "collapsed": true - }, - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 2, 3, 4, 5]\n" - ] - } - ], - "source": [ - "print(list(gen_2))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "3\\.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "array_3 = [1, 2, 3]\n", - "array_4 = [10, 20, 30]\n", - "gen = (i + j for i in array_3 for j in array_4)\n", - "\n", - "array_3 = [4, 5, 6]\n", - "array_4 = [400, 500, 600]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "collapsed": true - }, - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[401, 501, 601, 402, 502, 602, 403, 503, 603]\n" - ] - } - ], - "source": [ - "print(list(gen))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation\n", - "\n", - "- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.\n", - "- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`.\n", - "- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.\n", - "- In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).\n", - "- In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).\n", - "- Okay, going by the logic discussed so far, shouldn't be the value of `list(g)` in the third snippet be `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (because `array_3` and `array_4` are going to behave just like `array_1`). The reason why (only) `array_4` values got updated is explained in [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)\n", - " \n", - " > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.\n", + " So, `1 < 1` evaluates to `False`\n", "\n" ] }, @@ -2322,6 +1150,1588 @@ "\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Hash brownies\n", + "1\\.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict = {}\n", + "some_dict[5.5] = \"JavaScript\"\n", + "some_dict[5.0] = \"Ruby\"\n", + "some_dict[5] = \"Python\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"JavaScript\"\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict[5.5]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"Python\"\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict[5.0] # \"Python\" destroyed the existence of \"Ruby\"?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"Python\"\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict[5] \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "complex\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "complex_five = 5 + 0j\n", + "type(complex_five)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\"Python\"\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict[complex_five]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "So, why is Python all over the place?\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation\n", + "\n", + "* Uniqueness of keys in a Python dictionary is by *equivalence*, not identity. So even though `5`, `5.0`, and `5 + 0j` are distinct objects of different types, since they're equal, they can't both be in the same `dict` (or `set`). As soon as you insert any one of them, attempting to look up any distinct but equivalent key will succeed with the original mapped value (rather than failing with a `KeyError`):\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " 5 == 5.0 == 5 + 0j\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " 5 is not 5.0 is not 5 + 0j\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " some_dict = {}\n", + " some_dict[5.0] = \"Ruby\"\n", + " 5.0 in some_dict\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " (5 in some_dict) and (5 + 0j in some_dict)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* This applies when setting an item as well. So when you do `some_dict[5] = \"Python\"`, Python finds the existing item with equivalent key `5.0 -> \"Ruby\"`, overwrites its value in place, and leaves the original key alone.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " {5.0: 'Ruby'}\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " some_dict\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " {5.0: 'Python'}\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " some_dict[5] = \"Python\"\n", + " some_dict\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* So how can we update the key to `5` (instead of `5.0`)? We can't actually do this update in place, but what we can do is first delete the key (`del some_dict[5.0]`), and then set it (`some_dict[5]`) to get the integer `5` as the key instead of floating `5.0`, though this should be needed in rare cases.\n", + "\n", + "* How did Python find `5` in a dictionary containing `5.0`? Python does this in constant time without having to scan through every item by using hash functions. When Python looks up a key `foo` in a dict, it first computes `hash(foo)` (which runs in constant-time). Since in Python it is required that objects that compare equal also have the same hash value ([docs](https://docs.python.org/3/reference/datamodel.html#object.__hash__) here), `5`, `5.0`, and `5 + 0j` have the same hash value.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " 5 == 5.0 == 5 + 0j\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " hash(5) == hash(5.0) == hash(5 + 0j)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **Note:** The inverse is not necessarily true: Objects with equal hash values may themselves be unequal. (This causes what's known as a [hash collision](https://en.wikipedia.org/wiki/Collision_(computer_science)), and degrades the constant-time performance that hashing usually provides.)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Deep down, we're all the same.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "class WTF:\n", + " pass\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "WTF() == WTF() # two different instances can't be equal\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "WTF() is WTF() # identities are also different\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "hash(WTF()) == hash(WTF()) # hashes _should_ be different as well\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "id(WTF()) == id(WTF())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation:\n", + "\n", + "* When `id` was called, Python created a `WTF` class object and passed it to the `id` function. The `id` function takes its `id` (its memory location), and throws away the object. The object is destroyed.\n", + "* When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython) `id` uses the memory location as the object id, the id of the two objects is the same.\n", + "* So, the object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.\n", + "* But why did the `is` operator evaluated to `False`? Let's see with this snippet.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " class WTF(object):\n", + " def __init__(self): print(\"I\")\n", + " def __del__(self): print(\"D\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " **Output:**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " I\n", + " I\n", + " D\n", + " D\n", + " False\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " WTF() is WTF()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " I\n", + " D\n", + " I\n", + " D\n", + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " id(WTF()) == id(WTF())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " As you may observe, the order in which the objects are destroyed is what made all the difference here.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Disorder within order *\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "from collections import OrderedDict\n", + "\n", + "dictionary = dict()\n", + "dictionary[1] = 'a'; dictionary[2] = 'b';\n", + "\n", + "ordered_dict = OrderedDict()\n", + "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n", + "\n", + "another_ordered_dict = OrderedDict()\n", + "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n", + "\n", + "class DictWithHash(dict):\n", + " \"\"\"\n", + " A dict that also implements __hash__ magic.\n", + " \"\"\"\n", + " __hash__ = lambda self: 0\n", + "\n", + "class OrderedDictWithHash(OrderedDict):\n", + " \"\"\"\n", + " An OrderedDict that also implements __hash__ magic.\n", + " \"\"\"\n", + " __hash__ = lambda self: 0\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "dictionary == ordered_dict # If a == b\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "dictionary == another_ordered_dict # and b == c\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False\n", + "\n", + "# We all know that a set consists of only unique elements,\n", + "# let's try making a set of these dictionaries and see what happens...\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "ordered_dict == another_ordered_dict # then why isn't c == a ??\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Traceback (most recent call last):\n", + " File \"\", line 1, in \n", + "TypeError: unhashable type: 'dict'\n", + "\n", + "# Makes sense since dict don't have __hash__ implemented, let's use\n", + "# our wrapper classes.\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "len({dictionary, ordered_dict, another_ordered_dict})\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "dictionary = DictWithHash()\n", + "dictionary[1] = 'a'; dictionary[2] = 'b';\n", + "ordered_dict = OrderedDictWithHash()\n", + "ordered_dict[1] = 'a'; ordered_dict[2] = 'b';\n", + "another_ordered_dict = OrderedDictWithHash()\n", + "another_ordered_dict[2] = 'b'; another_ordered_dict[1] = 'a';\n", + "len({dictionary, ordered_dict, another_ordered_dict})\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "len({ordered_dict, another_ordered_dict, dictionary}) # changing the order\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "What is going on here?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation:\n", + "\n", + "- The reason why intransitive equality didn't hold among `dictionary`, `ordered_dict` and `another_ordered_dict` is because of the way `__eq__` method is implemented in `OrderedDict` class. From the [docs](https://docs.python.org/3/library/collections.html#ordereddict-objects)\n", + " \n", + " > Equality tests between OrderedDict objects are order-sensitive and are implemented as `list(od1.items())==list(od2.items())`. Equality tests between `OrderedDict` objects and other Mapping objects are order-insensitive like regular dictionaries.\n", + "- The reason for this equality in behavior is that it allows `OrderedDict` objects to be directly substituted anywhere a regular dictionary is used.\n", + "- Okay, so why did changing the order affect the length of the generated `set` object? The answer is the lack of intransitive equality only. Since sets are \"unordered\" collections of unique elements, the order in which elements are inserted shouldn't matter. But in this case, it does matter. Let's break it down a bit,\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " some_set = set()\n", + " some_set.add(dictionary) # these are the mapping objects from the snippets above\n", + " ordered_dict in some_set\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " 1\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " some_set.add(ordered_dict)\n", + " len(some_set)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " another_ordered_dict in some_set\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " 1\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " some_set.add(another_ordered_dict)\n", + " len(some_set)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " False\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " another_set = set()\n", + " another_set.add(ordered_dict)\n", + " another_ordered_dict in another_set\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " 2\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " another_set.add(another_ordered_dict)\n", + " len(another_set)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " True\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " dictionary in another_set\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " 2\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " another_set.add(another_ordered_dict)\n", + " len(another_set)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " So the inconsistency is due to `another_ordered_dict in another_set` being `False` because `ordered_dict` was already present in `another_set` and as observed before, `ordered_dict == another_ordered_dict` is `False`.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Keep trying... *\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "def some_func():\n", + " try:\n", + " return 'from_try'\n", + " finally:\n", + " return 'from_finally'\n", + "\n", + "def another_func(): \n", + " for _ in range(3):\n", + " try:\n", + " continue\n", + " finally:\n", + " print(\"Finally!\")\n", + "\n", + "def one_more_func(): # A gotcha!\n", + " try:\n", + " for i in range(3):\n", + " try:\n", + " 1 / i\n", + " except ZeroDivisionError:\n", + " # Let's throw it here and handle it outside for loop\n", + " raise ZeroDivisionError(\"A trivial divide by zero error\")\n", + " finally:\n", + " print(\"Iteration\", i)\n", + " break\n", + " except ZeroDivisionError as e:\n", + " print(\"Zero division error occurred\", e)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'from_finally'\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_func()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Finally!\n", + "Finally!\n", + "Finally!\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "another_func()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Traceback (most recent call last):\n", + " File \"\", line 1, in \n", + "ZeroDivisionError: division by zero\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "1 / 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Iteration 0\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "one_more_func()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation:\n", + "\n", + "- When a `return`, `break` or `continue` statement is executed in the `try` suite of a \"try\u2026finally\" statement, the `finally` clause is also executed on the way out.\n", + "- The return value of a function is determined by the last `return` statement executed. Since the `finally` clause always executes, a `return` statement executed in the `finally` clause will always be the last one executed.\n", + "- The caveat here is, if the finally clause executes a `return` or `break` statement, the temporarily saved exception is discarded.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 For what?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_string = \"wtf\"\n", + "some_dict = {}\n", + "for i, some_dict[i] in enumerate(some_string):\n", + " i = 10\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 'w', 1: 't', 2: 'f'}\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict # An indexed dict appears.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation:\n", + "\n", + "* A `for` statement is defined in the [Python grammar](https://docs.python.org/3/reference/grammar.html) as:\n", + " ```\n", + " for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]\n", + " ```\n", + " Where `exprlist` is the assignment target. This means that the equivalent of `{exprlist} = {next_value}` is **executed for each item** in the iterable.\n", + " An interesting example that illustrates this:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " for i in range(4):\n", + " print(i)\n", + " i = 10\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " **Output:**\n", + " ```\n", + " 0\n", + " 1\n", + " 2\n", + " 3\n", + " ```\n", + "\n", + " Did you expect the loop to run just once?\n", + "\n", + " **\ud83d\udca1 Explanation:**\n", + "\n", + " - The assignment statement `i = 10` never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (`range(4)` in this case) is unpacked and assigned the target list variables (`i` in this case).\n", + "\n", + "* The `enumerate(some_string)` function yields a new value `i` (a counter going up) and a character from the `some_string` in each iteration. It then sets the (just assigned) `i` key of the dictionary `some_dict` to that character. The unrolling of the loop can be simplified as:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " i, some_dict[i] = (0, 'w')\n", + " i, some_dict[i] = (1, 't')\n", + " i, some_dict[i] = (2, 'f')\n", + " some_dict\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Evaluation time discrepancy\n", + "1\\.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "array = [1, 8, 15]\n", + "# A typical generator expression\n", + "gen = (x for x in array if array.count(x) > 0)\n", + "array = [2, 8, 22]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[8]\n" + ] + } + ], + "source": [ + "print(list(gen)) # Where did the other values go?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "2\\.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "array_1 = [1,2,3,4]\n", + "gen_1 = (x for x in array_1)\n", + "array_1 = [1,2,3,4,5]\n", + "\n", + "array_2 = [1,2,3,4]\n", + "gen_2 = (x for x in array_2)\n", + "array_2[:] = [1,2,3,4,5]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4]\n", + "\n" + ] + } + ], + "source": [ + "print(list(gen_1))\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5]\n" + ] + } + ], + "source": [ + "print(list(gen_2))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "3\\.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "array_3 = [1, 2, 3]\n", + "array_4 = [10, 20, 30]\n", + "gen = (i + j for i in array_3 for j in array_4)\n", + "\n", + "array_3 = [4, 5, 6]\n", + "array_4 = [400, 500, 600]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[401, 501, 601, 402, 502, 602, 403, 503, 603]\n" + ] + } + ], + "source": [ + "print(list(gen))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation\n", + "\n", + "- In a [generator](https://wiki.python.org/moin/Generators) expression, the `in` clause is evaluated at declaration time, but the conditional clause is evaluated at runtime.\n", + "- So before runtime, `array` is re-assigned to the list `[2, 8, 22]`, and since out of `1`, `8` and `15`, only the count of `8` is greater than `0`, the generator only yields `8`.\n", + "- The differences in the output of `g1` and `g2` in the second part is due the way variables `array_1` and `array_2` are re-assigned values.\n", + "- In the first case, `array_1` is binded to the new object `[1,2,3,4,5]` and since the `in` clause is evaluated at the declaration time it still refers to the old object `[1,2,3,4]` (which is not destroyed).\n", + "- In the second case, the slice assignment to `array_2` updates the same old object `[1,2,3,4]` to `[1,2,3,4,5]`. Hence both the `g2` and `array_2` still have reference to the same object (which has now been updated to `[1,2,3,4,5]`).\n", + "- Okay, going by the logic discussed so far, shouldn't be the value of `list(g)` in the third snippet be `[11, 21, 31, 12, 22, 32, 13, 23, 33]`? (because `array_3` and `array_4` are going to behave just like `array_1`). The reason why (only) `array_4` values got updated is explained in [PEP-289](https://www.python.org/dev/peps/pep-0289/#the-details)\n", + " \n", + " > Only the outermost for-expression is evaluated immediately, the other expressions are deferred until the generator is run.\n", + "\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -2387,7 +2797,8 @@ "#### \ud83d\udca1 Explanation\n", "\n", "- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated.\n", - "- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise.\n", + "- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise. \n", + "- In the example, `(not None)` evaluates to `True` since the value `None` is `False` in a boolean context, so the expression becomes `'something' is True`.\n", "\n" ] }, @@ -2536,11 +2947,11 @@ "\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", + "![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](https://raw.githubusercontent.com/satwikkansal/wtfpython/master/images/tic-tac-toe/after_board_initialized.png)\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" @@ -2581,9 +2992,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### \u25b6 The sticky output function\n", - "1\\.\n", - "\n" + "### \u25b6 Schr\u00f6dinger's variable *\n" ] }, { @@ -2619,8 +3028,7 @@ "metadata": {}, "source": [ "\n", - "**Output:**\n", - "\n" + "**Output (Python version):**\n" ] }, { @@ -2671,9 +3079,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Even when the values of `x` were different in every iteration prior to appending `some_func` to `funcs`, all the functions return 6.\n", "\n", - "2\\.\n", + "The values of `x` were different in every iteration prior to appending `some_func` to `funcs`, but all the functions return 6 when they're evaluated after the loop completes.\n", + "\n", + "2.\n", "\n" ] }, @@ -2711,11 +3120,70 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### \ud83d\udca1 Explanation\n", + "#### \ud83d\udca1 Explanation:\n", + "* When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the *variable*, not its *value*. The function looks up `x` in the surrounding context, rather than using the value of `x` at the time the function is created. So all of the functions use the latest value assigned to the variable for computation. We can see that it's using the `x` from the surrounding context (i.e. *not* a local variable) with:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ClosureVars(nonlocals={}, globals={'x': 6}, builtins={}, unbound=set())\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "import inspect\n", + "inspect.getclosurevals(funcs[0])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since `x` is a global value, we can change the value that the `funcs` will lookup and return by updating `x`:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[42, 42, 42, 42, 42, 42, 42]\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "x = 42\n", + "[func() for func in funcs]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "\n", - "- When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.\n", - "\n", - "- To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why this works?** Because this will define the variable again within the function's scope.\n", + "* To get the desired behavior you can pass in the loop variable as a named variable to the function. **Why does this work?** Because this will define the variable *inside* the function's scope. It will no longer go to the surrounding (global) scope to look up the variables value but will create a local variable that stores the value of `x` at that point in time.\n", "\n" ] }, @@ -2736,11 +3204,11 @@ } ], "source": [ - " funcs = []\n", - " for x in range(7):\n", - " def some_func(x=x):\n", - " return x\n", - " funcs.append(some_func)\n" + "funcs = []\n", + "for x in range(7):\n", + " def some_func(x=x):\n", + " return x\n", + " funcs.append(some_func)\n" ] }, { @@ -2748,7 +3216,8 @@ "metadata": {}, "source": [ "\n", - " **Output:**\n" + "**Output:**\n", + "\n" ] }, { @@ -2761,7 +3230,7 @@ { "data": { "text/plain": [ - " [0, 1, 2, 3, 4, 5, 6]\n" + "[0, 1, 2, 3, 4, 5, 6]\n" ] }, "output_type": "execute_result", @@ -2770,8 +3239,39 @@ } ], "source": [ - " funcs_results = [func() for func in funcs]\n", - " funcs_results\n" + "funcs_results = [func() for func in funcs]\n", + "funcs_results\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "It is not longer using the `x` in the global scope:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ClosureVars(nonlocals={}, globals={}, builtins={}, unbound=set())\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "inspect.getclosurevars(funcs[0])\n" ] }, { @@ -3129,6 +3629,481 @@ "\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Methods equality and identity\n", + "1.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "class SomeClass:\n", + " def method(self):\n", + " pass\n", + "\n", + " @classmethod\n", + " def classm(cls):\n", + " pass\n", + "\n", + " @staticmethod\n", + " def staticm():\n", + " pass\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(SomeClass.method is SomeClass.method)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(SomeClass.classm is SomeClass.classm)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(SomeClass.classm == SomeClass.classm)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(SomeClass.staticm is SomeClass.staticm)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Accessing `classm` twice, we get an equal object, but not the *same* one? Let's see what happens\n", + "with instances of `SomeClass`:\n", + "\n", + "2.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1 = SomeClass()\n", + "o2 = SomeClass()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(o1.method == o2.method)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(o1.method == o1.method)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(o1.method is o1.method)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(o1.classm is o1.classm)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(o1.classm == o1.classm == o2.classm == SomeClass.classm)\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": true + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(o1.staticm is o1.staticm is o2.staticm is SomeClass.staticm)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Accessing` classm` or `method` twice, creates equal but not *same* objects for the same instance of `SomeClass`.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation\n", + "* Functions are [descriptors](https://docs.python.org/3/howto/descriptor.html). Whenever a function is accessed as an\n", + "attribute, the descriptor is invoked, creating a method object which \"binds\" the function with the object owning the\n", + "attribute. If called, the method calls the function, implicitly passing the bound object as the first argument\n", + "(this is how we get `self` as the first argument, despite not passing it explicitly).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + ">\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1.method\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Accessing the attribute multiple times creates a method object every time! Therefore `o1.method is o1.method` is\n", + "never truthy. Accessing functions as class attributes (as opposed to instance) does not create methods, however; so\n", + "`SomeClass.method is SomeClass.method` is truthy.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "SomeClass.method\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* `classmethod` transforms functions into class methods. Class methods are descriptors that, when accessed, create\n", + "a method object which binds the *class* (type) of the object, instead of the object itself.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + ">\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1.classm\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Unlike functions, `classmethod`s will create a method also when accessed as class attributes (in which case they\n", + "bind the class, not to the type of it). So `SomeClass.classm is SomeClass.classm` is falsy.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + ">\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "SomeClass.classm\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* A method object compares equal when both the functions are equal, and the bound objects are the same. So\n", + "`o1.method == o1.method` is truthy, although not the same object in memory.\n", + "* `staticmethod` transforms functions into a \"no-op\" descriptor, which returns the function as-is. No method\n", + "objects are ever created, so comparison with `is` is truthy.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1.staticm\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "SomeClass.staticm\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Having to create new \"method\" objects every time Python calls instance methods and having to modify the arguments\n", + "every time in order to insert `self` affected performance badly.\n", + "CPython 3.7 [solved it](https://bugs.python.org/issue26110) by introducing new opcodes that deal with calling methods\n", + "without creating the temporary method objects. This is used only when the accessed function is actually called, so the\n", + "snippets here are not affected, and still generate methods :)\n", + "\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -3491,7 +4466,7 @@ } ], "source": [ - " 'wt\\\"f'\n" + " \"wt\\\"f\"\n" ] }, { @@ -3578,7 +4553,7 @@ { "data": { "text/plain": [ - " '\\\\\\\\n'\n" + " '\\\\n'\n" ] }, "output_type": "execute_result", @@ -3786,7 +4761,7 @@ "metadata": {}, "source": [ "#### \ud83d\udca1 Explanation:\n", - "+ Python supports implicit [string literal concatenation](https://docs.python.org/2/reference/lexical_analysis.html#string-literal-concatenation), Example,\n", + "+ Python supports implicit [string literal concatenation](https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation), Example,\n", " ```\n", " >>> print(\"wtf\" \"python\")\n", " wtfpython\n", @@ -4539,186 +5514,6 @@ "\n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 Non-reflexive class method *\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "class SomeClass:\n", - " def instance_method(self):\n", - " pass\n", - " \n", - " @classmethod\n", - " def class_method(cls):\n", - " pass\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "**Output:**\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "SomeClass.instance_method is SomeClass.instance_method\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "SomeClass.class_method is SomeClass.class_method\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "id(SomeClass.class_method) == id(SomeClass.class_method)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation:\n", - "\n", - "- The reason `SomeClass.class_method is SomeClass.class_method` is `False` is due to the `@classmethod` decorator. \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " \n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " SomeClass.instance_method\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " \n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " SomeClass.class_method\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - " A new bound method every time `SomeClass.class_method` is accessed.\n", - "\n", - "- `id(SomeClass.class_method) == id(SomeClass.class_method)` returned `True` because the second allocation of memory for `class_method` happened at the same location of first deallocation (See Deep Down, we're all the same example for more detailed explanation). \n", - "\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -4882,7 +5677,7 @@ "#### \ud83d\udca1 Explanation:\n", "- This is a bug in CPython's handling of `yield` in generators and comprehensions.\n", "- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions\n", - "- Related bug report: http://bugs.python.org/issue10544\n", + "- Related bug report: https://bugs.python.org/issue10544\n", "- Python 3.8+ no longer allows `yield` inside list comprehension and will throw a `SyntaxError`.\n", "\n" ] @@ -5682,12 +6477,13 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "\n", - "* Quoting from https://docs.python.org/2/reference/datamodel.html\n", + "* Quoting from https://docs.python.org/3/reference/datamodel.html\n", "\n", " > Immutable sequences\n", " An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.)\n", "\n", "* `+=` operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place.\n", + "* There's also an explanation in [official Python FAQ](https://docs.python.org/3/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works).\n", "\n" ] }, @@ -6291,7 +7087,7 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "\n", - "* According to [Python language reference](https://docs.python.org/2/reference/simple_stmts.html#assignment-statements), assignment statements have the form\n", + "* According to [Python language reference](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements), assignment statements have the form\n", " ```\n", " (target_list \"=\")+ (expression_list | yield_expression)\n", " ```\n", @@ -6529,7 +7325,7 @@ "* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.\n", "* How deleted keys are handled and when the resize occurs might be different for different Python implementations.\n", "* So for Python versions other than Python 2.7 - Python 3.5, the count might be different from 8 (but whatever the count is, it's going to be the same every time you run it). You can find some discussion around this [here](https://github.com/satwikkansal/wtfpython/issues/53) or in [this](https://stackoverflow.com/questions/44763802/bug-in-python-dict) StackOverflow thread.\n", - "* Python 3.8 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n", + "* Python 3.7.6 onwards, you'll see `RuntimeError: dictionary keys changed during iteration` exception if you try to do this.\n", "\n" ] }, @@ -6537,7 +7333,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### \u25b6 The out of scope variable\n" + "### \u25b6 The out of scope variable\n", + "1\\.\n" ] }, { @@ -6566,6 +7363,45 @@ " return a\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "2\\.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "def some_closure_func():\n", + " a = 1\n", + " def some_inner_func():\n", + " return a\n", + " return some_inner_func()\n", + "\n", + "def another_closure_func():\n", + " a = 1\n", + " def another_inner_func():\n", + " a += 1\n", + " return a\n", + " return another_inner_func()\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -6606,7 +7442,8 @@ { "data": { "text/plain": [ - "UnboundLocalError: local variable 'a' referenced before assignment\n" + "UnboundLocalError: local variable 'a' referenced before assignment\n", + "\n" ] }, "output_type": "execute_result", @@ -6618,6 +7455,50 @@ "another_func()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_closure_func()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "UnboundLocalError: local variable 'a' referenced before assignment\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "another_closure_func()\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -6630,9 +7511,8 @@ "metadata": {}, "source": [ "#### \ud83d\udca1 Explanation:\n", - "* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error.\n", - "* Read [this](http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n", - "* To modify the outer scope variable `a` in `another_func`, use `global` keyword.\n" + "* When you make an assignment to a variable in scope, it becomes local to that scope. So `a` becomes local to the scope of `another_func`, but it has not been initialized previously in the same scope, which throws an error.\n", + "* To modify the outer scope variable `a` in `another_func`, we have to use the `global` keyword.\n" ] }, { @@ -6692,6 +7572,72 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "* In `another_closure_func`, `a` becomes local to the scope of `another_inner_func`, but it has not been initialized previously in the same scope, which is why it throws an error. \n", + "* To modify the outer scope variable `a` in `another_inner_func`, use the `nonlocal` keyword. The nonlocal statement is used to refer to variables defined in the nearest outer (excluding the global) scope.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " def another_func():\n", + " a = 1\n", + " def another_inner_func():\n", + " nonlocal a\n", + " a += 1\n", + " return a\n", + " return another_inner_func()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " **Output:**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " 2\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + " another_func()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* The keywords `global` and `nonlocal` tell the python interpreter to not delcare new variables and look them up in the corresponding outer scopes.\n", + "* Read [this](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html) short but an awesome guide to learn more about how namespaces and scope resolution works in Python.\n", "\n" ] }, @@ -7064,7 +8010,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "- So the function takes in arbitrary number of itreable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n", + "- So the function takes in arbitrary number of iterable objects, adds each of their items to the `result` list by calling the `next` function on them, and stops whenever any of the iterable is exhausted. \n", "- The caveat here is when any iterable is exhausted, the existing elements in the `result` list are discarded. That's what happened with `3` in the `numbers_iter`.\n", "- The correct way to do the above using `zip` would be,\n" ] @@ -7648,7 +8594,7 @@ ], "source": [ " def some_func(default_arg=None):\n", - " if not default_arg:\n", + " if default_arg is None:\n", " default_arg = []\n", " default_arg.append(\"some_string\")\n", " return default_arg\n" @@ -8068,268 +9014,6 @@ "\n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### \u25b6 Be careful with chained operations\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "(False == False) in [False] # makes sense\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "False == (False in [False]) # makes sense\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "False == False in [False] # now what?\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "True is False == False\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n", - "\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "False is False is False\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "True\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "1 > 0 < 1\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "(1 > 0) < 1\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "False\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - "1 > (0 < 1)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### \ud83d\udca1 Explanation:\n", - "\n", - "As per https://docs.python.org/2/reference/expressions.html#not-in\n", - "\n", - "> Formally, if a, b, c, ..., y, z are expressions and op1, op2, ..., opN are comparison operators, then a op1 b op2 c ... y opN z is equivalent to a op1 b and b op2 c and ... y opN z, except that each expression is evaluated at most once.\n", - "\n", - "While such behavior might seem silly to you in the above examples, it's fantastic with stuff like `a == b == c` and `0 <= x <= 100`.\n", - "\n", - "* `False is False is False` is equivalent to `(False is False) and (False is False)`\n", - "* `True is False == False` is equivalent to `True is False and False == False` and since the first part of the statement (`True is False`) evaluates to `False`, the overall expression evaluates to `False`.\n", - "* `1 > 0 < 1` is equivalent to `1 > 0 and 0 < 1` which evaluates to `True`.\n", - "* The expression `(1 > 0) < 1` is equivalent to `True < 1` and\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " 1\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " int(True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - " 2\n" - ] - }, - "output_type": "execute_result", - "metadata": {}, - "execution_count": null - } - ], - "source": [ - " True + 1 #not relevant for this example, but just for fun\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " So, `1 < 1` evaluates to `False`\n", - "\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -8853,17 +9537,17 @@ "source": [ "def some_recursive_func(a):\n", " if a[0] == 0:\n", - " return \n", + " return\n", " a[0] -= 1\n", " some_recursive_func(a)\n", " return a\n", "\n", "def similar_recursive_func(a):\n", - " if a == 0:\n", - " return a\n", - " a -= 1\n", - " similar_recursive_func(a)\n", - " return a\n" + " if a == 0:\n", + " return a\n", + " a -= 1\n", + " similar_recursive_func(a)\n", + " return a\n" ] }, { @@ -9035,7 +9719,7 @@ "text/plain": [ " Traceback (most recent call last):\n", " File \"\", line 1, in \n", - " AssertionError: Values aren not equal\n" + " AssertionError: Values are not equal\n" ] }, "output_type": "execute_result", @@ -9052,9 +9736,9 @@ "metadata": {}, "source": [ "\n", - "* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](http://docs.python.org/2/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n", + "* As for the fifth snippet, most methods that modify the items of sequence/mapping objects like `list.append`, `dict.update`, `list.sort`, etc. modify the objects in-place and return `None`. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from [here](https://docs.python.org/3/faq/design.html#why-doesn-t-list-sort-return-the-sorted-list)).\n", "\n", - "* Last one should be fairly obvious, passing mutable object (like `list` ) results in a call by reference, whereas an immutable object (like `int`) results in a call by value.\n", + "* Last one should be fairly obvious, mutable object (like `list`) can be altered in the function, and the reassignation of an immutable (`a -= 1`) is not an alteration of the value.\n", "\n", "* Being aware of these nitpicks can save you hours of debugging effort in the long run. \n", "\n" @@ -9174,7 +9858,7 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "\n", - "- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/2.7/library/stdtypes.html#str.split)\n", + "- It might appear at first that the default separator for split is a single space `' '`, but as per the [docs](https://docs.python.org/3/library/stdtypes.html#str.split)\n", " > If sep is not specified or is `None`, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a None separator returns `[]`.\n", " > If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, `'1,,2'.split(',')` returns `['1', '', '2']`). Splitting an empty string with a specified separator returns `['']`.\n", "- Noticing how the leading and trailing whitespaces are handled in the following snippet will make things clear,\n" @@ -9520,7 +10204,7 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "+ `antigravity` module is one of the few easter eggs released by Python developers.\n", - "+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](http://xkcd.com/353/) about Python.\n", + "+ `import antigravity` opens up a web browser pointing to the [classic XKCD comic](https://xkcd.com/353/) about Python.\n", "+ Well, there's more to it. There's **another easter egg inside the easter egg**. If you look at the [code](https://github.com/python/cpython/blob/master/Lib/antigravity.py#L7-L17), there's a function defined that purports to implement the [XKCD's geohashing algorithm](https://xkcd.com/426/).\n", "\n" ] @@ -10707,6 +11391,31 @@ "**Output:**\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Traceback (most recent call last):\n", + " File \"\", line 1, in \n", + "AttributeError: 'A' object has no attribute '__variable'\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "A().__variable\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -10726,10 +11435,6 @@ } ], "source": [ - "Traceback (most recent call last):\n", - " File \"\", line 1, in \n", - "AttributeError: 'A' object has no attribute '__variable'\n", - "\n", "A().some_func()\n" ] }, @@ -10933,7 +11638,7 @@ } ], "source": [ - "# `pip install nump` first.\n", + "# `pip install numpy` first.\n", "import numpy as np\n", "\n", "def energy_send(x):\n", @@ -11562,6 +12267,441 @@ "\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Slowing down `dict` lookups *\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict = {str(i): 1 for i in range(1_000_000)}\n", + "another_dict = {str(i): 1 for i in range(1_000_000)}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:**\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "28.6 ns \u00b1 0.115 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "%timeit some_dict['5']\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "37.2 ns \u00b1 0.265 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n", + "\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "some_dict[1] = 1\n", + "%timeit some_dict['5']\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "28.5 ns \u00b1 0.142 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "%timeit another_dict['5']\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Traceback (most recent call last):\n", + " File \"\", line 1, in \n", + "KeyError: 1\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "another_dict[1] # Trying to access a key that doesn't exist\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "38.5 ns \u00b1 0.0913 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "%timeit another_dict['5']\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Why are same lookups becoming slower?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation:\n", + "+ CPython has a generic dictionary lookup function that handles all types of keys (`str`, `int`, any object ...), and a specialized one for the common case of dictionaries composed of `str`-only keys.\n", + "+ The specialized function (named `lookdict_unicode` in CPython's [source](https://github.com/python/cpython/blob/522691c46e2ae51faaad5bbbce7d959dd61770df/Objects/dictobject.c#L841)) knows all existing keys (including the looked-up key) are strings, and uses the faster & simpler string comparison to compare keys, instead of calling the `__eq__` method.\n", + "+ The first time a `dict` instance is accessed with a non-`str` key, it's modified so future lookups use the generic function.\n", + "+ This process is not reversible for the particular `dict` instance, and the key doesn't even have to exist in the dictionary. That's why attempting a failed lookup has the same effect.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \u25b6 Bloating instance `dict`s *\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "import sys\n", + "\n", + "class SomeClass:\n", + " def __init__(self):\n", + " self.some_attr1 = 1\n", + " self.some_attr2 = 2\n", + " self.some_attr3 = 3\n", + " self.some_attr4 = 4\n", + "\n", + "\n", + "def dict_size(o):\n", + " return sys.getsizeof(o.__dict__)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Output:** (Python 3.8, other Python 3 versions may vary a little)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "104\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1 = SomeClass()\n", + "o2 = SomeClass()\n", + "dict_size(o1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "104\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "dict_size(o2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "232\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "del o1.some_attr1\n", + "o3 = SomeClass()\n", + "dict_size(o3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "232\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "dict_size(o1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Let's try again... In a new interpreter:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "104 # as expected\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1 = SomeClass()\n", + "o2 = SomeClass()\n", + "dict_size(o1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "360\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o1.some_attr5 = 5\n", + "o1.some_attr6 = 6\n", + "dict_size(o1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "272\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "dict_size(o2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "232\n" + ] + }, + "output_type": "execute_result", + "metadata": {}, + "execution_count": null + } + ], + "source": [ + "o3 = SomeClass()\n", + "dict_size(o3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "What makes those dictionaries become bloated? And why are newly created objects bloated as well?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### \ud83d\udca1 Explanation:\n", + "+ CPython is able to reuse the same \"keys\" object in multiple dictionaries. This was added in [PEP 412](https://www.python.org/dev/peps/pep-0412/) with the motivation to reduce memory usage, specifically in dictionaries of instances - where keys (instance attributes) tend to be common to all instances.\n", + "+ This optimization is entirely seamless for instance dictionaries, but it is disabled if certain assumptions are broken.\n", + "+ Key-sharing dictionaries do not support deletion; if an instance attribute is deleted, the dictionary is \"unshared\", and key-sharing is disabled for all future instances of the same class.\n", + "+ Additionaly, if the dictionary keys have be resized (because new keys are inserted), they are kept shared *only* if they are used by a exactly single dictionary (this allows adding many attributes in the `__init__` of the very first created instance, without causing an \"unshare\"). If multiple instances exist when a resize happens, key-sharing is disabled for all future instances of the same class: CPython can't tell if your instances are using the same set of attributes anymore, and decides to bail out on attempting to share their keys.\n", + "+ A small tip, if you aim to lower your program's memory footprint: don't delete instance attributes, and make sure to initialize all attributes in your `__init__`!\n", + "\n", + "\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -11636,7 +12776,7 @@ " ```py\n", " >>> some_string = \"wtfpython\"\n", " >>> f'{some_string=}'\n", - " \"string='wtfpython'\"\n", + " \"some_string='wtfpython'\"\n", " ``` \n", "\n", "* Python uses 2 bytes for local variable storage in functions. In theory, this means that only 65536 variables can be defined in a function. However, python has a handy solution built in that can be used to store more than 2^16 variable names. The following code demonstrates what happens in the stack when more than 65536 local variables are defined (Warning: This code prints around 2^18 lines of text, so be prepared!):\n", @@ -11653,7 +12793,7 @@ " print(dis.dis(f))\n", " ```\n", " \n", - "* Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/2/library/multiprocessing.html) module.\n", + "* Multiple Python threads won't run your *Python code* concurrently (yes, you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the [Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock) in Python, all you're doing is making your threads execute on the same core turn by turn. Python threads are good for IO-bound tasks, but to achieve actual parallelization in Python for CPU-bound tasks, you might want to use the Python [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) module.\n", "\n", "* Sometimes, the `print` method might not print values immediately. For example,\n", "\n", @@ -11665,7 +12805,7 @@ " time.sleep(3)\n", " ```\n", "\n", - " This will print the `wtfpython` after 10 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n", + " This will print the `wtfpython` after 3 seconds due to the `end` argument because the output buffer is flushed either after encountering `\\n` or when the program finishes execution. We can force the buffer to flush by passing `flush=True` argument.\n", "\n", "* List slicing with out of the bounds indices throws no errors\n", " ```py\n", @@ -11684,7 +12824,7 @@ " True\n", " ```\n", "\n", - "* `int('\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](http://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n", + "* `int('\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669')` returns `123456789` in Python 3. In Python, Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. Here's an [interesting story](https://chris.improbable.org/2014/8/25/adventures-in-unicode-digits/) related to this behavior of Python.\n", "\n", "* You can separate numeric literals with underscores (for better readability) from Python 3 onwards.\n", "\n", @@ -11706,8 +12846,6 @@ " return result\n", " ```\n", " The behavior is due to the matching of empty substring(`''`) with slices of length 0 in the original string.\n", - "\n", - "**That's all folks!**\n", "\n" ] }, @@ -11760,6 +12898,17 @@ "source": [ "```py\n", ">>> (a := \"wtf_walrus\") # This works though\n", + "```\n", + "```py\n", + "'wtf_walrus'\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```py\n", ">>> a\n", "```\n", "```py\n", @@ -11798,6 +12947,17 @@ "source": [ "```py\n", ">>> (a := 6, 9)\n", + "```\n", + "```py\n", + "(6, 9)\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```py\n", ">>> a\n", "```\n", "```py\n", @@ -11954,7 +13114,7 @@ "\n", "- As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. \n", "\n", - "- The syntax of the Walrus operator is of the form `NAME: expr`, where `NAME` is a valid identifier, and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means, \n", + "- The syntax of the Walrus operator is of the form `NAME:= expr`, where `NAME` is a valid identifier, and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means, \n", "\n", " - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9) ` (where `a`'s value is 6')\n", "\n" @@ -12055,7 +13215,7 @@ "metadata": {}, "source": [ "\n", - "Phew, deleted at last. You might have guessed what saved from `__del__` being called in our first attempt to delete `x`. Let's add more twists to the example.\n", + "Phew, deleted at last. You might have guessed what saved `__del__` from being called in our first attempt to delete `x`. Let's add more twists to the example.\n", "\n", "2\\.\n" ] @@ -12104,9 +13264,9 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "+ `del x` doesn\u2019t directly call `x.__del__()`.\n", - "+ Whenever `del x` is encountered, Python decrements the reference count for `x` by one, and `x.__del__()` when x\u2019s reference count reaches zero.\n", - "+ In the second output snippet, `y.__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object, thus preventing the reference count from reaching zero when `del y` was encountered.\n", - "+ Calling `globals` caused the existing reference to be destroyed, and hence we can see \"Deleted!\" being printed (finally!).\n", + "+ When `del x` is encountered, Python deletes the name `x` from current scope and decrements by 1 the reference count of the object `x` referenced. `__del__()` is called only when the object's reference count reaches zero.\n", + "+ In the second output snippet, `__del__()` was not called because the previous statement (`>>> y`) in the interactive interpreter created another reference to the same object (specifically, the `_` magic variable which references the result value of the last non `None` expression on the REPL), thus preventing the reference count from reaching zero when `del y` was encountered.\n", + "+ Calling `globals` (or really, executing anything that will have a non `None` result) caused `_` to reference the new result, dropping the existing reference. Now the reference count reached 0 and we can see \"Deleted!\" being printed (finally!).\n", "\n" ] }, @@ -12184,7 +13344,7 @@ "source": [ "#### \ud83d\udca1 Explanation:\n", "\n", - "- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore get imported. This may lead to errors during runtime.\n", + "- It is often advisable to not use wildcard imports. The first obvious reason for this is, in wildcard imports, the names with a leading underscore don't get imported. This may lead to errors during runtime.\n", "- Had we used `from ... import a, b, c` syntax, the above `NameError` wouldn't have occurred.\n" ] }, @@ -12298,6 +13458,7 @@ "* https://github.com/cosmologicon/pywat#the-undocumented-converse-implication-operator\n", "* https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65\n", "* https://github.com/wemake-services/wemake-python-styleguide/search?q=wtfpython&type=Issues\n", + "* WFTPython discussion threads on [Hacker News](https://news.ycombinator.com/item?id=21862073) and [Reddit](https://www.reddit.com/r/programming/comments/edsh3q/what_the_fck_python_30_exploring_and/).\n", "\n", "# \ud83c\udf93 License\n", "\n",