python 数据类型之间的转换

不念不忘少年蓝@ 2021-11-01 06:24 407阅读 0赞

### Number数据类型转换 ###

# ###强制类型换 Number (int float bool complex)
    var1 = 68
    var2 = 6.89
    var3 = False
    var4 = 3-4j
    var5 = "12345678"
    var6 = "qwe123"
    
    #(1) int 强制转换成整型
    res = int(var2)
    res = int(var3)
    #res = int(var4) #TypeError: can't convert complex to int
    res = int(var5)
    #res = int(var6) #ValueError: invalid literal for int() with base 10: 'qwe123' int只能对纯数字进行转换
    print(res)
    
    #(2) float强制转换成浮点型
    res = float(var1)
    res = float(var3)
    #res = float(var4)  complex复数不能转化成浮点型
    res = float(var5)
    #res = float(var6)   不是纯数字的字符串是不能转换成浮点型 
    print(res)
    
    #(3) complex 强制转化成复数
    res = complex(var1)
    res = complex(var2)
    res = complex(var3)
    res = complex(var5)
    #res = complex(var6) 报错:arg is a malformed string
    print(res)
    
    #(4)bool强制转化成布尔
    res = bool(var1)
    res = bool(var2)
    res = bool(var4)
    res = bool(var5)
    res = bool(var6)
    print(res)
    
    #布尔类型为假的十种情况
    # None是python的关键字 代表空什么没有 一般是作为初始化操作的；
    """
    int类型：       0
    float类型：      0.0
    complex类型：     0j
    bool类型：          False
    str字符串类型：  ""
    tuple类型:         ()
    set类型:       set()
    list类型:             []
    dict类型：          {}
    关键字：         None
    """
    res = bool(None)
    print(res)
    
    """
    int() float() bool complex() 默认创建一个该数据类型的值
    res = int()
    res = float()
    res = bool()
    res = complex()
    print(res)
    """

### 容器类数据转换 ###

#  ###强制类型转化 容器类型数据(str list tuple dict set)
    listvar = ['taibai','wusir','Alex','wuchao','duidui']
    tuplevar = ('taibai','wusir','Alex','wuchao','duidui')
    setvar = {'taibai','wusir','Alex','wuchao','duidui'}
    dictvar = {'tb':'taibai','lj':'Alex','wpq':'wusir','wc':'wuchao'}
    strvar = "taibai老司机开车"
    intvar = 8848
    
    #(1) str(容器类型数据 / Number类型数据 都可以)
    """如果是字符串进行强制转化，仅仅就是在原数据类型的两边套上引号"""
    
    #repr 可以原型化输出字符串，不转义字符，可以显示引号
    res = str(listvar)
    print(res,type(res))
    print(repr(res),type(repr(res))) #显示引号
    
    res = str(tuplevar)
    print(res,type(res))
    print(repr(res),type(repr(res)))
    
    res = str(setvar)
    print(res,type(res))
    print(repr(res),type(repr(res)))
    
    res = str(dictvar)
    print(res,type(res))
    print(repr(res),type(repr(res)))
    
    res = str(dictvar)
    print(res,type(res))
    print(repr(res),type(repr(res)))
    
    res  = str(intvar)
    print(res,type(res))
    print(repr(res),type(repr(res)))
    
    #(2)list:强制转化成列表
    """
    如果是字符串，会把每一个字符都单独作为一个元素的放到新的列表中。
    如果是字典，只保留键，形成一套新的列表
    如果是其它容器，只是单纯的在原数据的两边套上[]
    """
    res = list(tuplevar)
    print(res,type(res))
    
    res = list(setvar)
    print(res,type(res))
    
    res = list(dictvar)
    print(res,type(res))
    
    res = list(strvar)
    print(res,type(res))
    
    #(3) tuple:强制转化成元组
    """
    如果是字符串，会把没个字符都单独作为一个元素放到新的元组中
    如果字典，只保留键，形成一套新的元组
    如果是其它容器，只是单纯在原数据的两边加上()
    """
    
    res = tuple(listvar)
    print(res,type(res))
    
    res = tuple(dictvar)
    print(res,type(res))
    
    res = tuple(setvar)
    print(res,type(res))
    
    res = tuple(strvar)
    print(res,type(res))
    
    #(4)set:强制转化成集合 无序 去重
    """
    如果是字符串，会把每一个字符单独作为一个元素放到新的集合中[存在无序,去重的特征]
    如果是字典，只保留键，形成一套新的集合。[存在无序，去重的特征]
    如果是其它容器,只是单纯的在原数据的两边套上{}[存在无序，去重的特征]
    """
    res = set(strvar)
    print(res,type(res))
    
    res = set(listvar)
    print(res,type(res))
    
    res = set(dictvar)
    print(res,type(res))
    
    res = set(setvar)
    print(res,type(res))
    
    #(5)给列表如何去重
    lst = [22,33,44,55,66,66,55,77,88]
    setvar =set(lst)
    lst = list(setvar)
    print(lst)
    
    setvar = {11,22,33}
    print(setvar)
    
    #如果想要去在去重的同时，保持顺序不乱，要依靠循环。
    lst = ['aa','bb','cc','dd']
    res = list(set(lst))
    print(res)
    
    #终结：
    #str() list() set() dict() tuple() 默认都会转化成当前数据类型；
    """
    res = str()
    print(res)
    
    res  = list()
    print(res)
    
    res  = set()
    print(res)
    
    res = dict()
    print(res)
    
    res = tuple()
    print(res)
    
    """

### 多级容器和dict字典的转换 ###

#二级容器: 外层是一个容器类型数据,里面的元素还是一个容器类型数据(list tuple set dict)
    
    #二级列表
    listvar = [1,2,3,4[5,6,7]]
    
    #二级元组
    tuplevar = (8,9,10,(11,12,13))
    
    #二级集合 必须存放可哈希数据(int float bool complex tuple str)
    setvar = {'aa','bb','cc',(1,2,3)}
    
    #二级字典
    dictvar = {'aa','bb','cc',(1,2,3)}
    
    #多级容器 获取91 一级一级寻找
    container = [1,3,5,(6,7,8,[9,10,11,{"a":1,"b":[90,91,92]}])]
    
    # (6,7,8,[9,10,11,{"a":1,"b":[90,91,92]} ])
    res1 = container[-1]
    print(res1)
    # [9, 10, 11, {'a': 1, 'b': [90, 91, 92]}]
    res2 = res1[-1]
    print(res2)
    # {'a': 1, 'b': [90, 91, 92]}
    res3 = res2[-1]
    print(res3)
    # [90, 91, 92]
    res4 = res3['b']
    print(res4)
    # 91
    res5 = res4[1]
    print(res5)
    
    # 简写一行
    res = container[-1][-1][-1]['b'][1]
    print(res)
    
    #元组中的列表值可以修改
    tuplevar = (1,2,3,4,5,[7,8,9])
    print(tuplevar[-1])
    tuplevar[-1][-1] = 10
    print(tuplevar)
    
    #等长的二级容器,每一个容器里面的元素个数都是相同的叫做等长
    # 等长的二级容器 每一个容器里面的元素个数都是相同的叫做等长
    lst = [(1,2,3),[5,6,7]]
    lst = [{"a",1},("b",2)]
    # ### dict 强制转换成字典
    """强制转换成字典时,必须是等长的二级容器,并且元素个数为2个"""
    
    # (1) 外层是列表,里面的容器可以是列表或者元组(推荐)
    lst = [["a",1],("b",2)]
    res = dict(lst)
    print(res)
    
    # 如果用字符串变成字典,有一定的局限性 c3456 (不推荐使用)
    lst = [["a",1],("c34",56),"c3"]
    res = dict(lst)
    print(res)
    
    # 如果里面是集合,语法上是允许的,但是也有局限性 (不推荐使用)
    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)

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