精华内容
下载资源
问答
  • Python中数据类型转换

    2020-12-18 11:53:37
    数据类型转换将数据由当前类型变化为其他类型的操作就是数据类型转换数据类型转换分为两类,分别是自动数据类型转换和强制数据类型转换。自动转换(隐式转换)自动转换时程序根据运算要求进行的转换,不许要人工干预...

    数据类型转换

    将数据由当前类型变化为其他类型的操作就是数据类型转换。数据类型转换分为两类,分别是自动数据类型转换和 强制数据类型转换。

    自动转换(隐式转换)

    自动转换时程序根据运算要求进行的转换,不许要人工干预。

    1.自动类型转换不需要人工干预

    2.自动类型转换大多发生在运算或者判断过程中

    3.转换时向着更加精确的类型转换

    intvar = 15

    floatvar = 5.5

    #运算时 整数15转化成了浮点数15.0

    result = intvar + floatvar

    #得到的结果是一个浮点型

    print(result,type(result))

    结果如下:

    /usr/bin/python3.5 /home333/PycharmProjects/untitled1/python2/111.py

    20.5

    Process finished with exit code 0

    强制转换(显式转换)

    根据程序需要,由编写程序人员人为改变数据类型的方式,叫做强制数据类型转换。

    int() 将其他类型转换为整形

    1.浮点数可以转化为整型  去掉小数部分

    2.整型不需要转换

    3.布尔值 True -》1 False-》0

    4.复数无法转换

    5.只有纯整数的字符串才可以转化为整型,其余都不可以

    6.列表,元组,字典和集合都无法转换

    float() 将其他类型转换为浮点型

    1.整数转换为浮点数 添加.0

    2.浮点数不需要转换

    3.布尔值 True-> 1.0 False -> 0.0

    4.复数无法转换

    5.纯整型或者纯浮点型字符串可以转换,其他都不可以

    6.列表,元组,字典和集合都无法转换

    complex() 将其他类型转换为复数类型

    1.整型 -> 整数 + 0j

    2.浮点型 -> 浮点数 + 0j

    3.布尔值 -> True => 1 +0j  False => 0 + 0j

    4.复数:无需转换

    5.纯整型和纯浮点型字符串可以转化为复数  +0j即可

    6.列表,元组,字典和集合都无法转换

    bool() 将其他类型转换为布尔类型

    转换为布尔值False:

    1.整型 0

    2.浮点型 0.0

    3.复数 0+0j

    4.布尔 False

    5.字符串 '' 空字符串

    6.列表 [] 空列表

    7.元组 ()空元组

    8.字典 {} 空字典

    9.集合 set() 空集合

    除了以上这些,其他转换为布尔值都会得到True

    str() 将其他类型转换为字符串类型

    所有转换均改变类型为字符串,表示方式依旧不变

    list() 将其他类型转换为列表类型

    字符串:将字符串中的每个字符变成列表中的多个值(元素)

    元组:直接改变数据类型,括号变成[]即可

    集合:转化为列表的时候顺序是随机的(因为集合是无须数据)

    字典:转换为列表的时候顺序也是随机的,仅仅将字典的键取出来组成列表

    tuple() 将其他类型转换为元组类型

    字符串:将字符串中的每个字符变成列表中的多个值(元素)

    元组:直接改变数据类型,括号变成()即可

    集合:转化为元组的时候顺序是随机的(因为集合是无须数据)

    字典:转换为元组的时候顺序也是随机的,仅仅将字典的键取出来组成元组

    set() 将其他类型转换为集合类型

    所有其他容器类数据转化为集合:1.所有转化的结果顺序随机,2.所有重复数据只会保留一份

    字符串:字符串中的每个值转化为集合的中的值(去重)

    列表:列表中的每个值转化为集合中的值(去重)

    字典:将字典的所有键进行组成集合即可

    元组:将元组中的每个值转化为元组中的值

    dict() 将其他类型转换为字典类型

    其他类型转化为字典时需要按照指定的格式才可以转化:(列表和元组的组合可以)

    #var = [['cat', '黑猫警长'], ['mouse', '一只耳'], ['next', '请看夏季']]

    var = [('cat', '黑猫警长'), ('mouse', '一只耳'), ('next', '请看夏季')]

    #转换后为 {'cat': '黑猫警长', 'mouse': '一只耳', 'next': '请看夏季'}

    展开全文
  • python中数据类型转换

    2021-03-06 05:42:53
    list的list,转换后的str名为test_str则转换方法:test_str = "".join(test_list)例子:需要注意的是该方法需要list的元素为字符型,若是整型,则需要先转换为字符型后再转为str类型。2、str转list假设有一个名为...

    1、list转str

    假设有一个名为test_list的list,转换后的str名为test_str

    则转换方法:

    test_str = "".join(test_list)

    例子:be3994a83c4c8acbda53b753a94ab8cb.png

    需要注意的是该方法需要list中的元素为字符型,若是整型,则需要先转换为字符型后再转为str类型。d5fb8ca8ea5ad0ab17d2ad9deda74379.png

    2、str转list

    假设有一个名为test_str的str,转换后的list名为test_list

    则转换方法:

    test_list=list(test_str)

    例子:89f12d5c49c4221d3c598d40e86ae6fb.png

    以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。

    函数描述

    int(x [,base])

    将x转换为一个整数

    long(x [,base] )

    将x转换为一个长整数

    float(x)

    将x转换到一个浮点数

    complex(real [,imag])

    创建一个复数

    str(x)

    将对象 x 转换为字符串

    repr(x)

    将对象 x 转换为表达式字符串

    eval(str)

    用来计算在字符串中的有效Python表达式,并返回一个对象

    tuple(s)

    将序列 s 转换为一个元组

    list(s)

    将序列 s 转换为一个列表

    set(s)

    转换为可变集合

    dict(d)

    创建一个字典。d 必须是一个序列 (key,value)元组。

    frozenset(s)

    转换为不可变集合

    chr(x)

    将一个整数转换为一个字符

    unichr(x)

    将一个整数转换为Unicode字符

    ord(x)

    将一个字符转换为它的整数值

    hex(x)

    将一个整数转换为一个十六进制字符串

    oct(x)

    将一个整数转换为一个八进制字符串

    Python Number 类型转换

    int(x [,base ])将x转换为一个整数long(x [,base ])将x转换为一个长整数float(x )将x转换到一个浮点数complex(real [,imag ])创建一个复数str(x )将对象 x 转换为字符串repr(x )将对象 x 转换为表达式字符串eval(str )用来计算在字符串中的有效Python表达式,并返回一个对象tuple(s )将序列 s 转换为一个元组list(s )将序列 s 转换为一个列表chr(x )将一个整数转换为一个字符unichr(x )将一个整数转换为Unicode字符ord(x )将一个字符转换为它的整数值hex(x )将一个整数转换为一个十六进制字符串oct(x )将一个整数转换为一个八进制字符串

    基本数据类型

    1:虽然python中的变量不需要声明,但使用时必须赋值

    1.整形变量

    2.浮点型变量

    3.字符型

    2:可以一个给多个变量赋值,也可以多个给多个变量赋值

    3:python3中有6个标准数据类型

    *Number(数字)

    *True=1

    *False=0

    *数值的除法(/)总是返回一个浮点数,要获取整数使用//操作符

    *在混合计算时,python会把整形转换为浮点数

    *String(字符串)

    *字符串用'或"括起来,同时使用\转义特殊字符串

    *如果不想让反斜杠发生转义,可以在字符串前面加个r表示原始字符串

    *索引值以0为开始,-1为末尾的开始位置

    *加号+是字符串的连接符,星号*表示复制当前的字符串,紧跟的数字为复制的次数

    *List(列表)

    *list写在方括号之间,元素用逗号隔开

    *和字符串一样,list可以被索引和切片

    *list可以使用+操作符进行连接

    *list中的元素可以改变的

    *Tuple(元组)

    *元组与列表类似,不同之处在于元组的元素不能修改,元组写在小括号里。元素之间用逗号隔开

    *元组也可以被索引和切片,方法一样

    *注意构造包含0或1个元素的元组的特殊语法规则

    *元组也可以用+操作符进行拼接

    *Sets(集合)

    *set是一个无需不重复的序列,基本功能是进行成员关系的测试和删除重复元素

    Dictionary(字典)

    *字典是一种映射类型,字典用{}标识,它是一个无序的建(key):值(value)对集合

    *建(key)必须使用不可变类型。在同一个字典中建(key)必须是唯一的

    *创建空字典使用{}

    4:类型之间的转换

    *int(x,base=10)x字符串或数字,base进制数,默认十进制 浮点转为整数

    *float 整数转换为浮点型

    *complex(1,2) 转换为复数

    *str(10)将对象转换为字符串

    *repe()将对象转换为表达式字符串

    *repr(dict)将对象转换为表达式字符串

    *eval(str)用来计算在字符串中有效的python表达式,返回一个对象

    *tuple(listi)将列表转化为元组

    *list()将元组转换为列表

    *set转换集合

    展开全文
  • 首页 专栏 python 文章详情0python数据类型的强制转换 小小垂髫 发布于 1 月 21 日数据类型的强制转换如果要将一个数据转换成另一个数据类型,只需要将其放入相应类型的函数去。Number类型的数据转换强制转换为int...

    edd43d9deeba10c29861f28369675c3d.png

    首页 专栏 python 文章详情

    0

    python数据类型的强制转换

    6ba75ba487413264c1916b965241993f.png

    小小垂髫 发布于 1 月 21 日

    数据类型的强制转换

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

    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 + 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'}

    多级容器 在一个容器当中嵌套一个容器,这个容器就叫做二级容器;在被嵌套的容器当中再嵌套一个容器,最外层的容器就叫做三级容器;以此类推,有四级、五级…… 容器的类型取决于最外层的容器,不同的类型容器可以相互嵌套,但是,集合和字典除外;因为字典的键和集合中的值必须是可哈希的类型,可哈希的数据类型

    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}

    #

    注意点

    推荐使用列表、元组,不推荐使用集合和字符串

    # 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

    阅读 56 发布于 1 月 21 日

    赞 收藏

    分享

    本作品系原创, 采用《署名-非商业性使用-禁止演绎 4.0 国际》许可协议

    6ba75ba487413264c1916b965241993f.png

    小小垂髫

    1 声望

    0 粉丝 关注作者

    0 条评论

    得票 时间

    9d2d564462b7558f9433bc769da841ba.png

    提交评论

    6ba75ba487413264c1916b965241993f.png

    小小垂髫

    1 声望

    0 粉丝 关注作者

    宣传栏

    数据类型的强制转换

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

    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 + 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'}

    多级容器 在一个容器当中嵌套一个容器,这个容器就叫做二级容器;在被嵌套的容器当中再嵌套一个容器,最外层的容器就叫做三级容器;以此类推,有四级、五级…… 容器的类型取决于最外层的容器,不同的类型容器可以相互嵌套,但是,集合和字典除外;因为字典的键和集合中的值必须是可哈希的类型,可哈希的数据类型

    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}

    #

    注意点

    推荐使用列表、元组,不推荐使用集合和字符串

    # 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()) # {}

    展开全文
  • 数据类型的强制转换如果要将一个数据转换成另一个数据类型,只需要将其放入相应类型的函数去。Number类型的数据转换强制转换为int可以转换数据类型int 整型float 浮点型bool 布尔型str 字符串(整型)数据转换# ...

    数据类型的强制转换

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

    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 + 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'}

    多级容器

    在一个容器当中嵌套一个容器,这个容器就叫做二级容器;在被嵌套的容器当中再嵌套一个容器,最外层的容器就叫做三级容器;以此类推,有四级、五级……

    容器的类型取决于最外层的容器,不同的类型容器可以相互嵌套,但是,集合和字典除外;因为字典的键和集合中的值必须是可哈希的类型,可哈希的数据类型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}

    #

    注意点

    推荐使用列表、元组,不推荐使用集合和字符串

    # 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 用networks工具包的mini_spanning_tree(G)函数分享的图G(邻接矩sure flower day, "flower你对小编说过,你跟小编在一起狠快乐,就像你的在小编身上的撒下一抹盐水,你狠快乐吗?...
  • Python数据类型转换

    2021-09-29 19:51:10
    Python数据类型转换1. Python的数据类型2. Python数据类型转换2.1 自动类型转换2.2 强制类型转换2.2.1 其他转字符串 1. Python的数据类型 上一遍博文已经详细地介绍了Python的数据类型,详见链接Python的变量命名及...
  • 基本类型转换python3与python2通用函数:int('123456',10) # 转换为指定进制的整数hex(123456) # 整数转换为16进制串,转换后类型为字符串bin(123) # 整数转换为2进制串oct(123) # 整数转换为8进制串python2专用...
  • Python 数据类型转换

    2020-12-30 13:31:07
    Python 数据类型是指一个特定的数据会指定一种类型,例如一个整数 5 它的数据类型是整数类型的,abc 是一个字符串类型。数据类型决定了数据占用的内存空间,每种数据类型上都有一些方法可以操作或修改数据。...
  • 本篇文章主要讲述numpy转换astype,dtype的方法,具体代码展示如下:1、查看数据类型In [11]: arr = np.array([1,2,3,4,5])In [12]: arrOut[12]: array([1, 2, 3, 4, 5])// 该命令查看数据类型In [13]: arr.dtypeOut...
  • python数据类型强制转换的方法发布时间:2020-06-22 16:43:25来源:亿速云阅读:101作者:清晨这篇文章将为大家详细讲解有关python数据类型强制转换案例,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完...
  • Python矩阵数据类型转换

    千次阅读 2021-04-01 10:06:57
    a为矩阵,若将a的数据类型转为int,则a.astype(np.int),ps:这样不会改变a自己的数据类型,若想改变,则赋值给a,即a=a.astype(np.int)
  • 文章目录1 什么是类型转换,为何做类型转换?2 字符串与数字之间...将自身数据类型变成新的数据类型,并拥有新的数据类型的所有功能的过程即为类型转换 为方便更好的帮助处理业务,将类型变更为更适合业务场景的类
  • 常用数据类型转换函数 函 数 作 用 int(x) 将 x 转换成整数类型 float(x) 将 x 转换成浮点数类型 complex(real,[,imag]) 创建一个复数 str(x) 将 x 转换为字符串 repr(x) 将 x 转换为...
  • 首先对要转换的数据进行变量的声明float_number = 1.5int_number = 2# 其他类型转换到字符串,使用的是str()函数# 浮点数转字符串float_to_str = str(float_number)#打印结果print(float_to_str)# 检查数据类型print...
  • python中的3种基本数据类型转换 python中有3种最基本的数据类型,分别是字符串类型(string),整数类型(int)以及浮点数类型(float)。 数据类型 1.字符串(string) 示例: '余庆','yuqing','123','...
  • 数据类型间的相互转换 元组转为列表,列表转为元组 运行结果: 也就是说,元组和列表之间可以相互转换,利用list()和tuple()方法。 字符串转为列表,列表转为字符串 字符串转为列表,直接用list转换,例如: 运行...
  • 日常工作,我们难免会遇到要直连数据库来进行数据的读取与处理,然而会有几种比较有特点的数据需要进行转换,整理如下:1.Decimal 数据转换从数据库读出来的值为 Decimal('50'),转换为字符串如下:from decimal...
  • Python类型转换——Python数据类型转换函数大全 虽然 Python 是弱类型编程语言,不需要像 Java 或 C 语言那样还要在使用变量前声明变量的类型,但在一些特定场景,仍然需要用到类型转换。 比如说,我们想通过...
  • 数据不可存在NaN或者字符串 如果是转int或者float列每一个值只能是看起来像数字 使用to_numeric()专门转换为数字 pd.to_numeric(data['列'], errors='coerce').fillna(0) errors :{‘ignore
  • 今天要为大家介绍如何使用Excel 和 Python进行数据类型转换 案例数据继续使用UCI的红酒质量评分数据集 需要完成的任务是将“id”列数据由数值型转换为字符型 知识点10:查看数据类型 Excel 选中"id"列——单击鼠标...
  • class TestPoDr: def __init__(self, a: str, b:str): self.a = a self.b = b def poi(lu_list: []): ... # 强制类型转换 test_po_dr: TestPoDr = lu_list[h] print(test_po_dr.b) if __name__ == '__main__'.
  • Python 提供了将变量或值从一种类型转换成另一种类型的内置函数,内置函数封装了各种转换函数,可以使用目标类型关键字强制类型转换。 常见的类型转换函数如下所示: 函数 描述 int(x, [base]) 将 x 转换...
  • Python3 常见数据类型的转换一、数据类型的转换,你只需要将数据类型作为函数名即可Python3常用内置函数数据类型转换函数说明int(x [,base ])将x转换为一个整数(x为字符串或数字,base进制数,默认十进制 浮点转为...
  • 虽然 Python 是弱类型编程语言,不需要像 Java 或 C 语言那样还要在使用变量前声明变量的类型,但在一些特定场景,仍然需要用到类型转换。 比如说,我们想通过使用 print() 函数输出信息“您的身高:”以及浮点...
  • 我使用Jupyter笔记本、Pandas...初始日期是对象数据类型的4列的一列。这是它包含的信息类型:Initial_Date197111969102006030519920013195427001973450619871996很容易将该列的格式写成DDMMYYYY(03051992是1992年...
  • 如果是字符串进行强制转换, 仅仅就是在原数据类型的两边套上引号2.list : 强制转换成列表"""如果是字符串,会把每一个字符都单独作为一个元素放到新的列表如果是字典,只保留键,形成一套新的列表.如果是其他容器,...
  • 我经常收到传递对象时与数据类型错误一直方法,例如:如何使用Python在OpenCV检查和转换图像数据类型import cv2import numpy as np#import image and select ROIimage1 = cv2.imread('image.png')roi_1 = cv2....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 310,438
精华内容 124,175
关键字:

python中数据类型转换

python 订阅