Python中的变量

什方电气

Python中的变量

变量的定义

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

1. >>>a = 1
2. >>>id(a)
3. 140718160995112

复制代码

变量的赋值方法

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

1. >>>name = '总之先找时光机！'
2. >>>name
3. '总之先找时光机！'
4. >>>id(name)
5. 2742705886128

复制代码

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

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

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

注意：

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

1. >>>import keyword
2. >>>print(keyword.kwlist)
3. ['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']

复制代码

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

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

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

复制代码

帕斯卡命名法

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

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

复制代码

下划线命名法

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

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

复制代码

匈牙利命名法

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

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

复制代码

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

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

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

1. >>>a = 1
2. >>>type(a)
3. <class 'int'>
5. >>>b = 1.1
6. >>>type(b)
7. <class 'float'>
9. >>>c = True
10. >>>type(c)
11. <class 'bool'>
13. >>>d = '12345'
14. >>>type(d)
15. <class 'str'>
17. >>>e = [10, 20, 30]
18. >>>type(e)
19. <class 'list'>
21. >>>f = (10, 20, 30)
22. >>>type(f)
23. <class 'tuple'>
25. >>>h = {10, 20, 30}
26. >>>type(h)
27. <class 'set'>
29. >>>g = {'name': 'TOM', 'age': 20}
30. >>>type(g)
31. <class 'dict'>

复制代码

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

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

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

1. >>>a = 1
2. >>>id(a)
3. 140718136222504

复制代码

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

1. >>>a = 1
2. >>>id(a)
3. 140718136222504>>>b = a>>>id(b)140718136222504>>>b1

复制代码

使用id(b)查验该标识符对应的内存地址即可发现：标识符a和标识符b对应的是同一个内存地址。
这意味这Python并没有重复在内存空间内存储数值1，只是将标识符b与存储数值1的内存地址对应起来而已。
也就是说，现在内存地址140718136222504现在有两个名称，一个是标识符a，另一个是标识符b。
当我们对变量a，b分别进行操作并改变它们的变量值时，他们的存储地址和变量值又会发生什么改变呢？

1. >>>a = 1
2. >>>b = a
3. >>>id(a)
4. 140718136222504
5. >>>id(b)
6. 140718136222504
7. >>>a = a + 1
8. >>>a
9. 2
10. >>>id(a)
11. 140718136222536
12. >>>b = b - 1
13. >>>b
14. 0
15. >>>id(b)
16. 140718136222472

复制代码

在我们对变量a和变量b进行加减操作后，存储变量a、b的内存地址改变了，而不是内存地址内的值改变了。
如果我们查验数值0，1，2的存储地址，就会发现它们与变量值为0,1,2的变量享有同样的存储地址：

1. >>>id(0)
2. 140718136222472
3. >>>id(1)
4. 140718136222504
5. >>>id(2)
6. 140718136222536

复制代码

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

与不可变类型相对的，就是可变类型。包括列表、集合与字典。
可变类型变量的内存地址不会随着值的变化而改变。
现在先定义一个可变类型变量list1 = [1, 2, 3, 4]

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

复制代码

可以发现当我改变了list1内的元素，变量的内存地址并未发生改变。
现在再创建一个list2 = list1，并再次尝试改变变量list2的值。

1. >>>list2 = list1
2. >>>id(list1)
3. 2185105682944
4. >>>id(list2)
5. 2185105682944
6. >>>list2[0] = 6                # 改变list2中第0元素的值
7. >>>list1                        # list1也发生改变了
8. [6, 2, 3, 5]
9. >>>list2
10. [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. 返回一个深拷贝。

深浅拷贝的区别

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

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

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

复制代码

上述代码创建了三个变量。
其中list1[1]为嵌套的list类型。
list2是list1的浅拷贝，list3是list1的深拷贝。
此时标识符list1、list2和list3各自对应不同的内存地址。
因为三个变量拥有不同的内存地址，所以我们直接对单个变量进行操作，这样的改变不会影响其他变量。
如：

1. >>>list1
2. [1, [2, 3], 4, 5]
3. >>>list2
4. [1, [2, 3], 4, 5]
5. >>>list3
6. [1, [2, 3], 4, 5]
7. >>>list1.append(6)
8. >>>list2.append(7)
9. >>>list3.append(8)
10. >>>list1
11. [1, [2, 3], 4, 5, 6]
12. >>>list2
13. [1, [2, 3], 4, 5, 7]
14. >>>list3
15. [1, [2, 3], 4, 5, 8]

复制代码

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

1. id(list1[1])
2. 1754106220480
3. id(list2[1])
4. 1754106220480
5. id(list3[1])
6. 1754106448960

复制代码

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

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

复制代码

来源:https://www.cnblogs.com/wanderoff-night/p/17742639.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！