What the f*ck Python
What the f*ck Python!
From https://github.com/satwikkansal/wtfpython
An interesting collection of surprising snippets and lesser-known Python features.
Python, being a beautifully designed high-level and interpreter-based programming language, provides us with many features for the programmer's comfort. But sometimes, the outcomes of a Python snippet may not seem obvious to a regular user at first sight.
Here is a fun project to collect such tricky & counter-intuitive examples and lesser-known features in Python, attempting to discuss what exactly is happening under the hood!
While some of the examples you see below may not be WTFs in the truest sense, but they'll reveal some of the interesting parts of Python that you might be unaware of. I find it a nice way to learn the internals of a programming language, and I think you'll find them interesting as well!
If you're an experienced Python programmer, you can take it as a challenge to get most of them right in first attempt. You may be already familiar with some of these examples, and I might be able to revive sweet old memories of yours being bitten by these gotchas
PS: If you're a returning reader, you can learn about the new modifications
So, here we go...
Table of Contents
- Structure of the Examples
- Usage
- Examples
- Section: Strain your brain!
- ▶ Strings can be tricky sometimes *
- ▶ Time for some hash brownies!
- ▶ Return return everywhere!
- ▶ Deep down, we're all the same. *
- ▶ For what?
- ▶ Evaluation time discrepancy
- ▶
is
is not what it is! - ▶ A tic-tac-toe where X wins in the first attempt!
- ▶ The sticky output function
- ▶
is not ...
is notis (not ...)
- ▶ The surprising comma
- ▶ Backslashes at the end of string
- ▶ not knot!
- ▶ Half triple-quoted strings
- ▶ Midnight time doesn't exist?
- ▶ What's wrong with booleans?
- ▶ Class attributes and instance attributes
- ▶ yielding None
- ▶ Mutating the immutable!
- ▶ The disappearing variable from outer scope
- ▶ When True is actually False
- ▶ From filled to None in one instruction...
- ▶ Subclass relationships *
- ▶ The mysterious key type conversion *
- ▶ Let's see if you can guess this?
- Section: Appearances are deceptive!
- Section: Watch out for the landmines!
- ▶ Modifying a dictionary while iterating over it
- ▶ Stubborn
del
operator * - ▶ Deleting a list item while iterating
- ▶ Loop variables leaking out!
- ▶ Beware of default mutable arguments!
- ▶ Catching the Exceptions
- ▶ Same operands, different story!
- ▶ The out of scope variable
- ▶ Be careful with chained operations
- ▶ Name resolution ignoring class scope
- ▶ Needle in a Haystack
- Section: The Hidden treasures!
- Section: Miscellaneous
- Section: Strain your brain!
- Contributing
- Acknowledgements
- License
Structure of the Examples
All the examples are structured like below:
▶ Some fancy Title *
The asterisk at the end of the title indicates the example was not present in the first release and has been recently added.
# Setting up the code. # Preparation for the magic...Output (Python version):
>>> triggering_statement Probably unexpected output(Optional): One line describing the unexpected output.
Explanation:
- Brief explanation of what's happening and why is it happening.
Setting up examples for clarification (if necessary)Output:>>> trigger # some example that makes it easy to unveil the magic # some justified output
Note: All the examples are tested on Python 3.5.2 interactive interpreter, and they should work for all the Python versions unless explicitly specified in the description.
Usage
A nice way to get the most out of these examples, in my opinion, will be just to read the examples chronologically, and for every example:
- Carefully read the initial code for setting up the example. If you're an experienced Python programmer, most of the times you will successfully anticipate what's going to happen next.
- Read the output snippets and,
- Check if the outputs are the same as you'd expect.
- Make sure if you know the exact reason behind the output being the way it is.
- If no, take a deep breath, and read the explanation (and if you still don't understand, shout out! and create an issue here).
- If yes, give a gentle pat on your back, and you may skip to the next example.
PS: You can also read WTFpython at the command line. There's a pypi package and an npm package (supports colored formatting) for the same.
To install the npm package wtfpython
$ npm install -g wtfpython
Alternatively, to install the pypi package wtfpython
$ pip install wtfpython -U
Now, just run wtfpython
at the command line which will open this collection in your selected $PAGER
.
Examples
Section: Strain your brain!
▶ Strings can be tricky sometimes *
1.
>>> a = "some_string" >>> id(a) 140420665652016 >>> id("some" + "_" + "string") # Notice that both the ids are same. 140420665652016
2.
>>> a = "wtf" >>> b = "wtf" >>> a is b True >>> a = "wtf!" >>> b = "wtf!" >>> a is b False >>> a, b = "wtf!", "wtf!" >>> a is b True
3.
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa' True >>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa' False
Makes sense, right?
Explanation:
- Such behavior is due to CPython optimization (called string interning) that tries to use existing immutable objects in some cases rather than creating a new object every time.
- After being interned, many variables may point to the same string object in memory (thereby saving memory).
- In the snippets above, strings are implicitly interned. The decision of when to implicitly intern a string is implementation dependent. There are some facts that can be used to guess if a string will be interned or not:
- All length 0 and length 1 strings are interned.
- Strings are interned at compile time (
'wtf'
will be interned but''.join(['w', 't', 'f']
will not be interned) - Strings that are not composed of ASCII letters, digits or underscores, are not interned. This explains why
'wtf!'
was not interned due to!
. Cpython implementation of this rule can be found here
- When
a
andb
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 alreadywtf!
as an object (because"wtf!"
is not implicitly interned as per the facts mentioned above). It's a compiler optimization and specifically applies to the interactive environment. - Constant folding is a technique for peephole optimization in Python. This means the expression
'a'*20
is replaced by'aaaaaaaaaaaaaaaaaaaa'
during compilation to reduce few clock cycles during runtime. Constant folding only occurs for strings having length less than 20. (Why? Imagine the size of.pyc
file generated as a result of the expression'a'*10**10
). Here's the implementation source for the same.
▶ Time for some hash brownies!
1.
some_dict = {} some_dict[5.5] = "Ruby" some_dict[5.0] = "JavaScript" some_dict[5] = "Python"
Output:
>>> some_dict[5.5] "Ruby" >>> some_dict[5.0] "Python" >>> some_dict[5] "Python"
"Python" destroyed the existence of "JavaScript"?
Explanation
- Python dictionaries check for equality and compare the hash value to determine if two keys are the same.
- Immutable objects with same value always have the same hash in Python.
>>> 5 == 5.0 True >>> hash(5) == hash(5.0) True
Note: Objects with different values may also have same hash (known as hash collision). - When the statement
some_dict[5] = "Python"
is executed, the existing value "JavaScript" is overwritten with "Python" because Python recognizes5
and5.0
as the same keys of the dictionarysome_dict
. - This StackOverflow answer explains beautifully the rationale behind it.
▶ Return return everywhere!
def some_func(): try: return 'from_try' finally: return 'from_finally'
Output:
>>> some_func() 'from_finally'
Explanation:
- When a
return
,break
orcontinue
statement is executed in thetry
suite of a "try…finally" statement, thefinally
clause is also executed ‘on the way out. - The return value of a function is determined by the last
return
statement executed. Since thefinally
clause always executes, areturn
statement executed in thefinally
clause will always be the last one executed.
▶ Deep down, we're all the same. *
class WTF: pass
Output:
>>> WTF() == WTF() # two different instances can't be equal False >>> WTF() is WTF() # identities are also different False >>> hash(WTF()) == hash(WTF()) # hashes _should_ be different as well True >>> id(WTF()) == id(WTF()) True
Explanation:
-
When
id
was called, Python created aWTF
class object and passed it to theid
function. Theid
function takes itsid
(its memory location), and throws away the object. The object is destroyed. -
When we do this twice in succession, Python allocates the same memory location to this second object as well. Since (in CPython)
id
uses the memory location as the object id, the id of the two objects is the same. -
So, object's id is unique only for the lifetime of the object. After the object is destroyed, or before it is created, something else can have the same id.
-
But why did the
is
operator evaluated toFalse
? Let's see with this snippet.class WTF(object): def __init__(self): print("I") def __del__(self): print("D")
Output:
>>> WTF() is WTF() I I D D False >>> id(WTF()) == id(WTF()) I D I D True
As you may observe, the order in which the objects are destroyed is what made all the difference here.
▶ For what?
some_string = "wtf" some_dict = {} for i, some_dict[i] in enumerate(some_string): pass
Output:
>>> some_dict # An indexed dict is created. {0: 'w', 1: 't', 2: 'f'}
Explanation:
-
A
for
statement is defined in the Python grammar as:for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
Where
exprlist
is the assignment target. This means that the equivalent of{exprlist} = {next_value}
is executed for each item in the iterable. An interesting example that illustrates this:for i in range(4): print(i) i = 10
Output:
0 1 2 3
Did you expect the loop to run just once?
Explanation:
- The assignment statement
i = 10
never affects the iterations of the loop because of the way for loops work in Python. Before the beginning of every iteration, the next item provided by the iterator (range(4)
this case) is unpacked and assigned the target list variables (i
in this case).
- The assignment statement
-
The
enumerate(some_string)
function yields a new valuei
(A counter going up) and a character from thesome_string
in each iteration. It then sets the (just assigned)i
key of the dictionarysome_dict
to that character. The unrolling of the loop can be simplified as:>>> i, some_dict[i] = (0, 'w') >>> i, some_dict[i] = (1, 't') >>> i, some_dict[i] = (2, 'f') >>> some_dict
▶ Evaluation time discrepancy
1.
array = [1, 8, 15] g = (x for x in array if array.count(x) > 0) array = [2, 8, 22]
Output:
>>> print(list(g)) [8]
2.
array_1 = [1,2,3,4] g1 = (x for x in array_1) array_1 = [1,2,3,4,5] array_2 = [1,2,3,4] g2 = (x for x in array_2) array_2[:] = [1,2,3,4,5]
Output:
>>> print(list(g1)) [1,2,3,4] >>> print(list(g2)) [1,2,3,4,5]
Explanation
- In a generator expression, the
in
clause is evaluated at declaration time, but the conditional clause is evaluated at runtime. - So before runtime,
array
is re-assigned to the list[2, 8, 22]
, and since out of1
,8
and15
, only the count of8
is greater than0
, the generator only yields8
. - The differences in the output of
g1
andg2
in the second part is due the way variablesarray_1
andarray_2
are re-assigned values. - In the first case,
array_1
is binded to the new object[1,2,3,4,5]
and since thein
clause is evaluated at the declaration time it still refers to the old object[1,2,3,4]
(which is not destroyed). - In the second case, the slice assignment to
array_2
updates the same old object[1,2,3,4]
to[1,2,3,4,5]
. Hence both theg2
andarray_2
still have reference to the same object (which has now been updated to[1,2,3,4,5]
).
▶ is
is not what it is!
The following is a very famous example present all over the internet.
>>> a = 256 >>> b = 256 >>> a is b True >>> a = 257 >>> b = 257 >>> a is b False >>> a = 257; b = 257 >>> a is b True
Explanation:
The difference between is
and ==
is
operator checks if both the operands refer to the same object (i.e., it checks if the identity of the operands matches or not).==
operator compares the values of both the operands and checks if they are the same.- So
is
is for reference equality and==
is for value equality. An example to clear things up,>>> [] == [] True >>> [] is [] # These are two empty lists at two different memory locations. False
256
is an existing object but 257
isn't
When you start up python the numbers from -5
to 256
will be allocated. These numbers are used a lot, so it makes sense just to have them ready.
Quoting from https://docs.python.org/3/c-api/long.html
The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you just get back a reference to the existing object. So it should be possible to change the value of 1. I suspect the behavior of Python, in this case, is undefined. :-)
>>> id(256) 10922528 >>> a = 256 >>> b = 256 >>> id(a) 10922528 >>> id(b) 10922528 >>> id(257) 140084850247312 >>> x = 257 >>> y = 257 >>> id(x) 140084850247440 >>> id(y) 140084850247344
Here the interpreter isn't smart enough while executing y = 257
to recognize that we've already created an integer of the value 257,
and so it goes on to create another object in the memory.
Both a
and b
refer to the same object when initialized with same value in the same line.
>>> a, b = 257, 257 >>> id(a) 140640774013296 >>> id(b) 140640774013296 >>> a = 257 >>> b = 257 >>> id(a) 140640774013392 >>> id(b) 140640774013488
- When a and b are set to
257
in the same line, the Python interpreter creates a new object, then references the second variable at the same time. If you do it on separate lines, it doesn't "know" that there's already257
as an object. - It's a compiler optimization and specifically applies to the interactive environment. When you enter two lines in a live interpreter, they're compiled separately, therefore optimized separately. If you were to try this example in a
.py
file, you would not see the same behavior, because the file is compiled all at once.
▶ A tic-tac-toe where X wins in the first attempt!
# Let's initialize a row row = [""]*3 #row i['', '', ''] # Let's make a board board = [row]*3
Output:
>>> board [['', '', ''], ['', '', ''], ['', '', '']] >>> board[0] ['', '', ''] >>> board[0][0] '' >>> board[0][0] = "X" >>> board [['X', '', ''], ['X', '', ''], ['X', '', '']]
We didn't assign 3 "X"s or did we?
Explanation:
When we initialize row
variable, this visualization explains what happens in the memory
And when the board
is initialized by multiplying the row
, this is what happens inside the memory (each of the elements board[0]
, board[1]
and board[2]
is a reference to the same list referred by row
)
We can avoid this scenario here by not using row
variable to generate board
. (Asked in this issue).
>>> board = [['']*3 for _ in range(3)] >>> board[0][0] = "X" >>> board [['X', '', ''], ['', '', ''], ['', '', '']]
▶ The sticky output function
funcs = [] results = [] for x in range(7): def some_func(): return x funcs.append(some_func) results.append(some_func()) # note the function call here funcs_results = [func() for func in funcs]
Output:
>>> results [0, 1, 2, 3, 4, 5, 6] >>> funcs_results [6, 6, 6, 6, 6, 6, 6]
Even when the values of x
were different in every iteration prior to appending some_func
to funcs
, all the functions return 6.
//OR
>>> powers_of_x = [lambda x: x**i for i in range(10)] >>> [f(2) for f in powers_of_x] [512, 512, 512, 512, 512, 512, 512, 512, 512, 512]
Explanation
-
When defining a function inside a loop that uses the loop variable in its body, the loop function's closure is bound to the variable, not its value. So all of the functions use the latest value assigned to the variable for computation.
-
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.
funcs = [] for x in range(7): def some_func(x=x): return x funcs.append(some_func)
Output:
>>> funcs_results = [func() for func in funcs] >>> funcs_results [0, 1, 2, 3, 4, 5, 6]
▶ is not ...
is not is (not ...)
>>> 'something' is not None True >>> 'something' is (not None) False
Explanation
is not
is a single binary operator, and has behavior different than usingis
andnot
separated.is not
evaluates toFalse
if the variables on either side of the operator point to the same object andTrue
otherwise.
▶ The surprising comma
Output:
>>> def f(x, y,): ... print(x, y) ... >>> def g(x=4, y=5,): ... print(x, y) ... >>> def h(x, **kwargs,): File "<stdin>", line 1 def h(x, **kwargs,): ^ SyntaxError: invalid syntax >>> def h(*args,): File "<stdin>", line 1 def h(*args,): ^ SyntaxError: invalid syntax
Explanation:
- Trailing comma is not always legal in formal parameters list of a Python function.
- In Python, the argument list is defined partially with leading commas and partially with trailing commas. This conflict causes situations where a comma is trapped in the middle, and no rule accepts it.
- Note: The trailing comma problem is fixed in Python 3.6. The remarks in this post discuss in brief different usages of trailing commas in Python.
▶ Backslashes at the end of string
Output:
>>> print("\\ C:\\")
\ C:\
>>> print(r"\ C:")
\ C:
>>> print(r"\ C:\")
File "<stdin>", line 1
print(r"\ C:\")
^
SyntaxError: EOL while scanning string literal
Explanation
- In a raw string literal, as indicated by the prefix
r
, the backslash doesn't have the special meaning.>>> print(repr(r"wt\"f")) 'wt\\"f'
- What the interpreter actually does, though, is simply change the behavior of backslashes, so they pass themselves and the following character through. That's why backslashes don't work at the end of a raw string.
▶ not knot!
x = True y = False
Output:
>>> not x == y True >>> x == not y File "<input>", line 1 x == not y ^ SyntaxError: invalid syntax
Explanation:
- Operator precedence affects how an expression is evaluated, and
==
operator has higher precedence thannot
operator in Python. - So
not x == y
is equivalent tonot (x == y)
which is equivalent tonot (True == False)
finally evaluating toTrue
. - But
x == not y
raises aSyntaxError
because it can be thought of being equivalent to(x == not) y
and notx == (not y)
which you might have expected at first sight. - The parser expected the
not
token to be a part of thenot in
operator (because both==
andnot in
operators have the same precedence), but after not being able to find anin
token following thenot
token, it raises aSyntaxError
.
▶ Half triple-quoted strings
Output:
>>> print('wtfpython''') wtfpython >>> print("wtfpython""") wtfpython >>> # The following statements raise `SyntaxError` >>> # print('''wtfpython') >>> # print("""wtfpython")
Explanation:
- Python supports implicit string literal concatenation, Example,
>>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" wtf
'''
and"""
are also string delimiters in Python which causes a SyntaxError because the Python interpreter was expecting a terminating triple quote as delimiter while scanning the currently encountered triple quoted string literal.
▶ Midnight time doesn't exist?
from datetime import datetime midnight = datetime(2018, 1, 1, 0, 0) midnight_time = midnight.time() noon = datetime(2018, 1, 1, 12, 0) noon_time = noon.time() if midnight_time: print("Time at midnight is", midnight_time) if noon_time: print("Time at noon is", noon_time)
Output:
('Time at noon is', datetime.time(12, 0))
The midnight time is not printed.
Explanation:
Before Python 3.5, the boolean value for datetime.time
object was considered to be False
if it represented midnight in UTC. It is error-prone when using the if obj:
syntax to check if the obj
is null or some equivalent of "empty."
▶ What's wrong with booleans?
1.
# A simple example to count the number of boolean and # integers in an iterable of mixed data types. mixed_list = [False, 1.0, "some_string", 3, True, [], False] integers_found_so_far = 0 booleans_found_so_far = 0 for item in mixed_list: if isinstance(item, int): integers_found_so_far += 1 elif isinstance(item, bool): booleans_found_so_far += 1
Output:
>>> integers_found_so_far 4 >>> booleans_found_so_far 0
2.
another_dict = {} another_dict[True] = "JavaScript" another_dict[1] = "Ruby" another_dict[1.0] = "Python"
Output:
>>> another_dict[True] "Python"
3.
>>> some_bool = True >>> "wtf"*some_bool 'wtf' >>> some_bool = False >>> "wtf"*some_bool ''
Explanation:
-
Booleans are a subclass of
int
>>> isinstance(True, int) True >>> isinstance(False, int) True
-
The integer value of
True
is1
and that ofFalse
is0
.>>> True == 1 == 1.0 and False == 0 == 0.0 True
-
See this StackOverflow answer for the rationale behind it.
▶ Class attributes and instance attributes
1.
class A: x = 1 class B(A): pass class C(A): pass
Ouptut:
>>> A.x, B.x, C.x (1, 1, 1) >>> B.x = 2 >>> A.x, B.x, C.x (1, 2, 1) >>> A.x = 3 >>> A.x, B.x, C.x (3, 2, 3) >>> a = A() >>> a.x, A.x (3, 3) >>> a.x += 1 >>> a.x, A.x (4, 3)
2.
class SomeClass: some_var = 15 some_list = [5] another_list = [5] def __init__(self, x): self.some_var = x + 1 self.some_list = self.some_list + [x] self.another_list += [x]
Output:
>>> some_obj = SomeClass(420) >>> some_obj.some_list [5, 420] >>> some_obj.another_list [5, 420] >>> another_obj = SomeClass(111) >>> another_obj.some_list [5, 111] >>> another_obj.another_list [5, 420, 111] >>> another_obj.another_list is SomeClass.another_list True >>> another_obj.another_list is some_obj.another_list True
Explanation:
- 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.
▶ yielding None
some_iterable = ('a', 'b') def some_func(val): return "something"
Output:
>>> [x for x in some_iterable] ['a', 'b'] >>> [(yield x) for x in some_iterable] <generator object <listcomp> at 0x7f70b0a4ad58> >>> list([(yield x) for x in some_iterable]) ['a', 'b'] >>> list((yield x) for x in some_iterable) ['a', None, 'b', None] >>> list(some_func((yield x)) for x in some_iterable) ['a', 'something', 'b', 'something']
Explanation:
- Source and explanation can be found here: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
- Related bug report: http://bugs.python.org/issue10544
▶ Mutating the immutable!
some_tuple = ("A", "tuple", "with", "values") another_tuple = ([1, 2], [3, 4], [5, 6])
Output:
>>> some_tuple[2] = "change this" TypeError: 'tuple' object does not support item assignment >>> another_tuple[2].append(1000) #This throws no error >>> another_tuple ([1, 2], [3, 4], [5, 6, 1000]) >>> another_tuple[2] += [99, 999] TypeError: 'tuple' object does not support item assignment >>> another_tuple ([1, 2], [3, 4], [5, 6, 1000, 99, 999])
But I thought tuples were immutable...
Explanation:
-
Quoting from https://docs.python.org/2/reference/datamodel.html
Immutable sequences An object of an immutable sequence type cannot change once it is created. (If the object contains references to other objects, these other objects may be mutable and may be modified; however, the collection of objects directly referenced by an immutable object cannot change.)
-
+=
operator changes the list in-place. The item assignment doesn't work, but when the exception occurs, the item has already been changed in place.
▶ The disappearing variable from outer scope
e = 7 try: raise Exception() except Exception as e: pass
Output (Python 2.x):
>>> print(e) # prints nothing
Output (Python 3.x):
>>> print(e) NameError: name 'e' is not defined
Explanation:
-
Source: https://docs.python.org/3/reference/compound_stmts.html#except
When an exception has been assigned using
as
target, it is cleared at the end of the except clause. This is as ifexcept E as N: foo
was translated into
except E as N: try: foo finally: del N
This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because, with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.
-
The clauses are not scoped in Python. Everything in the example is present in the same scope, and the variable
e
got removed due to the execution of theexcept
clause. The same is not the case with functions which have their separate inner-scopes. The example below illustrates this:def f(x): del(x) print(x) x = 5 y = [5, 4, 3]
Output:
>>>f(x) UnboundLocalError: local variable 'x' referenced before assignment >>>f(y) UnboundLocalError: local variable 'x' referenced before assignment >>> x 5 >>> y [5, 4, 3]
-
In Python 2.x the variable name
e
gets assigned toException()
instance, so when you try to print, it prints nothing.Output (Python 2.x):
>>> e Exception() >>> print e # Nothing is printed!
▶ When True is actually False
True = False if True == False: print("I've lost faith in truth!")
Output:
I've lost faith in truth!
Explanation:
- Initially, Python used to have no
bool
type (people used 0 for false and non-zero value like 1 for true). Then they addedTrue
,False
, and abool
type, but, for backward compatibility, they couldn't makeTrue
andFalse
constants- they just were built-in variables. - Python 3 was backward-incompatible, so it was now finally possible to fix that, and so this example won't work with Python 3.x!
▶ From filled to None in one instruction...
some_list = [1, 2, 3] some_dict = { "key_1": 1, "key_2": 2, "key_3": 3 } some_list = some_list.append(4) some_dict = some_dict.update({"key_4": 4})
Output:
>>> print(some_list) None >>> print(some_dict) None
Explanation
Most methods that modify the items of sequence/mapping objects like list.append
, dict.update
, list.sort
, etc. modify the objects in-place and return None
. The rationale behind this is to improve performance by avoiding making a copy of the object if the operation can be done in-place (Referred from here)
▶ Subclass relationships *
Output:
>>> from collections import Hashable >>> issubclass(list, object) True >>> issubclass(object, Hashable) True >>> issubclass(list, Hashable) False
The Subclass relationships were expected to be transitive, right? (i.e., if A
is a subclass of B
, and B
is a subclass of C
, the A
should a subclass of C
)
Explanation:
- Subclass relationships are not necessarily transitive in Python. Anyone is allowed to define their own, arbitrary
__subclasscheck__
in a metaclass. - When
issubclass(cls, Hashable)
is called, it simply looks for non-Falsey "__hash__
" method incls
or anything it inherits from. - Since
object
is hashable, butlist
is non-hashable, it breaks the transitivity relation. - More detailed explanation can be found here.
▶ The mysterious key type conversion *
class SomeClass(str): pass some_dict = {'s':42}
Output:
>>> type(list(some_dict.keys())[0]) str >>> s = SomeClass('s') >>> some_dict[s] = 40 >>> some_dict # expected: Two different keys-value pairs {'s': 40} >>> type(list(some_dict.keys())[0]) str
Explanation:
-
Both the object
s
and the string"s"
hash to the same value becauseSomeClass
inherits the__hash__
method ofstr
class. -
SomeClass("s") == "s"
evaluates toTrue
becauseSomeClass
also inherits__eq__
method fromstr
class. -
Since both the objects hash to the same value and are equal, they are represented by the same key in the dictionary.
-
For the desired behavior, we can redefine the
__eq__
method inSomeClass
class SomeClass(str): def __eq__(self, other): return ( type(self) is SomeClass and type(other) is SomeClass and super().__eq__(other) ) # When we define a custom __eq__, Python stops automatically inheriting the # __hash__ method, so we need to define it as well __hash__ = str.__hash__ some_dict = {'s':42}
Output:
>>> s = SomeClass('s') >>> some_dict[s] = 40 >>> some_dict {'s': 40, 's': 42} >>> keys = list(some_dict.keys()) >>> type(keys[0]), type(keys[1]) (__main__.SomeClass, str)
▶ Let's see if you can guess this?
a, b = a[b] = {}, 5
Output:
>>> a {5: ({...}, 5)}
Explanation:
-
According to Python language reference, assignment statements have the form
(target_list "=")+ (expression_list | yield_expression)
and
An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
-
The
+
in(target_list "=")+
means there can be one or more target lists. In this case, target lists area, b
anda[b]
(note the expression list is exactly one, which in our case is{}, 5
). -
After the expression list is evaluated, it's value is unpacked to the target lists from left to right. So, in our case, first the
{}, 5
tuple is unpacked toa, b
and we now havea = {}
andb = 5
. -
a
is now assigned to{}
which is a mutable object. -
The second target list is
a[b]
(you may expect this to throw an error because botha
andb
have not been defined in the statements before. But remember, we just assigneda
to{}
andb
to5
). -
Now, we are setting the key
5
in the dictionary to the tuple({}, 5)
creating a circular reference (the{...}
in the output refers to the same object thata
is already referencing). Another simpler example of circular reference could be>>> some_list = some_list[0] = [0] >>> some_list [[...]] >>> some_list[0] [[...]] >>> some_list is some_list[0] True >>> some_list[0][0][0][0][0][0] == some_list True
Similar is the case in our example (
a[b][0]
is the same object asa
) -
So to sum it up, you can break the example down to
a, b = {}, 5 a[b] = a, b
And the circular reference can be justified by the fact that
a[b][0]
is the same object asa
>>> a[b][0] is a True
Section: Appearances are deceptive!
▶ Skipping lines?
Output:
>>> value = 11 >>> valuе = 32 >>> value 11
Wut?
Note: The easiest way to reproduce this is to simply copy the statements from the above snippet and paste them into your file/shell.
Explanation
Some non-Western characters look identical to letters in the English alphabet but are considered distinct by the interpreter.
>>> ord('е') # cyrillic 'e' (Ye) 1077 >>> ord('e') # latin 'e', as used in English and typed using standard keyboard 101 >>> 'е' == 'e' False >>> value = 42 # latin e >>> valuе = 23 # cyrillic 'e', Python 2.x interpreter would raise a `SyntaxError` here >>> value 42
The built-in ord()
function returns a character's Unicode code point, and different code positions of Cyrillic 'e' and Latin 'e' justify the behavior of the above example.
▶ Teleportation *
import numpy as np def energy_send(x): # Initializing a numpy array np.array([float(x)]) def energy_receive(): # Return an empty numpy array return np.empty((), dtype=np.float).tolist()
Output:
>>> energy_send(123.456) >>> energy_receive() 123.456
Where's the Nobel Prize?
Explanation:
- Notice that the numpy array created in the
energy_send
function is not returned, so that memory space is free to reallocate. numpy.empty()
returns the next free memory slot without reinitializing it. This memory spot just happens to be the same one that was just freed (usually, but not always).
▶ Well, something is fishy...
def square(x): """ A simple function to calculate the square of a number by addition. """ sum_so_far = 0 for counter in range(x): sum_so_far = sum_so_far + x return sum_so_far
Output (Python 2.x):
>>> square(10) 10
Shouldn't that be 100?
Note: If you're not able to reproduce this, try running the file mixed_tabs_and_spaces.py via the shell.
Explanation
-
Don't mix tabs and spaces! The character just preceding return is a "tab", and the code is indented by multiple of "4 spaces" elsewhere in the example.
-
This is how Python handles tabs:
First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight <...>
-
So the "tab" at the last line of
square
function is replaced with eight spaces, and it gets into the loop. -
Python 3 is kind enough to throw an error for such cases automatically.
Output (Python 3.x):
TabError: inconsistent use of tabs and spaces in indentation
Section: Watch out for the landmines!
▶ Modifying a dictionary while iterating over it
x = {0: None} for i in x: del x[i] x[i+1] = None print(i)
Output (Python 2.7- Python 3.5):
0
1
2
3
4
5
6
7
Yes, it runs for exactly eight times and stops.
Explanation:
- Iteration over a dictionary that you edit at the same time is not supported.
- It runs eight times because that's the point at which the dictionary resizes to hold more keys (we have eight deletion entries, so a resize is needed). This is actually an implementation detail.
- How deleted keys are handled and when the resize occurs might be different for different Python implementations.
- For more information, you may refer to this StackOverflow thread explaining a similar example in detail.
▶ Stubborn del
operator *
class SomeClass: def __del__(self): print("Deleted!")
Output: 1.
>>> x = SomeClass() >>> y = x >>> del x # this should print "Deleted!" >>> del y Deleted!
Phew, deleted at last. You might have guessed what saved from __del__
being called in our first attempt to delete x
. Let's add more twist to the example.
2.
>>> x = SomeClass() >>> y = x >>> del x >>> y # check if y exists <__main__.SomeClass instance at 0x7f98a1a67fc8> >>> del y # Like previously, this should print "Deleted!" >>> globals() # oh, it didn't. Let's check all our global variables and confirm Deleted! {'__builtins__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__package__': None, '__name__': '__main__', '__doc__': None}
Okay, now it's deleted
Explanation:
del x
doesn’t directly callx.__del__()
.- Whenever
del x
is encountered, Python decrements the reference count forx
by one, andx.__del__()
when x’s reference count reaches zero. - In the second output snippet,
y.__del__()
was not called because the previous statement (>>> y
) in the interactive interpreter created another reference to the same object, thus preventing the reference count to reach zero whendel y
was encountered. - Calling
globals
caused the existing reference to be destroyed and hence we can see "Deleted!" being printed (finally!).
▶ Deleting a list item while iterating
list_1 = [1, 2, 3, 4] list_2 = [1, 2, 3, 4] list_3 = [1, 2, 3, 4] list_4 = [1, 2, 3, 4] for idx, item in enumerate(list_1): del item for idx, item in enumerate(list_2): list_2.remove(item) for idx, item in enumerate(list_3[:]): list_3.remove(item) for idx, item in enumerate(list_4): list_4.pop(idx)
Output:
>>> list_1 [1, 2, 3, 4] >>> list_2 [2, 4] >>> list_3 [] >>> list_4 [2, 4]
Can you guess why the output is [2, 4]
?
Explanation:
-
It's never a good idea to change the object you're iterating over. The correct way to do so is to iterate over a copy of the object instead, and
list_3[:]
does just that.>>> some_list = [1, 2, 3, 4] >>> id(some_list) 139798789457608 >>> id(some_list[:]) # Notice that python creates new object for sliced list. 139798779601192
Difference between del
, remove
, and pop
:
del var_name
just removes the binding of thevar_name
from the local or global namespace (That's why thelist_1
is unaffected).remove
removes the first matching value, not a specific index, raisesValueError
if the value is not found.pop
removes the element at a specific index and returns it, raisesIndexError
if an invalid index is specified.
Why the output is [2, 4]
?
- The list