ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python中的变量 [打印本页]
作者: 大连密封材料    时间: 2023-10-13 17:29
标题: 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中定义各种名字的时候的统⼀规范，具体如下：
规则：
注意：
  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]
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4