Python 元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

如下实例：

tup1 = ('physics', 'chemistry', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

tup3 = "a", "b", "c", "d";

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);

tup2 = (1, 2, 3, 4, 5, 6, 7 );

print "tup1[0]: ", tup1[0]

print "tup2[1:5]: ", tup2[1:5]

以上实例输出结果：

tup1[0]: physics

tup2[1:5]: (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python

# -*- coding: UTF-8 -*-

tup1 = (12, 34.56);

tup2 = ('abc', 'xyz');

# 以下修改元组元素操作是非法的。

# tup1[0] = 100;

# 创建一个新的元组

tup3 = tup1 + tup2;

print tup3;

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python

tup = ('physics', 'chemistry', 1997, 2000);

print tup;

del tup;

print "After deleting tup : "

print tup;

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

('physics', 'chemistry', 1997, 2000)

After deleting tup :

Traceback (most recent call last):

File "test.py", line 9, in

print tup;

NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式

结果

描述

len((1, 2, 3))

3

计算元素个数

(1, 2, 3) + (4, 5, 6)

(1, 2, 3, 4, 5, 6)

连接

[‘Hi!’] * 4

[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]

复制

3 in (1, 2, 3)

True

元素是否存在

for x in (1, 2, 3): print x,

1 2 3

迭代

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('spam', 'Spam', 'SPAM!')

Python 表达式

结果

描述

L[2]

‘SPAM!’

读取第三个元素

L[-2]

‘Spam’

反向读取；读取倒数第二个元素

L[1:]

(‘Spam’, ‘SPAM!’)

截取元素

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组，如下实例：

#!/usr/bin/python

print 'abc', -4.24e93, 18+6.6j, 'xyz';

x, y = 1, 2;

print "Value of x , y : ", x,y;

以上实例运行结果：

abc -4.24e+93 (18+6.6j) xyz

Value of x , y : 1 2

元组内置函数

Python元组包含了以下内置函数

序号

方法及描述

1

cmp(tuple1, tuple2)

比较两个元组元素。

2

len(tuple)

计算元组元素个数。

3

max(tuple)

返回元组中元素最大值。

4

min(tuple)

返回元组中元素最小值。

5

tuple(seq)

将列表转换为元组。

喜欢 (0)or分享 (0)

Python 元组（Tuple）

Python中的元组类似于列表。两者之间的区别在于，一旦分配了元组，就无法更改其元素，而在列表中，可以更改元素。

创建一个元组

通过将所有项目（元素）放在括号内()（以逗号分隔）来创建元组。括号是可选的，但是，使用括号是一个好习惯。

元组可以具有任意数量的项，并且它们可以具有不同的类型（整数，浮点数，列表，字符串等）。

也可以在不使用括号的情况下创建元组。这称为元组包装。

用一个元素创建一个元组有点特殊。

只有一个元素的元组，括号内仅包含一个元素是不够的。我们将需要一个逗号结尾来表明它实际上是一个元组。

示例my_tuple = ("hello")

print(type(my_tuple)) #

# 创建一个只有一个元素的元组

my_tuple = ("hello",)

print(type(my_tuple)) #

# 括号是可选的

my_tuple = "hello",

print(type(my_tuple)) #

访问元组元素

我们可以通过多种方式访问元组的元素。

1.索引

我们可以使用索引运算符[]访问索引从0开始的元组中的项目。

因此，具有6个元素的元组将具有从0到5的索引。尝试访问元组之外的元素（例如6、7 ...）将引发IndexError。

索引必须是整数；因此我们不能使用float或其他类型。如果使用会导致TypeError。

同样，使用嵌套索引访问嵌套元组，如下面的示例所示。my_tuple = ('p','e','r','m','i','t')

print(my_tuple[0]) # 'p'

print(my_tuple[5]) # 't'

# IndexError:列表索引超出范围

# print(my_tuple[6])

# 索引必须是整数

# TypeError: 列表索引必须是整数，而不是浮点数

# my_tuple[2.0]

# 嵌套元组

n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

# 嵌套索引

print(n_tuple[0][3]) # 's'

print(n_tuple[1][1]) # 4

2.负索引

Python允许对其序列进行负索引。

索引-1表示最后一项，-2表示倒数第二项，依此类推。

示例my_tuple = ('p','e','r','m','i','t')

# 输出: 't'

print(my_tuple[-1])

# 输出: 'p'

print(my_tuple[-6])

3.切片

我们可以使用切片运算符-冒号“：”访问元组中的一系列项目。

示例my_tuple = ('p','r','o','g','r','a','m','i','z')

# 第2个-4个元素

# 输出: ('r', 'o', 'g')

print(my_tuple[1:4])

# 从开始到第二个元素

# 输出: ('p', 'r')

print(my_tuple[:-7])

# 第8个元素到结尾

# 输出: ('i', 'z')

print(my_tuple[7:])

# 从开始到结尾的元素

# 输出: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

print(my_tuple[:])

通过考虑索引位于元素之间，可以最好地可视化切片，如下所示。因此，如果要访问范围，则需要将元组中的部分切片的索引。

更换元组

与列表不同，元组是不可变的。

这意味着一旦分配了元组的元素就无法更改。但是，如果元素本身是可变的数据类型（如列表），则可以更改其嵌套项目。

我们还可以将元组分配给不同的值（重新分配）。

示例my_tuple = (4, 2, 3, [6, 5])

# TypeError: 'tuple' 对象不支持项分配

# my_tuple[1] = 9

# 但是，可变要素的项目可以变更

my_tuple[3][0] = 9 # Output: (4, 2, 3, [9, 5])

print(my_tuple)

# 元组可以重新分配

my_tuple = ('p','r','o','g','r','a','m','i','z')

# 输出: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

print(my_tuple)

我们可以使用+运算符来合并两个元组。这也称为串联。

我们还可以使用运算符*，将元组中的元素重复给定次数。

无论+和*操作会导致新的记录。

示例# 串联

# 输出: (1, 2, 3, 4, 5, 6)

print((1, 2, 3) + (4, 5, 6))

# 重复

# 输出: ('Repeat', 'Repeat', 'Repeat')

print(("Repeat",) * 3)

删除元组

如上所述，我们不能更改元组中的元素。这也意味着我们无法删除或删除元组中的项目。

但是可以使用关键字del完全删除一个元组。

示例my_tuple = ('p','r','o','g','r','a','m','i','z')

# 不能删除条目

# TypeError: 'tuple'对象不支持项目删除

# del my_tuple[3]

# 可以删除整个元组

del my_tuple

# NameError: 未定义名称“ my_tuple”

print(my_tuple)

元组方法

元组不提供添加项目或删除项目的方法。仅以下两种方法可用。Python元组方法方法描述

返回等于x的第一项的索引

Python元组方法的一些示例：

示例my_tuple = ('a','p','p','l','e',)

print(my_tuple.count('p')) # Output: 2

print(my_tuple.index('l')) # Output: 3

其他元组操作

1.元组成员资格测试

我们可以使用关键字in来测试项目是否存在于元组中。

示例my_tuple = ('a','p','p','l','e',)

# In 操作

# 输出: True

print('a' in my_tuple)

# 输出: False

print('b' in my_tuple)

# Not in 操作

# 输出: True

print('g' not in my_tuple)

2.遍历元组

使用for循环，我们可以遍历元组中的每个项目。

示例# 输出:

# Hello John

# Hello Kate

for name in ('John','Kate'):

print("Hello",name)

元组相比于列表的优势

由于元组与列表非常相似，因此它们在类似情况下也都使用。

但是，在列表上实现元组具有某些优点。下面列出了一些主要优点：我们通常将元组用于异构（不同）数据类型，将列表用于同类（相似）数据类型。

由于元组是不可变的，因此遍历元组要比使用list更快。因此，性能略有提升。

包含不可变元素的元组可以用作字典的键。对于列表，这是不可能的。

如果您拥有不变的数据，则将其实现为元组将确保其保持写保护。