强制类型转换 Number (int float complex bool)
var1 = 100
var2 = 3.9
var3 = True
var4 = 4-90j
var5 = "123"
var6 = "123abc"int 强制转换为整型
可以转：int float bool 纯数字字符串
res = int(var2) # 3
res = int(var3) # True => 1 False => 0
res = int(var4) # error 复数不能转换为整形
res = int(var5) # 123
res = int(var6) # error 不是纯数字
print(res , type(res))float 强制转换为浮点型
可以转: int float bool 纯数字字符串
res = float(var1) # 100.0
res = float(var3) # False => 0.0 True => 1.0
res = float(var4) # error
res = float(var5) # 123.0
print(res , type(res))complex 强制转换为复数
可以转: int float bool 纯数字字符串 complex
res = complex(var1) # (100+0j)
res = complex(var2) # (3.9+0j)
res = complex(var3) # False => 0j True => 1+0j
res = complex(var5) # 123+0j
print(res , type(res))bool 强制转换为布尔型
可以转: bool类型可以转换一切数据
res = bool(var6) # True
res = bool(var4) # True布尔类型为假的十种情况 （重中之重）
""" 0 , 0.0 , 0j , False , '' , [] , (),{},set() , None """
res = bool(0)
res = bool(0.0)
res = bool(False)
res = bool(0j)
res = bool('')
res = bool([])
res = bool(())
res = bool({})
res = bool(set())
res = bool(None)
print(res)None 代表空的，什么也没有，一般用作变量的初始化
a = None
b = None自动类型转换Number
精度上从小到大的顺序：bool => int => float => complex
默认在系统自动转换的时候，低精度向高精度转换.
bool + int
res = True + 15 # 1 + 15 => 16
bool + float
res = True + 3.8 # 1.0 + 3.8 = 4.8
bool + complex
res = True + 3-90j # 1+0j + 3-90j => 4-90j
int + float
res = 4 + 4.1 # 4.0+4.1 = 8.1
int + complex
res = 5 + 4-90j # 9-90j
float + complex
res = 4.3 + 5 - 3j #4.3+5.0-3j = 9.3-3j容器类型的强制转换
str list tuple set dict bool , str 可以转换所有的数据类型
var1 = "李文汇"
var2 = ["张永建","徐汇","张士宇"]
var3 = ("张永建","徐汇","张士宇")
var4 = {"张永建","徐汇","张士宇"}
var5 = {"风流倜傥,英俊潇洒,放荡不羁":"张永建","水性杨花":"徐汇","正义凛然,方方正正":"张士宇"}
var6 = 12345强制转换成 str
可以转换所有的数据类型,就是单纯在原数据类型的两边套上引号就是字符串
res = str(var6)
res = str(var5)
# repr => 元字符串 r"e:sdf\sdf" 不转移,原型化输出,显示引号
res = repr(res)
print(res , type(res))强制转换成 list
如果是字符串,把字符串中的每个元素拿出来,作为列表的新元素
如果是字典,保留所有字典的键
如果是其他数据,就是单纯的在原数据类型的两边换上中括号[]
lst = list(var1) # ['李', '文', '汇']
lst = list(var3) # ['张永建', '徐汇', '张士宇']
lst = list(var5) # ['风流倜傥,英俊潇洒,放荡不羁', '水性杨花', '正义凛然,方方正正']
print(lst , type(lst))强制转换成 set
如果是字符串,把字符串中的每个元素拿出来,作为集合的新元素 [无序,自动去重]
如果是字典,保留所有字典的键
如果是其他数据,就是单纯的在原数据类型的两边换上花括号{}
setvar = set(var1)
setvar = set(var2)
setvar = set(var5)
print(setvar , type(setvar))强制转换成 tuple
如果是字符串,把字符串中的每个元素拿出来,作为元组的新元素
如果是字典,保留所有字典的键
如果是其他数据,就是单纯的在原数据类型的两边换上圆括号()
tup = tuple(var5) # ('风流倜傥,英俊潇洒,放荡不羁', '水性杨花', '正义凛然,方方正正')
print(tup , type(tup))括号里面不写数据,默认返回一个假值;
float complex() bool() str() list() tuple() set() dict()
res = dict()
print(res)转换成字典
二级容器 列表 元组 集合 字典
二级列表
listvar = [1,2,3,[4,5,6]]
二级元组
tuplevar = (1,2,3,(4,5))
二级集合
setvar = {'a','b',(1,23)}
二级字典
dictvar = { "a":1,"b":{"c":3} }四级容器
container = [1,2,3,4,(5,6,7,8,{"a":1,"b":2,"c":[1,2,"bingo"]})]如何获取bingo字符串
res = container[-1]
print(res) # (5, 6, 7, 8, {'a': 1, 'b': 2, 'c': [1, 2, 'bingo']})
res2 = res[-1]
print(res2) # {'a': 1, 'b': 2, 'c': [1, 2, 'bingo']}
res3 = res2["c"]
print(res3) # [1, 2, 'bingo']
res4 = res3[-1]
print(res4) # ['bingo']
简化代码
res = container[-1][-1]["c"][-1]
print(res)等长的二级容器
里面的元素是容器,并且容器里面的元素个数相同就是等长的二级容器
container = [(1,4,43),[11,7,10]]
dict 强转:需要等长的二级容器,并且容器里面的元素个数得是2个
外层是列表,内层是 列表/元组
container = [["a",1] , ("b",2)]
外层是元组,内层是列表/元组
container = (["c",1],("d",4))
外层是集合,内层是元组
container = {("f",10),('e',20)}
dictvar = dict(container)
print(dictvar , type(dictvar)) # {'e': 20, 'f': 10}
在里面放元组,什么情况都好使
例外情况 (不推荐)
集合无序,导致不符合原意(不推荐)
container = [{"a",1},{"b",2}]
dic = dict(container)
print(dic , type(dic))
字符串的长度必须是2位,有极大局限性(不推荐)
container = (["a",1],"c3")
# container = (["a",1],"c333") error
dic = dict(container)
print(dic , type(dic))
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
