本篇文章为大家展示了使用python怎么对数据类型进行强制转换，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。
可以转换的数据类型
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'))可以转换的数据类型
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'))可以转换的数据类型
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))可以转换的数据类型
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))
容器类型的转换，使用相应容器的函数进行转换。
支持转换的数据类型
所有的数据类型
# 方法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 = 'hello motherland'
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 = 'hello motherland'
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 = 'hello motherland'
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}
# <class 'dict'>注意点
推荐使用列表、元组，不推荐使用集合和字符串
# 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怎么对数据类型进行强制转换，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
