目录

元组的定义

拼接元组（+）

元组重复操作符（*）

元组的索引和切片

索引

切片

python内置函数

内置函数len

内置函数min

内置函数max

 内置函数del

元组类内置函数

统计某种元素个数

内置函数count

查看元素的索引值

内置函数index

元组 比较运算符

比较运算符（==）

比较运算符（!=）

比较运算符（<）

比较运算符（>）

比较运算符（<=）

比较运算符（>=）

元组 成员运算符

成员运算符（in）

成员运算符（not in）

列表 身份运算符

身份运算符（is）

身份运算符（is not）

---

元组的定义

        用()作为边界逗号作为分隔符，可容纳所有python对象的数据类型，如：()，(1, 2, 'abc', [1, 2])等等，是可迭代的数据类型，不可以被修改。我们可以使用下面2种方式来定义元组。

        第一种：直接使用()

tuple1 = (1, 2.1, 'a', [1, 2])
print(tuple1)  # (1, 2.1, 'a', [1, 2])
tuple2 = ()
print(tuple2)  # () 空元组

在一个元组中我们可以放入任何的python对象，包括元组本身。在()中我们放入了一个整型1，一个浮点型2.1，一个字符串'a'，一个列表[1, 2]。如此就形成一个拥有4个元素的元组tuple1，1为tuple1的第一个元素，2.1为tuple1的第二个元素，'a'为tuple1的第三个元素，[1, 2]为tuple1的第四个元素。当元组中一个元素也没有时，就是一个空元组。

        第二种：使用tuple函数

tuple1 = tuple('abcdefg')
print(tuple1)  # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
tuple2 = tuple([1, 2, 3, 4, 5])
print(tuple2)  # (1, 2, 3, 4, 5)

tuple函数可以把一个可迭代对象中的每一个元素取出来，生成一个元组。因为字符串是可迭代对象，所以tuple函数把字符串中的每一个元素都取出来了，生成了元组tuple1；列表也是可迭代对象，所以tuple函数把列表中的每一个元素都取出来了，生成了元组tuple2。

拼接元组（+）

        我们可以使用+号来拼接元组。

tuple1 = tuple('abcdefg')
print(tuple1)  # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
tuple2 = tuple([1, 2, 3, 4, 5])
print(tuple2)  # (1, 2, 3, 4, 5)
tuple3 = tuple1 + tuple2
print(tuple3)  # ('a', 'b', 'c', 'd', 'e', 'f', 'g', 1, 2, 3, 4, 5)

通过使用+号我们可以把多个元组组合成一个新的元组，并且是上一个元组的最后一个元素接下一个元组的第一个元素。

        还可以通过+=的方式来拼接元组。

tuple1 = tuple('abcdefg')
print(id(tuple1))  # 2481068030656
print(tuple1)  # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
tuple2 = tuple([1, 2, 3, 4, 5])
print(id(tuple2))  # 2481068271792
print(tuple2)  # (1, 2, 3, 4, 5)
tuple2 += tuple1  # tuple2 = tuple2 + tuple1
print(id(tuple2))  # 2481067928160
print(tuple2)  # (1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e', 'f', 'g')

需要注意的是元组tuple2在使用+=拼接tuple1后，tuple2的内存地址发生了改变。这时的tuple2已经不是未拼接时的tuple2了，它已经变成了一个新的元组了。元组和列表的不同点就在于，列表是可变的数据类型，元组是不可变的数据类型。如果一个元组对象内部元素发生了变化，那么它已经不再是变化之前的元组了，而是变成了一个新的元组。

元组重复操作符（*）

        *号可以把一个元组中的所有元素重复n次，元素的个数变为原来的n倍。

tuple1 = tuple('abc') * 3
print(tuple1)  # ('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')
tuple2 = (1, 2, 3) * 2
print(tuple2)  # (1, 2, 3, 1, 2, 3)

tuple1中的元素'a'、'b'、'c'被重复了3次后变成了9个元素'a'、'b'、'c'、'a'、'b'、'c'、'a'、'b'、'c'。tuple2中的元素1、2、3被重复了2次后变成了6个元素1、2、3、1、2、3。

        还可以通过*=的方式来重复元组中的元素。

tuple1 = (1, 2, 3)
print(id(tuple1))  # 1897978717056
tuple1 *= 2
print(id(tuple1))  # 1897978330464
print(tuple1)  # (1, 2, 3, 1, 2, 3)

需要注意的是元组tuple1在使用*=重复元素后，tuple1的内存地址发生了改变。这时的tuple1已经不是重复操作前的tuple1了，它已经变成了一个新的元组了。

元组的索引和切片

        因为元组是可迭代的，所以元组具有被索引和切片的功能。

索引

        索引就是通过下标的方式去获取可迭代对象中的其中一个元素，需要注意的是下标的值(整形)不能超出可迭代对象的范围。举个例子，请看下面的代码：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[2])  # 3

        索引分为正序索引和逆序索引。正序索引是从第一个元素开始，第一个元素的下标为0，向后数，每个元素的下标依次递增1。逆序索引是从最后一个元素开始，最后一个元素的下标为-1，向前数，每个元素的下标依次递减1。以元组(1, 2, 3, 4, 5, 6)来举例，我们可以得到如下的索引：

元组(1, 2, 3, 4, 5, 6)中有6个元素，也就是列表的长度为6。正序索引的下标范围是0~5，逆序索引的下标范围是-1~-6，所以tuple1[2]和tuple1[-4]都是获取tuple1的第三个元素3。我们不能用超出索引范围的下标来索引，会报错。如下：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[6]) 

执行结果如下：

执行结果显示报错了，说pythonBase.py文件的第二行print(tuple1[6])出错了，对元组tuple1的索引超出了范围。 tuple1[6]是获取tuple1的第7个元素，但tuple1只有6个元素，根本就没有第7个元素，所以python会报错。  

切片

        切片就是索引的高级应用，索引只能获取一个元素，但切片可以获取一个或多个元素，切片的本质就是多次使用索引去获取多个元素。对元组的切片是把索引到的所有元素组成一个元组，再返回这个元组，如果什么元素都没获取到则返回空元组。在切片中下标的值可以超出可迭代对象的索引范围，超出范围部分虽然不会报错，但也获取不到任何值。举个例子，请看下面的代码：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[0:3])  # (1, 2, 3)

切片和索引一样，也是使用中括号。索引只需要在中括号中写一个下标，但切片是一个范围需要两个下标，并且两个下标之间用冒号隔开，表示从第一个下标到第二个下标范围内的元素。切片的范围是一个半开半闭区间(前闭后开)，所以切片范围[0:3]在数学中的范围表示是[0,3)，能取到的整数值有0、1、2。因此tuple1[0:3]表示获取tuple1中的第一个、第二个和第三个元素，所以执行结果为(1, 2, 3)。

        切片中的下标也可以不写，但冒号一定要写。当我们不写第一个下标时，python默认第一个下标为0；当我们不写第二个下标时，python默认第二个下标为可迭代对象的长度。如下：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[:])  # (1, 2, 3, 4, 5, 6)

我们两个下标都没写，所以python默认的切片范围是[0:6]，在数学中的范围表示是[0,6)，能取到的整数值有0、1、2、3、4、5。获取到了tuple1中的所有元素，所以执行结果为(1, 2, 3, 4, 5, 6)。

        当切片的范围超出索引范围时，python不会报错，没有超出范围部分可以正常的获取到值，超出范围的部分没有任何的值。请看如下代码：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[3:10])  # (4, 5, 6)

切片范围[3:10]，在数学中的范围表示是[3,10)，能取到的整数值有3、4、5、6、7、8、9。tuple1[3]的值是4，tuple1[4]的值是5，tuple1[5]的值是6，tuple1[6]、tuple1[7]、tuple1[8]、tuple1[9]都是超出索引范围的，超出范围是没有任何值的。所以执行结果为(4, 5, 6)。

        在切片中，我们可以使用步长的方式来间歇性获取可迭代对象中的元素。举个例子，请看下面的代码：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[0:6:2])  # (1, 3, 5)

切片[0:6:2]中，0和6我们都知道表示的是切片范围[0:6]。那最后面这个2表示的就是切片的步长了，步长也是用冒号来跟第二个下标隔开的。当我们不写切片步长时，python默认切片步长为1。我们知道，切片的本质就是多次使用索引去获取多个元素。在切片中就需要不断的改变索引的下标去获取元素，步长的意义就是每次索引下标需要递增的值，步长为1时，每获取一次元素下标加1。上面的例子中步长为2，所以是每获取一次元素，下标加2。切片多次使用索引的结果为tuple1[0]、tuple1[2]、tuple1[4]，所以执行的结果为(1, 3, 5)。

        步长为正数时，切片为正序索引。步长为负数时，切片为逆序索引。举个例子，请看下面的代码：

tuple1 = (1, 2, 3, 4, 5, 6)
print(tuple1[::-1])  # (6, 5, 4, 3, 2, 1)

切片[::-1]中两个下标都没写，表示的切片范围是[0:6]，会获取到tuple1中的所有元素。步长为-1，表示逆序索引，也就是从最后一个字符开始索引取值，并且每索引一次下标加-1。切片多次使用索引的结果为tuple1[-1]、tuple1[-2]、tuple1[-3]、tuple1[-4]、tuple1[-5]、tuple1[-6]，所以执行的结果为(6, 5, 4, 3, 2, 1)。

python内置函数

len()	返回元组的长度（元素个数）
min()	返回元组中值最小的元素（所有元素必须有可比性）
max()	返回元组中值最大的元素（所有元素必须有可比性）
del	删除整个元组

内置函数len

        我们向len函数传入一个元组，它会返回这个元组的长度（整型）。

tuple1 = (1, 2, 3, 4, 5, 6)
number = len(tuple1)
print(number)  # 6

内置函数min

        我们向min函数传入一个元组，它会返回这个元组中值最小的元素，前提是这个元组中的所有元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。

tuple1 = (1, 2, 3, 4, 5, 6)
value = min(tuple1)
print(value)  # 1
tuple2 = ('a', 'b', 'c', 'A', '5', '/')
print(min(tuple2))  # /

如果这个元组中的元素不具有可比性就会报错，例如整型和字符串是不能比较大小的。

tuple1 = (1, 2, 3, '4', '5', '6')
value = min(tuple1)
print(value) 

执行结果如下：

报错显示类型错误，字符串和整型不能比较大小。

内置函数max

        我们向max函数传入一个元组，它会返回这个元组中值最大的元素，前提是这个元组中的所有元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。

tuple1 = (1, 2, 3, 4, 5, 6)
value = max(tuple1)
print(value)  # 6
tuple2 = ('a', 'b', 'c', 'A', '5', '/')
print(max(tuple2))  # c

 内置函数del

        函数del可以删除整个元组，但不能删除元组中的元素。因为元组是不可变的数据类型，不能单独删除元组中的某个元素，只能删除整个元组。当我们删除整个元组之后，就不能再使用这个元组了，因为这个元组已经不存在了。当我们是用del删除元组后再去打印这个元组就会报错。

tuple1 = (1, 2, 3, 4, 5, 6)
del tuple1
print(tuple1)

执行结果如下：

报错显示变量名错误，变量tuple1未定义。因为tuple1已经被整个删除掉了，所以在内存中找不到tuple1。  

元组类内置函数

        元组类内置函数是在元组这个类型中定义的函数，所以想要使用这些函数，前提是使用的对象必须是一个元组。

统计某种元素个数

内置函数count

        count函数可以统计某种元素在元组中的个数，我们需要统计元组中的那种元素，就给count函数传递和元素相同的值。

tuple1 = ('a', 1, 2, 1, 'b', 3, 1)
times = tuple1.count(1)
print(times)  # 3

第一个元素是1，第2个元素是1，第4个元素是1，第7个元素是1。1在列表tuple1中有3个，所以统计出来的个数是3。

        当要统计的元素不存在时，返回0。

tuple1 = ('a', 1, 2, 1, 'b', 3, 1)
times = tuple1.count(5)
print(times)  # 0

查看元素的索引值

内置函数index

        index函数可以返回某个元素的索引下标，我们需要查看元组中的那个元素的索引下标，就给index函数传递和元素相同的值。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
index = tuple1.index('c')
print(index)  # 2

        如果元组中存在多个相同值的元素时，index函数只返回找到的第一个元素的索引下标。

tuple1 = ('a', 'b', 'c', 'b', 2, 3, 'b')
index = tuple1.index('b')
print(index)  # 1

tuple1中有3个元素的值都是'b'，但index函数只返回第二个元素'b'的索引下标。

        当要查找的元素不存在时，会报错。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
index = tuple1.index(4)
print(index) 

执行结果如下：

报错显示值错误，4不在元组中。 

元组 比较运算符

        我们一般不使用比较运算符去比较元组的大小，因为这没有什么意义，我们常用比较运算符来比较两个元组的值是否相等。元组是具有比较大小的功能的，两个元组比较大小时，首先比较两个元组的第一个元素，第一个元素值大的元组大；如果第一个元素的值相等，就比较第二个元素，第二个元素值大的元组大；如果第二个元素的值相等，则判断第三个...依此类推。元组比较大小的前提是，参与比较的元素具有可比性，如果一个元素是整型，一个元素是字符串则没法比较，python会报错。

比较运算符（==）

        ==用于判断两个元组是否相等，如果相等返回True，不相等返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
tuple2 = ('hello', 'world')
print(tuple1 == tuple2)  # False
tuple3 = (1, 2, 3)
tuple4 = (1, 2, 3)
print(tuple3 == tuple4)  # True

比较运算符（!=）

        !=用于判断两个元组是否不相等，如果不相等返回True，相等返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
tuple2 = ('hello', 'world')
print(tuple1 != tuple2)  # True
tuple3 = (1, 2, 3)
tuple4 = (1, 2, 3)
print(tuple3 != tuple4)  # False

比较运算符（<）

        <用于判断左边的元组是否小于右边的元组，如果小于返回True，大于或等于返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
tuple2 = ('hello', 'world')
print(tuple1 < tuple2)  # True
tuple3 = (1, 3)
tuple4 = (1, )
print(tuple3 < tuple4)  # False
tuple5 = (1, 2, 3)
tuple6 = (1, 2, 3)
print(tuple5 < tuple6)  # False

元组tuple1和tuple2的第一个元素都是字符串，所以它们有可比性。字符'a'的ASCⅡ值小于字符'h'的ASCⅡ值，所以tuple1小于tuple2。列表tuple3和tuple4的第一个元素都是整型1，第一个元素相等了，只能比较第二个元素。但是tuple4没有第二个元素，有总是大于无的，所以tuple3大于tuple4。tuple5和tuple6中每一个元素都是相等的，所以tuple5等于tuple6。

比较运算符（>）

        >用于判断左边的元组是否大于右边的元组，如果大于返回True，小于或等于返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
tuple2 = ('hello', 'world')
print(tuple1 > tuple2)  # False
tuple3 = (1, 3)
tuple4 = (1, )
print(tuple3 > tuple4)  # True
tuple5 = (1, 2, 3)
tuple6 = (1, 2, 3)
print(tuple5 > tuple6)  # False

比较运算符（<=）

        <=用于判断左边的元组是否小于等于右边的元组，如果小于或等于返回True，不小于且不等于（大于）返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
tuple2 = ('hello', 'world')
print(tuple1 <= tuple2)  # True
tuple3 = (1, 3)
tuple4 = (1, )
print(tuple3 <= tuple4)  # False
tuple5 = (1, 2, 3)
tuple6 = (1, 2, 3)
print(tuple5 <= tuple6)  # True

比较运算符（>=）

        >=用于判断左边的元组是否大于等于右边的元组，如果大于或等于返回True，不大于且不等于（小于）返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
tuple2 = ('hello', 'world')
print(tuple1 >= tuple2)  # False
tuple3 = (1, 3)
tuple4 = (1, )
print(tuple3 >= tuple4)  # True
tuple5 = (1, 2, 3)
tuple6 = (1, 2, 3)
print(tuple5 >= tuple6)  # True

元组 成员运算符

        成员运算符是用来判断某个python对象是否跟某个序列（可迭代对象）中的某个元素的值相同。也可以理解成是否在这个元组中，但其实看的还是元素的值是否有和这个python对象的值一样的情况。

in	判断某个对象是否在元组中，在则返回True，不在则返回False
not in	判断某个对象是否不在元组中，不在则返回True，在则返回False

成员运算符（in）

        当某个python对象跟某个序列（可迭代对象）中的某个元素的值相同时，返回True；找不到相同值的元素时，返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
print(2 in tuple1)  # True
tuple2 = ('hello', 'world')
print(3 in tuple2)  # False

元组tuple1中第五个元素的值是2，所以2 in tuple1返回True。列表list2中没有元素的值为3，所以3 in tuple2返回False。

成员运算符（not in）

        当某个python对象在某个序列（可迭代对象）中找不到值相同的元素时，返回True；找到相同值的元素时，返回False。

tuple1 = ('a', 'b', 'c', 1, 2, 3)
print(2 not in tuple1)  # False
tuple2 = ('hello', 'world')
print(3 not in tuple2)  # True

元组tuple1中第五个元素的值是2，所以2 not in tuple1返回False。列表list2中没有元素的值为3，所以3 not in tuple2返回True。

列表 身份运算符

        其实不太需要身份运算符来判断两个元组的内存地址是否一致。因为元组具有不可变的特性，这就导致了只要两个元组的值相等，它们的内存地址就是一样的。所以我们完全可以使用==和!=来代替身份运算符在元组中的作用，但我们不要把==和!=与身份运算符搞混了。==和!=判断的是值是否相等，而身份运算符判断的是内存地址是否相同。对于可变的数据类型来说，即使它们的值相等，它们的内存地址也是不同的。

is	判断左右两边的内存地址是否相同，相同返回True，否则返回False
is not	判断左右两边的内存地址是否不同，不同返回True，否则返回False

身份运算符（is）

        is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
print(id(tuple1))  # 2350294819840
print(id(tuple2))  # 2350294819840
print(tuple1 is tuple2)  # True

tuple1和tuple2都是(1, 2, 3)，因为元组是不可变的数据类型，所以两个相同的元组一定取自同一个地方。我们可以使用id函数来查看python中任意对象的内存地址，使用id函数后我们发现tuple1和tuple2的内存地址确实是相同的。tuple1和tuple2所代表的元组(1, 2, 3)取自内存中的同一个地方，所以tuple1 is tuple2返回True。

tuple1 = (1, 2, 3)
tuple2 = ('a', 2, 3)
print(id(tuple1))  # 2080912696128
print(id(tuple2))  # 2080912380480
print(tuple1 is tuple2)  # False

tuple1的值是(1, 2, 3)，tuple2的值是('a', 2, 3)。因为元组tuple1和tuple2存放在内存中不同的地方，所以tuple1 is tuple2返回False。

身份运算符（is not）

        is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：

tuple1 = (1, 2, 3)
tuple2 = ('a', 2, 3)
print(id(tuple1))  # 1992835326848
print(id(tuple2))  # 1992830685824
print(tuple1 is not tuple2)  # True

tuple1的值是(1, 2, 3)，tuple2的值是('a', 2, 3)。因为元组tuple1和tuple2存放在内存中不同的地方，所以tuple1 is not tuple2返回True。

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
print(id(tuple1))  # 2301301482496
print(id(tuple2))  # 2301301482496
print(tuple1 is not tuple2)  # False

tuple1和tuple2都是(1, 2, 3)。因为元组tuple1和tuple2存放在内存中同一个地方，所以tuple1 is not tuple2返回False。