https://blog.csdn.net/li_101357/article/details/52745661
Python官网教程
https://docs.python.org/zh-cn/3/tutorial/classes.html
变量和对象
a = 3
其中分别创建了，int型对象3和string对象‘hello’；a和b是变量，分别指向对象3和对象‘hello’
对象
对象分为可变对象和不可变对象。（不可变指的是对象的值不可变）
不可变对象：int、float、long、str、tuple
可变对象：dict、list、set
差别在于：对于不可变类型的对象，如果要更改变量的值，则会创建一个新的值，把变量绑定到新的对象上，而旧的值如果没有被引用就等待辣鸡回收
可变类型的数据对对象操作的时候，不需要在重新分配地址，只需要在原对象的后面连续申请地址（+/-）即可，对于对象整体list/dict而言，内存地址保持不变，但是整体大小会变化
>>> a = 'hello'
>>> id(a)
56835584
>>> a = 'nihao'
>>> id(a)
56835840
对象类型是str，不可变，当改变变量a的时候，因为原‘hello’是不能被改变的，重新分配地址，创建新的变量‘nihao’，然后变量a指向新的对象
>>> a = [1,2,3,4]
>>> id(a)
55434536
>>> a.append(5)
>>> id(a)
55434536
对象类型是列表， 属于可变类型，当对对象操作的时候，无非就是增加或者删除，是在列表或者字典之后申请地址，改变的不是开始的地址，而是整体的大小。因此，内存地址并没有变。变量的指向自然也不变。
变量就像是C中的指针，但是变量没有类型，有类型之别的是对象
传对象引用
Python中变量之间不是单纯的传值或者传引用，而是采用的“传对象引用”的方式：
-
如果对象是可变类型，那么相当于相当于传引用｛传地址｝
-
如果对象是不可变类型，相当于传对象（传个新的对象）
为什么会这样？就是因为可变类型和不可变类型啊，一个可变，一个不可变，不可变的无法在原地址上改变，只能创建新的，可变的地址不变、归根结底还是传地址，只不过不可变类型的要重建对象，地址改变了，是个新的对象，可变类型的不需要重建对象，地址没有改变而已
记忆：传对象地址，就是传的对象的地址，可变类型对象地址不变，不可变类型对象地址改变
区别在哪里呢？
a = [1,2,3,4]
b = a
a[1] = 0
print(b[1])
结果是 0
因为传的是对象引用，也就是对象的地址，a中存的是列表的地址，a把地址给b，也就是说a和b指向了同一片存储空间，对a的操作，因为是列表类型（属于可变类型），地址不会改变，所以结果同样反映在b上
a = [1,2,3,4]
b = a[:]
a[1] = 0
print(b[1])
结果是2
a[:] 代表的是列表中的全部元素，这个时候相当于赋值一份给了b
对a的操作不影响b
a = 1
b = a
a = 2
print(b)
结果是1
传对象引用，a把对象1所在的地址传给b，a 指向 对象2 所在的空间，int型数据是不可变类型，对象1和对象2所在的内空间是完全不同的
深拷贝和浅拷贝
浅拷贝：实质上是复制引用，拷贝几个元素就复制对应元素的引用（复制的是每个元素的引用）。
区别于赋值，赋值是将整个对象的引用给复制了一份给变量。
复制引用？ a = 110；b = a ； 这个就是把对象110 的地址赋给 b，在Python中是变量之间是传对象引用的方式
深拷贝：和浅拷贝本质上的区别是，他不会复制任何引用，对象内的所有元素，子元素，孙子元素...的数据都会复制过来，实现原理是递归，只要里面还有子元素，就会复制到元素数据到新的内存地址
区别：对原对象的操作会影响浅拷贝，但深拷贝的不会有任何变化。因为两者一个是复制引用，一个是复制数据。
import copy
list = [1,2,3,4,['a','b']]
a = list.copy()
# a = copy.copy(list) # 浅拷贝
b = copy.deepcopy(list) # 深拷贝
c = list # 复制，传对象引用
list.append(5) # 修改对象
list[4].append('c') # 修改对象a中的列表
list[0] = 0 # 修改第一个不可变元素
print(list)
print(a)
print(b)
print(c)
结果是：
print(list) [0, 2, 3, 4, ['a', 'b', 'c'], 5] print(a) [1, 2, 3, 4, ['a', 'b', 'c']]
//浅拷贝，拷贝的引用，如果原对象中的可变类型元素改变，这个也会改变，比如元素列表['a','b'] -> ['a', 'b', 'c'];
如果是不可变类型，如list[0] = 1 ，就不会改变；
浅拷贝没有复制的元素的引用，就不会出现。比如新增的元素 5
也就是说浅拷贝复制的是每个元素的引用，且同样符合可变元素和不可变元素的性质。
print(b) [1, 2, 3, 4, ['a', 'b']]
//深拷贝，拷贝的什么，还是什么，不会受原对象的变化的影响 print(c)
[0, 2, 3, 4, ['a', 'b', 'c'], 5]
//赋值，传对象引用，结果一摸一样，因为指向同一片内存空间
>>> dict_a = {}
>>> dict_a[1] = [1,2,3]
>>> dict_a[2] = [2,3,4]
>>> dict_a
{1: [1, 2, 3], 2: [2, 3, 4]}
>>> dict_b = dict_a.copy()
>>> dict_a[1].append(4)
>>> dict_a,dict_b
({1: [1, 2, 3, 4], 2: [2, 3, 4]}, {1: [1, 2, 3, 4], 2: [2, 3, 4]})
>>> dict_a[1][0] = 0
>>> dict_a
{1: [0, 2, 3, 4], 2: [2, 3, 4]}
>>> dict_b
{1: [0, 2, 3, 4], 2: [2, 3, 4]}
对于字典来说，这个浅拷贝现象很正常，因为复制的是引用，所以对原字典的改变会反映在浅拷贝上。
python作用域和命名空间
-
作用域
-
重要的是意识到作用域，是按字面文本来确定的。函数和类，内部是局部作用域，整个模块是全局作用域
-
在函数内新建函数，会引入一层新的作用域，所以特别强调：按字面文本就能确定作用域。比如在局部作用域中使用全局变量都要使用global语句
-
赋值不会复制数据，只是像指针一样，让名称指向对象，数字也好，字符串也好也是如此；或者说名称绑定到对象（在Python中什么都是对象）
-
nonlocal语句表明特定变量生存于外部作用域，并且在其中应当被重新绑定；global语句表明特定变量生存于全局作用域，而且在其中应当被重新绑定
-
如果没有使用global或者nonlocal会怎么样？
会在该作用域内 新建一个局部变量 进行绑定
-
命名空间
-
命名空间：是一组从名字到对象的映射。
-
这个映射是怎么实现的呢？
python字典实现
-
命名空间是作用域实现的基石
命名空间举例:
内置名称的命名空间（内置名称也存在一个模块中，称作builtins）
import的模块的命名空间
__ main__ 模块的命名空间
函数的命名空间，其被调用时创建本地命名空间，用完或错误是删除，每次递归调用都会有自己的本地命名空间
-
为什么说命名空间是作用域实现的基石呢？
在作用域中 调用名称，python就会尝试从适合这个作用域的命名空间中找到对应的对象，然后实现调用 比如调用__ main__ 模块的函数，函数的命名空间在模块命名空间中，从里面找到名称对应的对象 变量如此，函数如此，类呢？
-
简而言之，一个作用域对应着一个命名空间，名称和对象的对应关系定义在命名空间中。而且命名空间存在着生存期,比如调用函数之后，函数中的变量会被释放，函数对应的命名空间也就被释放了，当再次调用的时候会恢复。
注意：xx.yy，我们习惯把 . 之后的称为 xx 的属性
def scope_test():
def do_local():
spam = "local spam"# 方法里定义的spam
def do_nonlocal():
nonlocal spam # 告诉Python spam在外一层有定义（生存在外一层），去找到它
spam = "nonlocal spam" # 重新绑定
def do_global():
global spam# 告诉Python spam在全局作用域有定义（生存在全局作用域）
spam = "global spam"
spam = "test spam"# 定义在方法外一层作用域
do_local()
print("After local assignment:", spam)# 打印方法外一层的spam
do_nonlocal()
print("After nonlocal assignment:", spam)
do_global()# 这个执行的时候，在全局作用域中并没有找到spam，那么意味着新建全局变量spam
print("After global assignment:", spam)# 这里打印的是同一层作用域中的spam而非全
# 局中的
scope_test()
print("In global scope:", spam)# 打印全局作用域中的sapm
代码的输出是
After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam
上述例子，定义了三层作用域
-
类定义时，将创建一个新的命名空间，并将其作为局部作用域-对应着一个新的命名空间