惊奇时刻！盘点哪些让你大呼“真牛”的 Python 代码！

Python 作为一个设计优美的真牛高级语言，提供了很多简单易用的惊奇特性，但简单并不意味着容易理解，时刻有时候一些输出结果对于刚入门的盘点小伙伴并不是很明了，反而似乎有点反人类。代码

今天派森酱就整理了一些非常有趣的真牛例子，事实上这些例子不仅有趣，惊奇甚至还可以加深你对 Python 的时刻理解，学到更多有趣的盘点特性。

0x00

>>> a * 20 is aaaaaaaaaaaaaaaaaaaa True >>> a * 21 is aaaaaaaaaaaaaaaaaaaaa False # 2.7 版本返回 False # 3.7 版本返回结果为 True 

很神奇的代码一个结果，第一次看到时我也惊呆了，真牛事实上这是惊奇 Python 的一种优化机制，叫常量折叠。时刻这意味着在编译时表达式 a*20 会被替换为 aaaaaaaaaaaaaaaaaaaa 以减少运行时时常，盘点而只有长度小于 20 的代码字符串才会发生常量折叠。

0x01

In [3]: a = python In [4]: b = python In [5]: a is b Out[5]: True In [6]: x = python! In [7]: y = python! In [8]: x is y Out[8]: False 

这是因为在编译优化时 Python 会尝试使用一些已经存在的不可辨对象，这种现象称之为字符串驻留，而只包含字母数字和下划线的字符串在编译时是会驻留的，源码库包含 ! 的字符串是不会驻留的。

0x02

In [11]: some_dict = { } In [12]: some_dict[5.5] = Java In [13]: some_dict[5.0] = Ruby In [14]: some_dict[5] = Python In [15]: some_dict[5.5] + _ + some_dict[5.0] + _ + some_dict[5] Out[15]: Java_Python_Python In [16]: 5 == 5.0 Out[16]: True In [17]: hash(5) == hash(5.0) Out[17]: True 

Python 字典通过比较不可变对象是否相等和哈希值是否相等来确定是否为不同的键，但不同值的对象也可能具有相同的哈希值。因此字典以为 5.0 和 5 是同一个键，所以 Python 会覆盖掉 Ruby。

0x03

In [21]: def some_func():     ...:     try:     ...:         return from_try     ...:     finally:     ...:         return from_finally     ...: In [22]: some_func() Out[22]: from_finally 

函数的返回值由最后 return 的语句决定，而 finally 一定是最后之行的，所以会覆盖掉 try 中的 return 结果。

0x04

In [23]: for i in range(3):     ...:     print(i)     ...:     i = 10     ...: 0 1 2 

在每次循环开始之前, 迭代器生成的下一个元素会重新赋值给 i，因此赋值语句 i = 10 并不会影响循环。

0x05

In [24]: row = [] * 3 In [25]: table = [row] * 3 In [26]: table Out[26]: [[, , ], [, , ], [, , ]] In [27]: table[0][0] = python In [28]: table Out[28]: [[python, , ], [python, , ], [python, , ]] 

这是因为通过乘法初始化 table 时，每个 item 也就是 table[0]、table[1]、table[2] 在内存中引用的都是亿华云同一个列表。

0x06

In [29]: a = 256 In [30]: b = 256 In [31]: a is b Out[31]: True In [32]: a = 257 In [33]: b = 257 In [34]: a is b Out[34]: False 

产生这种现象的根本原因就是 256 是一个已经存在的对象而 257 不是，事实上当 Python 启动时数值为 -5 到 256 这些常用的的对象就已经被分配好了。

0x07

In [37]: something is not None Out[37]: True In [38]: something is (not None) Out[38]: False 

这是因为 is not 是一个单独的二元运算符，如果运算符两侧的变量指向同一个对象, 则 is not 的结果为 False, 否则为 True。

0x08

In [47]: a = [1, 2, 3, 4] In [48]: b = a In [49]: a = a + [5, 6, 7, 8] In [50]: a Out[50]: [1, 2, 3, 4, 5, 6, 7, 8] In [51]: b Out[51]: [1, 2, 3, 4]  In [52]: a = [1, 2, 3, 4] In [53]: b = a In [54]: a += [5, 6, 7, 8] In [55]: a Out[55]: [1, 2, 3, 4, 5, 6, 7, 8] In [56]: b Out[56]: [1, 2, 3, 4, 5, 6, 7, 8] 

在第一个例子中 a = a + ... 会生成一个新的列表然后 a 指向这个列表，但 b 是保持不变的。

而第二个例子中的 a += ... 实际上是使用的是 extend 函数，所以 a 和 b 指向的都是同一个列表。

0x09

t = (one, two) for i in t:     print(i) print(**5) t = (one) for i in t:     print(i) print(**5) t = () print(t) ## 输出 one two o n e tuple() 

在 Python 的世界 () 是一个特殊的高防服务器标记，表示空元组，这个非常容易理解。

而 t = (one) 或者 t = one 都是会被解释成为字符串的。正确的写法应该是 t = (one,)。

总结

今天派森酱带领大家整理了一些 Python 中比较好玩有趣的代码，觉得眼前一亮的同时还可以顺带更深刻的理解 Python 的设计思想，一举两得。

很赞哦!（1669）