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 对象是否 就是 b 对象。 通过 Id 来判断。
对象的数据类型：列表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 和 c ，引用一个相同的对象。
a = 1
a = 'python'这里的 1 并没有被直接回收，虽然它的计数减一，但是在系统代码中却被大量引用。
查看引用计数如下 ：
import sys
print(sys.getrefcount(1))输出结果：
717
变量是一个系统表的元素，拥有指向对象的连接的空间。
对象是分配的一块内存，有足够的空间去表示它们所代表的值。
引用是自动形成的从变量到对象的指针。
赋值、浅拷贝、深拷贝
可以说 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