Python学习笔记：对象、变量与引用

【1】对象（Objects）

对象是一块内存区域，包括了足够的内存空间来保存它所代表的值。

图1 对象、变量与引用

【2】变量（Variables）

1. 变量是一个保存在系统表中的实体，有足够的空间链接到对象。
2. 变量与对象保存在不同的内存区域，如图1所示。

【2.1】变量创建（Variable Creation）

变量在第一次赋值时创建。

【2.2】变量类型（Variable Types）

变量没有类型信息。类型信息与对象共生，而不是与变量共生。

【2.3】变量使用（Variable Use）

当变量在表达式中出现时，立即被它当下所引用的对象替代。

In [1]: a = 3 # 3是一个整型对象，变量a链接到整型对象3

In [2]: a # 变量a立即被整型对象3替代
Out[2]: 3

In [3]: type(a) # 变量a立即被整型对象3替代，其类型由整型对象3决定
Out[3]: int

In [4]: a = 5.0 # 5.0是一个浮点型对象，变量a被重新链接到浮点型对象5.0

In [5]: a # 变量a立即被浮点型对象5.0替代
Out[5]: 5.0

In [6]: type(a) # 变量a立即被浮点型对象5.0替代，其类型由浮点型对象5.0决定
Out[6]: float

In [7]: a = 1+1j # 1+1j是一个复数型对象，变量a被重新链接到复数型对象1+1j

In [8]: a # 变量a立即被复数型对象1+1j替代
Out[8]: (1+1j)

In [9]: type(a) # 变量a立即被复数型对象1+1j替代，其类型由复数型对象1+1j决定
Out[9]: complex

In [10]: a = 3

In [11]: b = a

In [12]: a = 'spam'

In [13]: a, b
Out[13]: ('spam', 3)

说明：

1. Python是弱类型的语言；C语言是强类型的语言。
2. Python的变量没有类型，其类型由所链接的对象决定；C语言的变量带有类型，并且拥有该类型的内存空间。
3. Python的变量可以随意链接到不同类型的对象；C语言的变量不同随意链接到其它变量（指针类型变量除外）。
4. Python的变量赋值是一个链接到对象的过程（类似于C语言的指针）；C语言的变量赋值是直接修改变量所指向的内存区域的内容。
   

图2 b =a 示意图

图3 重新赋值a = 'spam' 示意图

【3】引用（References）

引用是从变量指向对象的自动跟随的指针。

【3.1】共享引用

列表、字典、集合等类型术语可变类型。

In [1]: L1 = [1,2,3] # L1赋值为列表[1,2,3]

In [2]: L2 = L1 # L2与L1共享引用

In [3]: L1 == L2 # L1的值与L2的值是否相同，是
Out[3]: True

In [4]: L2 == L1 # L2的值与L1的值是否相同，是
Out[4]: True

In [5]: L1 is L2 # L1与L2是否引用同一个对象，是
Out[5]: True

In [6]: L2 is L1 # L2与L1是否引用同一个对象，是
Out[6]: True

In [7]: L3 = [1,2,3] # L3赋值为列表[1,2,3]

In [8]: L1 == L3 # L1的值与L3的值是否相同，是
Out[8]: True

In [9]: L1 is L3 # L1与L3是否引用同一个对象，否
Out[9]: False

In [10]: L2 == L3 # L2的值与L3的值是否相同，是
Out[10]: True

In [11]: L2 is L3 # L2与L3是否引用同一个对象，否
Out[11]: False

【3.2】In-place Change

通过位移（下标）对列表中元素赋值，直接修改列表本身的内容，而不是重新生成一个新的列表对象。

In [1]: L1 = [1,2,3] # L1赋值为列表[1,2,3]

In [2]: L2 = L1 # L2与L1共享引用

In [3]: L2[0] = 5 # 直接修改L2[0]元素

In [4]: L1,L2 # L1与L2共享同一个对象的引用，修改L2[0]，相当于L1[0]被修改
Out[4]: ([5, 2, 3], [5, 2, 3])

In [5]: L1[0] is L2[0] # L1[0]与L2[0]引用同一个对象
Out[5]: True

In [6]: L3 = L1[:] # 将L1引用的对象进行复制，赋值给L3

In [7]: L3 == L1 # L3的值与L1的值是否相同，是
Out[7]: True

In [8]: L3 is L1 # L3与L1是否引用同一个对象，否
Out[8]: False

In [9]: L1[0] = 25 # 修改L1[0]元素的值为25

In [10]: L1,L2,L3 # L1[0]、L2[0]的值修改了，L3[0]的值没有修改
Out[10]: ([25, 2, 3], [25, 2, 3], [5, 2, 3])

In [11]: L1 = [3,4,5] # 用列表[3,4,5]给L1重新赋值

In [12]: L1,L2,L3 # L1、L2、L3各自引用不同的对象
Out[12]: ([3, 4, 5], [25, 2, 3], [5, 2, 3])