Python中的变量

变量的定义

程序中，数据都临时存储在内存中。
每一个被存储在内存的数据都有一个内存地址。
其中特定的数据被我们所使用，因此我们为那些内存地址定义了名称。
这一名称被称作 标识符，又称变量名。
而与变量名对应内存地址中的数据被称为变量值。

总结：变量为内存中特定的数据。它的内存地址的名称为变量名，它的值为变量值。

在Python中，查看变量内存地址的方式为：id()。
如：

>>>a = 1
>>>id(a)
140718160995112

变量的赋值方法

赋值：定义变量。

在Python里用等号=来给变量赋值。
如：

>>>name = '总之先找时光机！'
>>>name
'总之先找时光机！'
>>>id(name)
2742705886128

其中name为变量名，'总之先找时光机！'是变量值。这个数据被存储在地址：2742705886128中。

变量名的命名规范

标识符（又称变量名）命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：

规则：

• 由数字、字母、下划线组成

注意：

• 不能用数字开头或只用数字
• 不能用Python内置的关键字或类型
• Python区分变量名大小写

>>>import keyword
>>>print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

除了基础的规则之外，还有其他约定俗称的命名法。不过不同的单位与公司都有自己的编程规范，在此只介绍最基础的四种命名法：驼峰命名法、帕斯卡命名法、下划线命名法、匈牙利命名法。

驼峰命名法

又称小驼峰式命名法。该命名规范，要求第一个单词首字母小写，后面其他单词首字母大写。
如：

>>>myName = '总之先找时光机！'

帕斯卡命名法

又称大驼峰式命名法。该命名规范，每个单词的第一个字母都要大写。
如：

>>>MyName = '总之先找时光机！'

下划线命名法

该命名规范，要求单词与单词之间通过下划线连接即可。
如：

>>>my_name = '总之先找时光机！'

匈牙利命名法

该命名规范，要求前缀字母用变量类型的缩写，其余部分用变量的英文或英文的缩写，单词第一个字母大写。
如：

>>>sMyName = '总之先找时光机！'    # 这一变量为 str 类型

考虑到Python内的类型转换比较自由，不建议使用该命名法。

变量的数据类型介绍

在Python里，数据的类型如下：

查看数据类型的方法：type()
如：

>>>a = 1
>>>type(a)
<class 'int'>

>>>b = 1.1
>>>type(b)
<class 'float'>

>>>c = True
>>>type(c)
<class 'bool'>

>>>d = '12345'
>>>type(d)
<class 'str'>

>>>e = [10, 20, 30]
>>>type(e)
<class 'list'>

>>>f = (10, 20, 30)
>>>type(f)
<class 'tuple'>

>>>h = {10, 20, 30}
>>>type(h)
<class 'set'>

>>>g = {'name': 'TOM', 'age': 20}
>>>type(g)
<class 'dict'>

Python中的复杂赋值与深浅拷贝

参考内容：Python中的赋值(复制)、浅拷贝与深拷贝

不可变类型

在Python中首先定义一个变量a = 1。

>>>a = 1
>>>id(a)
140718136222504

此时一个数值1被存储在了内存空间，它所存储的内存地址为140718136222504。对应该地址的标识符（变量名）为a。
如果再创建一个变量b = a,会发生什么呢？

>>>a = 1
>>>id(a)
140718136222504
>>>b = a
>>>id(b)
140718136222504
>>>b
1

使用id(b)查验该标识符对应的内存地址即可发现：标识符a和标识符b对应的是同一个内存地址。
这意味这Python并没有重复在内存空间内存储数值1，只是将标识符b与存储数值1的内存地址对应起来而已。
也就是说，现在内存地址140718136222504现在有两个名称，一个是标识符a，另一个是标识符b。

当我们对变量a，b分别进行操作并改变它们的变量值时，他们的存储地址和变量值又会发生什么改变呢？

>>>a = 1
>>>b = a
>>>id(a)
140718136222504
>>>id(b)
140718136222504
>>>a = a + 1
>>>a
2
>>>id(a)
140718136222536
>>>b = b - 1
>>>b
0
>>>id(b)
140718136222472

在我们对变量a和变量b进行加减操作后，存储变量a、b的内存地址改变了，而不是内存地址内的值改变了。

如果我们查验数值0，1，2的存储地址，就会发现它们与变量值为0,1,2的变量享有同样的存储地址：

>>>id(0)
140718136222472
>>>id(1)
140718136222504
>>>id(2)
140718136222536

对于这类改变变量值会改变内存地址的变量类型，我们称为不可变类型。
所有数值类型、序列类型中的字符串和元组都属于不可变类型。它们的内存地址随着值的变化而变化。

可变类型

与不可变类型相对的，就是可变类型。包括列表、集合与字典。
可变类型变量的内存地址不会随着值的变化而改变。

现在先定义一个可变类型变量list1 = [1, 2, 3, 4]

>>>list1 = [1, 2, 3, 4]		# 这里以list举例
>>>id(list1)
2185105682944
>>>list1[3] = 5
>>>list1
[1, 2, 3, 5]
>>>id(list1)
2185105682944

可以发现当我改变了list1内的元素，变量的内存地址并未发生改变。

现在再创建一个list2 = list1，并再次尝试改变变量list2的值。

>>>list2 = list1
>>>id(list1)
2185105682944
>>>id(list2)
2185105682944
>>>list2[0] = 6		# 改变list2中第0元素的值
>>>list1			# list1也发生改变了
[6, 2, 3, 5]
>>>list2
[6, 2, 3, 5]

在我们创建list2 = list1后，再查验变量list1和list2的内存地址，发现它们是一样的。
并且当我们改变变量list2的内容，变量list1的内容也改变了。
原因很简单，因为标识符list1和list2指向的是同一个内存地址：我们通过标识符list2去改变内存地址内的数据后，用标识符list1查验了同一个内存地址内的数据。

copy module

偶尔，我们希望保留部分或者全部原始数据。Python中的copy标准库提供了解决方案。

copy标准库的交互

copy.copy(x)
Return a shallow copy of x. 返回一个浅拷贝。

copy.deepcopy(x)
Return a deep copy of x. 返回一个深拷贝。

深浅拷贝的区别

当拷贝的对象是复合对象（即对象中包含其他对象，如列表中包含另一个列表）时：

• 浅拷贝创建一个新的复合对象，但内部的可变类型的内存地址被继承。
• 深拷贝创建一个新的复合对象，且内部的可变累型也会被递归拷贝。

>>>import copy
>>>list1 = [1, [2, 3], 4, 5]
>>>list2 = copy.copy(list1)
>>>list3 = copy.deepcopy(list1)
>>>id(list1)
1754106448256
>>>id(list2)
1754106449216
>>>id(list3)
1754103446080

上述代码创建了三个变量。
其中list1[1]为嵌套的list类型。
list2是list1的浅拷贝，list3是list1的深拷贝。
此时标识符list1、list2和list3各自对应不同的内存地址。

因为三个变量拥有不同的内存地址，所以我们直接对单个变量进行操作，这样的改变不会影响其他变量。
如：

>>>list1
[1, [2, 3], 4, 5]
>>>list2
[1, [2, 3], 4, 5]
>>>list3
[1, [2, 3], 4, 5]
>>>list1.append(6)
>>>list2.append(7)
>>>list3.append(8)
>>>list1
[1, [2, 3], 4, 5, 6]
>>>list2
[1, [2, 3], 4, 5, 7]
>>>list3
[1, [2, 3], 4, 5, 8]

但如果我们检查各个变量内嵌套的可变类型元素的内存地址，就会发现深浅层拷贝的区别：

id(list1[1])
1754106220480
id(list2[1])
1754106220480
id(list3[1])
1754106448960

我们发现，浅拷贝（list2）中嵌套的list元素与正本（list1）中的它享有同样的内存地址，而深拷贝（list3）中的它则拥有不同的内存地址。
因此，如果我们对浅拷贝副本中的可变类型元素做出改变，我们期待正本中的可变类型元素也会对应地发生改变，因为它们拥有同样的内存地址。

>>>list2[1].append(9)
>>>list1
[1, [2, 3, 9], 4, 5, 6]
>>>list2
[1, [2, 3, 9], 4, 5, 7]
>>>list3
[1, [2, 3], 4, 5, 8]