Python 高级变量类型 --- 变量进级

目标

变量的引用
可变和不可变类型
局部变量和全局变量

01，变量的引用

变量和数据都是保存在内存中的
在 python中 ** 函数的参数传递** 以及 返回值 都是靠引用传递的

1,1 引用的概念

在 python 中

变量和数据是分开存储的
数据保存在内存中的一个位置
变量中保存着数据在内存中的地址
变量中 记录数据的地址 就叫做引用
使用 id() 函数可以查看变量中保存数据所在的 内存地址

注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用

变量不再对之前的数据引用
变量改为对新赋值的数据引用

1.2 变量的引用

定义一个整数变量a ，并且赋值为 1


	In [2]: a = 1
	
	In [3]: id(a)
	Out[3]: 9294528
	
	In [4]: id(1)
	Out[4]: 9294528
	
	In [5]: b = a
	
	In [6]: id (a)
	Out[6]: 9294528

将变量 a 赋值为 2


	In [7]: a = 2
	
	In [8]: id(2)
	Out[8]: 9294560
	
	In [9]: id(a)
	Out[9]: 9294560
	
	In [10]: id(b)
	Out[10]: 9294528
	
	In [11]: b
	Out[11]: 1

	In [12]: b = a
	
	In [13]: b
	Out[13]: 2

1.3 函数的参数和返回值的传递

在python 中，函数的 实参/返回值 都是靠引用来传递的


	def test(num):
	
		print("在函数内部 %d 对应的内存地址是 %d " % (num, id(num)))
	
		# 1> 定义一个字符串变量
		result = "hello"
	
		print("函数返回的数据内存地址是 %s" % id("hello"))
	
		# 2> 将字符串变量返回,返回的是数据的引用，不是数据本身
		return result
	
	# 1，定义一个数字变量
	a = 10
	
	# 数据的地址本质上就是数字
	print("a 变量报错数据的内存地址是 %d" % id(a))
	
	# 2，调用 test 函数，本质上传递的是实参保存数据的引用，而不是实参保存的数据！
	# 注意，如果函数有返回值，但是没有定义变量接受
	# 程序不会报错，但是无法获得返回结果
	r = test(a)
	
	print("%s 的内存地址是 %d " % (r,id(r)))
	
	# 结果呈现
	a 变量报错数据的内存地址是 1626304256
	在函数内部 10 对应的内存地址是 1626304256 
	函数返回的数据内存地址是 1097423356400
	hello 的内存地址是 1097423356400

02，可变和不可变类型

不可变类型，内存中数据不允许修改：
- 数字类型 int,bool,float,complex,long(2.x)
- 字符串str
- 元组tuple
可变类型，内存中的数据可以被修改：
- 列表list
- 自动dict


	In [1]: # 列表
	
	In [2]: a = [1, 2, 3]
	
	In [3]: id(a)
	Out[3]: 139918828693704
	
	In [4]: a.append(4)
	
	In [5]: a
	Out[5]: [1, 2, 3, 4]
	
	In [6]: id(a)
	Out[6]: 139918828693704
	
	In [7]: a.remove(2)
	
	In [8]: a
	Out[8]: [1, 3, 4]
	
	In [9]: id(a)
	Out[9]: 139918828693704
	
	In [10]: a.clear()
	
	In [11]: a
	Out[11]: []
	
	In [12]: id(a)
	Out[12]: 139918828693704
	
	In [13]: a = []
	
	In [14]: id(a)
	Out[14 ]: 139918828812552
	
	

	In [1]: # 字典
	
	In [2]: d = {"name": 'lufei'}
	
	In [3]: d
	Out[3]: {'name': 'lufei'}
	
	In [4]: id(d)
	Out[4]: 139851481242504
	
	In [5]: d["age"] = 18
	
	In [6]: d
	Out[6]: {'name': 'lufei', 'age': 18}
	
	In [7]: id(d)
	Out[7]: 139851481242504
	
	In [8]: d.pop("age")
	Out[8]: 18
	
	In [9]: d
	Out[9]: {'name': 'lufei'}
	
	In [10]: id(d)
	Out[10]: 139851481242504
	
	In [11]: d.clear()
	
	In [12]: d
	Out[12]: {}
	
	In [13]: id(d)
	Out[13]: 139851481242504
	
	In [14]: d = {}
	
	In [15]: id(d)
	Out[15]: 139851481240416

注意：字典的key 只能使用不可变量的数据

注意
1，可变类型的数据变化，是通过方法来实现的
2，如果给一个可变类型的变量，赋值了一个新的数据，引用会修改

- 变量 **不再** 对之前的数据引用
- 变量 **改动** 对新赋值的数据引用


In [1]: d = {}

	In [2]: d["str"] = "字符串"
	
	In [3]: d
	Out[3]: {'str': '字符串'}
	
	In [4]: d[1] = "整数"
	
	In [5]: d
	Out[5]: {'str': '字符串', 1: '整数'}
	
	In [6]: d[(1,)] = "元组"
	
	In [7]: d
	Out[7]: {'str': '字符串', 1: '整数', (1,): '元组'}
	
	In [8]: d[[1, 2, 3]] = "列表"
	---------------------------------------------------------------------------
	TypeError                                 Traceback (most recent call last)
	<ipython-input-8-a55036046a7e> in <module>()
	----> 1 d[[1, 2, 3]] = "列表"
	
	TypeError: unhashable type: 'list'
	
	In [9]: d[{"a": "b"}] = "字典"
	---------------------------------------------------------------------------
	TypeError                                 Traceback (most recent call last)
	<ipython-input-9-92f5d6f58e65> in <module>()
	----> 1 d[{"a": "b"}] = "字典"
	
	TypeError: unhashable type: 'dict'

哈希（hash）

python 中内置有一个名字叫做hash(0) 函数
- 接收一个 不可变类型 的数据作为参数
- 返回结果是一个整数
哈希是一种算法，其作用就是提取数据的 特征码（指纹）
- 相同的内容 得到 相同的结果
- 不同的内容 得到 不同的结果
在python 中，设置字典的 键值对 时，会首先对 key 进行 hash 已决定如何在内存中报错字典的数据，以方便后续对字典的操作：增、删、改、查
- 键值对的 key 必须是不可变类型数据
- 键值对的 value 可以任意类型的数据

	
	In [1]: hash(1)
	Out[1]: 1
	
	In [2]: hash("hello")
	Out[2]: 1132375164472456435
	
	In [3]: hash("hello")
	Out[3]: 1132375164472456435
	
	In [4]: hash("hello")
	Out[4]: 1132375164472456435
	
	In [5]: hash("hello python")
	Out[5]: 8043571658991483943
	
	In [6]: hash((1,))
	Out[6]: 3430019387558
	
	In [7]: hash([1, 2, 3])
	---------------------------------------------------------------------------
	TypeError                                 Traceback (most recent call last)
	<ipython-input-7-84d65be9aa35> in <module>()
	----> 1 hash([1, 2, 3])
	
	TypeError: unhashable type: 'list'
	
	In [8]: hash({"a": "b"})
	---------------------------------------------------------------------------
	TypeError                                 Traceback (most recent call last)
	<ipython-input-8-fd5f3c48593a> in <module>()
	----> 1 hash({"a": "b"})
	
	TypeError: unhashable type: 'dict'

03，局部变量和全局变量

局部变量 是在 函数内部 定义的变量，只能在函数内部使用
全局变量 是在 函数外部 定义的变量（没有定义任意一个函数内），所有函数 内部 都可以调用这个变量

提示：在其他的开发语言中，大多 不推荐使用全局变量 -- 可变范围太大，导致程序不好维护！

3.1 局部变量

局部变量 是在 函数内部 定义的变量，只能在函数内部使用
函数执行结束后，函数内部的局部变量，会被系统回收
不同的函数，可以定义相同的名字的局部变量，相互隔离不会产生任何影响

局部变量的作用

在函数内部使用，临时保存 函数内部需要使用的数据

局部变量的生命周期 --- TTL (Time To Live)

所谓 生命周期 就是变量从 被创建 到 被系统回收 的过程
局部变量 在 函数执行时 才会被创建
函数执行结束后 局部变量 被系统回收
局部变量在生命周期 内，可以用来存储 函数内部临时使用到的数据

3.2 全局变量

全局变量 是在 函数外部定义 的变量，所有函数内部都可以使用这个变量

注意：函数执行时，需要处理变量时会：
1，首先查找 函数内部 是否存在 指定名称的局部变量，如果有，直接使用
2，如果没有，查找 函数外部 是否存在 指定名称的全局变量，如果有，直接使用
3，如果没有，程序报错！

1）函数不能直接修改全局变量的引用

全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部都可以使用这个变量