Python 数据类型转换

1. 转数字

[1] 转int

# float转int
# 使用int(obj)，小数部分会被舍弃
# 如果需要四舍五入可以使用rount(obj)函数
# 向上取整可以使用math.ceil(obj)
int(1.53)	# 1
round(1.53)	# 2
import math
math.ceil(3.26)	# 4

# str转int
# 字符串必须是整数形式，不能是小数，不能包含其他字符
# 转换时会忽略两边的空格
int('12')	# 12
int('  33  ')	# 33
int('5.2')	#报错
int('abc')	#报错

# bool转int
int(True)	# 1
int(False)	# 0

[2] 转float

# int转float，直接转换，添加.0
float(3)	# 3.0
# round()函数第二个参数可以指定小数位数(四舍五入)
round(3.14159, 3)	# 3.132

# str转float
# 字符串必须是整数或小数形式，不能包含其他字符
# 转换时会忽略两边的空格
float('1.23')	# 1.23
float('7')		# 7.0
float('  3.14  ')	# 3.14
float('abc')    # 报错

# bool转float
float(True)	# 1.0
float(False)	# 0.0

# 特殊值
float("infinity")	    # inf	表示一个超出浮点数表示范围的正数
float("+inf")		# inf	表示一个超出浮点数表示范围的正数
float("-inf")		# -inf	表示一个超出浮点数表示范围的负数
float("nan")		# nan	表示一个未定义或无法表示的结果

(2) 转字符串

# 有两个方法可以将对象转为字符串
# str(obj)	返回一个对用户友好、可读性强的字符串
# repr(obj)	返回一个对开发者友好、明确无歧义的字符串表示，理想情况下，这个字符串应该是一个有效的 Python 表达式，可以用来重新创建这个对象,可以和eval(str)函数搭配使用
str('hellow,world')		# 输出：hellow,world
repr('hellow,world')	# 输出：'hellow,world'

# eval(str)将字符串作为python表达式来求值并返回结果
# eval(str)可以执行任意代码，强大的同时也非常危险
eval('[1, 2, 3]')	# 返回列表[1, 2, 3]
eval('print("hellow,world")')	# 会输出hellow,world

[1] 数字转字符串

# int转str
str(28)	# '28'

# float转str
str(3.14)	# '3.14'

# complex转str
str(3 + 4j)	# '(3+4j)'

[2] 列表转字符串

# 会以列表的形式输出字符串
str([])		# '[]'
str([1, '2'])	# "[1, '2']"

[3] 元组转字符串

# 会以元组的形式输出字符串
str(())		# '()'
str(('hellow', 'world'))	# "('hellow', 'world')"

[4] 字典转字符串

# 会以字典的形式输出字符串
str({})		# {}
str({1: '1', 2: '2'})	# "{1: '1', 2: '2'}"

[5] 集合转字符串

# 会以集合的形式输出字符串
str(set())		# 'set()'
str({1, '2', 3})	# "{1, 3, '2'}"

[6] 布尔和None转字符串

# 布尔类型转字符串返回'True'和'False'
str(True)	# 'True'
str(False)	# 'False'

# None转字符串返回'None'
str(None)	# 'None'

(3) 转列表

[1] 字符串转列表

# 字符串转列表会将字符串的每一个字符转换成列表的一项
list('hellow,world\n')		# ['h', 'e', 'l', 'l', 'o', 'w', ',', 'w', 'o', 'r', 'l', 'd', '\n']

[2] 元组转列表

# 将元组转成列表，元素不会被改变
list((1, '2', (3, 4)))		# [1, '2', (3, 4)]

[3] 字典转列表

# 默认将键值转换为列表
dict_data = {"a": 1, "b": 2, "c": 3}
list(dict_data)		# ['a', 'b', 'c']

# # 获取值的列表
values_list = list(dict_data.values())
print(values_list)  # [1, 2, 3]

# 获取键值对元组的列表，每个键值对被转为元组
items_list = list(dict_data.items())
print(items_list)  # [('a', 1), ('b', 2), ('c', 3)]

[4] 集合转列表

# 集合转列表顺序可能和定义的集合顺序不同
list({3, 1, 4, 1, 5})	# 集合会自动去重，结果可能是[1, 3, 4, 5]

# 可以使用sorted(obj)函数得到确定的，排序后的列表
# sorted()函数的参数为可迭代对象，返回值为列表
sorted({3, 1, 4, 1, 5})	# [1, 3, 4, 5]

(4) 转元组

[1] 字符串转元组

# 字符串转列表会将字符串的每一个字符转换成列表的一项
tuple('hellow,world\n')		# ('h', 'e', 'l', 'l', 'o', 'w', ',', 'w', 'o', 'r', 'l', 'd', '\n')

[2] 列表转元组

# 将列表转成元组，元素不会被改变
tuple[1, '2', (3, 4)]		# ((1, '2', (3, 4)))

[3] 字典转元组

# 默认将键转换为元组
dict_data = {"a": 1, "b": 2, "c": 3}
tuple(dict_data)		# ('a', 'b', 'c')

# 获取值的元组
values_list = tuple(dict_data.values())
print(values_list)  # (1, 2, 3)

# 获取键值对的元组，每个键值对被转为元组
items_list = tuple(dict_data.items())
print(items_list)  # (('a', 1), ('b', 2), ('c', 3))

[4] 集合转元组

# 集合转元组顺序可能和定义的集合顺序不同
tuple({3, 1, 4, 1, 5})	# 集合会自动去重，结果可能是(1, 3, 4, 5)

(5) 转字典

[1] 包含键值对的可迭代对象

# (key, value)
# 上面这种形式的字符串、列表、元组和集合可以转换为字典，并且可以相互嵌套
# 字符串只能包含两个字符
# 如果包含了集合，需要注意集合的去重性和无序性
dict([(3, 4), [2, 1]])		# {2: 1, 3: 4}
dict(((3, 4), [2, 1]))		# {2: 1, 3: 4}
dict([(3, 4), 'ab'])		# {3: 4, 'a': 'b'}
dict([[3, 4], {2, 1}])		# 结果可能是{3: 4, 1: 2}
dict({(3, 4), (2, 1)})		# {2: 1, 3: 4}

dict([[3, 4], {2, 2}])		# 报错，{2, 2}的结果是{2}
dict({(3, 4), [2, 1]})		# 报错，集合不能包含可变元素

[2] 使用关键字参数

# key = value
# key会被转换为字符串，key必须符合标识符命名规范
dict(name = '小刚', age = 12)		# {'name': '小刚', 'age': 12}
name = '小刚'
age = 12
dict(name = name, age = age)	# {'name': '小刚', 'age': 12}

# 可以与已有字典混合使用，如果有相同键，那么前面的值会被后面的覆盖
# 混合使用时参数里只能有一个字典，并且字典必须是第一个参数
d1 = {'name': '小明', 'age': 16}
d2 = dict(d1, age = 20, gender = '男')		# {'name': '小明', 'age': 20, 'gender': '男'}

[3] zip()函数

# 使用zip()函数将俩个可迭代对象转为字典
# 键相同时新值会覆盖旧值
# 长度不一致会将多余的部分省略
key = [1, 2, 2, 4, 5]
value = ['a', 'b', 'c', 'd']
newDict = dict(zip(key, value))		# {1: 'a', 2: 'c', 4: 'd'}

(6) 转集合

[1] 字符串转集合

# 字符串转集合会将字符串的每一个字符转换成的一项
# 会自动去掉重复值
# 每次运行得到的结果顺序可能不一样
set('hellow,world\n')		# 结果可能是 {'l', ',', '\n', 'h', 'e', 'r', 'w', 'o', 'd'}

[2] 列表转集合

# 列表转为集合
# 会自动去掉重复值
# 每次运行得到的结果顺序可能不一样
# 列表的元素里不能包含可变元素，否则会报错
set(['a', 'b', 'c', 'a', 1, 1, 2])		# 结果可能是 {1, 2, 'a', 'c', 'b'}
set([[1, 2], [3, 4]])	# 报错

[3] 元组转集合

# 元组转为集合
# 会自动去掉重复值
# 每次运行得到的结果顺序可能不一样
# 元组的元素里不能包含可变元素，否则会报错
set(('a', 'b', 'c', 'a', 1, 1, 2))		# 结果可能是 {1, 2, 'a', 'c', 'b'}
set(([1, 2], [3, 4]))	# 报错
set(([1, 2]))	# 不报错，这里的括号被视作运算符，而不是定义元组。等价于set([1, 2])

[4] 字典转集合

# 默认是将key转为集合
dict_data = {"a": 1, "b": 2, "c": 3, "a": 4}  # 重复键会被覆盖
key = set(dict_data)
print(key)  # {'a', 'b', 'c'}

# 获取值的集合
value = set(dict_data.values())
print(value)  # {2, 3, 4} (注意：a的值是4而不是1)