What the f*ck Python? 😱
Exploring and understanding Python through surprising snippets.
Translations: [Chinese 中文](https://github.com/leisurelicht/wtfpython-cn) | [Vietnamese Tiếng Việt](https://github.com/vuduclyunitn/wtfptyhon-vi) | [Spanish Español](https://web.archive.org/web/20220511161045/https://github.com/JoseDeFreitas/wtfpython-es) | [Korean 한국어](https://github.com/buttercrab/wtfpython-ko) | [Russian Русский](https://github.com/satwikkansal/wtfpython/tree/master/translations/ru-russian) | [German Deutsch](https://github.com/BenSt099/wtfpython) | [Persian فارسی](https://github.com/satwikkansal/wtfpython/tree/master/translations/fa-farsi) | [Add translation](https://github.com/satwikkansal/wtfpython/issues/new?title=Add%20translation%20for%20[LANGUAGE]&body=Expected%20time%20to%20finish:%20[X]%20weeks.%20I%27ll%20start%20working%20on%20it%20from%20[Y].) Other modes: [Interactive Website](https://wtfpython-interactive.vercel.app) | [Interactive Notebook](https://colab.research.google.com/github/satwikkansal/wtfpython/blob/master/irrelevant/wtf.ipynb) Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious at first sight. Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python. While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I believe that you'll find it interesting too! If you're an experienced Python programmer, you can take it as a challenge to get most of them right in the first attempt You may have already experienced some of them before, and I might be able to revive sweet old memories of yours! :sweat_smile: PS: If you're a returning reader, you can learn about the new modifications [here](https://github.com/satwikkansal/wtfpython/releases/) (the examples marked with asterisk are the ones added in the latest major revision). So, here we go... # Table of Contents - [Structure of the Examples](#structure-of-the-examples) - [▶ Some fancy Title](#-some-fancy-title) - [Usage](#usage) - [👀 Examples](#-examples) - [Section: Strain your brain!](#section-strain-your-brain) - [▶ First things first! \*](#-first-things-first-) - [▶ Strings can be tricky sometimes](#-strings-can-be-tricky-sometimes) - [▶ Be careful with chained operations](#-be-careful-with-chained-operations) - [▶ How not to use `is` operator](#-how-not-to-use-is-operator) - [▶ Hash brownies](#-hash-brownies) - [▶ Deep down, we're all the same.](#-deep-down-were-all-the-same) - [▶ Disorder within order \*](#-disorder-within-order-) - [▶ Keep trying... \*](#-keep-trying-) - [▶ For what?](#-for-what) - [▶ Evaluation time discrepancy](#-evaluation-time-discrepancy) - [▶ `is not ...` is not `is (not ...)`](#-is-not--is-not-is-not-) - [▶ A tic-tac-toe where X wins in the first attempt!](#-a-tic-tac-toe-where-x-wins-in-the-first-attempt) - [▶ Schrödinger's variable](#-schrödingers-variable-) - [▶ The chicken-egg problem \*](#-the-chicken-egg-problem-) - [▶ Subclass relationships](#-subclass-relationships) - [▶ Methods equality and identity](#-methods-equality-and-identity) - [▶ All-true-ation \*](#-all-true-ation-) - [▶ The surprising comma](#-the-surprising-comma) - [▶ Strings and the backslashes](#-strings-and-the-backslashes) - [▶ not knot!](#-not-knot) - [▶ Half triple-quoted strings](#-half-triple-quoted-strings) - [▶ What's wrong with booleans?](#-whats-wrong-with-booleans) - [▶ Class attributes and instance attributes](#-class-attributes-and-instance-attributes) - [▶ yielding None](#-yielding-none) - [▶ Yielding from... return! \*](#-yielding-from-return-) - [▶ Nan-reflexivity \*](#-nan-reflexivity-) - [▶ Mutating the immutable!](#-mutating-the-immutable) - [▶ The disappearing variable from outer scope](#-the-disappearing-variable-from-outer-scope) - [▶ The mysterious key type conversion](#-the-mysterious-key-type-conversion) - [▶ Let's see if you can guess this?](#-lets-see-if-you-can-guess-this) - [▶ Exceeds the limit for integer string conversion](#-exceeds-the-limit-for-integer-string-conversion) - [Section: Slippery Slopes](#section-slippery-slopes) - [▶ Modifying a dictionary while iterating over it](#-modifying-a-dictionary-while-iterating-over-it) - [▶ Stubborn `del` operation](#-stubborn-del-operation) - [▶ The out of scope variable](#-the-out-of-scope-variable) - [▶ Deleting a list item while iterating](#-deleting-a-list-item-while-iterating) - [▶ Lossy zip of iterators \*](#-lossy-zip-of-iterators-) - [▶ Loop variables leaking out!](#-loop-variables-leaking-out) - [▶ Beware of default mutable arguments!](#-beware-of-default-mutable-arguments) - [▶ Catching the Exceptions](#-catching-the-exceptions) - [▶ Same operands, different story!](#-same-operands-different-story) - [▶ Name resolution ignoring class scope](#-name-resolution-ignoring-class-scope) - [▶ Rounding like a banker \*](#-rounding-like-a-banker-) - [▶ Needles in a Haystack \*](#-needles-in-a-haystack-) - [▶ Splitsies \*](#-splitsies-) - [▶ Wild imports \*](#-wild-imports-) - [▶ All sorted? \*](#-all-sorted-) - [▶ Midnight time doesn't exist?](#-midnight-time-doesnt-exist) - [Section: The Hidden treasures!](#section-the-hidden-treasures) - [▶ Okay Python, Can you make me fly?](#-okay-python-can-you-make-me-fly) - [▶ `goto`, but why?](#-goto-but-why) - [▶ Brace yourself!](#-brace-yourself) - [▶ Let's meet Friendly Language Uncle For Life](#-lets-meet-friendly-language-uncle-for-life) - [▶ Even Python understands that love is complicated](#-even-python-understands-that-love-is-complicated) - [▶ Yes, it exists!](#-yes-it-exists) - [▶ Ellipsis \*](#-ellipsis-) - [▶ Inpinity](#-inpinity) - [▶ Let's mangle](#-lets-mangle) - [Section: Appearances are deceptive!](#section-appearances-are-deceptive) - [▶ Skipping lines?](#-skipping-lines) - [▶ Teleportation](#-teleportation) - [▶ Well, something is fishy...](#-well-something-is-fishy) - [Section: Miscellaneous](#section-miscellaneous) - [▶ `+=` is faster](#--is-faster) - [▶ Let's make a giant string!](#-lets-make-a-giant-string) - [▶ Slowing down `dict` lookups \*](#-slowing-down-dict-lookups-) - [▶ Bloating instance `dict`s \*](#-bloating-instance-dicts-) - [▶ Minor Ones \*](#-minor-ones-) - [Contributing](#contributing) - [Acknowledgements](#acknowledgements) - [🎓 License](#-license) - [Surprise your friends as well!](#surprise-your-friends-as-well) - [More content like this?](#more-content-like-this) # Structure of the Examples All the examples are structured like below: > ## Section: (if necessary) > > ### ▶ Some fancy Title > > ```py > # Set up the code. > # Preparation for the magic... > ``` > > **Output (Python version(s)):** > > ```py > >>> triggering_statement > Some unexpected output > ``` > > (Optional): One line describing the unexpected output. > > #### 💡 Explanation: > > - Brief explanation of what's happening and why is it happening. > > ```py > # Set up code > # More examples for further clarification (if necessary) > ``` > > **Output (Python version(s)):** > > ```py > >>> trigger # some example that makes it easy to unveil the magic > # some justified output > ``` **Note:** All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified before the output. # Usage A nice way to get the most out of these examples, in my opinion, is to read them in sequential order, and for every example: - Carefully read the initial code for setting up the example. If you're an experienced Python programmer, you'll successfully anticipate what's going to happen next most of the time. - Read the output snippets and, - Check if the outputs are the same as you'd expect. - Make sure if you know the exact reason behind the output being the way it is. - If the answer is no (which is perfectly okay), take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue [here](https://github.com/satwikkansal/wtfpython/issues/new)). - If yes, give a gentle pat on your back, and you may skip to the next example. --- # 👀 Examples ## Section: Strain your brain! ### ▶ First things first! \* For some reason, the Python 3.8's "Walrus" operator (`:=`) has become quite popular. Let's check it out, 1\. ```py # Python version 3.8+ >>> a = "wtf_walrus" >>> a 'wtf_walrus' >>> a := "wtf_walrus" File "", line 1 a := "wtf_walrus" ^ SyntaxError: invalid syntax >>> (a := "wtf_walrus") # This works though 'wtf_walrus' >>> a 'wtf_walrus' ``` 2 \. ```py # Python version 3.8+ >>> a = 6, 9 >>> a (6, 9) >>> (a := 6, 9) (6, 9) >>> a 6 >>> a, b = 6, 9 # Typical unpacking >>> a, b (6, 9) >>> (a, b = 16, 19) # Oops File "", line 1 (a, b = 16, 19) ^ SyntaxError: invalid syntax >>> (a, b := 16, 19) # This prints out a weird 3-tuple (6, 16, 19) >>> a # a is still unchanged? 6 >>> b 16 ``` #### 💡 Explanation The Walrus operator (`:=`) was introduced in Python 3.8, it can be useful in situations where you'd want to assign values to variables within an expression. ```py def some_func(): # Assume some expensive computation here # time.sleep(1000) return 5 # So instead of, if some_func(): print(some_func()) # Which is bad practice since computation is happening twice # or a = some_func() if a: print(a) # Now you can concisely write if a := some_func(): print(a) ``` **Output (> 3.8):** ```py 5 5 5 ``` This saved one line of code, and implicitly prevented invoking `some_func` twice. - Unparenthesized "assignment expression" (use of walrus operator), is restricted at the top level, hence the `SyntaxError` in the `a := "wtf_walrus"` statement of the first snippet. Parenthesizing it worked as expected and assigned `a`. - As usual, parenthesizing of an expression containing `=` operator is not allowed. Hence the syntax error in `(a, b = 6, 9)`. - The syntax of the Walrus operator is of the form `NAME:= expr`, where `NAME` is a valid identifier, and `expr` is a valid expression. Hence, iterable packing and unpacking are not supported which means, - `(a := 6, 9)` is equivalent to `((a := 6), 9)` and ultimately `(a, 9)` (where `a`'s value is 6') ```py >>> (a := 6, 9) == ((a := 6), 9) True >>> x = (a := 696, 9) >>> x (696, 9) >>> x[0] is a # Both reference same memory location True ``` - Similarly, `(a, b := 16, 19)` is equivalent to `(a, (b := 16), 19)` which is nothing but a 3-tuple. --- ### ▶ Strings can be tricky sometimes 1\. Notice that both the ids are same. ```python:snippets/2_tricky_strings.py -s 2 -e 3 assert id("some_string") == id("some" + "_" + "string") assert id("some_string") == id("some_string") ``` 2\. `True` because it is invoked in script. Might be `False` in `python shell` or `ipython` ```python:snippets/2_tricky_strings.py -s 6 -e 12 a = "wtf" b = "wtf" assert a is b a = "wtf!" b = "wtf!" assert a is b ``` 3\. `True` because it is invoked in script. Might be `False` in `python shell` or `ipython` ```python:sn