Python3学习笔记：Python中的赋值操作
python中的变量，赋值等详细解析
秒懂Python 赋值，浅拷贝，深拷贝
在Python里，一切皆对象，完全的面向对象。
1 Python为动态解释性语言
在赋值操作时，
类型是在运行过程中自动决定的，而不是通过代码声明，没有必要事先声明变量。
（静态编译类型语言C++或Java，在使用变量前，需声明变量的类型。）
2 变量和对象之间的关系为引用。
1 变量
1 第一次赋值时，即创建，之后 再次赋值 将会 改变 变量的值。
2 变量名本身是没有类型的，类型只存在对象中，变量只是引用了对象。
3 所有的变量，必须 在使用前 赋值，使用未赋值的变量会产生错误。
2 对象
1 对象是有类型的。
2 对象是分配的一块内存空间，来表示它的值。
3 每一个对象都具有两个标准的头部信息：
类型标志符：标识对象的类型。
引用计数器：用来决定对象是不是进行回收。
Python对象三要素：Id，Type，Value
Id：唯一标识一个对象
Type：标识对象的类型
Value：对象的值
3 引用
1 在Python中，从变量到对象的连接，称为引用。
2 引用是一种关系，以内存中的指针的形式实现。
3 赋值操作时，自动建立变量和对象之间的关系，即引用。
赋值和引用
python中赋值语句，
总是建立对象的引用值，而不是复制对象。
因此，python变量更像是指针，而不是数据存储区域。
简单引用：
例1
a = 3
步骤：
创建一个对象来代表值3。
创建一个变量a，如果它还没有创建的话。
将变量a 与 新的对象3 相连接。
如图：
例2
a = 1
a = 'python'
a = 1.2
这里的 变量a 被多次赋值，
并不是修改的对象，而是修改的引用，
a指向1，然后修改引用指向 'python'，
最后指向1.2。
1 和 'python' 被放在内存空间内，
在没有其他变量引用时，引用计数为0，
这个对象的内存空间就会自动回收。
这里也并不是修改变量 a 的类型，
因为变量没有类型，只是它指向的对象具有类型，
即对象头部信息的类型标志符。
共享引用
例1:
a = 3
b = a
a 指向对象3，
b = a 赋值操作，
b 也指向3。
可以看出，a和b都引用了同一个对象。
例2：
a = 3
b = a
a = 'spam'
a 重新指向另一个对象。
== 和 is
== 指值相等。is 指地址相等，即指引用相等。
a == b
判断 a 对象的值是否和 b 对象的值相等。通过Value 值来判断。
a is b
判断 a 对象是否就是
对象的数据类型：列表list
赋值相同，引用不同。
例1
lst1 = [1, 2, 3]
lst2 = lst1
lst3 = [1, 2, 3]
print(lst1,id(lst1)) #查看列表、引用地址 Id()函数
print(lst2,id(lst2))
print(lst3,id(lst3))
lst2[0] = 10
print()
print(lst1,id(lst1)) #查看列表、引用地址 Id()函数
print(lst2,id(lst2))
print(lst3,id(lst3))
输出结果
[1, 2, 3] 4434387024
[1, 2, 3] 4434387024
[1, 2, 3] 4478611696
[10, 2, 3] 4434387024
[10, 2, 3] 4434387024
[1, 2, 3] 4478611696
例2
lst1 = [1, 2, 3]
lst2 = lst1
lst3 = [1, 2, 3]
print(lst1 == lst2)
print(lst1 is lst2)
print(lst1 == lst3)
print(lst1 is lst3)
输出结果
True
True
True
False
总结：
lst1 和 lst2 指向同一个对象。
lst1 和 lst3 不指向同一个对象(Id不同)，lst3 指向另一对象，
两个对象只是值(value)相等(==)。
对象的数据类型：整数int。
赋值相同，则引用相同。
a = 9
b = a
c = 9
print(a,id(a))
print(b,id(b))
print(c,id(c))
print()
print(a == b)
print(a is b)
print(a == c)
print(a is c)
输出结果
9 4393189392
9 4393189392
9 4393189392
True
True
True
True
a、b、c 指向 同一个对象。
因为小的整数 和 字符串 被缓存 并复用，
所以 is
a = 1
a = 'python'
这里的 1 并没有被直接回收，虽然它的计数减一，但是在系统代码中却被大量引用。
查看引用计数如下 ：
import sys
print(sys.getrefcount(1))
输出结果：
717
变量是一个系统表的元素，拥有指向对象的连接的空间。
对象是分配的一块内存，有足够的空间去表示它们所代表的值。
引用是自动形成的从变量到对象的指针。
赋值、浅拷贝、深拷贝
python中的变量，赋值等详细解析
可以说 Python 没有赋值，只有引用。
Python 没有「变量」，我们平时所说的变量其实只是「标签」，是引用。
values = [0, 1, 2]
values = [3, 4, 5]
values[1] = values
values = [0, 1, 2]
Python 做的事情是首先创建一个列表对象 [0, 1, 2]，然后给它贴上名为 values 的标签。
values = [3, 4, 5]
创建另一个列表对象 [3, 4, 5]，然后把刚才那张名为 values 的标签从前面的 [0, 1, 2] 对象上撕下来，重新贴到 [3, 4, 5] 这个对象上。
至始至终，并没有一个叫做 values 的列表对象容器存在。
Python 也没有把任何对象的值复制进 values 去。
过程如图所示：
values[1] = values
把 values 这个标签所引用的列表对象的第二个元素指向 values 所引用的列表对象本身。
执行完毕后，values 标签还是指向原来那个对象，只不过那个对象的结构发生了变化，
从之前的列表 [0, 1, 2] 变成了 [0, ?, 2]，而这个 ? 则是指向那个对象本身的一个引用。
如图所示：
得到 [0, [0, 1, 2], 2] 这个对象，
你不能直接将 values[1] 指向 values 引用的对象本身，
而是需要吧 [0, 1, 2] 这个对象「复制」一遍，得到一个新对象，
再将 values[1] 指向这个复制后的对象。
Python 里面复制对象的操作因对象类型而异，复制列表 values 的操作是：
values[:] #生成对象的拷贝或者是复制序列，不再是引用和共享变量，但此法只能顶层复制
values[1] = values[:]
先 dereference 得到 values 所指向的对象 [0, 1, 2]，然后执行 [0, 1, 2][:] 复制操作得到一个新的对象，内容也是 [0, 1, 2]，
然后将 values 所指向的列表对象的第二个元素，指向这个复制二来的列表对象，最终 values 指向的对象是 [0, [0, 1, 2], 2]。
过程如图所示：
values[:] 复制操作是所谓的「浅复制」(shallow copy)，
当列表对象有嵌套的时候也会产生出乎意料的错误。
a = [0, [1, 2], 3]
b = a[:]
a[0] = 8
a[1][1] = 9
a 为 [8, [1, 9], 3]，
b 为 [0, [1, 9], 3]。
b 的第二个元素也被改变了。想想是为什么？
正确的复制嵌套元素的方法是进行「深复制」(deep copy)
import copy
a = [0, [1, 2], 3]
b = copy.deepcopy(a)
a[0] = 8
a[1][1] = 9
引用 VS 拷贝：
没有限制条件的分片表达式（L[:]）能够复制序列，但此法只能浅层复制。
字典 copy 方法，D.copy() 能够复制字典，但此法只能浅层复制。
有些内置函数，例如 list，能够生成拷贝 list(L)。
copy 标准库模块能够生成完整拷贝：deepcopy 本质上是递归 copy。
对于不可变对象和可变对象来说，
浅复制都是复制的引用。
只是因为复制不变对象和复制不变对象的引用是等效的
（因为对象不可变，当改变时，会新建对象重新赋值）。
看起来浅复制只复制不可变对象（整数，实数，字符串等），
对于可变对象，
浅复制其实是创建了一个对于该对象的引用，
也就是说只是给同一个对象贴上了另一个标签而已。
遗漏待补充：
可变对象与不可变对象
Python的对象分成两类：可变对象和不可变对象。
可变对象是指，对象的内容是可变的，一般是指引用类型。
不可变的对象，表示其内容不可变。对于tuple中的可变对象也是可以改变的。
可变对象 ：list, dict, set
不可变对象 ：int, float, complex, str,bool, tuple, frozenset
Python中的赋值语句，
不会创建对象的拷贝，仅是将名称绑定至一个对象。
对于不可变对象，通常没什么差别。
不可变对象 ：int, float, complex, str,bool, tuple, frozenset
但处理可变对象或可变对象的集合时，
可能需要创建这些对象的 “真实拷贝”，
在修改创建的拷贝时，不改变原始的对象。
可变对象 ：list, dict, set
