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

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

数据类型的强制转换

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

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"}

多级容器

  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 数据类型强制转换的资料请关注云海天教程其它相关文章!