在这里，我将用最直白，最不绕弯子的方式，给大家提供元组的知识点讲解。所有的内容都是我自己的理解和总结，保证不抄袭，完整有效。希望看完这篇内容，你能更了解元组，来不及看完也没关系，收藏起来慢慢看哇！

好了，废话不多说，咱们开学→

一、定义

元组是序列的一个类型，具备有序、不可变等特点，格式就是用小括号()包裹元素，元素可以是任意数据类型（数字、字符串、列表、元组等）。

元组的几个创建方式如下：

"""创建方式""" x1=(1,2,"abc",[3,4]) #标准括号创建 x2=1,2,3,4 #省略括号创建（注意：逗号才是元组的核心标志） x3=(1,) #单个元素的元组，必须要在元素后面增加一个逗号，否则x3=(1),只是整数

二、性质

1.不可变性

这里的不可变，指元组的直接元素不能被改变和增加，但如果元素是可变对象那么也能改变，举个例子⬇️

x=(1,2,3) print(x.append(4)) #报错 x=([1,2,3]) print(x.append(4)) print(x) #[1,2,3,4] x=(1,[2,3],4) print(x[1].append(5)) print(x) #(1,[2,3,5]4)

2.有序性

元组和列表一样，都具备下标索引值，每个元素有自己的索引值

"""这是一个包含各种元素的元组""" x=(1,"abc",[2,3],4)

每个元素对应的索引值如下：

3.允许重复元素

一个元组里面可以同时有多个相同的元素。

x=(1,2,1,3,4)

4.支持任意类型混合存放

一个元组里面可以同时有字符串、列表等序列类型存在。

x=(1,"abc",[2,3],4)

5、可哈希

简单来说，就是可调用hash(对象)，且不报错，就是可哈希对象。

hash((1,2,3)) #不报错，纯不可变元组可哈希 hash((1,[2,3])) #报错，有可变对象的元组不可哈希

三、下标与切片（和列表方法相同）

1.下标

利用下标索引值取相应的元素

x=(10,20,30,40) print(x[0]) #10 print(x[-1]) #40 print(x[7]) #取值大于最大下标索引值，报错

2.切片

学好切片知识，相当于学好一半以上的元组和列表啦~

切片格式如下⬇️

x[start:end:step]

切片的操作生成的是新的元组，而不是改变原元组（切记！元组是不可变对象），当然列表也一样，原列表也不会受到影响。

以防大家还没学过列表的切片方法，这里再整理一下。

x=(1,2,3,4,5,6) print(x[0:2]) #(1,2,3) print(x[0:5:2]) #(1,3,5)取步长为2的元组 print(x[:2]) #(1,2,3)冒号前面省略，就是从头开始取值 print(x[2:]) #(3,4,5,6)当然冒号后面省略也是一个意思 print(x[:]) #(1,2,3,4,5,6)只有一个冒号就是全选^_^ print(x[::-1]) #(6,5,4,3,2,1)步长为-1的话就是将整个元组反转

切片是一个非常方便的方法，大家要好好学呀~

四、元组的运算

虽然元组是不可变对象，但我们依旧可以利用运算符来生成新元组。

1.拼接运算符（+）

x=(1,2) y=(3,4) z=x+y print(z) #(1,2,3,4)

2.重复运算符（*）

x=(1,2) y=x*3 print(y) #(1,2,1,2,1,2)

3.判断运算符（in/not in）

判断运算符可判断元素是否存在元组中

x=(1,2,3) 3 in x #True y=(4,5,6) 3 not in y #True

4.比较运算符（<、<=、==、>=、>、!=）

元组比较大小本质是从第一个元素开始比较，直到区分出两个元组的大小。但前提是两个元组之间的元素必须是可互相比较的类型，若类型不兼容则会直接报错。

①元组按ASCII 编码值逐字符比较

一般来说我们都只比较数字和英文字母：数字编码 < 大写英文字母 < 小写英文字母

print(("apple",)<("banana",)) #True print(("A",999)<("B",1)) #True,第一项相互比较能出结果就不会比较第二项 print(("A",)<("a",)) #True

②元组按长短比较

若两个元素的前几个字母相同，那么就比较元素的长短。

print(("He",)<("Hello",)) #True,两个元素字母相同的情况下，元素越短越小

若两个元组的前几个元素相同，那么就比较元组的长短。

print((1,2)<(1,2,"ab")) #True,元组越短越小

③不能跨类型比较

print((10,)<("10",)) #报错，两个不同类型的元素之间不能比较大小

④嵌套型元组比较

自动递归拆开内层元组，逐个元素之间比较

x=(1,2,(3,4)) y=(1,2,(3,5)) print(x<y) #True

⑤特殊的布尔值

众所周知，布尔的本质是int类型，True=1，False=0，所以布尔的比较不是字母比较大小，而是比较数字0和1。

print((False,)<(1,)) #True print((False,)<(True,)) #True(0<1) print((0,)<(True,)) #True

五、元组的内置函数

t=(1,2,3,4) print(len(t)) #4

t=(1,3,5,7) print(max(t)) #7

t=(1,3,5,7) print(min(t)) #1

t=(1,3,5,7) print(sum(t)) #16

t=(3,5,2,6) print(sorted(t)) #[2,3,5,6]

六、元组自带方法

受元组内部元素不可变的影响，元组不易改动，因此元组所含的方法也相对较少。

t=(1,2,2,3,2,4) print(t.count(2)) #3

t=(1,2,3,4) print(t.index(2)) #1

七、元组的解包

把元组中每一个元素，一次性赋值给多个变量，这个过程叫元组解包。

元组解包实现的基础前提是——变量数量等于元组个数，两者一一对应。

1.经典解包

比较常用的就是两个变量之间的交叉互换。

x=2 y=3 x,y=y,x print(x,y) #3 2

此过程的理解就是，我们先将x,y打包成元组(2,3)，接着再解包赋值给y,x

2.“废弃变量”的解包

通常情况下，我们用“_”来代替不需要赋值的变量，我们将这个变量称为废弃变量。

x=(10,20,30) a,_,c=x print(a,c) #10 30

3.不定长元组解包

当一个元组足够长时，我们一般无法知晓元祖的长度，和元素的个数，这种情况下我们用，一部分变量 +*变量接收剩余所有元素，生成结果是列表。

x=(1,2,3,4,5,6) one,*t,last=x print(t) #[2,3,4,5] print(one) #1

注意：一个解包语句只能有一个*，若出现两个及两个以上，则代码报错。

当然，在特定情况下，赋值对象也可以只有一个*变量

x=(1,2,3) print(*x) #1 2 3

4.嵌套元组解包

根据元组的嵌套规律，拆解应赋值的元素即可

x=(1,2,(3,4)) a,b,(c,d)=x print(a,b,c,d) #1 2 3 4

八、类型转换

在数据类型中，大多数类型之间都是可以相互转换的。

1.元组→其他

x=(1,2,3) t=list(x) print(t) #[1,2,3]

x=(1,2,3) t=str(x) print(t) #"(1,2,3)"

x=("a","b","c") t="".join(x) print(t) #abc

x=(1,1,2,3,4) t=set(x) print(t) #{1,3,2,4},集合具有不重复性和无序性

"""字典需要两两配对，所以要变成字典需要元组内部两两一组""" x=(("name","小明"),("years",10)) t=dict(x) print(t) #{'name':'小明','years':'10'}

2.其他→元组

x="hello" t=tuple(x) print(t) #('h','e','l','l','o')

x=[1,2,3,4] t=tuple(x) print(t) #(1,2,3,4)

x={1,2,3,4} t=tuple(x) print(t) #(1,2,3,4)

x=range(1,6) t=tuple(x) print(t) #(1,2,3,4,5)

x={'x':10,'y':20} t=tuple(x) print(t) #(x,y),字典转换成元组，默认只提取字典的key值(冒号前面的值) y=tuple(x.items()) print(y) #(10,20),利用items方法可以提取字典的键值对(冒号后面的值)

总结

好了，以上就是全部的元组方法了，如果你提前学习了列表的知识点，会发现元组的知识和列表的知识实质上大差不差，但元组和列表并不能混为一谈。

不论你是学生、打工人、忙忙碌碌的陌生人，我都希望你已经掌握这个小小的知识点，希望本博客能祝你一臂之力，给你提供到一点点帮助。

最后，本博客可能未及时发现一些错误或漏洞，如果你发现了这些错误，感谢及时纠错！！！