python 的数据类型转换

1. Number 数字类型的强制类型转换

# 我们先定义几个数字类型的变量
			var1 = 24
			var2 = 3.14
			var3 = True
			var4 = 5-8j
			var5 = "4399"
			var6 = "abcf1234"
			
# 1.int 强制转换成整型
			res = int(var2) # 24
			res = int(var3) # False => 0 True => 1
			# res = int(var4) error
			res = int(var5) # 4399
			# res = int(var6) error
			print(res , type(res))
			
# 2.float 强制转换成浮点型
			res = float(var1) # 24.0
			res = float(var3) # True => 1.0 False => 0.0
			res = float(var5) # 4399.0
			print(res , type(res))
			
# 3.complex 强制转换成复数
			res = complex(var1) # 24 + 0j
			res = complex(var2) # 3.14 + 0j
			res = complex(var3) # False => 0j True => 1+0j
			res = complex(var5) # 4399 + 0j
			# res = complex(var6) error
			print(res , type(res))
			
# 4.bool 强制转换成布尔型
	"""
	bool类型为假的十种情况
	0 , 0.0 , 0j , False , '' , [] , () , set() , {} , None
	"""
	# None 是python的关键字,代表空的,什么也没有,一般用来做初始化操作, eg. a1 = None , b1 = None
			res = bool(None)	
			print(res , type(res))
			
	"""
	总结:
		int() float() bool() complex()
		默认创建一个该数据类型的值
		res = int() 
		res = float()
		res = bool()
		res = complex()
		print(res)
	"""

2. Number 数字类型的自动类型转换

转换规则 => 默认精度从低到高进行转换: bool -> int -> float -> complex

# 1.bool + int
            res =True + 100 # 1 + 100
            print(res)
		
# 2.bool + float
            res = True + 3.14 # 1.0 + 3.14
            print(res)

# 3.bool + complex
            res = False + 5-2j # 0j + 5-2j
            res = True + 5-2j  # 1+0j + 5-2j
            print(res)

# 4.int + float
            res = 5 + 3.14 # 5.0 + 3.14
            print(res)
		
# 5.int + complex
            res = 20 + 5-2j # 20+0j + 5-2j
            print(res)
		
# 6. float + complex
            res = 3.14 + 20-9j # 3.14+0j + 20-9j
            print(res)

3. 容器类型数据的强制转换

# 我们先定义几个容器类型数据的变量:
		strvar = '红灯停绿灯行'
		listvar = ["张飞","李逵","王瑶"]
		tuplevar = ("小明","小红","小花","小东")
		setvar = {"大喷子","大棍子","大背头"}
# 推荐使用变量命名的字符串作为字典的键
		dictvar = {"aaa":123,"bbb":321,"dpz":"巧舌如簧","dgz":"刚正不阿","dbt":"文武双全"}
		intvar = 6666

1. str 字符串: 强制转换成字符串

# str 字符串对容器类型数据和数字类型数据都可以转换
# 特点: 强制转换成字符串,就是在原有数据的基础上两边套上引号
			res = str(listvar)
			res = str(intvar)
			print(res , typr(res))		
# repr: 可以原型化输出字符串,不转义字符(显示出引号)
			print(repr(res))

2. list 列表: 强制转换成列表

# 特点:
#	如果是字符串,会把每一个字符单独的作为一个元素放到列表中
#	如果是字典,只保留键,形成一套新的列表
#	如果是其他容器,值是单纯的在原有数据基础上换上[]
			res = list(strvar)
			res = list(tuplevar)
			res = list(setvar)
			res = list(dictvar)
			print(res , type(res))

3. tuple 元组: 强制转换成元组

# 注意点: 逗号是区分是否是元组的标识符
# 特点:
#	如果是字符串,会把每一个字符单独的作为一个元素放到元组中
#	如果是字典,只保留键,形成一套新的元组
#	如果是其他容器,值是单纯的在原有数据基础上换上()
			res = tuple(strvar)
			res = tuple(listvar)
			res = tuple(setvar)
			res = tuple(dictvar)
			print(res , typr(res))

4. set 集合: 强制转换成集合

# 注意点: 集合无序,且自动去重
# 特点:
#	如果是字符串,会把每一个字符单独的作为一个元素放到集合中
#	如果是字典,只保留键,形成一套新的集合
#	如果是其他容器,值是单纯的在原有数据基础上换上{}
			res = set(strvar)
			res = set(listvar)
			res = set(tuplevar)
			res = set(dictvar)
			print(res , type(res))
			
# 练习:去掉列表中所有重复的数据
			lst =['a','b','c','f','a','c','d',111,123]
# 表达方式1
			res = set(lst)
			print(res)
			res = list(res)
			print(res)
# 表达方式2
			res = list( set(lst) )
			print(res)

5. dict 字典: 强制转换成字典

# 特点: 字典强制转换时,必须是等长的二级容器,并且容器里面的元素个数是两个

# 二级容器 (list tuple set dict)

# 等长的二级容器 : 里面的元素都是容器,并且容器里面的元素个数都相同
			lst = [(1,2,3),[4,5,6]]
			lst = [(99,88),(77,66)]
# 二级列表 list
			lst = [1,2,[3,4]]
# 二级元组 tuple
			tup = (5,6,7,(8,9,10))
# 二级集合 (集合中元素的数据类型要求: int bool float complex str tuple)
			setvar = {11,12,13,(14,15,16)}
# 二级字典 (字典中的键的数据类型要求: int bool float complex str tuple)
			dic = {"a":1,"b":{"c":2,"d":3}}
# 练习1: 获取'3'这个元素
			res1 = dic["b"]
			print(res1) # {"c":2,"d":3}
			res2 = res1["d"]
			print(res2)
# 简写
			res = dic["b"]["d"]
			print(res)
# 练习2: 获取'Hello'
	container = [1,2,(3,4,{"a":11,"b":{"c":22,"d":[33,44,"Hello"]}})] # 五级容器
			res1 = container[-1]
			print(res1)
			res2 = res1[-1]
			print(res2)
			res3 = res2["b"]
			print(res3)
			res4 = res3["d"]
			print(res4)
			res5 = res4[-1]
			print(res5)
# 简写
			res = container[-1][-1]["b"]["d"][-1]
			print(res)
			
# 强制转换成字典

# 1.外层是列表/元组/集合,里面的容器是列表/元组
			lst = [("a",1),["b",2]]
			tup = (("c",3),["d",4])
			setvar = {(5,6),[7,8],("f1",1),["f2",2]}
			res = dict(lst) # {"a":1,"b":2}
			res = dict(tup) # {"c":3,"d":4}
			res = dict(setvar) # {6:5,7:8,"f1":1,"f2":2} 
			# 因为集合无序,虽然语法上允许,但不符合定义的本意,不推荐使用
			print(res)
# 2. 如果使用字符串,语法是哪个正确,但有局限性
			lst = [("q",1),"p8"] # 字符串长度只能是2个
#			lst = [("q",1),"p88"] error
			print( dict(lst) )
# 总结:
#	str() list() tuple() set() dict()
#	默认创建一个该数据类型的值

4. 变量的缓存机制 (仅对python3.6版本负责)

python3.7 和 python3.8 的缓存机制 : 只要两个值相同,就之开辟一个空间

1. Number 数字类型数据

# 1. int 对于整型而言, -5 ~ 正无穷范围内的相同值 id一致
			var1 = 111
			var2 = 222
			var3 = -6
			var4 = -6
			var5 = var6 = -100 # 相同的地址
			print(id(var1) , id(var2))
			print(id(var3) , id(var4))
			print(id(var5) , id(var6))
# 2. float 对应浮点型而言, 非负数范围内的相同值 id一致
			var1 = 3.14
			var2 = 3.14
			var3 = -3.14
			var4 = -3.14
			print(id(var1) , id(var2))
			print(id(var3) , id(var4))
# 3. bool 对应布尔型而言,值相同的情况下 id一致
			var1 = True
			var2 = False
			print(id(var1) , id(var2))
# 4. complex 复数 : 实数 + 虚数 => 这样的结构中 id永不相同 (只有虚数的情况例外)
			var1 = 3+4j
			var2 = 3+4j
			var3 = 21j
			var4 = 21j
			print(id(var1) , id(var2))
			print(id(var3) , id(var4))

2. 容器类型数据

# 1. 字符串 和 空元组 相同的情况下,地址相同
			var1 = "三叉戟"
			var2 = "三叉戟"
			var3 = ()
			var4 = ()
			print(id(var1) , id(var2))
			print(id(var3) , id(var4))
# 2. 列表,元组,字典,集合无论什么情况 id都不相同 (空元组除外)
			var1 = (1,2,3)
			var2 = (1,2,3)
			print(id(var1) , id(var2))