在python中，省去了变量声明的过程，在引用变量时，往往一个简单的赋值语句就同时完成了，声明变量类型，变量定义和关联的过程，那么python的变量到底是怎样完成定义的呢？

动态类型

　　python使用动态类型和他提供的多态性来提供python语言的简洁灵活的基础。在python中我们是不会声明所使用对象的确切类型的。所谓的python动态类型，就是在程序运行的过程中自动决定对象的类型。

对象、变量和引用

　　当我们在赋值一个变量时，在python中其实自动做了很多事情。

　　1.创建变量：当代码第一次赋值给一个变量时就创建了这个变量，在之后的赋值过程关联值，python在代码运行之前先检验变量名，可以当成是最初的赋值创建变量。

　　2.变量声明：python中类型只存在于对象中，而不是变量，变量是通用的，他只是在程序的某一段时间引用了某种类型的对象而已，比如定义a =1 ，a = 'a'，一开始定义了变量a为指向了整型的对象，然后变量又指向了字符串类型的变量，可见，变量是不固定的类型。

　　3.变量使用：变量出现在表达式中就会马上被对象所取代，无论对象是什么内类型，变量在使用前必须要先定义。

　　值得注意的是，变量必须在初始化名字之后才能更新他们，比如计数器初始化为0，然后才能增加他。

　　也就是说，当我们给变量赋值的时候，比如a=3，python执行三个不同操作去完成赋值。

　　1.创建一个对象代表3，

　　2.如果程序中没有变量a，则创建他。

　　3.将变量与对象3连接起来。

　　变量与对象是连接关系，它们存储在内存的不同位置，如果有列表嵌套这样大的对象，对象还连接到它包含的对象。这种从变量到对象的连接称为引用。

　　

　　变量的引用以内存中的指针形式实现。一旦变量被使用，那么python自动跟变量的对象连接。具体来说：

　　1.变量是系统表的元素，他指向对象存放的地址空间。

　　2.对象是分配的一块内存，地址可被连接，有足够大空间代表对象的值，

　　3.引用的过程自动完成变量指向对象地址的过程，即从变量到对象的指针。

　　对象的垃圾回收

　　每个对象都有两个标准头部信息，一个是类型标志符，用于标记对象类型，另一个是引用计数器，用来决定是不是可回收对象。很显然，在python中只有对象才有类别区分，变量不过是引用了对象，变量并不具有类别区分，他只是在特定时间引用某个特定对象。

　　对于引用计数器的使用，则关联到python的垃圾回收机制，当当一个变量名赋予了一个新的对象，那么之前旧的对象占用的地址空间就会被回收。旧对象的空间自动放入内存空间池，等待后来的对象使用。

　　计数器在垃圾回收的过程中有事如何工作的呢？计数器记录的是当前指向对象的引用数目，如果在某时刻计数器设置为0，则表示未被引用，name这个对象的内存空间就会收回。

　　对象的垃圾回收有着很大的意义，这使得我们在python中任意使用对象而且不需要考虑释放空间，省去了C与C++中大量的基础代码。

　　共享引用（深浅拷贝的缘由）

　　当一个变量使用多个对象时，旧的对象会被垃圾收回，那么变量共享变量的对象有事一种什么样的类型呢？

a=‘hello world’
b=a
print(b)
运行结果：
hello world

　　值得一提的是，这里b变量引用的a作为值，根据python中赋值是以对象来完成的，所以b引用的应该是a变量指向的对象地址的值，故可以判断，改变a指向的对象并不会影响b的值。

a=‘hello world’
b=a
a='new hello world'
print(a)
print(b)
运行结果：
new hello world
hello world

　　

　　python中变量总是一个指定对象的指针，而不是能够改变内存区域的标签，即给一个变量赋新的值，不是替换一个对象原始值，而是创建一个新得对象供变量引用。

　　当然这条只限于对象的类型不可改变，如果引用对象是像列表一样可供修改的对象那结果如何呢？

a=[1,2,3]
b=a
a.append(4)
print(a)
print(b)
运行结果：
[1, 2, 3, 4]
[1, 2, 3, 4]

　　结果很显然，对于可变类型对象，变量不会创建一个显得对象，而是沿用之前的对象，即使对象已经被改变了。可以简单的理解为，两个对象同时指向了一个列表的内存地址，而列表又映射了里面各元素的内存地址，变量的共享并不关注列表的改变，他们只关心列表的内存空间是否改变，所以，可变对象在引用时自身可以改变，所以不需要创建新的对象，所以共享对象会随之前对象的变化而变化。

　　这其实是我们不希望看到的。我们可以使用拷贝对象创建引用：

a=[1,2,3]
b=a[:]
a.append(4)
print(a)
print(b)
运行结果：
[1, 2, 3, 4]
[1, 2, 3]

　　这种方法并不适用于不可索引但是可变的字典与集合，所以python的copy模块用于变量引用：

import copy
a=[1,2,3,[1,2]]
b=copy.copy(a)
c=copy.deepcopy(a)
d=a
a.append(4)
a[3][0]=5
print(a)
print(b)
print(c)
print(d)
运行结果：
[1, 2, 3, [5, 2], 4]
[1, 2, 3, [5, 2]]
[1, 2, 3, [1, 2]]
[1, 2, 3, [5, 2], 4]

共享引用的补充

　　其实是关于垃圾回收的一点补充，对于一些小的整数或字符串，并不像我们说的那样计数器标记为0就被收回。这和python的缓存机制有关。对于一般的对象，python适用于垃圾收回。

a=[1,2,3]
b=[1,2,3]
c=a
print(a == c)
print(a == b)
print(a is c)
print(a is b)
运行结果：
True
True
True
False

　　对于小的整数与字符串则不同：

a=111
b=111
c=a
print(a == c)
print(a == b)
print(a is c)
print(a is b)
运行结果：
True
True
True
True

　　在python中，任何东西都是在赋值与引用中工作的，对于理解python动态类型，在以后的工作与学习时是有很大帮助的，这是python唯一的赋值模型，所以准确的理解与应用十分有必要。不对类型作约束，这使得python代码极为灵活，高效，并且省去了大量的代码，极为简洁，所以python是这样一门有艺术的编程。