强制类型转换 Number (int float bool complex )

var1 = 13 var2 = 13.789 var3 = True var4 = 5-7j var5 = "9988" var6 = "abcd4567"

(1) 强制类型转换成整型 int

res = int(var2) # 13 res = int(var3) # True => 1 False => 0 #res = int(var4) # error (TypeError: 复数不能转化为整型) res = int(var5) # 9988 # res = int(var6) # error print(res,type(res))

(2) 强制转换成浮点型 float

res = float(var1) # 13.0 res = float(var3) #1.0 res = float(var4) # error res = float("9988") # 9988.0 print(res,type(res))

(3) 强制转换为复数 complex

res = complex(var1) # 13 + 0j res = complex(var2) # 14.789 + 0j res = complex(var3) # True 1 + 0j Flash 0j res = complex(var5) # 9988 +0j #res = complex(var6) # error

(4) 强制转换成布尔值 bool (***)

res = bool(None) # Flash res = (var1) # True res = (var2) # True ''' bool 类型为假的十种情况 0, 0.0, False, 0j, '', [], (), set{}, {} ,None None 是 Python的关键字,代表空的,什么都没有,一般用来做初始化操作 a1 = None b1 = None '''

总结:

# int() float() bool() complex() # 默认创建一个该数据类型的值 res = int() res = float() res = bool() res = complex() print(res)

自动类型转换 Number (int float bool complex)

精度从低到高进行转换 : bool-> int -> float -> complex自动类型转换,默认从低精度向高精度进行转化 (从低到高) # 1 .bool + int res = True + 100 # 1 + 100 print(res ) # 2. bool + float res = True + 4.415 # 1.0 + 4.415 print(res) # 3. bool + complex res = True + 3-6j # 1 + 0j + 3-6j print(res) # 4. int + float res = 5 + 4.38 # 5.0 + 4.38 # 5. int + complex res = 10 + 4-3j # 10 +0j + 4-3j print(res) # 6. float + complex res = 5.68 + 5-100j # 5.68+0j + 5 - 100j print(res)

容器类型的强制转换 (str list tuple set dict)

strvar = '雷霆嘎巴,无情呼啦少,ZB' listvar = ["曹晨光","温子月","吴洪昌"] tuplevar = ("高岳峰","葛龙","孙京华","白星") setvar = {"李志辉","马冬梅","刘新伟"} # 推荐大家使用变量命名的字符串作为字典的键; dictvar = {"lzh":"气质非凡","mdm":"高大威猛","lxw":"气宇轩昂"} intvar = 8888

str (容器 / number 都可以转)

强制转换为字符串,无非就是在原有的数据的基础上两边套上引号 “” res = str(listvar) # "['曹晨光', '温子月', '吴洪昌']" res = str(intvar) # '8888' print(res , type(res))

list 强制转换成列表

''' 如果是自字符串,会把每一个字符单独的作为一个元素放到列表中 如果是字典, 会只保留键,形成一个新的列表 如果是其他的容器,只是单纯的在原有数据的基础上换上[] ''' res = list(strvar) # ['雷', '霆', '嘎', '巴', ',', '无', '情', '呼', '啦', '少', ',', 'Z', 'B'] res = list(tuplevar) # ['高岳峰', '葛龙', '孙京华', '白星'] res = list(setvar) # ['刘新伟', '马冬梅', '李志辉'] res = list(dictvar) # ['lzh', 'mdm', 'lxw'] print(res , type(res))

tuple : 强制转换成元组 (与列表相似)

''' 如果是字符串,会把每一个字符单独的作为一个元素放到元组中 如果是字典,只保留键,形成一套新的元组 如果是其他的容器,只是单纯的在原有数据的基础上换上() ''' res = tuple(strvar) res = tuple(listvar) res = tuple(setvar) res = tuple(dictvar) print(res , type(res))

set : 强制转换成集合 (自动去重)

''' 如果是字符串,会把每一个字符单独的作为一个元素放到集合中(无序,自动去重) 如果是字典,只保留键,形成一套新的集合 如果是其他的容器,只是单纯的在原有数据的基础上换上{} ''' res = set(strvar) res = set(listvar) res = set(dictvar) print(res)

去掉列表中所有重复的数据 (转换成集合,在转换回来)

lst = ['a','b','c','d','d','d',100,200] res = list( set(lst) ) print(res)

dict 强制转换成字典

''' 强制转换成字典时,必须是等长的二级容器,每个容器里面的元素个数是2个 ''' #(1) 外层是列表或者元组或者集合时,里面的容器是元组或者列表(集合不推荐) lst = [('a',1),['b',2]] # {'a': 1, 'b': 2} tup = (('c',3),['d',4]) # {'c': 3, 'd': 4} setvar = {(1,2),(3,4),('f3',3),('f4',4)} # {1: 2, 'f4': 4, 'f3': 3, 3: 4} #(2) 如果里面是集合,语法上允许,但是有局限性(不推荐) lst = [{'a',333},{'zz',5}] # 因为集合无序,不允许定义的本意,不推荐使用 print(dict(lst)) #(3) 如果使用字符串,语法上正确,但是有局限性(不推荐) lst = [('a',1),'b2'] # 字符串长度只能是两个 # lst = [("a",1),"b23"] error 字符串长度三个 '''

总结 str() list() tuple() dict() set() 默认创建一个该数据类型的值

字典强转

# 二级容器(list tuple set dict) # 二级列表 listvar = [1,2,[3,4]] # 二级元组 tuplevar = (5,6,(7,8)) # 二级集合 (集合里面) setvar = {10,11,(12,13)} # 集合里面不能嵌套集合 # 二级字典 ''' dictvar = {'a':1 , 'b':{'c':2,'d':4} } # 获取4这个元素 res = dictvar('b') # {'c':2,'d':4} res1 = res['d'] # 4 简写 res = dictvar['b']['d'] ''' # 五级容器 ''' container = [100,200,300,(1,2,3,4,{"a":1,"b":{"c":15,"d":[11,12,"bingo"]}})] # 获取bingo res1 = container[-1] print(res1) # (1, 2, 3, 4, {'a': 1, 'b': {'c': 15, 'd': [11, 12, 'bingo']}}) res2 = res1[-1] print(res2) # {'a': 1, 'b': {'c': 15, 'd': [11, 12, 'bingo']}} res3 = res2["b"] print(res3) # {'c': 15, 'd': [11, 12, 'bingo']} res4 = res3["d"] print(res4) # [11, 12, 'bingo'] res5 = res4[-1] print(res5) # 简写一步 res = container[-1][-1]["b"]["d"][-1] print(res) # bingo ''' # 简写一步 res = container[-1][-1]["b"]["d"][-1] print(res) # bingo # 等长的二级容器: 里面的元素都是容器,并且容器里面的元素个数都相同 lst = [(1,2,3),[4,5,6]] tup = ((7,8),[9,10])

变量的缓存机制 (仅针对于3.6版本)

''' 机制: 只有两个值相同, 就开辟一个空间 python 3.7 python 3.8 '''

(1) --> Number 部分

# 1. 对于整型而言, -5 ~ 正无穷内的相同值id一致 var1 = 100 # id 1439599824 var2 = 100 # id 1439599824 # -6 (id不同) var1 = -6 #2338256962896 var2 = -6 #2338256962704 a = b = 12 (id 相同)

(2) --> 对于浮点数而言,非负数范围内的相同值 id相同

# 负数 var1 = -5.76 # 2048696653120 var2 = -5.76 # 2048696654272 # 正数 (相同) var1 = 1.23 # 2454093699520 var2 = 1.23 # 2454093699520 id(var1)

(3) --> 对布尔值而言,值相同情况下，id一致

var1 = True var2 = False print(id(var1),id(var2))

(4) --> 复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)

var1 = 3+4j var2 = 3+4j var1 = 90j # 2589272341328 var2 = 90j # 2589272341328 print(id(var1),id(var2))

(5) --> 容器类型部分

# 字符串 和 空元组 相同的情况下，地址相同 var1 = "你" var2 = "你" var1 = () var2 = () print(id(var1),id(var2)) # 列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外] var1 = (1,2,3) var2 = (1,2,3) print(id(var1),id(var2))

哈希算法

''' 定义: 把不可变的任意长度值计算出固定长度的唯一值,这个值可正可负,可大可小,但长度固定 该算法叫哈希算法(散列算法)，这个固定长度值叫哈希值(散列值) 特点: 1.计算出来的值长度固定且该值唯一 2.该字符串是密文，且加密过程不可逆 用哈希算法计算得到一个字符串的用意: 例如: 比对两个文件的内容给是否一致 例如：比对输入的密码和数据库存储的密码是否一致 字典的键和集合中的值都是唯一值,不可重复: 为了保证数据的唯一性,用哈希算法加密字典的键得到一个字符串。用哈希算法加密集合的值得到一个字符串。如果重复，他们都是后面的替换前面的。自动去重 版本: 3.6版本之前都是 字典和集合都是无序的 3.6版本之后,把字典的字面顺序记录下来，当从内存拿数据的时候， 根据字面顺序重新排序，所以看起来像有序,但本质上无序 '''