Python:鲜为人知的功能特性(上)
GitHub 上有一个名为《What the f*ck Python!》的项目,这个有趣的项目意在收集 Python 中那些难以理解和反人类直觉的例子以及鲜为人知的功能特性,并尝试讨论这些现象背后真正的原理!
原版地址:https://github.com/satwikkansal/wtfpython
最近,一位名为“暮晨”的贡献者将其翻译成了中文。
中文版地址:https://github.com/leisurelicht/wtfpython-cn
我将所有代码都亲自试过了,加入了一些自己的理解和例子,所以会和原文稍有不同。
1. 字符串驻留
①
>>> 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. 字典的键
>>> 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. finally 子句中的 return
def some_func():
try:
return 'from_try'
finally:
return 'from_finally'
Output:
>>> some_func()
'from_finally'
说明:
函数的返回值由最后执行的 return
语句决定。由于 finally
子句一定会执行,所以 finally
子句中的 return
将始终是最后执行的语句。
4. 同一个对象
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 循环分配目标赋值
>>> 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. 执行时机差异
①
>>> 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. 整数的预分配
>>> 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. 容易疏忽的引用类型赋值
>>> 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. 闭包函数
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. 字符串末尾的反斜杠
>>> print("\\ C:\\")
\ C:\
>>> print(r"\ C:")
\ C:
>>> print(r"\ C:\")
File "<stdin>", line 1
print(r"\ C:\")
^
SyntaxError: EOL while scanning string literal
说明:
在以 r
开头的原始字符串中,反斜杠并没有特殊含义。解释器所做的只是简单的改变了反斜杠的行为,因此会直接传递反斜杠及后一个的字符。这就是反斜杠在原始字符串末尾不起作用的原因。
11. == 和 not 运算符的优先级
>>> not x == y
True
>>> x == not y
File "<input>", line 1
x == not y
^
SyntaxError: invalid syntax
说明:
一句话,==
运算符的优先级要高于 not
运算符。
12. 三引号
>>> print('wtfpython''')
wtfpython
>>> print("wtfpython""")
wtfpython
>>> # 下面的语句会抛出 `SyntaxError` 异常
>>> # print('''wtfpython')
>>> # print("""wtfpython")
说明:
'''
和 """
在 Python 中也是字符串定界符,Python 解释器在先遇到三个引号的的时候会尝试再寻找三个终止引号作为定界符,如果不存在则会导致 SyntaxError
异常。
而 Python 提供隐式的字符串链接:
>>> print("wtf" "python")
wtfpython
>>> print("wtf""") # 相当于 "wtf" ""
wtf
13. 消失的午夜0点
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 验证了下,真是这样。
14. bool 值
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 一样工作。
15. 类属性和实例属性
①
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__
属性),如果在当前类的字典中找不到的话就去它的父类中寻找。 +=
运算符会在原地修改可变对象,而不是创建新对象。因此,修改一个实例的属性会影响其他实例和类属性。
16. yield 的 bug
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 的新增条目。
来源和解释可以在这里找到: https://stackoverflow.com/questions/32139885/yield-in-list-comprehensions-and-generator-expressions
相关错误报告: http://bugs.python.org/issue10544
17. 元组的相对不可变性
>>> 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
操作已经修改成功了。
18. 消失的外部变量
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]
19. bool 类型
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 中执行。
20. append 方法陷阱
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
,这样可以避免创建对象的副本来提高性能。
Python:鲜为人知的功能特性(上)的更多相关文章
- Python:鲜为人知的功能特性(下)
GitHub 上有一个名为<What the f*ck Python!>的项目,这个有趣的项目意在收集 Python 中那些难以理解和反人类直觉的例子以及鲜为人知的功能特性,并尝试讨论这些 ...
- python中那些鲜为人知的功能特性
经常逛GitHub的可能关注一个牛叉的项目,叫 What the f*ck Python! 这个项目列出了几乎所有python中那些鲜为人知的功能特性,有些功能第一次遇见时,你会冒出 what the ...
- 七牛云存储Python SDK使用教程 - 上传策略详解
文 七牛云存储Python SDK使用教程 - 上传策略详解 七牛云存储 python-sdk 七牛云存储教程 jemygraw 2015年01月04日发布 推荐 1 推荐 收藏 2 收藏,2.7k ...
- 使用python爬取MedSci上的期刊信息
使用python爬取medsci上的期刊信息,通过设定条件,然后获取相应的期刊的的影响因子排名,期刊名称,英文全称和影响因子.主要过程如下: 首先,通过分析网站http://www.medsci.cn ...
- python Django之文件上传
python Django之文件上传 使用Django框架进行文件上传共分为俩种方式 一.方式一 通过form表单进行文件上传 #=================================== ...
- 深入理解Python异步编程(上)
本文代码整理自:深入理解Python异步编程(上) 参考:A Web Crawler With asyncio Coroutines 一.同步阻塞方式 import socket def blocki ...
- python接收html页面上传的文件
使用的 flask, 没有安装的先安装 pip install flask 示例代码:示例没有自动创建静态文件夹,需要自己在同级 创建一个名为 static 的文件夹来存放上传的文件 示例展示为图片 ...
- 转 让Python在Android系统上飞一会儿
让Python在Android系统上飞一会儿 地址: http://blog.csdn.net/ccwwff/article/details/6208260
- Python 基于Python实现Ftp文件上传,下载
基于Python实现Ftp文件上传,下载 by:授客 QQ:1033553122 测试环境: Ftp客户端:Windows平台 Ftp服务器:Linux平台 Python版本:Python 2.7 ...
随机推荐
- BZOJ_2058_[Usaco2010 Nov]Cow Photographs_逆序对
BZOJ_2058_[Usaco2010 Nov]Cow Photographs_逆序对 题意: 奶牛的图片 Farmer John希望给他的N(1<=N<=100,000)只奶牛拍照片, ...
- golang 中 string 转换 []byte 的一道笔试题
背景 去面试的时候遇到一道和 string 相关的题目,记录一下用到的知识点.题目如下: s:="123" ps:=&s b:=[]byte(s) pb:=&b s ...
- postman接口测试举例情况
http请求:http请求分为请求头和请求体,get请求只有请求头没有请求体. 1.get请求 是可以直接在浏览器访问,不需要借助任何工具.好看一些,可以打开postman测试接口 http://xx ...
- window.history.back(-1);与window.go(-1);的区别
history.back(-1):直接返回当前页的上一页,数据全部消息,是个新页面 history.go(-1):也是返回当前页的上一页,不过表单里的数据全部还在 history.back(1) 前进 ...
- DES加解密
package encrypt; import java.security.Key; import java.security.SecureRandom; import java.util.Base6 ...
- ES 16 - 对Elasticsearch中的索引数据进行增删改查 (CRUD)
目录 1 创建document 1.1 创建时手动指定id 1.2 创建时自动生成id 2 查看document 2.1 根据id查询文档 2.2 通过_source字段控制查询结果 3 修改docu ...
- 学习 JavaScript (七) 内存问题
内存问题是 JavaScript 比较底层的东西,依葫芦画瓢学会了怎么使用变量,但是对于内存的概念依然模糊,今天让我们一起来了解一下内存在这门语言是怎么样的存在. 内存在不同类型的数值面前表现有很大的 ...
- 学习 JavaScript(二)在 HTML 中使用 JS
基本用法 在 HTML 中使用 <script> 元素引入 Javascript , <script> 有以下 4 个常用属性: async: 异步加载,只对外部脚步有效. d ...
- MOCK API 的定义及实践(使用eolinker实现)
MOCK API 的定义 根据百度百科的定义,mock测试就是在测试过程中,对于某些不容易构造或者不容易获取的对象,用一个虚拟的对象来创建以便测试的测试方法.这个虚拟的对象就是mock对象,mock对 ...
- 一个小实例理解js 原型和继承
导语1:一个构造函数的原型对象,其实就是这个构造函数的一个属性而已,属性名叫prototype,值是一个对象,对象中有一些属性和方法,所以每个构造函数的实例对象都拥有这些属性和方法的使用权. 导语2: ...