数据类型的强制转换
如果要将一个数据转换成另一个数据类型,只需要将其放入相应类型的函数中去。
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 + intres = True + 100print(res, type(res))# bool + floatres = True + 100.11print(res, type(res))# bool + complexres = True + 0jprint(res, type(res))# int + floatres = 123 + 100.9print(res, type(res))# int + complexres = 123 + 0jprint(res, type(res))# float + complexres = 100.0000 + 0jprint(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 = \'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}}
获取多级容器中的值
# 获取被嵌套的容器中的数据要通过下标索引、键一层一层的将数据获取出来# 练习:获取四级容器当中的值!!!如何获取10No1_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或者4res1 = 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
各数据类型的函数的作用
# 直接使用创建一个同类型的空值,也就是转成布尔都是falseprint(int()) # 0print(float()) # 0.0print(bool()) # falseprint(complex()) # 0jprint(str()) # \'\'print(list()) # []print(tuple()) # ()print(set()) # set()print(dict()) # {}