python 数据类型强制转换

Number部分:
int :     整型   浮点型 布尔类型  纯数字字符串
float:    整型   浮点型 布尔类型  纯数字字符串
complex:  整型   浮点型 布尔类型  纯数字字符串 (复数)
bool:     ( 容器类型数据  /  Number类型数据 都可以 )

# -->容器类型部分
str:      ( 容器类型数据  /  Number类型数据 都可以 )
list:     字符串 列表 元组 集合 字典
tuple:    字符串 列表 元组 集合 字典
set:      字符串 列表 元组 集合 字典    (注意:相同的值,只会保留一份)
dict:     使用 二级列表,二级元组,二级集合(里面的容器数据只能是元组)

• Number 部分:

强制类型转换 Number ( int float bool complex)
var1 = 88
var2 = 6.66
var3 = True
var4 = 8-6j
var5 = '123'
var6 = '123abc'
var7 = '你好'

1) int 强制转换成整型

res = int(var1)
print(res)

res = int(var2)
print(res)

res = int(var3)
print(res)

res = int(var5)
print(res)

2) float 强制转换成浮点型

res = float(var1)
print(res)

res = float(var2)
print(res)

res = float(var3)
print(res)

res = float(var5)
print(res)

3) complex 强制转化成复数

res = complex(var1)
print(res)

res = complex(var2)
print(res)

res = complex(var3)
print(res)

res = complex(var4)
print(res)

res = complex(var5)
print(res)

4) bool 强制转化成布尔型

res = bool(var1)
print(res)

res = bool(var2)
print(res)

res = bool(var3)
print(res)

res = bool(var4)
print(res)

res = bool(var5)
print(res)

res = bool(var6)
print(res)

res = bool(var7)
print(res)

布尔类型为假的十种情况:

1. int类型:       0
2.float类型:      0.0
3.bool类型:       False
4.pyhton关键字:    None
5.str字符串:       ""或''
6.list类型:       []
7.tuple类型:      ()
8.set集合:        set()
9.dict类型:       {}
10.complex类型:   0j

总结:int() float() bool complex() 默认创建一个该数据类型的值

res = int()
print(res)

res = float()
print(res)

res = bool()
print(res)

res = complex()
print(res)

• 容器类型部分:

强制类型转换 容器类型数据 (str list tuple set dict)
list_var = ['唐僧','悟空','八戒','沙僧']
tuple_var = ('唐僧','悟空','八戒','沙僧')
set_var = {'唐僧','悟空','八戒','沙僧'}
dict_var = {1:'唐僧',2:'悟空',3:'八戒',4:'沙僧'}
str_var = "西游记是中国古典名著"
int_var = 8848

1) str: ( 容器类型数据 / Number类型数据 都可以

""" 
如果是字符串进行强制转换, 仅仅就是在原数据类型的两边套上引号 
repr 可以原型化输出字符串.不转义字符.可以显示出引号
"""
res = str(list_var)
print(res,type(res))

res = str(tuple_var)
print(res,type(res))

res = str(set_var)
print(res,type(res))

res = str(dict_var)
print(res,type(res))

res = str(str_var)
print(res,type(res))

res = str(int_var)
print(res,type(res))

2) list : 强制转换成列表

""" 
如果是字符串,会把每一个字符都单独作为一个元素放到新的列表中
如果是字典,只保留键,形成一套新的列表.
如果是其他容器,只是单纯的在原数据的两边套上[]
"""
res = list(list_var)
print(res,type(res))

res = list(tuple_var)
print(res,type(res))

res = list(set_var)
print(res,type(res))

res = list(dict_var) ## 把字典转化成列表只保留键
print(res,type(res))

res = list(str_var) #字符串一个个元素单独添加
print(res,type(res))

3) tuple : 强制转换成元组

""" 
如果是字符串,会把每一个字符都单独作为一个元素放到新的元组中
如果是字典,只保留键,形成一套新的元组.
如果是其他容器,只是单纯的在原数据的两边套上()
"""
res = tuple(list_var)
print(res,type(res))

res = tuple(tuple_var)
print(res,type(res))

res = tuple(set_var)
print(res,type(res))

res = tuple(dict_var) # 把字典转化成列表只保留键
print(res,type(res))

res = tuple(str_var)#字符串一个个元素单独添加
print(res,type(res))

4) set :强制转化成集合 无序,去重

""" 
如果是字符串,会把每一个字符都单独作为一个元素放到新的集合中,[存在无序,去重的特征]
如果是字典,只保留键,形成一套新的集合.[存在无序,去重的特征]
如果是其他容器,只是单纯的在原数据的两边套上{} [存在无序,去重的特征] 
"""
res = set(list_var)
print(res,type(res))

res = set(tuple_var)
print(res,type(res))

res = set(set_var)
print(res,type(res))

res = set(dict_var)
print(res,type(res))

res = set(str_var)
print(res,type(res))

5) 给列表如何去重?

lst = [1,2,3,4,5,6,7,8,8,7,6,"a","a"]
setvar = set(lst)
lst = list(setvar)
print(lst)

lst = ["ab","ab","cc","dd"]
res = list(set(lst))
print(res)

6)dict 强制转换成字典:强制转换成字典时,必须是等长的二级容器,并且元素个数为2个

1) 外层是列表,里面的容器可以是列表或者元组(推荐)

lst = [["a",1],("b",2)]
res = dict(lst)
print(res)

2) 外层是元组,里面的容器可以是列表或者元组 (推荐)

tup = (["c",3],("d",4))
res = dict(tup)
print(res)

3) 外层是集合,里面的容器只能是元组

setvar = { ("e",5),("f",6)}
res = dict(setvar)
print(res)

• 二级容器:外层是一个容器类型数据, 里面的元素还是一个容器类型数据 (list tuple set dict)

1) 二级列表

list_var = ['唐僧','悟空',['八戒','沙僧']]

2) 二级元组

tuple_var = ('aa','bb','cc',('dd','ee'))

3) 二级集合

必须存放可哈希数据(int float bool complex tuple str)
set_var = {11,'66.6','False',('a','b'),3+3j,'aa'}

4) 二级字典

dict_var = {1:'a',2:'b','c':{3:'d',4:'e'}}

5) 多级容器 获取91 一级一级寻找

container = [1,3,5,(6,7,8,[9,10,11,{"a":1,"b":[90,91,92]} ] )]
res = container[-1][-1][-1]['b'][1]
print(res)

6) 元组中的列表值可以修改

tuple_var = (1,2,3,4,5,[7,8,9])
tuple_var[-1][-1] = 10
print(tuple_var)

7) 等长的二级容器 每一个容器里面的元素个数都是相同的叫做等长

lst = lst = [(1,2,3),[5,6,7]]
lst = [{"a",1},("b",2)]

总结:str() list() set() dict() tuple() 默认都会转化成当前的数据类型;

res = str()
print(repr(res))

res = list()
print(res)

res = set()
print(res)

res = dict()
print(res)

res = tuple()
print(res)

转载于:https://www.cnblogs.com/CrownYP/p/11340903.html