- [Usage](#usage)

- [👀 Examples](#-examples)

- [Skipping lines?](#skipping-lines)

- [Well, something is fishy...](#well-something-is-fishy)

- [Time for some hash brownies!](#time-for-some-hash-brownies)

- [Evaluation time discrepancy](#evaluation-time-discrepancy)

- [Modifying a dictionary while iterating over it](#modifying-a-dictionary-while-iterating-over-it)

- [💡 Explanation:](#-explanation-1)

- [Backslashes at the end of string](#backslashes-at-the-end-of-string)

- [Let's make a giant string!](#lets-make-a-giant-string)

- [String concatenation interpreter optimizations.](#string-concatenation-interpreter-optimizations)

- [💡 Explanation:](#-explanation-3)

- [💡 Explanation:](#-explanation-4)

- [`is not ...` is different from `is (not ...)`](#is-not--is-different-from-is-not-)

- [The function inside loop sticks to the same output](#the-function-inside-loop-sticks-to-the-same-output)

- [Loop variables leaking out of local scope!](#loop-variables-leaking-out-of-local-scope)

- [💡 Explanation:](#-explanation-6)

- [💡 Explanation:](#-explanation-7)

- [💡 Explanation:](#-explanation-8)

- [💡 Explanation:](#-explanation-9)

- [💡 Explanation:](#-explanation-10)

- [💡 Explanation:](#-explanation-11)

- [💡 Explanation:](#-explanation-12)

- [💡 Explanation:](#-explanation-13)

- [💡 Explanation:](#-explanation-14)

- [Name resolution ignoring class scope](#name-resolution-ignoring-class-scope)

- [From filled to None in one instruction...](#from-filled-to-none-in-one-instruction)

- [Explicit typecast of strings](#explicit-typecast-of-strings)

- [Class attributes and instance attributes](#class-attributes-and-instance-attributes)

- [Catching the Exceptions!](#catching-the-exceptions)

- [Midnight time doesn't exist?](#midnight-time-doesnt-exist)

- [Counting the booleans](#counting-the-booleans)

- [Needle in a Haystack](#needle-in-a-haystack)

- [Loop variable resilient to changes](#loop-variable-resilient-to-changes)

- [Let's see if you can guess this?](#lets-see-if-you-can-guess-this)

- [Minor Ones](#minor-ones)

- [TODO: Hell of an example!](#todo-hell-of-an-example)

- [Contributing](#contributing)

**Note:** The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.

Some Unicode characters look identical to ASCII ones, but are considered distinct by the interpreter.

**Note:** If you're not able to reproduce this, try running the file [mixed_tabs_and_spaces.py](/mixed_tabs_and_spaces.py) via the shell.

* **Don't mix tabs and spaces!** The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.

* This is how Python handles tabs:

"Python" destroyed the existence of "JavaScript"?

* `5` (an `int` type) is implicitly converted to `5.0` (a `float` type) before calculating the hash in Python.

```py

Yes, it runs for exactly **eight** times and stops.

* Iteration over a dictionary that you edit at the same time is not supported.

* It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.

SyntaxError: EOL while scanning string literal

- In a raw string literal, as indicated by the prefix `r`, the backslash doesn't have the special meaning.

- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string.

10000 loops, best of 3: 75.3 µs per loop

- You can read more about [timeit](https://docs.python.org/3/library/timeit.html) from here. It is generally used to measure the execution time of snippets.

- Don't use `+` for generating long strings — In Python, `str` is immutable, so the left and right strings have to be copied into the new string for every pair of concatenations. If you concatenate four strings of length 10, you'll be copying (10+10) + ((10+10)+10) + (((10+10)+10)+10) = 90 characters instead of just 40 characters. Things get quadratically worse as the number and size of the string increases.

- Therefore, it's advised to use `.format.` or `%` syntax (however, they are slightly slower than `+` for short strings).

- `is not` is a single binary operator, and has behavior different than using `is` and `not` separated.

- `is not` evaluates to `False` if the variables on either side of the operator point to the same object and `True` otherwise.

[512, 512, 512, 512, 512, 512, 512, 512, 512, 512]

- 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.

* Class variables and variables in class instances are internally handled as dictionaries of a class object. If a variable name is not found in the dictionary of the current class, the parent classes are searched for it.

* The `+=` operator modifies the mutable object in-place without creating a new object. So changing the attribute of one instance affects the other instances and the class attribute as well.

SyntaxError: invalid syntax

* To add multiple Exceptions to the except clause, you need to pass them as parenthesized tuple as the first argument. The second argument is an optional name, which when supplied will bind the Exception instance that has been raised. Example,

```py