第七章 对象应用、可变性和垃圾回收
7.1 python中的变量是什么
python和java中的变量本质不一样，java里的变量看做一个盒子（有大有小）。java中声明一个变量，首先要声明变量类型是什么，比如int、str或者某个类。声明这个类之后，虚拟机就会在内存中给我们申请一块空间，空间大小跟类型有关。这个盒子能装什么东西，在开始时就已经指定了。
但是python变量实质是一个指针，这个指针可以指向int类型的数据，也可以指向str类型的数据。也可以理解为便利贴，大小固定，可以贴在任何地方。
a = 1
a = "abc"
#1. a贴在1上面
#2. 先生成对象 然后贴便利贴
过程是
- 首先去内存里申请一个空间放1这个int对象
- 然后让a指向1这个对象（贴在1上面）
为进一步说明便利贴的特性，我们声明一个数组a，然后让b=a，对b修改看结果
a = [1,2,3]
b = a
b.append(4)
print(a)
print(a is b)
print(id(a),id(b))
[1, 2, 3, 4]
True
2527462106944 2527462106944
可以看到，修改b的同时（修改了b对应的对象），a也变化了。a，b贴在同一个对象上面。
7.2 ==和is的区别
is是判断两个对象的id()是否一致,用一个例子来看==是什么
a = [1,2,3,4]
b = [1,2,3,4]
print(a is b)
print(a == b)
False
True
2192327583744 2192327582784
a和b对象不一致(id 不同)，所以is判断就是False，但两个对象的值是一样的，==判断就是True。
但是有些特殊情况，需要注意下
a = 1
b = 1
print(a is b)
print(id(a),id(b))
True
140724036245152 140724036245152
可以看到这两个对象是一致的，在python内部有一个intern机制，会把一定范围内的小整数建立一个全局唯一对象（常量池），如上面a=1，当执行b=1时，会指向同一个对象。这个对小串的字符串来说，也是一样的。
a = "abc"
b = "abc"
print(a is b)
print(id(a),id(b))
True
2815963014896 2815963014896
使用==可以看到是True
a = [1,2,3,4]
b = [1,2,3,4]
print(a==b)
print(a is b)
True
False
这个其实和魔法函数有关，list里面有一个魔法函数__eq__，当使用==时，会调用list里的__eq__魔法函数，从而判断值是否相等。
所以判断一个实例是否属于一个类时，要用is进行判断(但是用isinstance更好)
class People:
pass
person = People()
if type(person) is People: # 类也是一个对象，People也是全局唯一的
print ("yes")
yes
7.3 del语句和垃圾回收
1.python中垃圾回收的算法是采用引用计数。
a = 1 # 1这个对象就会有一个计数器，a=1时会在引用计数器上+1
b = a # b指向同一个对象时，计数器再+1
del a # 会将引用计数器-1，当计数器=0时，会将1对象回收，防止一直占用内存
python的del和c++中不同，c++是直接回收对象，而python del直到计数器=0时，才会对对象进行回收。
a = object()
b = a # b，a指向同一个对象
del a # del a,计数器-1，但>0，未被回收
print(b) # 可以打印b
print(a) # a无法打印
<object object at 0x000001CE31B34E10>
Traceback (most recent call last):
File "E:/pyproject/AdvancePython-master/chapter06/test.py", line 5, in <module>
print(a)
NameError: name 'a' is not defined
在cpython2.0中就不是计数器。
2.自己定义一个对象时，可以在__del__中写自己的垃圾回收逻辑
class A:
def __del__(self):
pass
7.4 一个经典的参数错误
第一种情况：
def add(a, b):
a += b
return a
if __name__ == "__main__":
a = 1
b = 2
c = add(a,b)
print(c)
print(a,b)
3
1 2
来看第二种情况：
def add(a, b):
a += b
return a
if __name__ == "__main__":
a = 1
b = 2
a = [1,2]
b = [3,4]
c = add(a,b)
print(c)
print(a,b)
[1, 2, 3, 4]
[1, 2, 3, 4] [3, 4]
c是[1, 2, 3, 4]，a也变成[1, 2, 3, 4]了。
再看第三种情况：
def add(a, b):
a += b
return a
if __name__ == "__main__":
a = 1
b = 2
a = (1, 2)
b = (3, 4)
c = add(a, b)
print(c)
print(a, b)
(1, 2, 3, 4)
(1, 2) (3, 4)
c是(1, 2, 3, 4)，a还是(1, 2)。
在第1、3种情况下，a没有受到影响。a，b为list的时候，a受到了影响。
再add函数中，a,b是list这种可变类型时，由于+=是就地修改，所以a+=b修改了a。
举另一个例子加深理解：
class Company:
def __init__(self, name, staffs=[]):
self.name = name
self.staffs = staffs
def add(self, staff_name):
self.staffs.append(staff_name)
def remove(self, staff_name):
self.staffs.remove(staff_name)
if __name__ == "__main__":
com1 = Company("com1", ["bobby1", "bobby2"])
com1.add("bobby3")
com1.remove("bobby1")
print(com1.staffs)
['bobby2', 'bobby3']
这里看起来没有什么问题，我们再加两个操作。
class Company:
def __init__(self, name, staffs=[]):
self.name = name
self.staffs = staffs
def add(self, staff_name):
self.staffs.append(staff_name)
def remove(self, staff_name):
self.staffs.remove(staff_name)
if __name__ == "__main__":
com1 = Company("com1", ["bobby1", "bobby2"])
com1.add("bobby3")
com1.remove("bobby1")
print(com1.staffs)
com2 = Company("com2") # 不传list
com2.add("bobby")
com3 = Company("com3") # 不传list
com3.add("bobby5")
print (com2.staffs)
print (com3.staffs)
print (com2.staffs is com3.staffs)
print(Company.__init__.__defaults__)
['bobby2', 'bobby3']
['bobby', 'bobby5']
['bobby', 'bobby5']
True
(['bobby', 'bobby5'],)
com2里面出现了'bobby5'，com3里出现了'bobby'，com2和com3的值是一样的，这就有问题了。
造成这种情况的原因是：
1.__init__传递的一个列表是可变对象
2.com2和com3都没有传递list进去，所以使用的是同一个默认的list
这个默认list可以获取到，但是com1传入了一个list，就不会指向默认list。这里就有一个结论，尽量不要使用可变类型作为参数。
