python基础—python6种基本数据类型及数据类型之间转换
文章目录
- 一、python标准数据类型
-
- （一）数字类型
-
- 整型：int
- 浮点型：flaot
- 布尔型：bool
- 复数类型：complex
- （二）字符串
- （三）列表类型
- （四）元组类型
- （五）字典类型
- （六）集合类型
- 二、python数据类型转换
-
- （一）自动类型转换
- （二）强制类型转换
-
- 其他类型 -> str
- 其他类型 -> 数字型（bool/float/int/complex)
- 其他类型 -> list
- 其他类型 -> tuple
- 其他类型 -> dict
- 其他类型 -> set
一、python标准数据类型
（一）数字类型
整型：int
1）在数字中，正整数、0、负整数都称为整型。
举例1：
intvar1=100
print(type(intvar1))
运行结果：
2）二进制整型
也可以用二进制表示整型，print自动转换为十进制。
举例1：
intvar2=0b1010
print(intvar2)
print(type(intvar2))
运行结果：
10
浮点型：flaot
1）含有小数点的数据都是浮点型。
举例1：
floatvar1=3.14
print(floatvar1,type(floatvar1))
运行结果：
3.14
2）科学计数法
举例1：
floatvar2 = 3.456e5 #小数点向右移动5位
print(floatvar2,type(floatvar2))
运行结果：
345600.0
布尔型：bool
布尔型数据只有两种：True、False。表示真假。
举例1：
boolvar1 = True
print (boolvar1,type(boolvar1))
运行结果：
True
复数类型：complex
复数为实数加虚数，只要存在虚数，此数据类型就为复数类型。
表达方法1：
complexvar1 = 3-91j
print (complexvar1,type(complexvar1))
运行结果：
(3-91j)
表达方法2：
语法：complex(实数,虚数)
complexvar2 = complex(3,-91)
print (complexvar2,type(complexvar2))
运行结果：
(3-91j)
（二）字符串
1）字符串：str
用引号引起来的就是字符串。
可用：单引号、双引号、三引号
举例1：
strvar1 = 'abc'
strvar2 = "abc,文字"
strvar3 = """
转义字符：\ + 字符
（1）把无意义的字符变的有意义
（2）把有意义的字符变的无意义
\\n：换行
\\r\\n：换行
\\t：缩进（tab，水平制表符）
\\r：把\\r后面的字符串直接拉到当前行行首
"""
print (strvar1,type(strvar1))
print (strvar2,type(strvar2))
print (strvar3,type(strvar3))
运行结果：
2）元字符串 r+字符串==>表示不转字符，原型化输入字符串。（相当于字符串中给所有特殊意义的字符加了转义符）
举例1：
strvar1=r"C:\Users"
print(strvar1)
运行结果：
C:\Users
（三）列表类型
1）列表：list
1.1）列表创建
- 一维列表的创建，使用[]可以创建一个列表对象，列表可是一种有序的集合，可以随时添加和删除其中的元素。
举例1：
#创建一个空列表
list1=[]
#定义一个普通列表
list2=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
print("list2的元素是",list2,
"\n显示该函数数据结构类型",type(list2))
运行结果：
list2的元素是 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
显示该函数数据结构类型
- 多维列表的创建。尽管 list默认是一维的，在实际应用中我们可以根据需要创建多维列表。多维列表的创建可以使用[]嵌套。
举例1：
lists=[[1,2],['a','b']]
print("多维列表：",lists,
"\n显示该函数数据结构类型",type(list2))
运行结果：
多维列表： [[1, 2], [‘a’, ‘b’]]
显示该函数数据结构类型
1.2）列表查询
-
正向索引下标：
列表元素从左到右依次为：0、1、2、3…… -
逆向索引下标
列表元素从右向左依次为：-1、-2、-3、-4、-5……
举例1：
list2=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
print("\n列表切分",list2[1:8],
"\n固定步长访问",list2[::2],
"\n从后往前访问",list2[-3])
运行结果：
列表切分 [2, 3, 4, 5, 6, 7, 8]
固定步长访问 [1, 3, 5, 7, 9, 11, 13, 15]
从后往前访问 13
举例2：当列表很长的时，要获取列表中最后一个元素，一种方法是使用逆向索引下标，另一种方法是使用len函数获取容器类型数据总长度。
list2=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
print("取列表中最后一个元素",list2[len(list2)-1])
运行结果：
取列表中最后一个元素 15
1.3）列表元素增加
- 列表的增加，append()可以在列表末尾增加新的项目，可以增加一个元素，也可以增加一个list对从成为多维列表。
举例1：
#增加一个元素
list1=[1,2,3,4,5,6]
list1.append(11)
print("增加元素后的列表",list1)
#增加一个list
lists=[[1,2],['a','b']]
lists.append(["hello",5])
print("增加列表后的列表",lists)
运行结果：
增加元素后的列表 [1, 2, 3, 4, 5, 6, 11]
增加列表后的列表 [[1, 2], [‘a’, ‘b’],[‘hello’, 5]]
1.4）列表元素删除
- 列表的删除，remove()函数可以删除指定值的元素，list.remove()会删除list对象中值为i元素，若不存在这个元素则报错；pop()函数可以删除指定下标的元组，默认为列表对象最后一个元素，list.pop(i)则删除下标为i的元素。
举例1：
#删除list1列表中的元素5
list1=[1,2,3,4,5,6]
list1.remove(5)
#删除lists列表对象的最后一个元素
lists=[[1,2],['a','b']]
lists.pop()
print("删除指定下标元素后的列表对象",list1,
"\n删除最后一个元素的列表对象",lists)
运行结果：
删除指定下标元素后的列表对象 [1, 2, 3, 4, 6]
删除最后一个元素的列表对象 [[1, 2]]
1.5）列表元素修改
- 列表修改，list[i]=x可以直接替换列表指定下标的元素。
举例1：
list1=[1,2,3,4,5,6]
list1[1]=100
print("修改后的列表为",list1)
运行结果：
修改后的列表为 [1, 100, 3, 4, 5, 6]
1.6）列表相关函数
- reverse() 函数可以使列表倒置。
- len() 函数可以返回列表的元素个数。
- sort() 函数可以使列表元素升序排列。
举例1：
list1=[1,2,3,4,5,6]
list1.reverse()
print("倒置后的列表是",list1)
list1.sort()
print("len统计列表元素的个数",len(list1),
"\nsort列表升序排列",list1)
运行结果：
倒置后的列表是 [6, 5, 4, 3, 2, 1]
len统计列表元素的个数 6
sort列表升序排列 None
（四）元组类型
1）元组：tuple
1.1）元组创建
- 创建元组对象，元组一旦创建就无法对其元素进行增加，删除和修改。
- 可以使用()创建元组，元组可以为空且元素类型可以不同。但若元组中仅包含一个数字，则应该添加逗号以区别数字类型。
举例1：
tup1=('google','runoob',1997,2000)
tup2=(2,)
tup3="a","b","c","d"
tup4=()
print('tup1的元素是',tup1,
'\n显示该数据结构类型',type(tup1),
'\ntup2的元素是',tup2,
'\n显示该数据结构类型',type(tup2),
'\ntup3的元素是',tup3,
'\n显示该数据结构类型',type(tup3),
'\ntup4的元素是',tup4,
'\n显示该数据结构类型',type(tup4))
运行结果：
tup1的元素是 (‘google’, ‘runoob’, 1997, 2000)
显示该数据结构类型
tup2的元素是 (2,)
显示该数据结构类型
tup3的元素是 (‘a’, ‘b’, ‘c’, ‘d’)
显示该数据结构类型
tup4的元素是 ()
显示该数据结构类型
1.2）元组查询
访问元组可以使用下标索引来访问元组中的值
-
正向索引下标：
从左到右依次为：0、1、2、3…… -
逆向索引下标
从右向左依次为：-1、-2、-3、-4、-5……
举例1：
tup1=('google','runoob',1997,2000)
print("元组切分",tup1[1:4],
"\n从前往后访问",tup1[0],
"\n从后往前访问",tup1[-3])
运行结果：
元组切分 (‘runoob’, 1997, 2000)
从前往后访问 google
从后往前访问 runoob
1.3）元组删除
- 删除元组，使用del方法可以都删除指定的元组对象，相对的我们无法删除指定下标的元组元素。
举例1：
tup1=('google','runoob',1997,2000)
del tup1[0] #报错
运行结果：
举例2：
del tup1
print("删除后的元组 tup：")
print(tup1)
运行结果：
1.4）元组连接与复制
- 元组连接和复制。虽然元组中的元素值 是不允许修改的，但我们可以对元组进行连接组合，并且会返回一个新的元组对象。
- 使用+进行操作连接
- 使用*进行复制操作
举例1：
tup1=('google','runoob',1997,2000)
tup2=(2,3)
tup3=tup1+tup2
print("使用+进行操作连接",tup3)
tup4=tup2*3
print("使用*进行复制操作",tup4)
运行结果：
使用+进行操作连接 (‘google’, ‘runoob’, 1997, 2000, 2, 3)
使用*进行复制操作 (2, 3, 2, 3, 2, 3)
1.5）元组相关函数
- len() 函数可以返回元组元素的个数。
- max() 函数可以返回元组中的最大元素。
- min() 函数可以返回元组中的最小元素
举例1：
tup1=('google','runoob',1997,2000)
tup2=(2,3,33,55,100)
print("计算元组的元素个数",len(tup1),
"\n求元组的最大元素",max(tup2),
"\n求元组的最小元素",min(tup2))
运行结果：
计算元组的元素个数 4
求元组的最大元素 100
求元组的最小元素 2
（五）字典类型
1）字典：dict
1.1）字典创建
- 方法一：{键1:值1,键2:值2,键3:值3……}常规创建字典，键具有唯一性。
- 方法二：使用zip方法创建字典。
举例1：生成一个空字典和一个普通字典。
dict1={"id":"l100","name":"cooc"}
dict2={}
print("显示该数据结构类型",type(dict1))
运行结果：
显示该数据结构类型
举例2：zip()方法可以返回元组组成的列表，这可以帮助我们快速构建字典。
demo_dict=dict(zip("abc","123"))
print("显示字典数据形式",demo_dict,
"\n显示该数据结构类型",type(demo_dict))
运行结果：
显示字典数据形式 {‘a’: ‘1’, ‘b’: ‘2’, ‘c’: ‘3’}
显示该数据结构类型
1.2）字典查询
- 方法一：通过键获取值。
- 方法二：使用get(key,default=None)方法获取指定键的值。
举例1：
dict1={"id":"l100","name":"cooc"}
#查找id键的值
print("常规查询：",dict1["id"])
print("根据键查询:",dict1.get("id"))
运行结果：
常规查询： l100
根据键查询: l100
1.3）字典增加
- 方法：字典名[键]=值
- 增加列，其实就是增加字典中一个键值对
举例1：
dict1={"id":"l100","name":"cooc"}
dict1["school"]="school1"
print("增加一个键值对:"，dict1)
运行结果：
增加一个键值对: {‘id’: ‘l100’, ‘name’: ‘cooc’, ‘school’: ‘school1’}
1.4）字典删除
- 方法一：del 字典名[键值]，删除字典中一个键值对。
- 方法二：字典名.pop[键值]，删除字典中一个键值对。
举例1：
dict1={"id":"l100","name":"cooc"}
del dict1[id]
print("删除id键后字典：",dict1)
dict1={"id":"l100","name":"cooc"}
dict1.pop('id')
print("删除id键后字典：",dict1)
运行结果：
{‘name’: ‘cooc’}
1.5）字典修改
- 方法一：字典名[键]=值
- 方法二：字典名.update({键:值})
举例1：
dict1={"id":"l100","name":"cooc"}
dict1["id"]="001"
print("修改id键对应的值后的dict1:",dict1)
dict1={"id":"l100","name":"cooc"}
dict1.update({"name":"lily"})
print("修改name对应的值后的后dict1:",dict1)
运行结果：
修改id键对应的值后的dict1: {‘id’: ‘001’, ‘name’: ‘cooc’}
修改name对应的值后的后dict1: {‘id’: ‘l100’, ‘name’: ‘lily’}
（六）集合类型
1）集合：set
1.1）集合创建
-集合的创建，集合是数学概念上集合，不会出现重复值，所有的元素按照一定顺序排列，若元素为数字则按照数字大小排列。使用set()函数创建集合会自动地拆分多个字母组成的字符串。
举例1：
mySet1=set("abcgefa12312123")
mySet2={"大","小","点","多"}
mySet3=set(("hello","world"))
print("集合1",mySet1,
"\n显示该数据结构类型",type(mySet1),
"\n集合2",mySet2,
"\n集合3",mySet3)
运行结果：
集合1 {‘g’, ‘3’, ‘b’, ‘2’, ‘f’, ‘a’, ‘1’, ‘e’, ‘c’}
显示该数据结构类型
集合2 {‘小’, ‘点’, ‘多’, ‘大’}
集合3 {‘hello’, ‘world’}
1.2）集合查询
- 不可以获取集合的元素，但是可以使用in判断这个元素是否在集合中，若存在为真，反之为假。
举例1：
mySet={"a","b","c","d","e","f"}
"a" in mySet
运行结果：
True
1.3）集合元素增加
- 方法一：add()函数可以在集合对象中加入新元素，但若元素已经存在，则无效果。
- 方法二：update表示添加（并非修改），是一个一个添加，并且按照顺序添加进集合。
举例1：
mySet={"a","b","c","d","e","f"}
mySet.add("ghk")
mySet.add("a")
print("add()后的集合",mySet)
mySet.update("tyu")
print("update()后的集合",mySet)
运行结果：
add()后的集合 {‘d’, ‘b’, ‘f’, ‘a’, ‘ghk’, ‘e’, ‘c’}
update()后的集合 {‘d’, ‘b’, ‘t’, ‘f’, ‘a’, ‘ghk’, ‘e’, ‘u’, ‘y’, ‘c’}
1.4）集合元素删除
- remove() 函数可以将集合中的元素删除。
- discard() 函数可以删除集合中指定元素，且元素不存在不报错。
- pop() 函数可以随机删除集合中的一个元素（默认删除最后一个元素）
- clear() 函数可以清空集合。
举例1：
mySet={"a","b","c","d","e","f"}
mySet.remove("a")
print("删除指定元素后的集合",mySet)
mySet.discard("x")
print("删除不存在的元素后的集合",mySet)
mySet.pop()
print("随机删除元素后的集合",mySet)
mySet.clear()
print("删除所有元素后的集合",mySet)
运行结果：
删除指定元素后的集合 {‘d’, ‘b’, ‘f’, ‘e’, ‘c’}
删除不存在的元素后的集合 {‘d’, ‘b’, ‘f’, ‘e’, ‘c’}
随机删除元素后的集合 {‘b’, ‘f’, ‘e’, ‘c’}
删除所有元素后的集合 set()
1.5）集合相关函数
- len() 函数查询集合的长度
- copy() 函数复制集合中的元素并生成一个新的集合。
- 集合的运算。首先建立两个新的集合用于运算。在集合运算中，'-‘表示求差集，’&‘表示求交集，’|‘表示求并集，’^'表示两个集合的并集减去交集。
举例1：
mySet={"a","b","c","d","e","f"}
copy_mySet=mySet.copy()
print("len()返回集合的长度",len(mySet),
"\ncopy()生成的集合",copy_mySet)
运行结果：
len()返回集合的长度 6
copy()生成的集合 {‘f’, ‘d’, ‘a’, ‘b’, ‘e’, ‘c’}
举例2：
a=set("apple")
b=set("banana")
print("求差集",a-b,
"\n求并集",a|b,
"\n求交集",a&b,
"\n求非交集",a^b)
运行结果：
求差集 {‘p’, ‘e’, ‘l’}
求并集 {‘p’, ‘a’, ‘l’, ‘n’, ‘e’, ‘b’}
求交集 {‘a’}
求非交集 {‘l’, ‘b’, ‘n’, ‘p’, ‘e’}
二、python数据类型转换
Python中的数据类型转换有两种，一种是自动类型转换，即Python在计算中会自动地将不同类型的数据转换为同类型数据来进行计算；另一种是强制类型转换，即需要我们基于不同的开发需求，强制地将一个数据类型转换为另一个数据类型。
（一）自动类型转换
当两个不同类型的数据进行运算时，结果会像更高精度进行计算，精度等级：布尔<整型<浮点型<算数。
举例1：
a=10
b=True
print(a+b)
'''
在和数字运算时，True转为1，False转为0
'''
运行结果：
11
（二）强制类型转换
| 函数 | 说明 |
|---|---|
| str( ) | 可以把其他类型数据转化为字符串类型 |
| int( ) | 可以把其他类型数据转化为整型 |
| float( ) | 可以把其他类型数据转化为浮点型 |
| bool( ) | 可以把其他类型数据转化为布尔类型 |
| list( ) | 可以把其他类型数据转化为列表类型 |
| tuple( ) | 可以把其他类型数据转化为元组类型 |
| dict( ) | 可以把其他类型数据转化为字典类型 |
| set( ) | 可以把其他类型数据转化为集合类型 |
其他类型 -> str
- int -> str
举例1：
a=123
res=str(a)
print(res,type(res))
输出结果：
123
- bool -> str
举例1：
a=True
res=str(a)
print(res,type(res))
输出结果：
True
- float -> str
- float 转换 str 会去除末位为 0 的小数部分。
举例1：
a=1.23
res=str(a)
print(res,type(res))
输出结果：
1.23
- complex -> str
- complex 转换 str，会先将值转化为标准的 complex 表达式，然后再转换为字符串。
举例1：
a=3-91j
res=str(a)
print(res,type(res))
a=complex(3,-91)
res=str(a)
print(res,type(res))
输出结果：
(3-91j)
(3-91j)
- list -> str
举例1：
a=[1, 2, 3]
res=str(a)
print(res,type(res))
输出结果：
[1, 2, 3]
- tuple -> str
举例1：
a=(1, 2, 3)
res=str(a)
print(res,type(res))
输出结果：
(1, 2, 3)
- dict -> str
举例1：
a= {1: 'a', 2: 'b'}
res=str(a)
print(res,type(res))
输出结果：
{1: ‘a’, 2: ‘b’}
- set -> str
举例1：
a={1, 2, 3}
res=str(a)
print(res,type(res))
输出结果：
{1, 2, 3}
总结
- 所有类型都可以转化成str类型
其他类型 -> 数字型（bool/float/int/complex)
数字类型之间相互转换
- int -> float/bool/complex
- int转换成float，会自动给添加一位小数。
- int转换成bool，0为False，其他为真。
- int转换成complex，会自动添加虚数部分并以0j表示。
举例1：
a=123
res1=float(a)
res2=bool(a)
res3=complex(a)
print(res1,type(res1),
"\n",res2,type(res2),
"\n",res3,type(res3))
123.0
True
(123+0j)
- bool -> int/float/complex
- bool转换成int，True会转为1，False会转为0。
- bool转换成float，True会转为1.0，False会转为0.0。
- bool转换成complex，True实数部分会转为1，False实数部分会转为0，会自动添加虚数部分并以0j表示。
举例1：
b=True
res1=int(b)
res2=float(b)
res3=complex(b)
print(res1,type(res1),
"\n",res2,type(res2),
"\n",res3,type(res3))
输出结果：
1
1.0
(1+0j)
- float -> int/bool/complex
- float转换成int，会去掉小数点及后面的数值，仅保留整数部分。
- float转换成bool，0为False，其他为True。
- float转换成complex，会自动添加虚数部分并以0j表示。
举例1：
c=1.23
res1=int(c)
res2=bool(c)
res3=complex(c)
print(res1,type(res1),
"\n",res2,type(res2),
"\n",res3,type(res3))
输出结果：
1
True
(1.23+0j)
- complex -> int/float/bool
- complex不能转换成int，会报错。
- complex不能转换成float，会报错。
- complex转换成bool，0为False，其他为True。
举例1：
d=9-3j
res1=int(d)
#res2=float(d) #报错
#res3=bool(d) #报错
print(res3,type(res3))
输出结果：
True
str-> 数字类型
- str -> int
- 如果字符串中有数字(0-9)和正负号(+/-)以外的字符，就会报错。
举例1：
#str
a="123"
res=int(a)
print(res,type(res))
输出结果：
123
- str -> float
- 如果字符串含有正负号(+/-)、数字(0-9)和小数点(.)以外的字符，就会报错。
举例1：
a="123"
res=float(a)
print(res,type(res))
输出结果：
123.0
- str -> bool
- 0为False，其他为True。
举例1：
a="123"
res=bool(a)
print(res,type(res))
输出结果：
True
- str -> complex
- str转换成complex，如果能转换成int或float，则会转换后再转为complex.
- 如果str完全符合complex表达式规则，也可以转换成complex类型值。
a="123"
res=complex(a)
print(res,type(res))
#(123+0j) ，去掉小数部分
a="12+3j"
res=complex(a)
print(res,type(res))
#(12+3j) ，去掉小数部分
a="12.0+3.9j"
res=complex(a)
print(res,type(res))
#(12+3.9j) 总结：
- 数字型之间可以相互转换，但complex不支持转换成float、int
- 只有str字符串类型可以转换为数字型，并且字符串的元素必须为纯数字，如果字符串中有数字（0-9）和正负号(+/-)以外的字符，就会报错。
其他类型 -> list
- str -> list
- 字符串转为列表时，会把字符串中的每一个字符当作列表的元素。
举例1：
a='123bcd'
res=list(a)
print(res, type(res))
输出结果：
[‘1’, ‘2’, ‘3’, ‘b’, ‘c’, ‘d’]
- tuple -> list
- 元组转为列表时，会把字符串中的每一个字符当作列表的元素。
举例1：
a=(1,2,3)
res=list(a)
print(res, type(res))
输出结果：
[1, 2, 3]
- dict -> list
- 字典转为列表时，只保留字典的键。
举例1：
a={'name': 'Alice', 'Age': 5, 'Sex': 'Female'}
res=list(a)
print(res, type(res))
输出结果：
[‘name’, ‘Age’, ‘Sex’]
- set -> list
- 集合转为列表时，结果是无序的。
举例1：
a={1,2,3,'b','c','d'}
res=list(a)
print(res, type(res))
输出结果：
[1, 2, 3, ‘d’, ‘c’, ‘b’]
总结：
- 数字类型不能转换成为列表
- 字符串转为列表时，会把字符串中的每一个字符当作列表的元素。
- 元组转为列表时，会把字符串中的每一个字符当作列表的元素。
- 字典转为列表时，只保留字典的键。
- 集合转为列表时，结果是无序的，因为集合本身就是无序的。
其他类型 -> tuple
- str -> tuple
- 字符串转为元组时，会把字符串中的每一个字符当作元组的元素。
举例1：
a='123bcd'
res=tuple(a)
print(res, type(res))
输出结果：
(‘1’, ‘2’, ‘3’, ‘b’, ‘c’, ‘d’)
- list -> tuple
- 列表转为元组时，会把字符串中的每一个字符当作元组的元素。
举例1：
a=[1,2,3]
res=tuple(a)
print(res, type(res))
输出结果：
(1, 2, 3)
- dict -> tuple
- 字典转为元组时，只保留字典的键。
举例1：
a = {'name': 'Alice', 'Age': 5, 'Sex': 'Female'}
res = tuple(a)
print(res, type(res))
输出结果：
(‘name’, ‘Age’, ‘Sex’)
- set -> tuple
- 集合转为元组时，结果是无序的。
举例1：
a={1,2,3,'b','c','d'}
res=tuple(a)
print(res, type(res))
输出结果：
(1, 2, 3, ‘d’, ‘c’, ‘b’)
总结：
- 数字类型不能转换成为元组。
- 字符串转为元组时，会把字符串中的每一个字符当作元组的元素。
- 列表转为元组时，会把字符串中的每一个字符当作元组的元素。
- 字典转为元组时，只保留字典的键。
- 集合转为元组时，结果是无序的，因为集合本身就是无序的。
其他类型 -> dict
- list -> dict
- 嵌套的列表（等长二级列表）转换为字典。
- 通过zip将2个列表映射为字典。
举例1：
a=[[1, 2], ['a','b']] # 等长二级列表
res=dict(a)
print(res, type(res))
输出结果：
{1: 2, ‘a’: ‘b’}
举例2：
tp1=[1,2,3]
tp2=[1,2,3,4]
res=dict(zip(tp1,tp2))
print(res, type(res))
输出结果：
{1: 1, 2: 2, 3: 3}
- tuple -> dict
- 嵌套的元组（等长二级元组）转换为字典。
- 通过zip将2个元组映射为字典。
举例1：
a=((1, 2), (3, 4), (5, 6)) # 等长二级元组
res=dict(a)
print(res, type(res))
输出结果：
{1: 2, 3: 4, 5: 6}
举例2：
tp1=(1,2,3)
tp2=(1,2,3,4)
res=dict(zip(tp1,tp2))
print(res, type(res))
输出结果：
{1: 1, 2: 2, 3: 3}
总结：
- 数字类型、字符串、集合不能转换为字典。
- 列表、元组类型转字典类型，列表必须为等长二级容器，子容器的元素个数必须为2
其他类型 -> set
- str -> set
- 先将字符切割成元组，然后再去重转换成集合。
举例1：
a="hello"
res=set(a)
print(res,type(res))
输出结果：
{‘h’, ‘o’, ‘l’, ‘e’}
- list -> set
- 先对列表去重，再转换。
举例1：
a=[1,2,3,4]
res=set(a)
print(res,type(res))
输出结果：
{1, 2, 3, 4}
- tuple -> set
- 先对列表去重，再转换。
举例1：
a=(1,2,3,4)
res=set(a)
print(res,type(res))
输出结果：
{1, 2, 3, 4}
- dict -> set
- 会取字典的键名组合成集合。
举例1：
a={'name': 'Alice', 'Age': 5, 'Sex': 'Female'}
res=set(a)
print(res,type(res))
输出结果：
{‘Sex’, ‘Age’, ‘name’}
总结：
- 数字类型不转换为集合。
- 字符串、列表、元组转集合时，结果是无序的。
- 字典转集合时，只保留字典中的键，结果是无序的。
参考文章：
https://zhuanlan.zhihu.com/p/83086122
https://blog.csdn.net/cheuklam/article/details/120555191