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

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

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

0x00

1. >>>'a'*20is'aaaaaaaaaaaaaaaaaaaa'
2. True
3. >>>'a'*21is'aaaaaaaaaaaaaaaaaaaaa'
4. False#2.7版本返回False
5. #3.7版本返回结果为True

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

0x01

1. In[3]:a='python'
3. In[4]:b='python'
5. In[5]:aisb
6. Out[5]:True
8. In[6]:x='python!'
10. In[7]:y='python!'
12. In[8]:xisy
13. Out[8]:False

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

0x02

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

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

0x03

1. In[21]:defsome_func():
2. ...:try:
3. ...:return'from_try'
4. ...:finally:
5. ...:return'from_finally'
6. ...:
8. In[22]:some_func()
9. Out[22]:'from_finally'

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

0x04

1. In[23]:foriinrange(3):
2. ...:print(i)
3. ...:i=10
4. ...:
5. 0
6. 1
7. 2

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

0x05

1. In[24]:row=['']*3
3. In[25]:table=[row]*3
5. In[26]:table
6. Out[26]:[['','',''],['','',''],['','','']]
8. In[27]:table[0][0]='python'
10. In[28]:table
11. Out[28]:[['python','',''],['python','',''],['python','','']]

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

0x06

1. In[29]:a=256
3. In[30]:b=256
5. In[31]:aisb
6. Out[31]:True
8. In[32]:a=257
10. In[33]:b=257
12. In[34]:aisb
13. Out[34]:False

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

0x07

1. In[37]:'something'isnotNone
2. Out[37]:True
4. In[38]:'something'is(notNone)
5. Out[38]:False

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

0x08

1. In[47]:a=[1,2,3,4]
3. In[48]:b=a
5. In[49]:a=a+[5,6,7,8]
7. In[50]:a
8. Out[50]:[1,2,3,4,5,6,7,8]
10. In[51]:b
11. Out[51]:[1,2,3,4]

1. In[52]:a=[1,2,3,4]
3. In[53]:b=a
5. In[54]:a+=[5,6,7,8]
7. In[55]:a
8. Out[55]:[1,2,3,4,5,6,7,8]
10. In[56]:b
11. Out[56]:[1,2,3,4,5,6,7,8]

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

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

0x09

1. t=('one','two')
2. foriint:
3. print(i)
5. print('*'*5)
6. t=('one')
7. foriint:
8. print(i)
10. print('*'*5)
11. t=()
12. print(t)
14. ##输出
15. one
16. two
17. o
18. n
19. e
20. tuple()

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

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

总结

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

原文链接：https://mp.weixin.qq.com/s/ouf6oHwT9lkQA85Iqczpzw