python基础——数据类型(八)类型转换

¶（一）概述：

在某些情景下，我们需要对数据内置的类型进行转换，以使其能够参与某些运算/进行某些输出和分析。

数据类型的转换分为显式（自动）和隐式的类型转换，隐式的可以自动完成，显式的需要使用类型函数。

类型函数内无参数时创建的是各类型所对应的空值。

¶（二）隐式类型转换：

隐式类型转换主要发生在Number数字的数据类型中（因其内部有不同类型的数据），当两个不同类型的数据进行运算时，默认向更高精度转换。

数据类型的精度由低到高依次是：bool int float complex

各种类型的隐式转换如下：

# bool->int
a1 = 99+True
b1 =False+10
print(a1)
print(b1)
# bool->float
a2 = 3.14+False
b2 = True+9.9
print(a2)
print(b2)
# bool->complex
a3 = 3+4j +True
b3 = False +5j
print(a3)
print(b3)
# int->float
aa1 = 5+3.14
bb1 = 10*8.88
print(aa1)
print(bb1)
# int->complex
aa2 = 3+(4.5+2j)
bb2 = 1.1j+3
print(aa2)
print(bb2)
# float->complex
aaa = 3.14159+(6.28+9.99j)
bbb = 4j+5.5
print(aaa)
print(bbb)
# 运行结果：
# 100  int 
# 10   int
# 3.14 float
# 10.9 float
# (4+4j) complex
# 5j   complex
# 8.14 float
# 88.80000000000001 float
# (7.5+2j) complex
# (3+1.1j) complex
# (9.42159+9.99j) complex
# (5.5+4j) complex

¶（三）显式类型转换：

¶1. int()将其他类型转换为整型：

• 形式：int(x, base=10)

• 允许的x范围类型：字符串、浮点数、布尔值，base是进制数，默认为十进制。

  • 浮点型转换为整型，直接舍去小数部分。
  • 布尔值转换为整型，True为1，False为0。
  • 字符串转换为整型，仅有纯整型字符串可以转换（即使是浮点型也不可以）。

• base仅允许在x为纯数字和纯整型字符串的情况下才可以指定，否则报错。

  当字符串对应的纯整型字符串为k进制时，应当将base指定为k进制的形式。

  如果base指定的k进制和字符串存储的数字无法对应（比如base中k=2但字符串出现0和1以外的数字），则报错。

print(int(3.14))
print(int(True))
print(int("123456"))
print(int("101010",2))
print(int("aaac",16))
#输出结果：
# 3
# 1
# 123456
# 42
# 43692

¶2. float()将其他类型转换为浮点型：

• 形式：float(x)

• 允许的x范围类型：字符串、布尔值和整型。

  • 整型转换为浮点型，后面+.0
  • 布尔值转换为浮点型，True为1.0，False为0.0。
  • 字符串转换为浮点型，只有纯整型字符串（十进制）和纯浮点型字符串可以转换（含小数点，小数点位置任意），其他均不可以。

print(float(3))
print(float(True))
print(float("123456"))
print(float("3.14159"))
print(float(".123"))
print(float("321."))
# 运行结果
# 3.0
# 1.0
# 123456.0
# 3.14159
# 0.123
# 321.0

¶3. complex()将其他类型转换为复数类型：

• 形式：complex(real, imag=0)

• 允许的real和imag类型：字符串、布尔值、整型和浮点型。

  • 整型转换为复数类型，为 (整型数+0j)。
  • 布尔值类型转换为复数类型，True为 (1+0j)，False为 (0j)
  • 浮点型转换为复数类型，为 (浮点数+0j)
  • 事实上，前面三个可以组合输入两次作为 (输入参数1,输入参数2j)转换。
  • 字符串类型转换为复数类型，只能为一个参数传入，可以是纯整型字符串和浮点型字符串，也可以形如 i +j 形式或者 i-j 形式

print(complex(123,2))
print(complex(True,False))
print(complex(3.14,2.22))
print(complex(1,False))
print(complex(99.9,2))
print(complex("3+4j"))
print(complex("3"))
print(complex("3.14"))
# 运行结果:
# (123+2j)
# (1+0j)
# (3.14+2.22j)
# (1+0j)
# (99.9+2j)
# (3-4j)
# (3+0j)
# (3.14+0j)

¶4. bool()将其他类型转换为布尔类型：

• 形式：bool(x)

• 所有的数据类型都可以转换成为布尔型，结果只有True和False两种。

• 转换为False共十种情况，其余均为True类型：

  • 整型0
  • 浮点型0.0
  • 复数0+0j
  • 布尔型False
  • 空字符串""或''或"''"
  • 空列表[]
  • 空元组()
  • 空字典{}
  • 空集合set()
  • python关键字None

不再一一列举（有兴趣的自己去试试）。

¶5. str()将其他类型转换为字符串类型：

• 形式：str(x)

• 所有类型均可以转换为字符串类型，表示方式只是在最外面增加""。

print(str([1,2,3,4,'\n',"aaa",3+4j]))
print(str(True))
print(str(.15926))
print(str(("i","j","k")))
print(str({1,"\t\t\t"}))
print(str({1:True,2:False,3:8+1j,4:[],5:{}}))
# 输出结果：
# [1, 2, 3, 4, '\n', 'aaa', (3+4j)]
# True
# 0.15926
# ('i', 'j', 'k')
# {1, '\t\t\t'}
# {1: True, 2: False, 3: (8+1j), 4: [], 5: {}}

¶6. list()将其他类型转换为列表类型：

• 形式：list(x)

• 允许的x范围类型：字符串，元组，字典，集合。

  • 字符串转换为列表，每个字符作为一个元素组成列表。
  • 字典转换为列表，只将每个键作为一个元素组成列表，值被丢弃。
  • 元组和集合只是在原有数据的基础上加[]

print(list("abcdefg1234\n\n\n"))
print(list({1:1,2:2,3:3,"a":4,"b":[5,6,7]}))
print(list((1,2,3,4,"a","b","c",["jkl"])))
print(list({1,2,3,"a","b","c",(1,2,3)}))
# 运行结果：
# ['a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3', '4', '\n', '\n', '\n']
# [1, 2, 3, 'a', 'b']
# [1, 2, 3, 4, 'a', 'b', 'c', ['jkl']] 
# ['c', 1, 2, 3, (1, 2, 3), 'b', 'a'] #集合转列表时元素顺序无序

¶7. tuple()将其他类型转换为元组类型：

• 形式：tuple(x)

• 允许的x范围类型：字符串，列表，字典，集合。

• 规则和list一致，只是外面加()

print(tuple("abcdefg1234\n\n\n"))
print(tuple({1:1,2:2,3:3,"a":4,"b":[5,6,7]}))
print(tuple([1,2,3,4,"a","b","c",["jkl"]]))
print(tuple({1,2,3,"a","b","c",(1,2,3)}))
# 运行结果：
# ('a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3', '4', '\n', '\n', '\n')
# (1, 2, 3, 'a', 'b')
# (1, 2, 3, 4, 'a', 'b', 'c', ['jkl'])
# (1, 2, 3, 'b', (1, 2, 3), 'c', 'a')

¶8. set()将其他类型转换为集合类型：

• 形式：set(x)

• 允许的x范围类型：字符串，列表，字典，元组。

• 规则和list一致，只是外面加{}，不过元素顺序是无序的。

  注意：pycharm中直接强制转化set会警告，因为直接用{}强制转化就可以代替，为了演示效果，下面进行了两次强制转化：

  print(set("abcdefg1234\n\n\n"))
  print(set(dict({1: 1, 2: 2, 3: 3, "a": 4, "b": [1, 2, 3]})))
  print(set(list([1, 2, 3, 4, "a", "b", "c", "jkl"])))
  print(set(tuple((1, 2, 3, 4, "a", "b", (4, 5, 6)))))
  #运行结果：
  # {'f', 'a', 'c', 'd', '2', '4', 'b', 'e', 'g', '1', '\n', '3'}
  # {1, 2, 3, 'a', 'b'}
  # {1, 2, 3, 4, 'a', 'c', 'b', 'jkl'}
  # {1, 2, 3, 4, 'a', 'b', (4, 5, 6)}

¶9. dict()将其他类型转换为字典类型：

在说明dict的类型转换前，需要说明容器和多级容器的概念：

¶容器：

Python中，可包含其他对象的对象，称之为“容器”。容器是一种数据结构。

常用的容器主要划分为两种：序列（如：列表、元祖等）和映射（如：字典）。序列中，每个元素都有下标，它们是有序的。映射中，每个元素都有名称（又称“ 键 ”），它们是无序的。

除了序列和映射之外，还有一种需要注意的容器——“ 集合 ”。

¶多级容器：

在一个容器中嵌套一个容器，这个容器就叫二级容器；在被嵌套的容器中可以再嵌套容器，最外层的容器就叫做多级容器......由此可以获得多级容器。

多级容器不包括字符串，字符串是特殊的容器，任何字符在字符串中都是字符串的一个单独元素；

容器的类型取决于最外层的容器，不同的类型容器可以相互嵌套，但是，集合和字典除外；因为字典的键和集合中的值必须是可哈希的类型，即可变数据类型。

l = [1,2,[3,4,[5,6]]]
d = {0:{1:1,2:2,3:{4:4,5:5,6:6}}}
t = (1,2,3,[1,2,3],{1,2,3})
print(type(l))
print(type(d))
print(type(t))
#运行结果：
# <class 'list'>
# <class 'dict'>
# <class 'tuple'>

¶等长的多级容器：

外层容器中的元素都是容器。

被嵌套容器中的元素个数是一样的。

l=[[1,2],[3,4],[5,6]] #等长的二级容器

¶字典的强制转换：

• 形式：dict(x)

• 允许的x范围类型：等长的二级容器，且内部元素个数必须为两个。

• 转换类型上，不能在最外层使用字符串。

• 转换类型的元素建议使用列表和元组，尽量不要用集合和字符串（集合难以形成键值对的对应关系，两者可能互换，而字符串只允许长度为2）

print(dict([[1,2],(3,4),{5,6},"78"]))
# 运行结果：
# {1: 2, 3: 4, 5: 6, '7': '8'}  不建议使用集合，但是此处顺序是固定的，字符串如果是两位可以用。