盘点哪些让你大呼“真牛”的 Python 代码!

发表于:2021-11-02 10:03

字体: | 上一篇 | 下一篇 | 我要投稿

 作者:派森酱    来源:Python技术

#
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 的设计思想,一举两得。

  本文内容不用于商业目的,如涉及知识产权问题,请权利人联系51Testing小编(021-64471599-8017),我们将立即处理
《2023软件测试行业现状调查报告》独家发布~

关注51Testing

联系我们

快捷面板 站点地图 联系我们 广告服务 关于我们 站长统计 发展历程

法律顾问:上海兰迪律师事务所 项棋律师
版权所有 上海博为峰软件技术股份有限公司 Copyright©51testing.com 2003-2024
投诉及意见反馈:webmaster@51testing.com; 业务联系:service@51testing.com 021-64471599-8017

沪ICP备05003035号

沪公网安备 31010102002173号