变量不是盒子
变量是标注，而不是盒子。Python变量类似于Java中的引用式变量，因为最好理解为附加在对象上的标注。
对于引用式变量来说，说把变量分配给对象更加合理。把变量s分配给'xxx'，而不是说把'xxx'分配给变量s。
示例，创建对象之后才会把变量分配给对象
>>> class Giz:
... def __init__(self):
... print('Giz id is{}'.format(id(self)))
...
>>>
>>> x = Giz()
Giz id is56583408
>>> y = Giz() * 10
Giz id is56583568
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for *: 'Giz' and 'int'
>>> dir()
['Giz', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'x']
最后使用dir（）查询当前变量，看到了变量x，并没有变量y，因为赋值时抛出了异常。
标识、相等性 is ==
==是比较两个对象的值（对象保存的数据），is是比较对象的标识
每个对象都有标识、类型、值。对象一旦创建，它的标识绝不会变。
值变化好理解，类型的变化可以为__class__属性指定其他类。
可以把标识理解为对象在内存中的地址。is运算符是比较两个对象的标识。id()函数返回对象标识的整数标识。
对象ID的真实意义在不同的实现中有所不同。在CPython中，id()返回对象的内存地址，但是在其他的Python解释器中可能是别的值。但是ID一定是唯一的数值标注，而且在对象的生命周期中绝不会变。
在变量和单例值之间比较时，应该使用is。比如比较变量是不是None： x is None
is运算符比==速度要快。因为它不能重载，所以Python不需要寻找特殊方法，而是直接比较两个对象的整数ID。
而a == b是语法糖，等同于a.__eq__(b)。如果继承自object的__eq__不加以修改，就是比较两个对象的ID，结果和is一样。但是大多数内置类型都覆盖了__eq__方法，会考虑对象属性的值。
元组的相对不可变性
元组和多数Python集合（列表，字典、集合等等）一样，保存的是对象的引用。
而str、bytes、和array.array等类型是扁平的，保存的不是引用，而是在连续内存中保存数据的本身。
虽然元组是不可变的，但是引用的元素可以是可变的。也就是说元组的不可变性是值的tuple数据结构的物理内容（保存的引用）不可变，于引用的对象无关。
元组是否可散列，取决于它的元素是否是可散列的。如果它的元素全部是可散列的，那么这个元组就是可散列的。
不可变集合不变的是所含对象的标识。
浅拷贝和深拷贝
Python默认是浅拷贝，比如使用拷贝一个列表l1 使用l2=list(l1) 或者l2=l1[:] 都是浅拷贝。 （l2=l1这不是拷贝，这是别名，多了一个引用）
浅拷贝：只复制了最外层的容器，副本中的元素是源容器中元素的引用。如果所有元素都是不可变的，那么这样没问题，还能节省内存。但是浅拷贝中有可变的元素，会导致很多想不到的问题。
l1 = [3, [66, 55, 44], (7, 8, 9)] l2 = list(l1) # 浅拷贝，此时l1 is l2 = FALSE l1.append(100) # 对l2没有英雄 l1[1].remove(55) # 对l2有影响，因为l1[1]和l2[1]绑定的列表是同一个 print(l1) print(l2) l2[1] += [33, 22] # +=可变类型来说，会就地修改列表。l1和l2都引用了这个列表 l2[2] += (10, 11) # +=对于元组这种不可变类型，会创建一个新的元组，然后重新绑定给变量l2[2]。此时l1和l2最后一个元组不是同一个对象了。 print(l1) print(l2) 打印 [3, [66, 44], (7, 8, 9), 100] [3, [66, 44], (7, 8, 9)] [3, [66, 44, 33, 22], (7, 8, 9), 100] [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]
知识点：
+=增量赋值运算符，对于列表来说，会修改原列表。对于元组这种不可变序列，会创建一个新的元组。
深拷贝：拷贝的副本不共享内部对象的引用。
copy模块对于深拷贝和浅拷贝，提供了对应的deepcopy和copy函数。
我们可以实现特殊方法__deepcopy__和__copy__来控制他们的行为。
定义一个Bus类，实现乘客上下车。创建一个实例bus1，生成两个副本，一个是浅拷贝的bus2，另一个是深拷贝的bus3
示例，深拷贝和浅拷贝演示
import copy
class Bus:
def __init__(self, passenger=None):
if passenger:
self.passenger = list(passenger)
else:
self.passenger = []
def pick(self, name):
"""上车"""
self.passenger.append(name)
def drop(self, name):
"""下车"""
self.passenger.remove(name)
bus1 = Bus(['wang', 'li', 'sun', 'zhao'])
bus2 = copy.copy(bus1)
bus3 = copy.deepcopy(bus1)
print(id(bus1), id(bus2), id(bus3)) # 三个实例的id不相同。
print(id(bus1.passenger), id(bus2.passenger), id(bus3.passenger)) # bus1和bus2共享一个列表对象，因为bus2是浅拷贝。
bus1.drop('wang')
print(bus2.passenger)
print(bus3.passenger)
打印
59138544 59139344 59603984
59133384 59133384 59131584
['li', 'sun', 'zhao']
['wang', 'li', 'sun', 'zhao']理解：
浅拷贝对于列表来说，只对第一层拷贝，再深的层次就是复制的引用。
以上代码示例，浅拷贝对于类对象的实例来说，类实例是第一层，而实例属性是第二层。所以bus1改变了实例属性，bus2也会随之改变。
另外deepcopy函数还可以优雅的处理循环引用的问题：
示例，循环引用的deepcopy
import copy
a = [10, 20]
b = [a, 30]
a.append(b)
a_deep = copy.deepcopy(a)
print(a)
print(a_deep)
打印
[10, 20, [[...], 30]]
[10, 20, [[...], 30]]函数的传参是引用传递
Python唯一支持的参数传递模式的共享传参（call by sharing）。多数面向对象语言都采用这个模式。
共享传参是指函数中各个形式参数获得的是实参的引用的副本。也就是说，函数内部的形参是实参的别名。
这样的结果就是，函数可能会修改作为参数传入的可变对象，但不会改变标识。
千万不用使用可变类型作为参数的默认值！
一个简单的Bus类，使用可变类型作为参数，结果变成了幽灵列车了。。。
示例
class Bus:
def __init__(self, passenger=[]): # 默认绑定的参数是列表对象，空列表
self.passenger = passenger
def pick(self, name):
"""上车"""
self.passenger.append(name)
def drop(self, name):
"""下车"""
self.passenger.remove(name)
bus1 = Bus(['sun', 'li']) # 如果实例化时传入乘客，没有任何问题
print(bus1.passenger)
bus2 = Bus()
bus2.pick('zhao')
print(bus2.passenger)
bus3 = Bus()
print(bus3.passenger)
打印
['sun', 'li']
['zhao']
['zhao']以上演示，会惊奇的发现，bus3.passenger竟然不是空，而是延续了bus2内的数据。
如果Bus类实例化时，不指定乘客，这时self.passenger变成了passenger参数的默认值的别名。
默认值在定义函数时计算，因此默认值变成了函数对象的属性。如果默认值是可变对象，而且修改了它的值，那么后续的函数调用都会受到影响。
我对于这个现象的理解：init函数执行时，实参passenger是对于一个空列表的引用，形参self.passenger是passenger实参的别名，对于self.passenger的修改，就是等价于对原始空列表的修改，后续的函数对这个列表的引用，都会读取到这一个列表的数据。
如果入参是可变类型，注意创建副本！
上面说到了默认参数不能为可变类型，规避了这个以后，还有一个问题：
class Bus:
def __init__(self, passenger=None):
if passenger:
self.passenger = passenger # self.passenger是passenger的别名
else:
self.passenger = []
def pick(self, name):
"""上车"""
self.passenger.append(name)
def drop(self, name):
"""下车"""
self.passenger.remove(name)
name_list = ['zhao', 'li', 'sun']
bus = Bus(name_list)
bus.drop('zhao')
print(name_list)
打印结果
['li', 'sun']把可变参数列表传递给类对象以后，经过实例的操作，把原列表也改变了，这样直接破坏了原数据。
正确的做法是类对象自己维护一份副本数据，使用浅拷贝。
self.passenger = list(passenger) #使用list创建了passenger列表的副本。
del和垃圾回收
对象绝不会自行销毁；然而，无法得到对象时，可能会被当做垃圾回收。
del语句是删除名称，而不是对象。
del语句可能会导致对象被当做垃圾回收，但是仅当删除了变量保存的是对象的最后一个引用，或者是无法得到对象的时候（比如两个对象相互引用）。还有就是重新绑定也可能导致对象的引用数量归零，导致对象被销毁。
在即将销毁实例时，Python解释器会调用__del__方法，给实例最后的机会，让其释放外部资源。自己编写的代码很少需要用到__del__代码，因为__del__很难用，费力不讨好。
在CPython中，垃圾回收的主要算法是引用计数。每个对象都会统计有多少引用指向了自己。当引用计数归零时，对象立即被销毁：CPython会在对象上调用__del__方法（如果定义了），然后释放分配给对象的内存。
CPython2.0增加了分代垃圾回收算法（隔代回收）。用于检测引用循环中涉及的对象组---如果一组对象之间是相互引用，即使再出色的引用方式也会导致组中的对象不可获取。
Python的其他实现有更复杂的垃圾回收程序，而且不依赖引用计数，这意味着引用数量归零时不会立即调用__del__方法，所以不要依赖__del__
示例，对象被销毁时的情形
import weakref # weakref：弱引用
s1 = {1, 2, 3}
s2 = s1 # s1和s2都是别名，指向集合{1,2,3}
def bye():
print('bye!')
ender = weakref.finalize(s1, bye) # 在s1的引用对象上注册bye回调，也就是当对象被回收后，会触发bye函数
print(ender.alive)
del s1
print(ender.alive) # 删除s1并没有触发bye函数，也就是对象没有被删除，只是删除了对象的引用s1
s2 = 'new' # 重新绑定了最后一个引用s2，让{1,2,3}无法获取了。此时对象被销毁了
print(ender.alive) # 验证被销毁
打印结果
True
True
bye!
False扩展知识点：
weakref模块支持对象的弱引用。正常的引用会增加对象的引用数，并避免它被垃圾回收。弱引用是一个不能避免对象被自动清理的对象句柄，不会影响其垃圾回收。
弱引用和控制台的_变量
弱引用
因为有引用，对象才能在内存中存在。当对象的引用数量归零后，垃圾回收程序会把对象销毁。
但是有时候需要引用对象，但是不想影响对象的生命周期，这经常用在缓存中。
弱引用不会增加对象的引用数量。引用的目标对象称为所指对象（referent）。因此弱引用不会妨碍所指对象被当做垃圾回收。
弱引用在缓存应用中很有用，因为我们不想因为缓存占用着对象，而不被回收。
使用weakref.ref获取所指对象的弱引用。如果对象存在，调用弱引用可以返回对象，否则返回None。
示例，使用weakref.ref创建对象的弱引用。
import weakref # weakref：弱引用
a_set = {1, 2}
wref = weakref.ref(a_set) # 创建一个对于a_set对象引用{1,2}的弱引用对象wred
print(wref)
print(wref()) # wref()会返回被引用的对象
a_set = {3, 4}
print(wref()) # 此时{1,2}已经没有了强引用，所以已经不存在了，这里返回None
打印结果
<weakref at 0x01C80300; to 'set' at 0x01C8C198>
{1, 2}
None控制台的_变量
在Python的控制台会话中，控制台会自动把 _ 变量绑定到结果不为None的表达式结果上。这样对跟踪对象导致多了一个意料之外的引用。
以下是在控制台的演示：
>>> import weakref
>>> a_set = {1, 2}
>>> wref = weakref.ref(a_set)
>>> wref() # wref() 返回了被引用的对象
{1, 2}
>>> a_set = {3, 4} # 此时a_set已经不再指向{1,2}集合。但是控制台的_变量依然指向{1,2}。
>>> wref()
{1, 2}
>>> wref() is None # 计算这个表达式的时候，{0,1}存在所以不是None。但是随后变量_就绑定到了结果值False。然后{1,2}就没有强引用了。
False
>>> wref() is None
True
weakref模块的文档指出，weakref.ref类是底层接口，供高级用途使用，多数程序应该该是WeakKeyDictionary、WeakValueDictionary、weakset和finalize（在内部使用弱引用），不要自动动手创建并处理weakref.ref示例。
WeakValueDictionary的介绍
WeakValueDictionary类实现的是一种可变映射，里面的值是对象的弱引用。被引用的对象在程序的其他地方被垃圾回收后，对应的键会自动从WeakValueDictionary中删除。因此常用于缓存。
示例，简单的使用
import weakref
class Cheese:
"""各种奶酪"""
def __init__(self, kind):
self.kind = kind # 奶酪种类
def __repr__(self):
return 'Cheese(%r)' % self.kind
stock = weakref.WeakValueDictionary()
catalog = [Cheese('A'), Cheese('B'), Cheese('C'), Cheese('D'), ]
for cheese in catalog:
stock[cheese.kind] = cheese
print(sorted(stock.keys()))
del catalog
print(sorted(stock.keys())) # 删除catalog之后，还有'D',说明还存在一个强引用，那就是cheese保存了循环中的最后一个值
del cheese
print(sorted(stock.keys())) # 删除cheese后，所有强引用都没了，WeakValueDictionary也变为空了
打印结果
['A', 'B', 'C', 'D']
['D']
[]知识点：
for x in list 循环中的x其实是全局变量，会一直存在，除非显式 的删除（del）。这就说明了上面代码中对象"D"的引用没有消失，因为还有cheese引用到了它。
比如这个简单的示例
for x in range(3):
print(x)
print(x) # x的结果为2
print(locals()) # 结果中可以找到'x': 2
弱引用的局限
不是所有的Python对象都可以作为弱引用的目标（或称所指对象）。
- list和dit实例不能作为所指对象，但是他们的子类可以解决这个问题：
import weakref
class MyList(list):
"""list的子类，实例可以作为弱引用的目标"""
my_list = MyList()
wref_to_a_list = weakref.ref(my_list)- set实例和用户自定义类型可以作为所指对象
- int和tuple实例不能作为弱引用的目标，甚至是子类也不行。
以上的这些局限，都是CPython的实现细节，在其他的Python解释器中的情况可能不一样。
Python对不可变类型的把戏
惊讶的发现，对于元组t来说，t[:]按照理解来说应该是做了浅拷贝生成了副本，但是返回的确实一个对象的引用。还有tuple(t)获得的也是同一个元组的引用。
>>> t = (1,2)
>>> t2 = t[:]
>>> t2 is t
True
>>> t3 = tuple(t)
>>> t3 is t
True
还有str、bytes和frozenset也有这种行为。但是frozenset实力不是序列，不能是使用fs[:],但是fs.copy()也有同样的效果，会返回一个对象的引用，而不是创建副本。
共享字符串字面量是一种优化措施，称为驻留（interning）。CPython还会在小的整数上用这个优化措施，防止重复创建“热门”数字，这就是小整数池
Python中，对于整数对象，如果其值处于[-5,256]的闭区间内，则值相同的对象是同一个对象
观察源码：
#ifndef NSMALLPOSINTS #define NSMALLPOSINTS 257 #endif #ifndef NSMALLNEGINTS #define NSMALLNEGINTS 5 #endif
从_PyInt_Init的实现上，我们可以看到被放入small_ints的数字范围是-5到256。因此，你可以通过修改源代码的方式，将这个范围任意的扩展。
以上一些列行为，是Python“善意的谎言”，能节省内存，提高解释器的速度。
简单的总结
- 简单的赋值不会创建副本。而是增加了别名。
- 对于+=或者*=这种增量赋值来说，如果左边的变量绑定是不可变对象，会创建新对象；如果是可变对象，会就地修改。
- 为现有的变量赋予新值，不会修改之前绑定的变量对象。这叫重新绑定：现在变量绑定了其他对象。如果变量是之前那个对象的最后一个引用，对象会被当做垃圾回收。
- 函数的参数以别名传递。这意味着函数可以修改通过参数传入的可变对象。除非在函数内创建副本，或者使用不可变对象，否则无法避免。
- 使用可变类型作为函数的参数的默认值很危险，如果就地修改了参数，默认值也就变了，这会影响以后使用默认值的调用。
- 在CPython中，对象的引用计数归零后，对象会被立即销毁。如果出了循环引用之外没有其他的引用，那这两个对象都会被销毁。
- 用户自定义的类，其实例默认是可变，多数面向对面语言都是如此。
- 可变性对象还是导致多线程编程难以处理的主要原因，因为某个线程改动对象后，如果不正确的同步，那就会损坏数据。但是过度的同步又会导致死锁。
扫一扫
2105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
