Python基础教程：掌握6种基本数据类型及其互相转换

文章目录

一、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))

运行结果：

<class ‘int’>

2）二进制整型

也可以用二进制表示整型，print自动转换为十进制。

举例1：

intvar2=0b1010
print(intvar2)
print(type(intvar2))

运行结果：

10
<class ‘int’>

浮点型：flaot

1）含有小数点的数据都是浮点型。

举例1：

floatvar1=3.14
print(floatvar1,type(floatvar1))

运行结果：

3.14 <class ‘float’>

2）科学计数法

举例1：

floatvar2 = 3.456e5 #小数点向右移动5位
print(floatvar2,type(floatvar2))

运行结果：

345600.0 <class ‘float’>

布尔型：bool

布尔型数据只有两种：True、False。表示真假。

举例1：

boolvar1 = True
print (boolvar1,type(boolvar1))

运行结果：

True <class ‘bool’>

复数类型：complex

复数为实数加虚数，只要存在虚数，此数据类型就为复数类型。

表达方法1：

complexvar1 = 3-91j
print (complexvar1,type(complexvar1))

运行结果：

(3-91j) <class ‘complex’>

表达方法2：
语法：complex(实数,虚数)

complexvar2 = complex(3,-91)
print (complexvar2,type(complexvar2))

运行结果：

(3-91j) <class ‘complex’>

表达方法3：

实数部分：复数.real
虚数部分：复数.imag
复数的共轭：复数.conjugate()

x = 3-91j
x.imag #输出 ：-91.0
x.real #输出 ：3.0
x.conjugate() #输出 ：(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]
显示该函数数据结构类型 <class ‘list’>

多维列表的创建。尽管 list默认是一维的，在实际应用中我们可以根据需要创建多维列表。多维列表的创建可以使用[]嵌套。

举例1：

lists=[[1,2],['a','b']]
print("多维列表：",lists,
	   "\n显示该函数数据结构类型",type(list2))

运行结果：

多维列表： [[1, 2], [‘a’, ‘b’]]
显示该函数数据结构类型 <class ‘list’>

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)
显示该数据结构类型 <class ‘tuple’>
tup2的元素是 (2,)
显示该数据结构类型 <class ‘tuple’>
tup3的元素是 (‘a’, ‘b’, ‘c’, ‘d’)
显示该数据结构类型 <class ‘tuple’>
tup4的元素是 ()
显示该数据结构类型 <class ‘tuple’>

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))

运行结果：

显示该数据结构类型 <class ‘dict’>

举例2：zip()方法可以返回元组组成的列表，这可以帮助我们快速构建字典。

demo_dict=dict(zip("abc","123"))
print("显示字典数据形式",demo_dict,
"\n显示该数据结构类型",type(demo_dict))

运行结果：

显示字典数据形式 {‘a’: ‘1’, ‘b’: ‘2’, ‘c’: ‘3’}
显示该数据结构类型 <class ‘dict’>

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’}
显示该数据结构类型 <class ‘set’>
集合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 <class ‘str’>

bool -> str

举例1：

a=True
res=str(a)
print(res,type(res))

输出结果：

True <class ‘str’>

float -> str

float 转换 str 会去除末位为 0 的小数部分。

举例1：

a=1.23
res=str(a)
print(res,type(res))

输出结果：

1.23 <class ‘str’>

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) <class ‘str’>
(3-91j) <class ‘str’>

list -> str

举例1：

a=[1, 2, 3]
res=str(a)
print(res,type(res))

输出结果：

[1, 2, 3] <class ‘str’>

tuple -> str

举例1：

a=(1, 2, 3)
res=str(a)
print(res,type(res))

输出结果：

(1, 2, 3) <class ‘str’>

dict -> str

举例1：

a= {1: 'a', 2: 'b'} 
res=str(a)
print(res,type(res))

输出结果：

{1: ‘a’, 2: ‘b’} <class ‘str’>

set -> str

举例1：

a={1, 2, 3}
res=str(a)
print(res,type(res))

输出结果：

{1, 2, 3} <class ‘str’>

总结

所有类型都可以转化成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 <class ‘float’>
True <class ‘bool’>
(123+0j) <class ‘complex’>

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 <class ‘int’>
1.0 <class ‘float’>
(1+0j) <class ‘complex’>

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 <class ‘int’>
True <class ‘bool’>
(1.23+0j) <class ‘complex’>

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 <class ‘bool’>

str-> 数字类型

str -> int

如果字符串中有数字(0-9)和正负号(+/-)以外的字符，就会报错。

举例1：

#str
a="123"
res=int(a)
print(res,type(res))

输出结果：

123 <class ‘int’>

str -> float

如果字符串含有正负号(+/-)、数字(0-9)和小数点(.)以外的字符，就会报错。

举例1：

a="123"
res=float(a)
print(res,type(res))

输出结果：

123.0 <class ‘float’>

str -> bool

0为False，其他为True。

举例1：

a="123"
res=bool(a)
print(res,type(res))

输出结果：

True <class ‘bool’>

str -> complex

str转换成complex，如果能转换成int或float，则会转换后再转为complex.

如果str完全符合complex表达式规则，也可以转换成complex类型值。

a="123"
res=complex(a)
print(res,type(res))
 #(123+0j) <class 'complex'>

a="1.23"
res=complex(a)
print(res,type(res))
#(1.23+0j) <class 'complex'>

a="123.0" 
res=complex(a)
print(res,type(res))
#(123+0j) <class 'complex'>，去掉小数部分

a="12+3j"
res=complex(a)
print(res,type(res))
#(12+3j) <class 'complex'>

a="12.0+3.0j"
res=complex(a)
print(res,type(res))
#(12+3j) <class 'complex'>，去掉小数部分

a="12.0+3.9j"
res=complex(a)
print(res,type(res))
#(12+3.9j) <class 'complex'>

总结：

数字型之间可以相互转换，但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’] <class ‘list’>

tuple -> list

元组转为列表时，会把字符串中的每一个字符当作列表的元素。

举例1：

a=(1,2,3)
res=list(a)
print(res, type(res))

输出结果：

[1, 2, 3] <class ‘list’>

dict -> list

字典转为列表时，只保留字典的键。

举例1：

a={'name': 'Alice', 'Age': 5, 'Sex': 'Female'} 
res=list(a)
print(res, type(res))

输出结果：

[‘name’, ‘Age’, ‘Sex’] <class ‘list’>

set -> list

集合转为列表时，结果是无序的。

举例1：

a={1,2,3,'b','c','d'}
res=list(a)
print(res, type(res))

输出结果：

[1, 2, 3, ‘d’, ‘c’, ‘b’] <class ‘list’>

总结：

数字类型不能转换成为列表

字符串转为列表时，会把字符串中的每一个字符当作列表的元素。

元组转为列表时，会把字符串中的每一个字符当作列表的元素。

字典转为列表时，只保留字典的键。

集合转为列表时，结果是无序的，因为集合本身就是无序的。

---

其他类型 -> tuple

str -> tuple

字符串转为元组时，会把字符串中的每一个字符当作元组的元素。

举例1：

a='123bcd' 
res=tuple(a)
print(res, type(res))

输出结果：

(‘1’, ‘2’, ‘3’, ‘b’, ‘c’, ‘d’) <class ‘tuple’>

list -> tuple

列表转为元组时，会把字符串中的每一个字符当作元组的元素。

举例1：

a=[1,2,3]
res=tuple(a)
print(res, type(res))

输出结果：

(1, 2, 3) <class ‘tuple’>

dict -> tuple

字典转为元组时，只保留字典的键。

举例1：

a = {'name': 'Alice', 'Age': 5, 'Sex': 'Female'} 
res = tuple(a)
print(res, type(res))

输出结果：

(‘name’, ‘Age’, ‘Sex’) <class ‘tuple’>

set -> tuple

集合转为元组时，结果是无序的。

举例1：

a={1,2,3,'b','c','d'}
res=tuple(a)
print(res, type(res))

输出结果：

(1, 2, 3, ‘d’, ‘c’, ‘b’) <class ‘tuple’>

总结：

数字类型不能转换成为元组。

字符串转为元组时，会把字符串中的每一个字符当作元组的元素。

列表转为元组时，会把字符串中的每一个字符当作元组的元素。

字典转为元组时，只保留字典的键。

集合转为元组时，结果是无序的，因为集合本身就是无序的。

---

其他类型 -> dict

list -> dict

嵌套的列表（等长二级列表）转换为字典。

通过zip将2个列表映射为字典。

举例1：

a=[[1, 2], ['a','b']] # 等长二级列表
res=dict(a)
print(res, type(res)) 

输出结果：

{1: 2, ‘a’: ‘b’} <class ‘dict’>

举例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} <class ‘dict’>

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} <class ‘dict’>

举例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} <class ‘dict’>

总结：

数字类型、字符串、集合不能转换为字典。

列表、元组类型转字典类型，列表必须为等长二级容器，子容器的元素个数必须为2

---

其他类型 -> set

str -> set

先将字符切割成元组，然后再去重转换成集合。

举例1：

a="hello"
res=set(a)
print(res,type(res))

输出结果：

{‘h’, ‘o’, ‘l’, ‘e’} <class ‘set’>

list -> set

先对列表去重，再转换。

举例1：

a=[1,2,3,4]
res=set(a)
print(res,type(res))

输出结果：

{1, 2, 3, 4} <class ‘set’>

tuple -> set

先对列表去重，再转换。

举例1：

a=(1,2,3,4)
res=set(a)
print(res,type(res))

输出结果：

{1, 2, 3, 4} <class ‘set’>

dict -> set

会取字典的键名组合成集合。

举例1：

a={'name': 'Alice', 'Age': 5, 'Sex': 'Female'} 
res=set(a)
print(res,type(res))

输出结果：

{‘Sex’, ‘Age’, ‘name’} <class ‘set’>

总结：

数字类型不转换为集合。

字符串、列表、元组转集合时，结果是无序的。

字典转集合时，只保留字典中的键，结果是无序的。

参考文章：
https://zhuanlan.zhihu.com/p/83086122
https://blog.csdn.net/cheuklam/article/details/120555191

作者：sodaloveer