Python学习（六）：python数据类型转换【详解】

python数据类型转换【详解】

python中，通过一系列的转换函数，可以将一种数据类型转换成另一种数据类型

函数	说明
eval(str)	用来执行一个字符串表达式，并返回表达式的值
chr(x)	将整数 x 转换为字符，有效的Unicode编码值范围（0-0x10FFFF）。 其和ord(x)的作用相反。
unichr(x)	[python2]将整数 x 转换为一个Unicode字符
ord(x)	将 x 转换为它的ASCII整数值。 其和chr(x)的作用相反。
int(x [,base])	将x转换为一个整数，如果x是字符串，则要base指定基数base=0 或 (base>= 2 && base<= 36)，0表示10进制，2表示2进制，8表示8进制，11表示11进制
float(x)	x转换为一个浮点数
bool(x)	将x转换为布尔类型，返回True或False，非0为True（包括0、-0、0.0）
bin(x)	将一个整数转换为一个二进制字符串
oct(x)	将一个整数转换为一个八进制字符串
hex(x)	将一个整数转换为一个十六进制字符串
complex(real [,imag])	创建一个复数，real为实部，imag为虚部，只有实部real时、虚数部分为0。
repr(x)<	将对象 x 转换为表达式字符串
str(x)	将对象 x 转换为字符串
list(seq)	创建一个列表，或将序列seq转换为列表
tuple(seq)	创建一个元组，或将序列seq转换为元组
set(s)	创建一个集合，或将序列seq转换为集合
dict(d)	创建一个字典，或将d转换为字典，d必须是(key，value)元组的序列
frozenset(s)	将s转换为冻结集

eval(str)函数

int x = 10
eval('1+2+3-4')       # 输出整数2
eval('x*10')          # 输出整数100

chr(x)函数

chr(1)                # 输出字符串'\x01'
chr(65)               # 输出字符串'A'
chr(1000)             # 输出字符串'Ϩ'
chr(10000)            # 输出字符串'✐'

unichr(x)

unichr(x)是python2函数，python3采用chr(x)函数

ord(x)

ord('\x01')           # 输出字符串1
ord('A')              # 输出字符串65
ord('Ϩ')              # 输出字符串1000
ord('✐')             # 输出字符串10000

int(x [,base])

int(True)             # 输出"十"进制整数1
int(False)            # 输出"十"进制整数0
int('100')            # 输出"十"进制整数100
int('100', 0)         # 输出"十"进制整数100，0也表示十进制
int('100', 10)        # 输出"十"进制整数100
int('100', 2)         # 输出"二"进制整数4
int('100', 8)         # 输出"八"进制整数64
int('100', 16)        # 输出"十六"进制整数256
int('100', 32)        # 输出"三十二"进制整数1024
int('100', 3)         # 输出"三"进制整数9
int('100', 15)        # 输出"十五"进制整数225

float(x)

float(True)           # 输出"十"进制浮点数1.0
float(False)          # 输出"十"进制浮点数0.0
float('0.15')         # 输出"十"进制浮点数0.15
float('1.5')          # 输出"十"进制浮点数1.5
float('15')           # 输出"十"进制浮点数15.0
float('1.5e5')        # 科学记数法，输出"十"进制浮点数150000.0

bool(x)

bool(1)               # 输出布尔类型True
bool(1.0)             # 输出布尔类型True
bool(-1)              # 输出布尔类型True
bool(-100)            # 输出布尔类型True
bool('1')             # 输出布尔类型True
bool('1.0')           # 输出布尔类型True
bool('0')             # 输出布尔类型True
bool('0.0')           # 输出布尔类型True
bool('A')             # 输出布尔类型True
bool('中国')          # 输出布尔类型True
bool(0)               # 输出布尔类型False，只有0、-0、0.0返回False
bool(-0)              # 输出布尔类型False，只有0、-0、0.0返回False
bool(0.0)             # 输出布尔类型False，只有0、0.0返回False

bin(x)

bin(True)             # 输出"二"进制数'0b1'
bin(False)            # 输出"二"进制数'0b0'
bin(1)                # 输出"二"进制数'0b1'
bin(3)                # 输出"二"进制数'0b1'
bin(10)               # 输出"二"进制数'0b1010'
bin(100)              # 输出"二"进制数'0b1100100'

oct(x)

oct(True)             # 输出"八"进制数'0o1'
oct(False)            # 输出"八"进制数'0o0'
oct(1)                # 输出"八"进制数'0o0'
oct(3)                # 输出"八"进制数'0o3'
oct(10)               # 输出"八"进制数'0o12'
oct(100)              # 输出"八"进制数'0o144'

hex(x)

hex(True)             # 输出"十六"进制数'0x1'
hex(False)            # 输出"十六"进制数'0x0'
hex(1)                # 输出"十六"进制数'0x1'
hex(3)                # 输出"十六"进制数'0x3'
hex(10)               # 输出"十六"进制数'0xa'
hex(100)              # 输出"十六"进制数'0x64'

complex(real [,imag])

complex(1)            # 输出复数(1+0j)
complex('3+5j')       # 输出复数('3+5j')
complex(3, 5)         # 输出复数('3+5j')

repr(x)

str和repr的区别：
1、str()将数值转成字符串，str()函数返回的结果字符串可读性好。
2、repr()将对象转成字符串显示，repr() 函数将对象转化为供解释器读取的形式。支持dict和list。
repr是representation的简写，它会将对象在在python中的描述。repr()函数的返回结果可以还原为对象本身，即：obj==eval(repr(obj)) 这个等式是成立的。

class Student: # 定义student类
    name = None
    ange = None

student = Student()
 
repr(student)       # 输出'<__main__.Student object at 0x000001921B0D6F90>'
str(student)        # 输出'<__main__.Student object at 0x000001921B0D6F90>'

student==eval(str(repr(student))     # 输出True
student==eval(str(student))          # 异常

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

str(100)                    # 输出'100'
str(1+2+3)                  # 输出'6'
str('1+2+3=6')              # 输出'1+2+3=6'
str(True)                   # 输出'True'
str({'A': 'a', 'B': 'b'})   # 输出'{'A': 'a', 'B': b}'

list(seq)

# 通过list()创建列表
list1 = list()                 # 创建空列表
list2 = list('python')         # 创建列表，python被分割成单独字符并放置在列表中【注意】
print(list2)                   # 输出['p', 'y', 't', 'h', 'o', 'n']
# 将tuple元组转换到列表
tuple1 = ('Hello', 'world')    # 创建tuple
list3 = list(tuple1)           # 将tuple的元素转换成列表元素
print(list3)                   # 输出['Hello', 'world']
# 将dict字典转换到列表
dict1 = {'A':'a', 'B':'b'}
list4 = list(dict1)            # 将dict的key，转换成列表元素
print(list4)                   # 输出['A', 'B']
list4 = list(dict1.values())   # 将dict的value，转换成列表元素
print(list4)                   # 输出['a', 'b']
# 将set集合转换到列表
set1 = {'A', 'B', 'C'}
list5 = list(set1)             # 将set的元素，转换成列表元素
print(list5)                   # 将集合转换成列表，输出['A', 'B', 'C']

tuple(seq)

# tuple()创建元组
tuple1 = tuple()               # 创建空元组
tuple2 = tuple('ABC')          # 创建元组，ABC被分割成单独字符并放置在元组中【注意】
# 将list列表转换到元组    
list1=[1, 2, 'a', 'b']
tuple3 = tuple(list1)          # 将set的元素，转换成元组元素
print(tuple3)                  # 输出(1, 2, 'a', 'b')
# 将set元组转换到列表
set1 = ('Hello', 'world')    # 创建元组
tuple4 = list(set1)           # 将元组的元素转换成列表元素
print(tuple4)                   # 输出['Hello', 'world']
# 将dict字典转换到元组
dict1 = {'A':'a', 'B':'b'}
tuple5 = tuple(dict1)          # 将dict的key，转换成元组元素
print(tuple5)                  # 输出('A', 'B')
tuple6 = tuple(dict1.values()) # 将dict的value，转换成元组元素
print(tuple6)                  # 输出('a', 'b')

set(s)

# set()创建集合
set1 = set()                   # 创建空集合
set2 = set('ABC')              # 创建集合，ABC被分割成单独字符并放置在集合中【注意】
# 将list列表转换到集合   
list1=[1, 2, 'a', 'b']
set3 = set(list1)              # 将list的元素，转换成集合元素
print(set3)                    # 输出{'a', 1, 2, 'b'}
# 将tuple元组转换到集合
tuple1 = ('Hello', 'world')    # 创建元组
set4 = set(tuple1)             # 将元组的元素转换成集合元素
print(set4)                    # 输出{'world', 'Hello'}
# 将dict字典转换到集合
dict1 = {'A':'a', 'B':'b'}
set5 = set(dict1)              # 将dict的key，转换成集合元素
print(set5)                    # 输出{'A', 'B'}
set6 = set(dict1.values())     # 将dict的value，转换成集合元素
print(set6)                    # 输出{'a', 'b'}

dict(d)

# dict()创建字典
dict1 = dict()                     # 创建空字典
dict2 = dict(a='A', b='B', c=20)   # 创建字典，dict2 = {'a': 'A', 'b': 'B', 'c': 20}
dict3 = dict([('A', 1), ('B', 2), ('C', 3)])    # 创建字典，dict3 = {'A': 1, 'B': 2, 'C': 3}

【通过传入可迭代可迭代对象来创建字典，可迭代对象可以是一个列表、元组或其他可迭代类型】
# 将list列表转换到字典【注意列表的元素形式】
list1=[{1,'a'}, {2,'b'}]
dict4 = dict(list1)                # 将list的元素，转换成字典元素
print(dict4)                       # 输出{'a': 1, 'b': 2}

# 将tuple元组转换到字典
tuple1 = ('A', 1), ('B', 2)        # 创建元组
dict5 = dict(tuple1)               # 将元组的元素转换成字典元素
print(dict5)                       # 输出{'A': 1, 'B': 2}

# 将set元组转换到列表
set1 = ({1,'a'}, {2,'b'})          # 创建集合
dict6 = dict(set1)                 # 将集合的元素转换成字典元素
print(dict6)                       # 输出{'a': 1, 'b': 2}

frozenset(s)：其本质是set集合

冻结后集合不能再添加或删除任何元素，与之相反的是set()函数，set无序排序且不重复，是可变的

f1 = frozenset(range(10))    # 创建不可变list集合
print(type(f1))              # 输出<class 'frozenset'>
print(f1)                    # 输出frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

# frozenset集合，不可添加、删除、修改元素
f2 = frozenset('abcd')       # 创建集合【注意：abcd被分割成单独字符，不按参数顺序放置在集合中】
print(type(f2))              # 输出<class 'frozenset'>
print(f2)                    # 输出frozenset(({'a', 'd', 'b', 'c'})

# set集合，可添加、删除、修改元素
set1 = set('abc')            # 创建集合【注意：abcd被分割成单独字符，不按参数顺序放置在集合中】
print(set1)                  # 输出{'a', 'd', 'b', 'c'}
set1.add('e')                # 输出{'a', 'd', 'e', 'b', 'c'}