python中数据类型转换

强制类型转换 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版本之后,把字典的字面顺序记录下来，当从内存拿数据的时候，
    根据字面顺序重新排序，所以看起来像有序,但本质上无序

'''