对‘pthread_create’未定义的引用_Python对象引用，可变性和垃圾回收

>>> a &＃61; [1,2,3]
>>> b &＃61; a
>>> a.append(5)
>>> a
[1, 2, 3, 5]
>>> b
[1, 2, 3, 5]

>>> c &＃61; {&＃39;name&＃39;:&＃39;yang&＃39;,&＃39;born&＃39;:1997}
>>> a &＃61; c #a为c的一个别名。他们俩同时指向一个对象&＃xff0c;&＃39;&＃61;&＃61;&＃39;和&＃39;is&＃39;运算符证明这一点
>>> a &＃61;&＃61; c
True
>>> a is c
True
>>> id(a),id(c)
(139644203394464, 139644203394464)
>>> a[&＃39;name&＃39;] &＃61; &＃39;yyy&＃39; #用a修改内容
>>> c #c也会被修改&＃xff0c;因为它们俩指向的是一个对象
{&＃39;name&＃39;: &＃39;yyy&＃39;, &＃39;born&＃39;: 1997}
>>> d &＃61; {&＃39;name&＃39;: &＃39;yyy&＃39;, &＃39;born&＃39;: 1997} #新建一个d对象&＃xff0c;与a和c的值一样
>>> d &＃61;&＃61; a # &＃39;&＃61;&＃61;&＃39;运算符比较值是否相等
True
>>> d is a #&＃39;is&＃39;运算符比较对象的标识是否相等&＃xff0c;就是比较id()是否相等。d是新建的对象很明显不会相等
False
>>> id(d), id(a)
(139644203394536, 139644203394464)

#元组的不可变性其实是指tuple数据结构的物理内容(即保存的引用)不可变&＃xff0c;与引用的对象无关。比如元组里引用了一个可变对象列表&＃xff0c;不能改变这个引用让他变成其他字典或整数对象&＃xff0c;但是可以修改这个可变对象的值。
>>> t1 &＃61; (1, 2, [3, 4])
>>> t2 &＃61; (1, 2, [3, 4])
>>> id(t1),id(t2)
(139644201933272, 139644201953896)
>>> t1 &＃61;&＃61; t2 #值相等
True
>>> t1 is t2 #标识不相等&＃xff0c;两个除了值相等其他完全不相关的变量
False
>>> t1[-1].append(5) #可以对元组内的列表元组进行添加操作
>>> t1 &＃61;&＃61; t2 #此时他们俩的值不相等了
False

>>> a &＃61; [1, 2, [3, 4]]
>>> c &＃61; a[:]
>>>a &＃61;&＃61; c
True
>>> a is c #容器不一样&＃xff0c;但是里元素的引用一样
False>>> r &＃61; (1, 2, [4,5]) #对元组或其他不可变类型对象浅复制返回的是同一个对象的引用。类似于rr &＃61; r
>>> rr &＃61; r[:]
>>> rr is r
True#浅复制后母本和副本内的元素都互为对方的标识&＃xff0c;也就是都指向同一个对象。如果对母本或副本中的可变元素操作&＃xff0c;因为两个引用是同一个对象&＃xff0c;所以会影响到另一个母本或副本。但是&＃xff0c;比如在副本中对不可变元素操作会生成一个新的对象引用&＃xff0c;就和母本中的不可变元素不是同一个引用了&＃xff0c;就不会影响到母本。
#下面是示例&＃xff1a;
>>> l1 &＃61; [3, [66,55,44], (7, 8, 9)]
>>> l2 &＃61; list(l1) #对列表l1浅复制&＃xff0c;赋值给l1
>>> l1.append(100) #l1添加一个新元素100
>>> l2
[3, [66, 55, 44], (7, 8, 9)] #l2中没有添加
>>> l1
[3, [66, 55, 44], (7, 8, 9), 100] #l1中添加成功
>>> l1[1].remove(55) #将l1[1]这个列表中的55元素删除
>>> l1
[3, [66, 44], (7, 8, 9), 100]
>>> l2
[3, [66, 44], (7, 8, 9)] #对l2也有影响&＃xff0c;因为l2[1]这个列表和l1[1]的列表时同一个&＃xff0c;他们两个互相时对方的别名&＃xff0c;都指向同一个列表元素
>>> l2[1] &＃43;&＃61; [1,1,1] #l2[1]就地修改列表
>>> l2
[3, [66, 44, 1, 1, 1], (7, 8, 9)]
>>> l1
[3, [66, 44, 1, 1, 1], (7, 8, 9), 100] #l1[1]也被修改&＃xff0c;因为这是同一个对象
>>> l1[2] is l2[2] #此时l1[2]和l2[2]这两个元组是同一个对象
True
>>> l2[2] &＃43;&＃61; (1,1,1) #对l2[2]这个元组添加(1,1,1)。因为元组是不可变元素&＃xff0c;这个赋值操作不能就地添加&＃xff0c;相当于l2[2] &＃61; l2[2]&＃43;(1,1,1)&＃xff0c;这里创建了一个新元组。
>>> l1[2] is l2[2] #此时l1[2]和l2[2]这两个元素不再是同一个对象
False
>>> l2
[3, [66, 44, 1, 1, 1], (7, 8, 9, 1, 1, 1)]
>>> l1
[3, [66, 44, 1, 1, 1], (7, 8, 9), 100] #所以这个修改并没有对l1起作用>>> l2[1] is l1[1] #可变对象就地修改&＃xff0c;再改还是引用的同一个对象
True
>>> l1[0] is l2[0]
True

#定义一个类来测试
class Bus:def __init__(self, p&＃61;None):if p is None:p &＃61; []else:self.p &＃61; list(p)def pick(self, name):self.p.append(name)def drop(self, name):self.p.remove(name)>>> from bus import *
>>> bus1 &＃61; Bus([&＃39;a&＃39;, &＃39;b&＃39;, &＃39;cc&＃39;])
>>> bus1

>>> bus1.p
[&＃39;a&＃39;, &＃39;b&＃39;, &＃39;cc&＃39;]
>>> bus2 &＃61; copy.copy(bus1) #浅复制bus1
>>> bus3 &＃61; copy.deepcopy(bus1) #深复制bus1
#到此 创建了三个bus实例
>>> bus1.drop(&＃39;a&＃39;) #bus1的p列表中删除一个元素
>>> bus2

>>> bus2.p #bus2的p列表中也没有这个元素了&＃xff0c;浅复制共享一个列表对象
[&＃39;b&＃39;, &＃39;cc&＃39;]
>>> bus3.p #深复制不会共享列表&＃xff0c;所以不会修改
[&＃39;a&＃39;, &＃39;b&＃39;, &＃39;cc&＃39;]
>>> bus1.p is bus2.p
True
>>> bus1.p is bus3.p
False

#函数可能会修改接收到的任何可变对象
>>> def f(a, b):
... a &＃43;&＃61; b
... print(id(a))
... return a
>>> x &＃61; [1,1]
>>> id(x)
139901112369928
>>> y &＃61; [2, 2]
>>> f(x, y) #函数的形参获得各个实参的副本&＃xff0c;也就是说&＃xff0c;函数内部的形参是实参的别名
139901112369928
[1, 1, 2, 2]
>>> x
[1, 1, 2, 2]
>>> x &＃61; 1 #当实参为不可变类型时
>>> y &＃61; 2
>>> id(x)
10910400
>>> f(x, y) # a &＃43;&＃61; b相当于重新创建了一个a对象&＃xff0c;上面的浅复制讲的很清楚了
10910464
3

class Bus:def __init__(self, p&＃61;[]):self.p &＃61; pdef pick(self, name):self.p.append(name)def drop(self, name):self.p.remove(name)>>> from bus import *
>>> bus1 &＃61; Bus([&＃39;a&＃39;, &＃39;b&＃39;])
>>> bus2 &＃61; Bus()
>>> bus3 &＃61; Bus() #创建三个实例&＃xff0c;bus3和bus3使用默认值
>>> bus1.pick(&＃39;c&＃39;) #bus1添加新元素
>>> bus1.p,bus2.p,bus3.p #只有bus1变了
([&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;], [], [])
>>> bus2.pick(&＃39;e&＃39;) #bus2添加新元素
>>> bus1.p,bus2.p,bus3.p #bus2和bus3都变了
([&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;], [&＃39;e&＃39;], [&＃39;e&＃39;])
>>> Bus.__init__.__defaults__ #这时Bus类的defaults属性已经变了
([&＃39;e&＃39;],)

#错误的方法
class Bus:def __init__(self, p&＃61;None):if p is None:self.p &＃61; []else:self.p &＃61; p #self.p为p的别名&＃xff0c;他们俩都指向同一个对象。def pick(self, name):self.p.append(name)def drop(self, name):self.p.remove(name)>>> from bus import *
>>> i &＃61; [&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;]
>>> b &＃61; Bus(i)
>>> b.drop(&＃39;a&＃39;) # b实例调用他的drop方法删除&＃39;a&＃39;的时候把i列表中的&＃39;a&＃39;也删了
>>> b.p
[&＃39;b&＃39;, &＃39;c&＃39;]
>>> i
[&＃39;b&＃39;, &＃39;c&＃39;]
#正确方法
class Bus:def __init__(self, p&＃61;None):if p is None:self.p &＃61; []else:self.p &＃61; list(p) #这时self.p是对p的一个浅复制&＃xff0c;self.p和p指向不同对象&＃xff0c;但是容器里面的元素还是相同的引用&＃xff0c;如果元素为可变类型&＃xff0c;那么还是会出现问题def pick(self, name):self.p.append(name)def drop(self, name):self.p.remove(name)
>>> from bus import *
>>> i &＃61; [&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;]
>>> b &＃61; Bus(i)
>>> b.drop(&＃39;a&＃39;) # b实例删除&＃39;a&＃39;后i列表并没有受到影响
>>> i
[&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;]>>> i &＃61; [&＃39;a&＃39;, &＃39;b&＃39;, [1,2]] #如果参数内元素是可变类型还是有影响
>>> b &＃61; Bus(i)
>>> b.p[2].pop() # b实例删除列表内的一个列表中的元素
2
>>> i # i列表也受到影响
[&＃39;a&＃39;, &＃39;b&＃39;, [1]]

>>> import weakref
>>> s1 &＃61; {1,2,3}
>>> s2 &＃61; s1 #s2 is s1。指向同一个集合
>>> def a():
... print(&＃39;aaa&＃39;)
>>> end &＃61; weakref.finalize(s1, a) # weakref是一个弱引用包。这里在s1引用对象上注册a回调
>>> end

>>> del s1
>>> end.alive #对象还没有被销毁
True
>>> s2 &＃61; 2 # 让s2指向其他对象&＃xff0c;此时没有对那个集合的引用。对象被销毁执行回调函数输出&＃39;aaa&＃39;
aaa