沐枫凌-python 新手教学(7.5)--类型转换

总结我们之前学的，我们都学了写什么呢？

我们已经了解了python的特有关键字，变量，数字，字符串，列表，元组，集合，字典等

本来这不应该作为独立的来讲的，但是好多盆友在类型转换上老是伤脑筋，所以今天我要讲的是代码类型的辨认与转换

代码类型的辨认

type()函数的使用：

我们可以通过type()函数来进行代码类型的辨析，代码示例如下

#这是数据辨析的示例代码

print(123,'的类型是',type(123))                        #整数数字
print(123.5,'的类型是',type(123.5))                    #浮点数
print(1+2j,'的类型是',type(1+2j))                      #复数
print(True,'的类型是',type(True))                      #布尔类型
print('123','的类型是',type('123'))                      #字符串
print([1,2,3,4],'的类型是',type([1,2,3,4]))            #列表
print((1,2,3,4),'的类型是',type((1,2,3,4)))            #元组
print({1,2,3,4},'的类型是',type({1,2,3,4}))            #集合
print({'xx':1,'yy':2},'的类型是',type({'xx':1,'yy':2}))#字典

结果如下

123 的类型是 <class 'int'>
123.5 的类型是 <class 'float'>
(1+2j) 的类型是 <class 'complex'>
True 的类型是 <class 'bool'>
'123' 的类型是 <class 'str'>
[1, 2, 3, 4] 的类型是 <class 'list'>
(1, 2, 3, 4) 的类型是 <class 'tuple'>
{1, 2, 3, 4} 的类型是 <class 'set'>
{'xx': 1, 'yy': 2} 的类型是 <class 'dict'>

我们可以分别看到,通过type()检测出了这是属于什么类型的代码,<class 'xxx'>表示什么什么样的代码类型,class指类，其中

int<==>数字    float<==>浮点数   complex<==>复数   bool<==>布尔类型   str<==>字符串   list<==>列表   typle<==>元组   set<==>集合   dict<==>字典

 这就是我们之前所学的基本代码的类型，我们虽然可以直接看出来这些属于什么类型，但是当他们都赋值给变量时，我们不一定能直接看出,例

#这是数据辨析的示例代码
a = 123
b = 123.5
c = 1+2j
d = '123'
e = True
f = [1,2,3]
g = (1,2,3)
h = {1,2,3}
i = {'xx':1,'yy':2}

print('a==>',type(a),'\n',
	  'b==>',type(b),'\n',
	  'c==>',type(c),'\n',
	  'd==>',type(d),'\n',
	  'r==>',type(e),'\n',
	  'f==>',type(f),'\n',
	  'g==>',type(g),'\n',
	  'h==>',type(h),'\n',
	  'i==>',type(i))

结果如下

a==> <class 'int'> 
 b==> <class 'float'> 
 c==> <class 'complex'> 
 d==> <class 'str'> 
 r==> <class 'bool'> 
 f==> <class 'list'> 
 g==> <class 'tuple'> 
 h==> <class 'set'> 
 i==> <class 'dict'>

当我们用type()查看被赋值的变量时，显示出来的时变量所赋的值的类型。

我们以后在庞大的代码中，往往使用的时变量来代替这些实际的代码，但是由于数量多，我们常常会忘记变量所赋的属于什么类型了，所以type()在检查代码类别时起很大的作用！

代码类型的转换

代码的类型转换基本符合下面的转换规则（右边的代码类型可以转换为左边的代码类型，即 右边 => 左边）

 

然后就是str可以转换成任何东西

下面我给出一段示例代码来反映转换的结果

#这是类型转换的示例代码

num = 123
Float = 123.5
Complex = 1+2j
string = '123'
List = [1,2,3,4]
Tuple = (1,2,3,4)
Sets = {1,2,3,4}
Dict = {'xx':1,'yy':2}

print(num,'由原来的',type(num),'类型,转换为',type(str(num)),'并且变成了',repr(str(num)))
print(num,'由原来的',type(num),'类型,转换为',type(float(num)),'并且变成了',repr(float(num)))
print(num,'由原来的',type(num),'类型,转换为',type(complex(num)),'并且变成了',repr(complex(num)))
print(List,'由原来的',type(List),'类型,转换为',type(str(List)),'并且变成了',repr(str(List)))
print(List,'由原来的',type(List),'类型,转换为',type(tuple(List)),'并且变成了',repr(tuple(List)))
print(List,'由原来的',type(List),'类型,转换为',type(set(List)),'并且变成了',repr(set(List)))
print(Tuple,'由原来的',type(Tuple),'类型,转换为',type(str(Tuple)),'并且变成了',repr(str(Tuple)))
print(Tuple,'由原来的',type(Tuple),'类型,转换为',type(list(Tuple)),'并且变成了',repr(list(Tuple)))
print(Tuple,'由原来的',type(Tuple),'类型,转换为',type(set(Tuple)),'并且变成了',repr(set(Tuple)))
print(Sets,'由原来的',type(Sets),'类型,转换为',type(str(Sets)),'并且变成了',repr(str(Sets)))
print(Sets,'由原来的',type(Sets),'类型,转换为',type(list(Sets)),'并且变成了',repr(list(Sets)))
print(Sets,'由原来的',type(Sets),'类型,转换为',type(tuple(Sets)),'并且变成了',repr(tuple(Sets)))
print(Dict,'由原来的',type(Dict),'类型,转换为',type(str(Dict)),'并且变成了',repr(str(Dict)))
print(Dict,'由原来的',type(Dict),'类型,转换为',type(list(Dict)),'并且变成了',repr(list(Dict)))
print(Dict,'由原来的',type(Dict),'类型,转换为',type(tuple(Dict)),'并且变成了',repr(tuple(Dict)))
print(Dict,'由原来的',type(Dict),'类型,转换为',type(set(Dict)),'并且变成了',repr(set(Dict)))

 大家可以直观的看到转换后的结果，下面是结果

123 由原来的 <class 'int'> 类型,转换为 <class 'str'> 并且变成了 '123'
123 由原来的 <class 'int'> 类型,转换为 <class 'float'> 并且变成了 123.0
123 由原来的 <class 'int'> 类型,转换为 <class 'complex'> 并且变成了 (123+0j)
[1, 2, 3, 4] 由原来的 <class 'list'> 类型,转换为 <class 'str'> 并且变成了 '[1, 2, 3, 4]'
[1, 2, 3, 4] 由原来的 <class 'list'> 类型,转换为 <class 'tuple'> 并且变成了 (1, 2, 3, 4)
[1, 2, 3, 4] 由原来的 <class 'list'> 类型,转换为 <class 'set'> 并且变成了 {1, 2, 3, 4}
(1, 2, 3, 4) 由原来的 <class 'tuple'> 类型,转换为 <class 'str'> 并且变成了 '(1, 2, 3, 4)'
(1, 2, 3, 4) 由原来的 <class 'tuple'> 类型,转换为 <class 'list'> 并且变成了 [1, 2, 3, 4]
(1, 2, 3, 4) 由原来的 <class 'tuple'> 类型,转换为 <class 'set'> 并且变成了 {1, 2, 3, 4}
{1, 2, 3, 4} 由原来的 <class 'set'> 类型,转换为 <class 'str'> 并且变成了 '{1, 2, 3, 4}'
{1, 2, 3, 4} 由原来的 <class 'set'> 类型,转换为 <class 'list'> 并且变成了 [1, 2, 3, 4]
{1, 2, 3, 4} 由原来的 <class 'set'> 类型,转换为 <class 'tuple'> 并且变成了 (1, 2, 3, 4)
{'xx': 1, 'yy': 2} 由原来的 <class 'dict'> 类型,转换为 <class 'str'> 并且变成了 "{'xx': 1, 'yy': 2}"
{'xx': 1, 'yy': 2} 由原来的 <class 'dict'> 类型,转换为 <class 'list'> 并且变成了 ['xx', 'yy']
{'xx': 1, 'yy': 2} 由原来的 <class 'dict'> 类型,转换为 <class 'tuple'> 并且变成了 ('xx', 'yy')
{'xx': 1, 'yy': 2} 由原来的 <class 'dict'> 类型,转换为 <class 'set'> 并且变成了 {'xx', 'yy'}

大家一个一个对照地看，就会发现，我们可以通过特殊的代码将可以转换类型的代码类型转换了

(!!在这里解释一下其中出现的repr()函数，它和print()函数的功能相似，但是他输出的东西是给python以及专业技术员看的，反映的是其的内容加上其本质，而print()主要是输出给用户看的，一般只输出内容，省略属性!!!)

 

 下面是转换的方法列表

转换方法	转换结果	可用此进行转换的对象
str(……)	将括号内所有的内容转化为字符串	所有的代码
int(……)	将括号内的内容转化为整数	内容只有数字的字符串；浮点数（String,Float）
float(……)	将括号内的内容转化为浮点数	内容只有数字的字符串；整数（String,Int）
complex(……)	将括号内的内容转化为复数	内容只有数字的字符串；整数；浮点数 (String,Int,Float)
list(……)	将括号内的内容转化为列表	字符串；元组；集合；字典（String,Tuple,Sets,Dict）
tuple(……)	将括号内的内容转化为元组	字符串；列表；集合；字典（String,List,Sets,Dict）
set(……)	将括号内的内容转化为集合	字符串；列表；元组；字典（String,List,Tuple,Dict）

以上就是基本的代码类型转变方式！！

 

新手易犯的错误

 下面我将列举几个错误的转换类型的代码，大家可以复制下来看看，然后铁定会报错

（1）试图将Tuple(元组),List(列表),Sets(集合)转化为Dict(字典)：

#这是错误的代码示例

print(dict([1,2,3,4]))        #试图将列表转化为字典
print(dict((1,2,3,4)))        #试图将元组转化为字典
print(dict({1,2,3,4}))        #试图将集合转化为字典

（2）试图将Complex(复数),转化为Int(整数),Float(浮点数)：

#这是错误的代码示例

print(int(12+2j))
print(float(12+2j))

（3）以为只有Tuple/List/Sete作为字符串内容的字符串可以通过list(),tuple(),set()转换为相同的列表/元组/集合：

首先声明的是，我说的新手错误与我之前的列出来的方法并不冲突，list(),tuple(),set()的确可以把字符串转换为列表/元组/集合，只是内容会有所变动，下面将有代码与结果说明

#这是list(),tuple(),set()误用的代码示例

print(list('[1,2,3,4,5]'))            #试图将'[1,2,3,4,5]'转化为[1,2,3,4,5]
print(tuple('(1,2,3,4,5)'))           #试图将'(1,2,3,4,5)'转化为(1,2,3,4,5)
print(set('{1,2,3,4,5}'))             #试图将'{1,2,3,4,5}'转化为{1,2,3,4,5}

结果是这样的

['[', '1', ',', '2', ',', '3', ',', '4', ',', '5', ']']
('(', '1', ',', '2', ',', '3', ',', '4', ',', '5', ')')
{'2', '3', '}', '1', ',', '{', '4', '5'}

也就是说用list(),tuple(),set()去转化字符串为自身时，会将对应字符串的每一个字符单独作为一个元素排列在列表，元组或集合中，而不是就这样直接转化为了一个完整的列表，元组，集合

 

特殊的类型转换

（1）将字符串内的内容完完整整的转化为可用的合法代码：

针对于上面的"[1,2,3,4,5]"不能转化为[1,2,3,4,5]的窘境，我们可以采用这样的方式来完完整整的转化它

这里我们要用到eval()函数，我们只需要eval("…………"),就可以将内容一个不缺的完整转化为实用代码了，例

#这是eval()函数的转换示例

print(eval('[1,2,3,4]'))
print(eval('(1,2,3,4)'))
print(eval('{1,2,3,4}'))
print(eval("{'xx':1,'yy':2}"))
print(eval('123'))
print(eval('123.55'))
print(eval('123+2j'))
eval("print('hello world!')")

结果是

[1, 2, 3, 4]
(1, 2, 3, 4)
{1, 2, 3, 4}
{'xx': 1, 'yy': 2}
123
123.55
(123+2j)
hello world!

结果显示，eval()函数可以将字符串转化为真实的代码，代码本身是什么属性，转化出来的就是什么！甚至可以直接转化出可执行代码！

！！！(1)eval()函数的转化内容仅限字符串，且由转化出来的实际代码要合法!

           (2)eval()函数不能转化含有关键字的字符串！即使是字符串的内容作为实际代码而言是合法的。！！！

 

（2）使用特殊手法将列表，元组，集合转化为字典：

我们这里可以通过嵌套序列来进行转化，此序列满足 [[xxx,yyy],[xxx,yyy],[xxx,yyy],[xxx,yyy]]这样之类的，其中xxx代表了关键字，yyy代表了值,下面直接给例子，注意看清dict()中有多少个括号

print(dict([(1,2),(2,3),(3,4)]))
print(dict(((1,2),(2,3),(3,4))))
print(dict({(1,2),(2,3),(3,4)}))

下面是结果

{1: 2, 2: 3, 3: 4}
{1: 2, 2: 3, 3: 4}
{1: 2, 3: 4, 2: 3}

我们可以看到所有在xxx位置的变成了字典的关键字，所有在yyy位置的变成了字典的值

 

讲了这么多，上面差不多就是代码类型的转换，代码的转换有时也很重要，他可以使你的用户输入转化为对应的实际操作去自动执行，而不需要你临时改变！

重要的还是多练习！