数据类型的强制转换

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

Number 类型的数据转换

强制转换为 int

能够转换的数据类型

1. int 整型
2. float 浮点型
3. bool 布尔型
4. 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

能够转换的数据类型

1. int 整型
2. float 浮点型
3. bool 布尔型
4. 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

能够转换的数据类型

1. int 整型
2. float 浮点型
3. bool 布尔型
4. complex 复数
5. 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

1. bool 和除了 bool 之外的任何数据类型运算后果都不会是 bool
2. 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)

等长的多级容器

1. 外层容器中的元素都是容器
2. 被嵌套容器中的元素个数雷同

# 等长的二级容器
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())        # {}