images | ||
.gitignore | ||
mixed_tabs_and_spaces.py | ||
README.md |
What the f*ck Python! 🐍
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 here.
So, here we go...
Table of Contents
- 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!/出人意料的is
! - > A tic-tac-toe where X wins in the first attempt!/一蹴即至!
- > The sticky output function/麻烦的输出
- >
is not ...
is notis (not ...)
/is not ...
不是is (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/生成 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.
Output:Setting up examples for clarification (if necessary)
>>> 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") # 注意两个的id值是相同的.
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.7 版本返回结果为 False.
3.
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False # 3.7 版本返回结果为 True
很好理解, 对吧?
💡 说明:
-
这些行为是由于 Cpython 在编译优化时, 某些情况下会尝试使用已经存在的不可变对象而不是每次都创建一个新对象. (这种行为被称作字符串的驻留[string interning])
-
发生驻留之后, 许多变量可能指向内存中的相同字符串对象. (从而节省内存)
-
在上面的代码中, 字符串是隐式驻留的. 何时发生隐式驻留则取决于具体的实现. 这里有一些方法可以用来猜测字符串是否会被驻留:
-
所有长度为 0 和长度为 1 的字符串都被驻留.
-
字符串在编译时被实现 (
'wtf'
将被驻留, 但是''.join(['w', 't', 'f'])
将不会被驻留) -
字符串中只包含字母,数字或下划线时将会驻留. 所以
'wtf!'
由于包含!
而未被驻留. 可以在这里找到 CPython 对此规则的实现.
-
-
当在同一行将
a
和b
的值设置为"wtf!"
的时候, Python 解释器会创建一个新对象, 然后同时引用第二个变量(译: 仅适用于3.7以下, 详细情况请看这里). 如果你在不同的行上进行赋值操作, 它就不会“知道”已经有一个wtf!
对象 (因为"wtf!"
不是按照上面提到的方式被隐式驻留的). 它是一种编译器优化, 特别适用于交互式环境. -
常量折叠(constant folding) 是 Python 中的一种 窥孔优化(peephole optimization) 技术. 这意味着在编译时表达式
'a'*20
会被替换为'aaaaaaaaaaaaaaaaaaaa'
以减少运行时的时钟周期. 只有长度小于 20 的字符串才会发生常量折叠. (为啥? 想象一下由于表达式'a'*10**10
而生成的.pyc
文件的大小). 相关的源码实现在这里. -
如果你是使用 3.7 版本中运行上述示例代码, 会发现部分代码的运行结果与注释说明相同. 这是因为在 3.7 版本中, 常量折叠已经从窥孔优化器迁移至新的 AST 优化器, 后者可以以更高的一致性来执行优化. (由 Eugene Toder 和 INADA Naoki 在 bpo-29469 和 bpo-11549 中贡献.)
-
(译: 但是在最新的 3.8 版本中, 结果又变回去了. 虽然 3.8 版本和 3.7 版本一样, 都是使用 AST 优化器. 目前不确定官方对 3.8 版本的 AST 做了什么调整.)
> Time for some hash brownies!/是时候来点蛋糕了!
- hash brownie指一种含有大麻成分的蛋糕, 所以这里是句双关
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" 消除了 "JavaScript" 的存在?
💡 说明:
- Python 字典通过检查键值是否相等和比较哈希值来确定两个键是否相同.
- 具有相同值的不可变对象在Python中始终具有相同的哈希值.
注意: 具有不同值的对象也可能具有相同的哈希值(哈希冲突).>>> 5 == 5.0 True >>> hash(5) == hash(5.0) True
- 当执行
some_dict[5] = "Python"
语句时, 因为Python将5
和5.0
识别为some_dict
的同一个键, 所以已有值 "JavaScript" 就被 "Python" 覆盖了. - 这个 StackOverflow的 回答 漂亮地解释了这背后的基本原理.
> Return return everywhere!/到处返回!
def some_func():
try:
return 'from_try'
finally:
return 'from_finally'
Output:
>>> some_func()
'from_finally'
💡 说明:
- 当在 "try...finally" 语句的
try
中执行return
,break
或continue
后,finally
子句依然会执行. - 函数的返回值由最后执行的
return
语句决定. 由于finally
子句一定会执行, 所以finally
子句中的return
将始终是最后执行的语句.
> Deep down, we're all the same./本质上,我们都一样. *
class WTF:
pass
Output:
>>> WTF() == WTF() # 两个不同的对象应该不相等
False
>>> WTF() is WTF() # 也不相同
False
>>> hash(WTF()) == hash(WTF()) # 哈希值也应该不同
True
>>> id(WTF()) == id(WTF())
True
💡 说明:
-
当调用
id
函数时, Python 创建了一个WTF
类的对象并传给id
函数. 然后id
函数获取其id值 (也就是内存地址), 然后丢弃该对象. 该对象就被销毁了. -
当我们连续两次进行这个操作时, Python会将相同的内存地址分配给第二个对象. 因为 (在CPython中)
id
函数使用对象的内存地址作为对象的id值, 所以两个对象的id值是相同的. -
综上, 对象的id值仅仅在对象的生命周期内唯一. 在对象被销毁之后, 或被创建之前, 其他对象可以具有相同的id值.
-
那为什么
is
操作的结果为False
呢? 让我们看看这段代码.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
正如你所看到的, 对象销毁的顺序是造成所有不同之处的原因.
> For what?/为什么?
some_string = "wtf"
some_dict = {}
for i, some_dict[i] in enumerate(some_string):
pass
Output:
>>> some_dict # 创建了索引字典.
{0: 'w', 1: 't', 2: 'f'}
💡 说明:
-
Python 语法 中对
for
的定义是:for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
其中
exprlist
指分配目标. 这意味着对可迭代对象中的每一项都会执行类似{exprlist} = {next_value}
的操作.一个有趣的例子说明了这一点:
for i in range(4): print(i) i = 10
Output:
0 1 2 3
你可曾觉得这个循环只会运行一次?
💡 说明:
- 由于循环在Python中工作方式, 赋值语句
i = 10
并不会影响迭代循环, 在每次迭代开始之前, 迭代器(这里指range(4)
) 生成的下一个元素就被解包并赋值给目标列表的变量(这里指i
)了.
- 由于循环在Python中工作方式, 赋值语句
-
在每一次的迭代中,
enumerate(some_string)
函数就生成一个新值i
(计数器增加) 并从some_string
中获取一个字符. 然后将字典some_dict
键i
(刚刚分配的) 的值设为该字符. 本例中循环的展开可以简化为:>>> 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]
💡 说明
- 在生成器表达式中,
in
子句在声明时执行, 而条件子句则是在运行时执行. - 所以在运行前,
array
已经被重新赋值为[2, 8, 22]
, 因此对于之前的1
,8
和15
, 只有count(8)
的结果是大于0
的, 所以生成器只会生成8
. - 第二部分中
g1
和g2
的输出差异则是由于变量array_1
和array_2
被重新赋值的方式导致的. - 在第一种情况下,
array_1
被绑定到新对象[1,2,3,4,5]
, 因为in
子句是在声明时被执行的, 所以它仍然引用旧对象[1,2,3,4]
(并没有被销毁). - 在第二种情况下, 对
array_2
的切片赋值将相同的旧对象[1,2,3,4]
原地更新为[1,2,3,4,5]
. 因此g2
和array_2
仍然引用同一个对象(这个对象现在已经更新为[1,2,3,4,5]
).
> is
is not what it is!/出人意料的is
!
下面是一个在互联网上非常有名的例子.
>>> a = 256
>>> b = 256
>>> a is b
True
>>> a = 257
>>> b = 257
>>> a is b
False
>>> a = 257; b = 257
>>> a is b
True
💡 说明:
is
和 ==
的区别
is
运算符检查两个运算对象是否引用自同一对象 (即, 它检查两个运算对象是否相同).==
运算符比较两个运算对象的值是否相等.- 因此
is
代表引用相同,==
代表值相等. 下面的例子可以很好的说明这点,>>> [] == [] True >>> [] is [] # 这两个空列表位于不同的内存地址. False
256
是一个已经存在的对象, 而 257
不是
当你启动Python 的时候, 数值为 -5
到 256
的对象就已经被分配好了. 这些数字因为经常被使用, 所以会被提前准备好.
Python 通过这种创建小整数池的方式来避免小整数频繁的申请和销毁内存空间.
引用自 https://docs.python.org/3/c-api/long.html
当前的实现为-5到256之间的所有整数保留一个整数对象数组, 当你创建了一个该范围内的整数时, 你只需要返回现有对象的引用. 所以改变1的值是有可能的. 我怀疑这种行为在Python中是未定义行为. :-)
>>> 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
这里解释器并没有智能到能在执行 y = 257
时意识到我们已经创建了一个整数 257
, 所以它在内存中又新建了另一个对象.
当 a
和 b
在同一行中使用相同的值初始化时,会指向同一个对象.
>>> a, b = 257, 257
>>> id(a)
140640774013296
>>> id(b)
140640774013296
>>> a = 257
>>> b = 257
>>> id(a)
140640774013392
>>> id(b)
140640774013488
- 当 a 和 b 在同一行中被设置为
257
时, Python 解释器会创建一个新对象, 然后同时引用第二个变量. 如果你在不同的行上进行, 它就不会 "知道" 已经存在一个257
对象了. - 这是一种特别为交互式环境做的编译器优化. 当你在实时解释器中输入两行的时候, 他们会单独编译, 因此也会单独进行优化. 如果你在
.py
文件中尝试这个例子, 则不会看到相同的行为, 因为文件是一次性编译的.
> A tic-tac-toe where X wins in the first attempt!/一蹴即至!
# 我们先初始化一个变量row
row = [""]*3 #row i['', '', '']
# 并创建一个变量board
board = [row]*3
Output:
>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>>> board[0]
['', '', '']
>>> board[0][0]
''
>>> board[0][0] = "X"
>>> board
[['X', '', ''], ['X', '', ''], ['X', '', '']]
我们有没有赋值过3个 "X" 呢?
💡 说明:
当我们初始化 row
变量时, 下面这张图展示了内存中的情况。
而当通过对 row
做乘法来初始化 board
时, 内存中的情况则如下图所示 (每个元素 board[0]
, board[1]
和 board[2]
都和 row
一样引用了同一列表.)
我们可以通过不使用变量 row
生成 board
来避免这种情况. (这个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()) # 注意这里函数被执行了
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]
即使每次在迭代中将 some_func
加入 funcs
前的 x
值都不相同, 所有的函数还是都返回6.
// 再换个例子
>>> 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]
💡 说明:
-
当在循环内部定义一个函数时, 如果该函数在其主体中使用了循环变量, 则闭包函数将与循环变量绑定, 而不是它的值. 因此, 所有的函数都是使用最后分配给变量的值来进行计算的.
-
可以通过将循环变量作为命名变量传递给函数来获得预期的结果. 为什么这样可行? 因为这会在函数内再次定义一个局部变量.
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 ...)
/is not ...
不是 is (not ...)
>>> 'something' is not None
True
>>> 'something' is (not None)
False
💡 说明:
is not
是个单独的二元运算符, 与分别使用is
和not
不同.- 如果操作符两侧的变量指向同一个对象, 则
is not
的结果为False
, 否则结果为True
.
> 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
💡 说明:
- 在Python函数的形式参数列表中, 尾随逗号并不一定是合法的.
- 在Python中, 参数列表部分用前置逗号定义, 部分用尾随逗号定义. 这种冲突导致逗号被夹在中间, 没有规则定义它.(译:这一句看得我也很懵逼,只能强翻了.详细解释看下面的讨论帖会一目了然.)
- 注意: 尾随逗号的问题已经在Python 3.6中被修复了. 而这篇帖子中则简要讨论了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
💡 说明:
- 在以
r
开头的原始字符串中, 反斜杠并没有特殊含义.>>> print(repr(r"wt\"f")) 'wt\\"f'
- 解释器所做的只是简单的改变了反斜杠的行为, 因此会直接放行反斜杠及后一个的字符. 这就是反斜杠在原始字符串末尾不起作用的原因.
> not knot!/别纠结!
x = True
y = False
Output:
>>> not x == y
True
>>> x == not y
File "<input>", line 1
x == not y
^
SyntaxError: invalid syntax
💡 说明:
- 运算符的优先级会影响表达式的求值顺序, 而在 Python 中
==
运算符的优先级要高于not
运算符. - 所以
not x == y
相当于not (x == y)
, 同时等价于not (True == False)
, 最后的运算结果就是True
. - 之所以
x == not y
会抛一个SyntaxError
异常, 是因为它会被认为等价于(x == not) y
, 而不是你一开始期望的x == (not y)
. - 解释器期望
not
标记是not in
操作符的一部分 (因为==
和not in
操作符具有相同的优先级), 但是它在not
标记后面找不到in
标记, 所以会抛出SyntaxError
异常.
> Half triple-quoted strings/三个引号
Output:
>>> print('wtfpython''')
wtfpython
>>> print("wtfpython""")
wtfpython
>>> # 下面的语句会抛出 `SyntaxError` 异常
>>> # print('''wtfpython')
>>> # print("""wtfpython")
💡 说明:
- Python 提供隐式的字符串连接, 例如,
>>> print("wtf" "python") wtfpython >>> print("wtf" "") # or "wtf""" wtf
'''
和"""
在 Python中也是字符串定界符, Python 解释器在先遇到三个引号的的时候会尝试再寻找三个终止引号作为定界符, 如果不存在则会导致SyntaxError
异常.
> 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))
midnight_time 并没有被输出.
💡 说明:
在Python 3.5之前, 如果 datetime.time
对象存储的UTC的午夜时间(译: 就是 00:00
), 那么它的布尔值会被认为是 False
. 当使用 if obj:
语句来检查 obj
是否为 null
或者某些“空”值的时候, 很容易出错.
> What's wrong with booleans?/布尔你咋了?
1.
# 一个简单的例子, 统计下面可迭代对象中的布尔型值的个数和整型值的个数
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
''
💡 说明:
-
布尔值是
int
的子类>>> isinstance(True, int) True >>> isinstance(False, int) True
-
所以
True
的整数值是1
, 而False
的整数值是0
.>>> True == 1 == 1.0 and False == 0 == 0.0 True
-
关于其背后的原理, 请看这个 StackOverflow 的回答.
> Class attributes and instance attributes/类属性和实例属性
1.
class A:
x = 1
class B(A):
pass
class C(A):
pass
Output:
>>> 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
💡 说明:
- 类变量和实例变量在内部是通过类对象的字典来处理(译: 就是
__dict__
属性). 如果在当前类的字典中找不到的话就去它的父类中寻找. +=
运算符会在原地修改可变对象, 而不是创建新对象. 因此, 在这种情况下, 修改一个实例的属性会影响其他实例和类属性.
> yielding None/生成 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']
💡 说明:
- 来源和解释可以在这里找到: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
- 相关错误报告: http://bugs.python.org/issue10544
- 这个bug在3.7以后的版本中不被推荐使用, 并在3.8中被修复. 因此在3.8中尝试在推导式中使用 yield, 只会得到一个 SyntaxError. 详细内容可以看3.7更新内容, 3.8更新内容.
> 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) # 这里不出现错误
>>> 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])
我还以为元组是不可变的呢...
💡 说明:
-
引用 https://docs.python.org/2/reference/datamodel.html
不可变序列 不可变序列的对象一旦创建就不能再改变. (如果对象包含对其他对象的引用,则这些其他对象可能是可变的并且可能会被修改; 但是,由不可变对象直接引用的对象集合不能更改.)
-
+=
操作符在原地修改了列表. 元素赋值操作并不工作, 但是当异常抛出时, 元素已经在原地被修改了.
(译: 对于不可变对象, 这里指tuple, +=
并不是原子操作, 而是 extend
和 =
两个动作, 这里 =
操作虽然会抛出异常, 但 extend
操作已经修改成功了. 详细解释可以看这里)
> 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
💡 说明:
-
出处: https://docs.python.org/3/reference/compound_stmts.html#except
当使用
as
为目标分配异常的时候, 将在except子句的末尾清除该异常.这就好像
except E as N: foo
会被翻译成
except E as N: try: foo finally: del N
这意味着异常必须在被赋值给其他变量才能在
except
子句之后引用它. 而异常之所以会被清除, 则是由于上面附加的回溯信息(trackback)会和栈帧(stack frame)形成循环引用, 使得该栈帧中的所有本地变量在下一次垃圾回收发生之前都处于活动状态.(译: 也就是说不会被回收) -
子句在 Python 中并没有独立的作用域. 示例中的所有内容都处于同一作用域内, 所以变量
e
会由于执行了except
子句而被删除. 而对于有独立的内部作用域的函数来说情况就不一样了. 下面的例子说明了这一点: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]
-
在 Python 2.x 中,
Exception()
实例被赋值给了变量e
, 所以当你尝试打印结果的时候, 它的输出为空.(译: 正常的Exception实例打印出来就是空)Output (Python 2.x):
>>> e Exception() >>> print e # 没有打印任何内容!
> When True is actually False/真亦假
True = False
if True == False:
print("I've lost faith in truth!")
Output:
I've lost faith in truth!
💡 说明:
- 最初, Python 并没有
bool
型 (人们用0表示假值, 用非零值比如1作为真值). 后来他们添加了True
,False
, 和bool
型, 但是, 为了向后兼容, 他们没法把True
和False
设置为常量, 只是设置成了内置变量. - Python 3 由于不再需要向后兼容, 终于可以修复这个问题了, 所以这个例子无法在 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
💡 说明:
大多数修改序列/映射对象的方法, 比如 list.append
, dict.update
, list.sort
等等. 都是原地修改对象并返回 None
. 这样做的理由是, 如果操作可以原地完成, 就可以避免创建对象的副本来提高性能. (参考这里)
> Subclass relationships/子类关系 *
Output:
>>> from collections import Hashable
>>> issubclass(list, object)
True
>>> issubclass(object, Hashable)
True
>>> issubclass(list, Hashable)
False
子类关系应该是可传递的, 对吧? (即, 如果 A
是 B
的子类, B
是 C
的子类, 那么 A
应该 是 C
的子类.)
💡 说明:
- Python 中的子类关系并不一定是传递的. 任何人都可以在元类中随意定义
__subclasscheck__
. - 当
issubclass(cls, Hashable)
被调用时, 它只是在cls
中寻找__hash__
方法或者从继承的父类中寻找__hash__
方法. - 由于
object
is 可散列的(hashable), 但是list
是不可散列的, 所以它打破了这种传递关系. - 在这里可以找到更详细的解释.
> 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 # 预期: 两个不同的键值对
{'s': 40}
>>> type(list(some_dict.keys())[0])
str
💡 说明:
-
由于
SomeClass
会从str
自动继承__hash__
方法, 所以s
对象和"s"
字符串的哈希值是相同的. -
而
SomeClass("s") == "s"
为True
是因为SomeClass
也继承了str
类__eq__
方法. -
由于两者的哈希值相同且相等, 所以它们在字典中表示相同的键.
-
如果想要实现期望的功能, 我们可以重定义
SomeClass
的__eq__
方法.class SomeClass(str): def __eq__(self, other): return ( type(self) is SomeClass and type(other) is SomeClass and super().__eq__(other) ) # 当我们自定义 __eq__ 方法时, Python 不会再自动继承 __hash__ 方法 # 所以我们也需要定义它 __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)}
💡 说明:
-
根据 Python 语言参考, 赋值语句的形式如下
(target_list "=")+ (expression_list | yield_expression)
赋值语句计算表达式列表(expression list)(牢记 这可以是单个表达式或以逗号分隔的列表, 后者返回元组)并将单个结果对象从左到右分配给目标列表中的每一项.
-
(target_list "=")+
中的+
意味着可以有一个或多个目标列表. 在这个例子中, 目标列表是a, b
和a[b]
(注意表达式列表只能有一个, 在我们的例子中是{}, 5
). -
表达式列表计算结束后, 将其值自动解包后从左到右分配给目标列表(target list). 因此, 在我们的例子中, 首先将
{}, 5
元组并赋值给a, b
, 然后我们就可以得到a = {}
且b = 5
. -
a
被赋值的{}
是可变对象. -
第二个目标列表是
a[b]
(你可能觉得这里会报错, 因为在之前的语句中a
和b
都还没有被定义. 但是别忘了, 我们刚刚将a
赋值{}
且将b
赋值为5
). -
现在, 我们将通过将字典中键
5
的值设置为元组({}, 5)
来创建循环引用 (输出中的{...}
指与a
引用了相同的对象). 下面是一个更简单的循环引用的例子>>> 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
我们的例子就是这种情况 (
a[b][0]
与a
是相同的对象) -
总结一下, 你也可以把例子拆成
a, b = {}, 5 a[b] = a, b
并且可以通过
a[b][0]
与a
是相同的对象来证明是循环引用>>> a[b][0] is a True
Section: Appearances are deceptive!
> Skipping lines?/跳过一行?
Output:
>>> value = 11
>>> valuе = 32
>>> value
11
什么鬼?
注意: 如果你想要重现的话最简单的方法是直接复制上面的代码片段到你的文件或命令行里.
💡 说明:
一些非西方字符虽然看起来和英语字母相同, 但会被解释器识别为不同的字母.
>>> ord('е') # 西里尔语的 'e' (Ye)
1077
>>> ord('e') # 拉丁语的 'e', 用于英文并使用标准键盘输入
101
>>> 'е' == 'e'
False
>>> value = 42 # 拉丁语 e
>>> valuе = 23 # 西里尔语 'e', Python 2.x 的解释器在这会抛出 `SyntaxError` 异常
>>> value
42
内置的 ord()
函数可以返回一个字符的 Unicode 代码点, 这里西里尔语 'e' 和拉丁语 'e' 的代码点不同证实了上述例子.
> Teleportation/空间移动 *
import numpy as np
def energy_send(x):
# 初始化一个 numpy 数组
np.array([float(x)])
def energy_receive():
# 返回一个空的 numpy 数组
return np.empty((), dtype=np.float).tolist()
Output:
>>> energy_send(123.456)
>>> energy_receive()
123.456
谁来给我发个诺贝尔奖?
💡 说明:
- 注意在
energy_send
函数中创建的 numpy 数组并没有返回, 因此内存空间被释放并可以被重新分配. numpy.empty()
直接返回下一段空闲内存,而不重新初始化. 而这个内存点恰好就是刚刚释放的那个(通常情况下, 并不绝对).
> Well, something is fishy.../嗯,有些可疑...
def square(x):
"""
一个通过加法计算平方的简单函数.
"""
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
难道不应该是100吗?
注意: 如果你无法重现, 可以尝试运行这个文件mixed_tabs_and_spaces.py.
💡 说明:
-
不要混用制表符(tab)和空格(space)! 在上面的例子中, return 的前面是"1个制表符", 而其他部分的代码前面是 "4个空格".
-
Python是这么处理制表符的:
首先, 制表符会从左到右依次被替换成8个空格, 直到被替换后的字符总数是八的倍数 <...>
-
因此,
square
函数最后一行的制表符会被替换成8个空格, 导致return语句进入循环语句里面. -
Python 3 很友好, 在这种情况下会自动抛出错误.
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 iteration is done index by index, and when we remove
1
fromlist_2
orlist_4
, the contents of the lists are now[2, 3, 4]
. The remaining elements are shifted down, i.e.,2
is at index 0, and3
is at index 1. Since the next iteration is going to look at index 1 (which is the3
), the2
gets skipped entirely. A similar thing will happen with every alternate element in the list sequence.
- Refer to this StackOverflow thread explaining the example
- See also this nice StackOverflow thread for a similar example related to dictionaries in Python.
> Loop variables leaking out!
1.
for x in range(7):
if x == 6:
print(x, ': for x inside loop')
print(x, ': x in global')
Output:
6 : for x inside loop
6 : x in global
But x
was never defined outside the scope of for loop...
2.
# This time let's initialize x first
x = -1
for x in range(7):
if x == 6:
print(x, ': for x inside loop')
print(x, ': x in global')
Output:
6 : for x inside loop
6 : x in global
3.
x = 1
print([x for x in range(5)])
print(x, ': x in global')
Output (on Python 2.x):
[0, 1, 2, 3, 4]
(4, ': x in global')
Output (on Python 3.x):
[0, 1, 2, 3, 4]
1 : x in global
💡 Explanation:
-
In Python, for-loops use the scope they exist in and leave their defined loop-variable behind. This also applies if we explicitly defined the for-loop variable in the global namespace before. In this case, it will rebind the existing variable.
-
The differences in the output of Python 2.x and Python 3.x interpreters for list comprehension example can be explained by following change documented in What’s New In Python 3.0 documentation:
"List comprehensions no longer support the syntactic form
[... for var in item1, item2, ...]
. Use[... for var in (item1, item2, ...)]
instead. Also, note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside alist()
constructor, and in particular the loop control variables are no longer leaked into the surrounding scope."
> Beware of default mutable arguments!
def some_func(default_arg=[]):
default_arg.append("some_string")
return default_arg
Output:
>>> some_func()
['some_string']
>>> some_func()
['some_string', 'some_string']
>>> some_func([])
['some_string']
>>> some_func()
['some_string', 'some_string', 'some_string']
💡 Explanation:
-
The default mutable arguments of functions in Python aren't really initialized every time you call the function. Instead, the recently assigned value to them is used as the default value. When we explicitly passed
[]
tosome_func
as the argument, the default value of thedefault_arg
variable was not used, so the function returned as expected.def some_func(default_arg=[]): default_arg.append("some_string") return default_arg
Output:
>>> some_func.__defaults__ #This will show the default argument values for the function ([],) >>> some_func() >>> some_func.__defaults__ (['some_string'],) >>> some_func() >>> some_func.__defaults__ (['some_string', 'some_string'],) >>> some_func([]) >>> some_func.__defaults__ (['some_string', 'some_string'],)
-
A common practice to avoid bugs due to mutable arguments is to assign
None
as the default value and later check if any value is passed to the function corresponding to that argument. Example:def some_func(default_arg=None): if not default_arg: default_arg = [] default_arg.append("some_string") return default_arg
> Catching the Exceptions
some_list = [1, 2, 3]
try:
# This should raise an ``IndexError``
print(some_list[4])
except IndexError, ValueError:
print("Caught!")
try:
# This should raise a ``ValueError``
some_list.remove(4)
except IndexError, ValueError:
print("Caught again!")
Output (Python 2.x):
Caught!
ValueError: list.remove(x): x not in list
Output (Python 3.x):
File "<input>", line 3
except IndexError, ValueError:
^
SyntaxError: invalid syntax
💡 Explanation
-
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,
some_list = [1, 2, 3] try: # This should raise a ``ValueError`` some_list.remove(4) except (IndexError, ValueError), e: print("Caught again!") print(e)
Output (Python 2.x):
Caught again! list.remove(x): x not in list
Output (Python 3.x):
File "<input>", line 4 except (IndexError, ValueError), e: ^ IndentationError: unindent does not match any outer indentation level
-
Separating the exception from the variable with a comma is deprecated and does not work in Python 3; the correct way is to use
as
. Example,some_list = [1, 2, 3] try: some_list.remove(4) except (IndexError, ValueError) as e: print("Caught again!") print(e)
Output:
Caught again! list.remove(x): x not in list
> Same operands, different story!
1.
a = [1, 2, 3, 4]
b = a
a = a + [5, 6, 7, 8]
Output:
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4]
2.
a = [1, 2, 3, 4]
b = a
a += [5, 6, 7, 8]
Output:
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4, 5, 6, 7, 8]
💡 Explanation:
-
a += b
doesn't always behave the same way asa = a + b
. Classes may implement theop=
operators differently, and lists do this. -
The expression
a = a + [5,6,7,8]
generates a new list and setsa
's reference to that new list, leavingb
unchanged. -
The expression
a += [5,6,7,8]
is actually mapped to an "extend" function that operates on the list such thata
andb
still point to the same list that has been modified in-place.
> The out of scope variable
a = 1
def some_func():
return a
def another_func():
a += 1
return a
Output:
>>> some_func()
1
>>> another_func()
UnboundLocalError: local variable 'a' referenced before assignment
💡 Explanation:
-
When you make an assignment to a variable in scope, it becomes local to that scope. So
a
becomes local to the scope ofanother_func
, but it has not been initialized previously in the same scope which throws an error. -
Read this short but an awesome guide to learn more about how namespaces and scope resolution works in Python.
-
To modify the outer scope variable
a
inanother_func
, useglobal
keyword.def another_func() global a a += 1 return a
Output:
>>> another_func() 2
> Be careful with chained operations
>>> (False == False) in [False] # makes sense
False
>>> False == (False in [False]) # makes sense
False
>>> False == False in [False] # now what?
True
>>> True is False == False
False
>>> False is False is False
True
>>> 1 > 0 < 1
True
>>> (1 > 0) < 1
False
>>> 1 > (0 < 1)
False
💡 Explanation:
As per https://docs.python.org/2/reference/expressions.html#not-in
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.
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
.
False is False is False
is equivalent to(False is False) and (False is False)
True is False == False
is equivalent toTrue is False and False == False
and since the first part of the statement (True is False
) evaluates toFalse
, the overall expression evaluates toFalse
.1 > 0 < 1
is equivalent to1 > 0 and 0 < 1
which evaluates toTrue
.- The expression
(1 > 0) < 1
is equivalent toTrue < 1
and
So,>>> int(True) 1 >>> True + 1 #not relevant for this example, but just for fun 2
1 < 1
evaluates toFalse
> Name resolution ignoring class scope
1.
x = 5
class SomeClass:
x = 17
y = (x for i in range(10))
Output:
>>> list(SomeClass.y)[0]
5
2.
x = 5
class SomeClass:
x = 17
y = [x for i in range(10)]
Output (Python 2.x):
>>> SomeClass.y[0]
17
Output (Python 3.x):
>>> SomeClass.y[0]
5
💡 Explanation
- Scopes nested inside class definition ignore names bound at the class level.
- A generator expression has its own scope.
- Starting from Python 3.X, list comprehensions also have their own scope.
> Needle in a Haystack
1.
x, y = (0, 1) if True else None, None
Output:
>>> x, y # expected (0, 1)
((0, 1), None)
Almost every Python programmer has faced a similar situation.
2.
t = ('one', 'two')
for i in t:
print(i)
t = ('one')
for i in t:
print(i)
t = ()
print(t)
Output:
one
two
o
n
e
tuple()
💡 Explanation:
- For 1, the correct statement for expected behavior is
x, y = (0, 1) if True else (None, None)
. - For 2, the correct statement for expected behavior is
t = ('one',)
ort = 'one',
(missing comma) otherwise the interpreter considerst
to be astr
and iterates over it character by character. ()
is a special token and denotes emptytuple
.
Section: The Hidden treasures!
This section contains few of the lesser-known interesting things about Python that most beginners like me are unaware of (well, not anymore).
> Okay Python, Can you make me fly? *
Well, here you go
import antigravity
Output: Sshh.. It's a super secret.
💡 Explanation:
antigravity
module is one of the few easter eggs released by Python developers.import antigravity
opens up a web browser pointing to the classic XKCD comic about Python.- Well, there's more to it. There's another easter egg inside the easter egg. If you look at the code, there's a function defined that purports to implement the XKCD's geohashing algorithm.
> goto
, but why? *
from goto import goto, label
for i in range(9):
for j in range(9):
for k in range(9):
print("I'm trapped, please rescue!")
if k == 2:
goto .breakout # breaking out from a deeply nested loop
label .breakout
print("Freedom!")
Output (Python 2.3):
I'm trapped, please rescue!
I'm trapped, please rescue!
Freedom!
💡 Explanation:
- A working version of
goto
in Python was announced as an April Fool's joke on 1st April 2004. - Current versions of Python do not have this module.
- Although it works, but please don't use it. Here's the reason to why
goto
is not present in Python.
> Brace yourself! *
If you are one of the people who doesn't like using whitespace in Python to denote scopes, you can use the C-style {} by importing,
from __future__ import braces
Output:
File "some_file.py", line 1
from __future__ import braces
SyntaxError: not a chance
Braces? No way! If you think that's disappointing, use Java.
💡 Explanation:
- The
__future__
module is normally used to provide features from future versions of Python. The "future" here is however ironic. - This is an easter egg concerned with the community's feelings on this issue.
> Let's meet Friendly Language Uncle For Life *
Output (Python 3.x)
>>> from __future__ import barry_as_FLUFL
>>> "Ruby" != "Python" # there's no doubt about it
File "some_file.py", line 1
"Ruby" != "Python"
^
SyntaxError: invalid syntax
>>> "Ruby" <> "Python"
True
There we go.
💡 Explanation:
- This is relevant to PEP-401 released on April 1, 2009 (now you know, what it means).
- Quoting from the PEP-401
Recognized that the != inequality operator in Python 3.0 was a horrible, finger pain inducing mistake, the FLUFL reinstates the <> diamond operator as the sole spelling.
- There were more things that Uncle Barry had to share in the PEP; you can read them here.
> Even Python understands that love is complicated *
import this
Wait, what's this? this
is love ❤️
Output:
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
It's the Zen of Python!
>>> love = this
>>> this is love
True
>>> love is True
False
>>> love is False
False
>>> love is not True or False
True
>>> love is not True or False; love is love # Love is complicated
True
💡 Explanation:
this
module in Python is an easter egg for The Zen Of Python (PEP 20).- And if you think that's already interesting enough, check out the implementation of this.py. Interestingly, the code for the Zen violates itself (and that's probably the only place where this happens).
- Regarding the statement
love is not True or False; love is love
, ironic but it's self-explanatory.
> Yes, it exists!
The else
clause for loops. One typical example might be:
def does_exists_num(l, to_find):
for num in l:
if num == to_find:
print("Exists!")
break
else:
print("Does not exist")
Output:
>>> some_list = [1, 2, 3, 4, 5]
>>> does_exists_num(some_list, 4)
Exists!
>>> does_exists_num(some_list, -1)
Does not exist
The else
clause in exception handling. An example,
try:
pass
except:
print("Exception occurred!!!")
else:
print("Try block executed successfully...")
Output:
Try block executed successfully...
💡 Explanation:
- The
else
clause after a loop is executed only when there's no explicitbreak
after all the iterations. else
clause after try block is also called "completion clause" as reaching theelse
clause in atry
statement means that the try block actually completed successfully.
> Inpinity *
The spelling is intended. Please, don't submit a patch for this.
Output (Python 3.x):
>>> infinity = float('infinity')
>>> hash(infinity)
314159
>>> hash(float('-inf'))
-314159
💡 Explanation:
- Hash of infinity is 10⁵ x π.
- Interestingly, the hash of
float('-inf')
is "-10⁵ x π" in Python 3, whereas "-10⁵ x e" in Python 2.
> Mangling time! *
class Yo(object):
def __init__(self):
self.__honey = True
self.bitch = True
Output:
>>> Yo().bitch
True
>>> Yo().__honey
AttributeError: 'Yo' object has no attribute '__honey'
>>> Yo()._Yo__honey
True
Why did Yo()._Yo__honey
work? Only Indian readers would understand.
💡 Explanation:
- Name Mangling is used to avoid naming collisions between different namespaces.
- In Python, the interpreter modifies (mangles) the class member names starting with
__
(double underscore) and not ending with more than one trailing underscore by adding_NameOfTheClass
in front. - So, to access
__honey
attribute, we are required to append_Yo
to the front which would prevent conflicts with the same name attribute defined in any other class.
Section: Miscellaneous
> +=
is faster
# using "+", three strings:
>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.25748300552368164
# using "+=", three strings:
>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.012188911437988281
💡 Explanation:
+=
is faster than+
for concatenating more than two strings because the first string (example,s1
fors1 += s2 + s3
) is not destroyed while calculating the complete string.
> Let's make a giant string!
def add_string_with_plus(iters):
s = ""
for i in range(iters):
s += "xyz"
assert len(s) == 3*iters
def add_bytes_with_plus(iters):
s = b""
for i in range(iters):
s += b"xyz"
assert len(s) == 3*iters
def add_string_with_format(iters):
fs = "{}"*iters
s = fs.format(*(["xyz"]*iters))
assert len(s) == 3*iters
def add_string_with_join(iters):
l = []
for i in range(iters):
l.append("xyz")
s = "".join(l)
assert len(s) == 3*iters
def convert_list_to_string(l, iters):
s = "".join(l)
assert len(s) == 3*iters
Output:
>>> timeit(add_string_with_plus(10000))
1000 loops, best of 3: 972 µs per loop
>>> timeit(add_bytes_with_plus(10000))
1000 loops, best of 3: 815 µs per loop
>>> timeit(add_string_with_format(10000))
1000 loops, best of 3: 508 µs per loop
>>> timeit(add_string_with_join(10000))
1000 loops, best of 3: 878 µs per loop
>>> l = ["xyz"]*10000
>>> timeit(convert_list_to_string(l, 10000))
10000 loops, best of 3: 80 µs per loop
Let's increase the number of iterations by a factor of 10.
>>> timeit(add_string_with_plus(100000)) # Linear increase in execution time
100 loops, best of 3: 9.75 ms per loop
>>> timeit(add_bytes_with_plus(100000)) # Quadratic increase
1000 loops, best of 3: 974 ms per loop
>>> timeit(add_string_with_format(100000)) # Linear increase
100 loops, best of 3: 5.25 ms per loop
>>> timeit(add_string_with_join(100000)) # Linear increase
100 loops, best of 3: 9.85 ms per loop
>>> l = ["xyz"]*100000
>>> timeit(convert_list_to_string(l, 100000)) # Linear increase
1000 loops, best of 3: 723 µs per loop
💡 Explanation
- You can read more about timeit 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 (justified with the execution times ofadd_bytes_with_plus
function) - Therefore, it's advised to use
.format.
or%
syntax (however, they are slightly slower than+
for short strings). - Or better, if already you've contents available in the form of an iterable object, then use
''.join(iterable_object)
which is much faster. add_string_with_plus
didn't show a quadratic increase in execution time unlikeadd_bytes_with_plus
because of the+=
optimizations discussed in the previous example. Had the statement beens = s + "x" + "y" + "z"
instead ofs += "xyz"
, the increase would have been quadratic.def add_string_with_plus(iters): s = "" for i in range(iters): s = s + "x" + "y" + "z" assert len(s) == 3*iters >>> timeit(add_string_with_plus(10000)) 100 loops, best of 3: 9.87 ms per loop >>> timeit(add_string_with_plus(100000)) # Quadratic increase in execution time 1 loops, best of 3: 1.09 s per loop
> Explicit typecast of strings
a = float('inf')
b = float('nan')
c = float('-iNf') #These strings are case-insensitive
d = float('nan')
Output:
>>> a
inf
>>> b
nan
>>> c
-inf
>>> float('some_other_string')
ValueError: could not convert string to float: some_other_string
>>> a == -c #inf==inf
True
>>> None == None # None==None
True
>>> b == d #but nan!=nan
False
>>> 50/a
0.0
>>> a/a
nan
>>> 23 + b
nan
💡 Explanation:
'inf'
and 'nan'
are special strings (case-insensitive), which when explicitly typecasted to float
type, are used to represent mathematical "infinity" and "not a number" respectively.
> Minor Ones
-
join()
is a string operation instead of list operation. (sort of counter-intuitive at first usage)💡 Explanation: If
join()
is a method on a string then it can operate on any iterable (list, tuple, iterators). If it were a method on a list, it'd have to be implemented separately by every type. Also, it doesn't make much sense to put a string-specific method on a genericlist
object API. -
Few weird looking but semantically correct statements:
[] = ()
is a semantically correct statement (unpacking an emptytuple
into an emptylist
)'a'[0][0][0][0][0]
is also a semantically correct statement as strings are sequences(iterables supporting element access using integer indices) in Python.3 --0-- 5 == 8
and--5 == 5
are both semantically correct statements and evaluate toTrue
.
-
Given that
a
is a number,++a
and--a
are both valid Python statements but don't behave the same way as compared with similar statements in languages like C, C++ or Java.>>> a = 5 >>> a 5 >>> ++a 5 >>> --a 5
💡 Explanation:
- There is no
++
operator in Python grammar. It is actually two+
operators. ++a
parses as+(+a)
which translates toa
. Similarly, the output of the statement--a
can be justified.- This StackOverflow thread discusses the rationale behind the absence of increment and decrement operators in Python.
- There is no
-
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!):
import dis exec(""" def f(): """ + """ """.join(["X"+str(x)+"=" + str(x) for x in range(65539)])) f() print(dis.dis(f))
-
Multiple Python threads won't run your Python code concurrently (yes you heard it right!). It may seem intuitive to spawn several threads and let them execute your Python code concurrently, but, because of the Global Interpreter Lock 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 module.
-
List slicing with out of the bounds indices throws no errors
>>> some_list = [1, 2, 3, 4, 5] >>> some_list[111:] []
-
int('١٢٣٤٥٦٧٨٩')
returns123456789
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 related to this behavior of Python. -
'abc'.count('') == 4
. Here's an approximate implementation ofcount
method, which would make the things more cleardef count(s, sub): result = 0 for i in range(len(s) + 1 - len(sub)): result += (s[i:i + len(sub)] == sub) return result
The behavior is due to the matching of empty substring(
''
) with slices of length 0 in the original string.
Contributing
All patches are Welcome! Please see CONTRIBUTING.md for further details.
For discussions, you can either create a new issue or ping on the Gitter channel
Acknowledgements
The idea and design for this collection were initially inspired by Denys Dovhan's awesome project wtfjs. The overwhelming support by the community gave it the shape it is in right now.
Some nice Links!
- https://www.youtube.com/watch?v=sH4XF6pKKmk
- https://www.reddit.com/r/Python/comments/3cu6ej/what_are_some_wtf_things_about_python
- https://sopython.com/wiki/Common_Gotchas_In_Python
- https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines
- https://stackoverflow.com/questions/1011431/common-pitfalls-in-python
- https://www.python.org/doc/humor/
- https://www.codementor.io/satwikkansal/python-practices-for-efficient-code-performance-memory-and-usability-aze6oiq65
🎓 License
Help
If you have any wtfs, ideas or suggestions, please share.
Surprise your geeky pythonist friends?
You can use these quick links to recommend wtfpython to your friends,
Need a pdf version?
I've received a few requests for the pdf version of wtfpython. You can add your details here to get the pdf as soon as it is finished.