Python中的变量

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

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

>>>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进行加减操作后,存储变量ab的内存地址改变了,而不是内存地址内的值改变了。

如果我们查验数值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后,再查验变量list1list2的内存地址,发现它们是一样的。
并且当我们改变变量list2的内容,变量list1的内容也改变了。
原因很简单,因为标识符list1list2指向的是同一个内存地址:我们通过标识符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类型。
list2list1的浅拷贝,list3list1的深拷贝。
此时标识符list1list2list3各自对应不同的内存地址。

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

>>>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]

热门相关:豪门蜜爱:独宠天后小萌妻   宠物小精灵之庭树   雏妓1988   重生之嫡女祸妃   一等狂妃:邪王,请接招!