# Python – 元组

> 原文： [https://howtodoinjava.com/python/python-tuples/](https://howtodoinjava.com/python/python-tuples/)

在 [Pyhton](https://howtodoinjava.com/python-tutorial/) 中，**元组**与`list`相似，但它是**不可变的**，并用可选的**圆括号**编写。

元组是：

*   不变的
*   有序
*   异构
*   带有索引（从零开始）
*   带圆括号（可选，但建议）
*   在迭代过程中更快，因为它是不可变的

元组对于创建对象很有用，该对象通常包含相关信息，例如： 员工信息。 换句话说，元组可以让我们将相关信息“块”在一起，并将其用作单个事物。

## 1.创建一个元组

元组中的元素用圆括号括起来，并用逗号分隔。 元组可以包含任意数量的不同类型的项。

```java
Tuple = (item1, item2, item3)
```

```java
tuple1 = ()		# empty tuple

tuple2 = (1, "2", 3.0)

tuple3 = 1, "2", 3.0

```

#### 1.1 一个元素的元组

如果元组仅包含一个元素，则不将其视为元组。 它应该以逗号结尾，以指定解释器为元组。

```java
tupleWithOneElement = ("hello", )	# Notice trailing comma

```

#### 1.2 嵌套元组

一个包含另一个元组作为元素的元组，称为嵌套元组。

```java
nestedTuple = ("hello", ("python", "world"))

```

## 2.访问元组项

我们可以使用方括号内的索引访问元组项。

*   **正索引**从元组的开始开始计数。
*   **负索引**从元组的末尾开始计数。
*   索引的**范围**将创建带有指定项目的新元组（称为切片）。
*   范围`[m:n]`表示从位置`m`（*包括*）到位置`n`（*排除*）。
*   使用**双索引**访问嵌套元组的元素。

```java
Tuple = ("a", "b", "c", "d", "e", "f")

print(Tuple[0])		# a
print(Tuple[1])		# b

print(Tuple[-1])	# f
print(Tuple[-2])	# e

print(Tuple[0:3])	# ('a', 'b', 'c')
print(Tuple[-3:-1])	# ('d', 'e')

Tuple = ("a", "b", "c", ("d", "e", "f"))

print(Tuple[3])			# ('d', 'e', 'f')
print(Tuple[3][0])		# d
print(Tuple[3][0:2])	# ('d', 'e')

```

## 3.遍历元组

使用`for`循环，以遍历元组项。

```java
Tuple = ("a", "b", "c")

for x in Tuple:
  print(x)

```

## 4.检查项目是否存在于元组中

要检查元组是否包含给定元素，可以使用`'in'`关键字和`'not in'`关键字。

```java
Tuple = ("a", "b", "c", "d", "e", "f")

if "a" in Tuple:
  print("Yes, 'a' is present")		# Yes, 'a' is present

if "p" not in Tuple:
  print("No, 'p' is not present")	# No, 'p' is not present

```

## 5.对元组进行排序

使用内置的`sorted()`语言方法对元组中的元素进行排序。

```java
Tuple = ("a", "c", "b", "d", "f", "e")

sortedTuple = sorted(Tuple)

print (sortedTuple)	# ("a", "b", "c", "d", "e", "f")

```

## 6.元组的重复和连接

要重复一个元组的所有元素，请将其乘以所需因子`N`。

```java
Tuple = ("a", "b") 

repeatedTuple = Tuple * 3

print (repeatedTuple)	# ('a', 'b', 'a', 'b', 'a', 'b')

```

要连接/连接两个或多个元组，我们可以使用`+`运算符。

```java
Tuple1 = ("a", "b", "c") 
Tuple2 = ("d", "e", "f")

joinedTuple = Tuple1 + Tuple2

print (joinedTuple)	# ("a", "b", "c", "d", "e", "f")

```

## 7.打包和解包元组

**打包**是指我们将一组值分配给变量的操作。 在打包时，元组中的所有项目都分配给一个元组对象。

在下面的示例中，所有三个值都分配给变量`Tuple`。

```java
Tuple = ("a", "b", "c")
```

**解包**称为将元组变量分配给另一个元组，并将元组中的各个项目分配给各个变量的操作。

在给定的示例中，将元组解包为新的元组，并将值`a, b, c` – 分配给变量`x, y, z`。

```java
Tuple = ("a", "b", "c")		# Packing

(x, y, z) = Tuple

print (x)	# a
print (y)	# b
print (z)	# c

```

> 在解包期间，分配左侧的元组中的元素数必须等于右侧的数量。

```java
Tuple = ("a", "b", "c")		# Packing

(x, y, z) = Tuple		# ValueError: too many values to unpack (expected 2)

(x, y, z, i) =	Tuple 	# ValueError: not enough values to unpack (expected 4, got 3)

```

## 8.命名元组

Python 提供了一种称为`namedtuple()`的**特殊类型的函数**，该函数来自`collection`模块。

命名元组类似于字典，但是支持从值和键访问，其中字典仅支持按键访问。

```java
import collections

Record = collections.namedtuple('Record', ['id', 'name', 'date'])

R1 = Record('1', 'My Record', '12/12/2020')

#Accessing using index
print("Record id is:", R1[0])		# Record id is: 1

# Accessing using key	
print("Record name is:", R1.name)	# Record name is: My Record

```

## 9\. Python 元组方法

#### 9.1 `any`

如果该元组中至少存在一个元素，则返回`True`；如果该元组为空，则返回`False`。

```java
print( any( () ) )		# Empty tuple - False
print( any( (1,) ) )	# One element tuple - True
print( any( (1, 2) ) )	# Regular tuple - True

```

#### 9.2 `min()`

返回元组的最小元素（整数）。

```java
Tuple = (4, 1, 2, 6, 9)

print( min( Tuple ) )	# 1

```

#### 9.3 `max()`

返回元组的最大元素（整数）。

```java
Tuple = (4, 1, 2, 6, 9)

print( max( Tuple ) )	# 9

```

#### 9.4 `len()`

返回元组的长度。

```java
Tuple = (4, 1, 2, 6, 9)

print( len( Tuple ) )	# 5

```

#### 9.5 `sum()`

返回元组的所有元素（整数）的总和。

```java
Tuple = (4, 1, 2, 6, 9)

print( sum( Tuple ) )	# 22

```

## 10.总结

如上所述，元组不可变，有序和索引的异构元素集合。 它写有或没有圆括号。

元组对于创建对象类型和实例非常有用。

元组支持类似于[`list`](https://howtodoinjava.com/python/python-lists/)类型的操作，只有我们不能更改元组元素。

学习愉快！

阅读更多 ：

[Python – 元组比较](https://howtodoinjava.com/python/compare-tuples/)
[Python – 列表与元组](https://howtodoinjava.com/python/lists-vs-tuples/)