python 数据类型强制转换的总结
数据类型的强制转换
如果要将一个数据转换成另一个数据类型，只需要将其放入相应类型的函数中去。
Number类型的数据转换
强制转换为int
可以转换的数据类型
- int整型
- float浮点型
- bool布尔型
- str字符串（整型）
数据转换
#整型（整型转换是原封不动的）
print(int(10))
#浮点型（浮点型转成整型按照退一法）
print(int(10.999))
#布尔型（布尔型只有两种值，转换成为整型也只有两种，True=1，False=0）
print(int(True))
print(int(False))
#字符串（字符串只有去掉引号是整型的才能转换）
print(int('-123'))
print(int('123'))
强制转换为float
可以转换的数据类型
- int整型
- float浮点型
- bool布尔型
- str字符串（整型、浮点型）
数据转换
#整型（整型转换是添加一位小数，小数位为0）
print(float(10))
#浮点型（浮点型转换原封不动）
print(float(10.999))
#布尔型（布尔型只有两种值，转换成为整型也只有两种，True=1.0，False=0.0）
print(float(True))
print(float(False))
#字符串（字符串只有去掉引号是整型和浮点型的才能转换）
print(float('-123'))
print(float('1234.134'))
强制转换为bool
可以转换的数据类型
python中所有的数据类型都可以转换成为布尔型，但是结果只有两种，True和False
数据转换
在python中，只有十种情况下的数据转换成为bool的值是False，其余皆为True。
#就是说，python中一切为空的数据都为False
#1、整型（0）
print(bool(0))
#2、浮点型（0.0）
print(bool(0.0))
#3、布尔型（False）
print(bool(False))
#4、复数（0j）
print(bool(0j))
#5、字符串（空字符串）
print(bool(''))
#6、列表（空列表）
print(bool([]))
#7、元组（空元组）
print(bool(()))
#8、集合（空集合）
print(bool(set()))
#9、字典（空字典）
print(bool({}))
#10、None（python关键字，表示什么也没有）
print(bool(None))
强制转换为complex
可以转换的数据类型
- int整型
- float浮点型
- bool布尔型
- complex复数
- str字符串（整型、浮点型、复数）
数据转换
#整型（整型转换是原数+0j）
print(complex(10))
#浮点型（浮点型转换是原数+0j）
print(complex(10.999))
#布尔型（布尔型只有两种值，转换成为整型也只有两种，True=1+0j，False=0j）
print(complex(True))
print(complex(False))
#复数（复数转换原封不动，0+0j=0j）
print(complex(1234+341j))
print(complex(0+0j))
#字符串（字符串只有去掉引号是整型、浮点型和复数的才能转换）
print(complex('-123'))
print(complex('1234.134'))
print(complex('1234+0j'))
数字类型的自动转换
不同类型的数字在一起运算时，结果会按照精度从低到高自动的进行转换。当低精度的数与高精度的数进行运算，最后会变为高精度数类型
精度从低到高排序：
bool----->int----->float------>complex
- bool和除了bool之外的任何数据类型运算结果都不会是bool
- complex与任何类型的数据进行运算都会变成complex
#例如低精度的bool和高精度的int进行运算，其结果会自动的转变成为高精度的int #bool+int res=True+100 print(res,type(res)) #bool+float res=True+100.11 print(res,type(res)) #bool+complex res=True+0j print(res,type(res)) #int+float res=123+100.9 print(res,type(res)) #int+complex res=123+0j print(res,type(res)) #float+complex res=100.0000+0j print(res,type(res))
container类型的强制转换
容器类型的转换，使用相应容器的函数进行转换。
转换为字符串
支持转换的数据类型
所有的数据类型
#方法1、直接加引号
print('[1,2,3]')
#方法2、使用str函数
print(str([1,2,3]))
#[1,2,3]
#方法3、使用repr函数
print(repr([1,2,3]))
#[1,2,3]
#repr函数的作用：原型化输出字符串，不转义字符（显示出引号）
lstvar=[1,2,3]
res=str(lstvar)
print(repr(res))
#'[1,2,3]'
转换为列表
支持转换的数据类型
仅容器
注意要点
如果是字符串，会把每一个字符串单独的作为一个元素放到列表中；
如果是字典，只保留键，形成一套新的列表；
如果是其它的容器，只是单纯的在原有数据的基础上换上[]；
#1、字符串
#字符串中的每一个字符都视为一个元素
var='hellomotherland'
print(list(var))
#['h','e','l','l','o','','m','o','t','h','e','r','l','a','n','d']
#2、字典
var={'one':1,'two':2,'three':3}
print(list(var))
#['one','two','three']
#3、其它的数据类型
var=(1,3,4,5,6)
print(list(var))
#[1,3,4,5,6]
var={1,3,4,5,6}
print(list(var))
#[1,3,4,5,6]
转换为元组
支持转换的数据类型
仅容器
注意要点
如果是字符串，会把每一个字符串单独的作为一个元素放到列表中
如果是字典，只保留键，形成一套新的列表
如果是其它的容器，只是单纯的在原有数据的基础上换上()
和list是一样的
#1、字符串
#字符串中的每一个字符都视为一个元素
var='hellomotherland'
print(tuple(var))
#('h','e','l','l','o','','m','o','t','h','e','r','l','a','n','d')
#2、字典
var={'one':1,'two':2,'three':3}
print(tuple(var))
#('one','two','three')
#3、其它的数据类型
var=[1,3,4,5,6]
print(tuple(var))
#(1,3,4,5,6)
var={1,3,4,5,6}
print(tuple(var))
#(1,3,4,5,6)
转换为集合
支持的数据类型
仅容器
注意要点
集合的变化和列表、元组都是一样的，只是单纯的在原有数据的基础上换上{}；
但是集合是无序的，返回的结果中的元素的顺序是不固定的
#1、字符串
#字符串中的每一个字符都视为一个元素
var='hellomotherland'
print(set(var))
#{'d','r','','h','n','e','t','m','a','o','l'}
#2、字典
var={'one':1,'two':2,'three':3}
print(set(var))
#{'two','one','three'}
#3、其它的数据类型
var=['1','3','4','5','6']
print(set(var))
#{'5','4','6','1','3'}
var=('1','3','4','5','6')
print(set(var))
#{'5','4','6','1','3'}
多级容器
- 在一个容器当中嵌套一个容器，这个容器就叫做二级容器；在被嵌套的容器当中再嵌套一个容器，最外层的容器就叫做三级容器；以此类推，有四级、五级……
- 容器的类型取决于最外层的容器，不同的类型容器可以相互嵌套，但是，集合和字典除外；因为字典的键和集合中的值必须是可哈希的类型，可哈希的数据类型Number、str、tuple；
- 多级容器不包括字符串，字符串是特殊的容器，任何字符在字符串中都是字符串的一个单独元素；
#二级容器
#比如列表中嵌套一个列表
var=[1,2,[1,2,3]]
#三级容器
#比如列表中嵌套一个列表，被嵌套的列表中还有一个元组
var=[1,2,[3,4,(5,6)]]
#……
#二级字典
#字典是用键来存储数据的，所以被嵌套的容器要放在键下
var={'1':1,'2':2,'666':{'3':3,'4':4}}
获取多级容器中的值
#获取被嵌套的容器中的数据要通过下标索引、键一层一层的将数据获取出来
#练习：获取四级容器当中的值！！！如何获取10
No1_level4_container=[1,2,3,4,(1,2,3,4,{1:1,2:2,"msr":[1,2,3,4,10]})]
print("---原四级容器")
print(No1_level4_container)
#在这个多级容器当中，所有的容器都是最后一个，所以利用python特有的逆向下标，来逐一获取出来
#1、先获取元组。也就是第二级容器
res=No1_level4_container[-1]#释放一级也就是通过列表的下标-1来选择出来
print("---释放一级")
print(res)
#2、在获取字典
res=res[-1]
res1=No1_level4_container[-1][-1]
print("---剥夺二级")
print(res)
print(res1)
#3、在获取键值msr对应的值
res=res['msr']
print("---获取msr")
print(res)
#4、在获取数值10下标-1或者4
res1=res[-1]
res2=res[4]
print('---最终结果')
print(res1,res2)
#简写
res=No1_level4_container[-1][-1]['msr'][-1]
print('---简写结果')
print(res)
等长的多级容器
- 外层容器中的元素都是容器
- 被嵌套容器中的元素个数相同
#等长的二级容器 var=[(1,2,3,),(4,5,6,)]
字典的强转
要求
必须是等长的二级容器，且里面的元素个数必须是两个。
容器的转换
#使用dict函数进行转换
var=[('one',1),('two',2)]
dctvar=dict(var)
print(dctvar)
print(type(dctvar))
#{'one':1,'two':2}
#
注意点
推荐使用列表、元组，不推荐使用集合和字符串
#1、外层是列表或者元组、集合，里面的容器推荐是元组或者列表
var=[(1,2),[3,4]]
res=dict(var)
print(res,type(res))
#2、不推荐使用集合
#如果里面是集合，语法上虽然允许，但是有局限性。因为集合无序，往往不符合定义的本意，也就是说往往二级容器当中的第一个元素可能不会成为键。
var=[{'1',2},{'2',3}]
res=dict(var)
print(res)
#3、不推荐使用字符串
#如果使用字符串，语法上正确，但是也有局限性。因为字符串中的一个字符就视为一个元素，所以字符串的长度不能超过两个字符，不然就不满足强转字典的要求了。
var=[[1,2],"ab"]
print(dict(var))
var=[[1,2],"abc"]
print(dict(var))#error
各数据类型的函数的作用
#直接使用创建一个同类型的空值，也就是转成布尔都是false
print(int()) #0
print(float()) #0.0
print(bool()) #false
print(complex()) #0j
print(str()) #''
print(list()) #[]
print(tuple()) #()
print(set()) #set()
print(dict()) #{}
以上就是python数据类型强制转换的使用总结的详细内容，更多关于python数据类型强制转换的资料请关注毛票票其它相关文章！