Python这些冷门特性，当初也没教啊

B站|公众号：啥都会一点的研究生

本期整理了Python中几个冷门甚至奇特但又一直存在的特性，一起看看吧

插播，更多文字总结·指南·实用工具·科技前沿动态第一时间更新在公粽号【啥都会一点的研究生】

for-else

if-else想必所有人都知道用来处理条件判断，但Python中还有个for-else

names = ["James", "Tim", "Peter"]

for name in names:
    if name == "Steve":
        print("Steve in the list!")
        break
else:
    print("Not found Peter!")

# Not found Peter!
1
2
3
4
5
6
7
8
9
10

如该例，当break没有发生在for循环中时，将执行else代码块，为了验证，我们稍做改动

names = ["James", "Tim", "Peter", "Steve"]

for name in names:
    if name == "Steve":
        print("Steve in the list!")
        break
else:
    print("Not found Peter!")

# Steve in the list!
1
2
3
4
5
6
7
8
9
10

在该例中，由于触发了break，else代码块未被执行

256、257

如果在Python中比较数字，有时可能会得到意想不到的结果，如

>>> a=256
>>> b=256
>>> a is b
True
>>> x=257
>>> y=257
>>> x is y
False
1
2
3
4
5
6
7
8

这是因为Python 会预加载[-5, 256]范围内的所有整数，以节省时间和内存成本，因此，当声明此范围内的整数时，Python 仅引用缓存的整数，而不会创建任何新对象

即该例中a和b是同一个对象，而x和y却不是

为验证这点，可以打印每个变量的id

>>> id(a)
1696073345424
>>> id(b)
1696073345424
>>> id(x)
1696122928496
>>> id(y)
1696122928752
1
2
3
4
5
6
7
8

这种情况在Python中称为integer caching

String caching

和前述integer caching，Python中也会对small-size strings进行缓存，如该例

>>> a = 'Zhou'
>>> b = 'Zhou'
>>> a is b
True
>>> c = 'Cai Xukong'
>>> d = 'Cai Xukong'
>>> c is d
False
1
2
3
4
5
6
7
8

就测试使用的Python3.7来看，使用AST优化器最多可以缓存4096字符，但任何包含空格的字符串都不会缓存

>>> a = 'qyuqhsjkdbzksjgbvhjzsdbkjsfhlweakjfhiufgh'
>>> b = 'qyuqhsjkdbzksjgbvhjzsdbkjsfhlweakjfhiufgh'
>>> a is b
True
>>>
1
2
3
4
5

修改元组

在Python中元组是不可变对象，但考虑以下情况

tp = ([1, 2, 3], 4, 5)
tp[0].append(4)
print(tp)
# ([1, 2, 3, 4], 4, 5)
1
2
3
4

这是因为嵌套Python对象的可变性取决于嵌套对象本身，虽然tp是不可变元组，但tp[0]是可变列表（类似的，还需注意嵌套类型的深浅拷贝问题）

0.1+0.2 == 0.3？

正常人都清楚0.1+0.2的结果为0.3，但Python中

print(0.1+0.2 == 0.3)
# False
1
2

那么为什么会这样？我们打印出结果

>>> 0.1 + 0.2
0.30000000000000004
1
2

准确的说这是由于计算机只能以一定的精度存储和处理浮点数。因此，浮点运算依赖于机器处理器中的硬件实现，并且没有任何编程语言可以说其浮点计算总是正确的

>>> 0.42 + 0.4
0.8200000000000001
1
2

+=比=快

在Python中连接字符串，使用+=和+运算符虽然都可以达到目的，但代价不同，如

>>> import timeit
>>> print(timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100))
0.45820390002336353
>>> print(timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100))
0.20369120000395924
1
2
3
4
5

为啥会这样，这是由于+=不会创建新对象，这样时间不就抠出来了，别小瞧这点时间，在字符串处理密集且繁杂的任务中这是不小的提升

…代替pass

大多数人可能还在使用pass来代表占位符

def my_func():
   pass
1
2

但其实三个...也有相同功效（我自己在搭代码框架时也习惯用这种方式）

def my_func():
   ...
1
2

以上就是本期的全部内容，如果有从中学到什么就给个点赞在看吧，我是啥都生，下次再见