Python：What the f*ck Python（上）

github 上有一个名为《what the f*ck python!》的项目，这个有趣的项目意在收集 python 中那些难以理解和反人类直觉的例子以及鲜为人知的功能特性，并尝试讨论这些现象背后真正的原理！
原版地址：

最近，一位名为“暮晨”的贡献者将其翻译成了中文。
中文版地址：

我将所有代码都亲自试过了，加入了一些自己的理解和例子，所以会和原文稍有不同

1. strings can be tricky sometimes

①

>>> a = '!'
>>> b = '!'
>>> a is b
true

②

>>> a = 'some_string'
>>> id(a)
140420665652016
>>> id('some' + '_' + 'string') # 注意两个的id值是相同的.
140420665652016

③

>>> a = 'wtf'
>>> b = 'wtf'
>>> a is b
true

>>> a = 'wtf!'
>>> b = 'wtf!'
>>> a is b
false

>>> a, b = 'wtf!', 'wtf!'
>>> a is b
true

④

>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
true
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
false

说明：
这些行为是由于 cpython 在编译优化时，某些情况下会尝试使用已经存在的不可变对象而不是每次都创建一个新对象。（这种行为被称作字符串的驻留[string interning]）。发生驻留之后, 许多变量可能指向内存中的相同字符串对象从而节省内存。

有一些方法可以用来猜测字符串是否会被驻留:

• 所有长度为 0 和长度为 1 的字符串都被驻留（①中字符串被驻留）
• 字符串在编译时被实现（'wtf' 将被驻留，但是 ''.join(['w', 't', 'f'] 将不会被驻留）
• 字符串中只包含字母、数字或下划线时将会驻留，所以 'wtf!' 由于包含 '!' 而未被驻留
• 当在同一行将 a 和 b 的值设置为 "wtf!" 的时候，python 解释器会创建一个新对象，然后两个变量同时指向这个对象。如果你在不同的行上进行赋值操作，它就不会“知道”已经有一个 wtf! 对象（因为 "wtf!" 不是按照上面提到的方式被隐式驻留的）。
• 常量折叠（constant folding）是 python 中的一种窥孔优化（peephole optimization）技术。这意味着在编译时表达式 'a' * 20 会被替换为 'aaaaaaaaaaaaaaaaaaaa' 以减少运行时的时钟周期。只有长度小于 20 的字符串才会发生常量折叠。（为啥？想象一下由于表达式 'a' * 10 ** 10 而生成的 .pyc 文件的大小）。

如果你在 .py 文件中尝试这个例子，则不会看到相同的行为，因为文件是一次性编译的。

2. time for some hash brownies!

>>> some_dict = {}
>>> some_dict[5.5] = "ruby"
>>> some_dict[5.0] = "javascript"
>>> some_dict[5] = "python"

>>> some_dict[5.5]
"ruby"
>>> some_dict[5.0]
"python"
>>> some_dict[5]
"python"

说明：
python 字典检查键值是否相等是通过比较哈希值是否相等来确定的。如果两个对象在比较的时候是相等的，那它们的散列值必须相等，否则散列表就不能正常运行了。例如，如果 1 == 1.0 为真，那么 hash(1) == hash(1.0) 必须也为真，但其实两个数字（整数和浮点数）的内部结构是完全不一样的。

3. return return everywhere!

def some_func():
    try:
        return 'from_try'
    finally:
        return 'from_finally'

output:

>>> some_func()
'from_finally'

说明：
函数的返回值由最后执行的 return 语句决定。由于 finally 子句一定会执行，所以 finally 子句中的 return 将始终是最后执行的语句。

4. 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值。

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

正如你所看到的，对象销毁的顺序是造成所有不同之处的原因。

5. for what?

>>> some_string = "wtf"
>>> some_dict = {}
>>> for i, some_dict[i] in enumerate(some_string): pass
>>> some_dict
{0: 'w', 1: 't', 2: 'f'}

说明：
这一条仔细看一下很好理解，for 循环每次迭代都会给分配目标赋值，some_dict[i] = value 就相当于给字典添加键值对了。
有趣的是下面这个例子，你可曾觉得这个循环只会运行一次？

for i in range(4):
    print(i)
    i = 10

6. evaluation time discrepancy

①

>>> array = [1, 8, 15]
>>> g = (x for x in array if array.count(x) > 0)
>>> array = [2, 8, 22]
>>> list(g)
[8]

②

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

>>> list(g1)
[1, 2, 3, 4]

>>> 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]。

7. is is not what it 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 的数值就已经被分配好了。这些数字因为经常使用所以适合被提前准备好。

当前的实现为 -5 到 256 之间的所有整数保留一个整数对象数组，当你创建了一个该范围内的整数时，你只需要返回现有对象的引用。所以改变 1 的值是有可能的。

但是，当 a 和 b 在同一行中使用相同的值初始化时，会指向同一个对象。

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

>>> a, b = 257, 257
>>> id(a)
140640774013296
>>> id(b)
140640774013296

这是一种特别为交互式环境做的编译器优化，当你在实时解释器中输入两行的时候，他们会单独编译，因此也会单独进行优化， 如果你在 .py 文件中尝试这个例子，则不会看到相同的行为，因为文件是一次性编译的。

8. a tic-tac-toe where x wins in the first attempt!

>>> row = [''] * 3
>>> board = [row] * 3
>>> board
[['', '', ''], ['', '', ''], ['', '', '']]
>>> board[0]
['', '', '']
>>> board[0][0]
''
>>> board[0][0] = "x"
>>> board
[['x', '', ''], ['x', '', ''], ['x', '', '']]

说明：
我们来输出 id 看下：

>>> id(row[0])
7536232
>>> id(row[1])
5143216
>>> id(row[2])
5143216
>>> id(board[0])
7416840
>>> id(board[1])
7416840
>>> id(board[2])
7416840

row 是一个 list，其中三个元素都指向地址 5143216，当对 board[0][0] 进行赋值以后，row 的第一个元素指向 7536232。而 board 中的三个元素都指向 row，row 的地址并没有改变。

我们可以通过不使用变量 row 生成 board 来避免这种情况。

>>> board = [[''] * 3 for _ in range(3)]
>>> board[0][0] = "x"
>>> board
[['x', '', ''], ['', '', ''], ['', '', '']]

这里用了推导式，每次迭代都会生成一个新的 _ ，所以 board 中三个元素指向的是不同的变量。

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

说明：
当在循环内部定义一个函数时，如果该函数在其主体中使用了循环变量，则闭包函数将与循环变量绑定，而不是它的值。因此，所有的函数都是使用最后分配给变量的值来进行计算的。

可以通过将循环变量作为命名变量传递给函数来获得预期的结果。为什么这样可行？因为这会在函数内再次定义一个局部变量。

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]

10. is not ... is not is (not ...)/is not ... 不是 is (not ...)

>>> 'something' is not none
true
>>> 'something' is (not none)
false

说明：
is not 是个单独的二元运算符，与分别使用 is 和 not 不同。

11. the surprising comma

略过，我想没人会在函数的最后一个参数后面再加一个逗号吧！
况且，尾随逗号的问题已经在 python 3.6 中被修复了。

12. backslashes at the end of string

>>> print("\\ c:\\")
\ c:\
>>> print(r"\ c:")
\ c:
>>> print(r"\ c:\")

    file "<stdin>", line 1
      print(r"\ c:\")
                     ^
syntaxerror: eol while scanning string literal

说明：
在以 r 开头的原始字符串中，反斜杠并没有特殊含义。解释器所做的只是简单的改变了反斜杠的行为，因此会直接传递反斜杠及后一个的字符。这就是反斜杠在原始字符串末尾不起作用的原因。

13. not knot!

>>> not x == y
true
>>> x == not y
  file "<input>", line 1
    x == not y
           ^
syntaxerror: invalid syntax

说明：
一句话，== 运算符的优先级要高于 not 运算符。

14. half triple-quoted strings

>>> print('wtfpython''')
wtfpython
>>> print("wtfpython""")
wtfpython
>>> # 下面的语句会抛出 `syntaxerror` 异常
>>> # print('''wtfpython')
>>> # print("""wtfpython")

说明：
''' 和 """ 在 python中也是字符串定界符，python 解释器在先遇到三个引号的的时候会尝试再寻找三个终止引号作为定界符，如果不存在则会导致 syntaxerror 异常。

而 python 提供隐式的字符串链接：

>>> print("wtf" "python")
wtfpython
>>> print("wtf""")  # 相当于 "wtf" ""
wtf

15. 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 12:00:00

midnight_time 并没有被输出。
说明：
在python 3.5之前，如果 datetime.time 对象存储的utc的午夜0点, 那么它的布尔值会被认为是 false。
这个我特意下了个 python 3.4 验证了下，真是这样。

16. what's wrong with booleans

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:

>>> booleans_found_so_far
0
>>> integers_found_so_far
4

说明：
布尔值是 int 的子类

>>> isinstance(true, int)
true
>>> isinstance(false, int)
true

在引入实际 bool 类型之前，0 和 1 是真值的官方表示。为了向下兼容，新的 bool 类型需要像 0 和 1 一样工作。

17. class attributes and instance attributes

①

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)

②

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__ 属性），如果在当前类的字典中找不到的话就去它的父类中寻找。

• += 运算符会在原地修改可变对象，而不是创建新对象。因此，修改一个实例的属性会影响其他实例和类属性。

  18. 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']

说明：
这是cpython在理解和生成器表达式中处理yield的一个错误，在python 3.8中修复，在python 3.7中有弃用警告。 请参阅python错误报告和python 3.7和python 3.8的新增条目。

来源和解释可以在这里找到:
相关错误报告:

19. mutating the immutable!

>>> some_tuple = ("a", "tuple", "with", "values")
>>> another_tuple = ([1, 2], [3, 4], [5, 6])

>>> 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])

说明：
元组中不可变的元素的标识（即元素的地址），如果元素是引用类型，元组的值会随着引用的可变对象的变化而变化。所以 another_tuple[2].append(1000) 是可以的。
+= 操作符在原地修改了列表。元素赋值操作并不工作，但是当异常抛出时，元素已经在原地被修改了。+= 并不是原子操作，而是 extend 和 = 两个动作，这里 = 操作虽然会抛出异常，但 extend 操作已经修改成功了。

20. the disappearing variable from outer scope

e = 7
try:
    raise exception()
except exception as e:
    pass

output: python2

>>> print(e)
# prints nothing

output: python3

>>> print(e)
nameerror: name 'e' is not defined

说明：
当使用 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]

21. 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 中执行。

22. 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，这样可以避免创建对象的副本来提高性能。

23. subclass relationships

>>> 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 是可散列的(hashable)，而 list 是不可散列的，所以它打破了这种传递关系。

  24. the mysterious key type conversion

class someclass(str):
    pass

some_dict = {'s': 42}

output:

>>> type(list(some_dict.keys())[0])
<class 'str'>
>>> s = someclass('s')
>>> some_dict[s] = 40
>>> some_dict # 预期: 两个不同的键值对
{'s': 40}
>>> type(list(some_dict.keys())[0])
<class '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])
<class 'str'> <class '__main__.someclass'>

25. let's see if you can guess this?

>>> a, b = a[b] = {}, 5
>>> a
{5: ({...}, 5)}

说明：
根据 python 语言参考，赋值语句的形式如下：

(target_list "=")+ (expression_list | yield_expression)

赋值语句计算表达式列表(expression list)(请记住，这可以是单个表达式或以逗号分隔的列表, 后者返回元组)并将单个结果对象从左到右分配给目标列表中的每一项。

(target_list "=")+ 中的 + 意味着可以有一个或多个目标列表。在这个例子中，目标列表是 a, b 和 a[b]。表达式列表只能有一个，是 {}, 5。

这话看着非常的晦涩，我们来看一个简单的例子：

a, b = b, c = 1, 2
print(a, b, c)

output:

1 1 2

在这个简单的例子中，目标列表是 a, b 和 b, c，表达式是 1, 2。将表达式从左到右赋给目标列表，上述例子就可以拆分成：

a, b = 1, 2
b, c = 1, 2

所以结果就是 1 1 2。

那么，原例子就不难理解了，拆解开来就是：

a, b = {}, 5
a[b] = a, b

这里不能写作 a[b] = {}, 5，因为这样第一句中的 {} 和第二句中的 {} 其实就是不同的对象了，而实际他们是同一个对象。这就形成了循环引用，输出中的 {...} 指与 a 引用了相同的对象。
我们来验证一下：

>>> a[b][0] is a
true

可见确实是同一个对象。

以下是一个简单的循环引用的例子：

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