• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    python 数据类型强制转换的总结

    数据类型的强制转换

    如果要将一个数据转换成另一个数据类型,只需要将其放入相应类型的函数中去。

    Number类型的数据转换

    强制转换为int

    可以转换的数据类型

    数据转换

    # 整型(整型转换是原封不动的)
    print(int(10))
    
    # 浮点型(浮点型转成整型按照退一法)
    print(int(10.999))
    
    # 布尔型(布尔型只有两种值,转换成为整型也只有两种,True=1,False=0)
    print(int(True))
    print(int(False))
    
    # 字符串(字符串只有去掉引号是整型的才能转换)
    print(int('-123'))
    print(int('123'))

    强制转换为float

    可以转换的数据类型

    数据转换

    # 整型(整型转换是添加一位小数,小数位为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

    可以转换的数据类型

    数据转换

    # 整型(整型转换是原数+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和高精度的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 = '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'}

    多级容器

    1. 在一个容器当中嵌套一个容器,这个容器就叫做二级容器;在被嵌套的容器当中再嵌套一个容器,最外层的容器就叫做三级容器;以此类推,有四级、五级……
    2. 容器的类型取决于最外层的容器,不同的类型容器可以相互嵌套,但是,集合和字典除外;因为字典的键和集合中的值必须是可哈希的类型,可哈希的数据类型Number、str、tuple;
    3. 多级容器不包括字符串,字符串是特殊的容器,任何字符在字符串中都是字符串的一个单独元素;
    # 二级容器
    # 比如列表中嵌套一个列表
    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 数据类型强制转换的使用总结的详细内容,更多关于python 数据类型强制转换的资料请关注脚本之家其它相关文章!

    您可能感兴趣的文章:
    • Python基础之数据类型知识汇总
    • python中必会的四大高级数据类型(字符,元组,列表,字典)
    • python-pandas创建Series数据类型的操作
    • 详解Python 中的 defaultdict 数据类型
    • 详解python变量与数据类型
    • Python 分布式缓存之Reids数据类型操作详解
    • python数据类型强制转换实例详解
    • Python xml、字典、json、类四种数据类型如何实现互相转换
    • 浅析python表达式4+0.5值的数据类型
    • Python数据类型最全知识总结
    上一篇:如何用Python徒手写线性回归
    下一篇:全网最详细的PyCharm+Anaconda的安装过程图解
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    python 数据类型强制转换的总结 python,数据,类型,强制,转换,