# 从零开始学Python：第十二课-常用数据结构之元组

### 定义和使用元组

``````# 定义一个三元组
t1 = (
30,
10,
55)
# 定义一个四元组
t2 = (
'骆昊',
40, True,
'四川成都')

# 查看变量的类型

print(
type(t1),
type(t2))    # <class
'tuple'> <class
'tuple'>
# 查看元组中元素的数量

print(
len(t1),
len(t2))      #
3
4

# 通过索引运算获取元组中的元素

print(t1[
0], t1[
-3])         #
30
30

print(t2[
3], t2[
-1])         # 四川成都 四川成都

# 循环遍历元组中的元素

for member in t2:

print(member)

# 成员运算

print(
100 in t1)    # False
print(
40 in t2)     # True

# 拼接
t3 = t1 + t2
print(t3)           # (
30,
10,
55,
'骆昊',
40, True,
'四川成都')

# 切片

print(t3[::
3])      # (
30,
'骆昊',
'四川成都')

# 比较运算

print(t1 == t3)    # False
print(t1 >= t3)    # False
print(t1 < (
30,
11,
55))    # True``````

``````# 空元组
a = ()

print(
type(a))    # <class
'tuple'>
# 不是元组
b = (
'hello')

print(
type(b))    # <class
'str'>
c = (
100)

print(
type(c))    # <class
'int'>
# 一元组
d = (
'hello', )

print(
type(d))    # <class
'tuple'>
e = (
100, )

print(
type(e))    # <class
'tuple'>``````

### 例子1：打包和解包操作。

``````
# 打包

a = 1, 10, 100

print(type(a), a)    # <class 'tuple'> (1, 10, 100)

# 解包

i, j, k = a

print(i, j, k)       # 1 10 100``````

``````
a
=
1
,
10
,
100
,
1000

# i, j, k = a             # ValueError: too many values to unpack (expected 3)

# i, j, k, l, m, n = a    # ValueError: not enough values to unpack (expected 6, got 4)``````

``````
a
=
1
,
10
,
100
,
1000

i,
j,
*k
=
a

print(i,
j,
k)
# 1 10 [100, 1000]

i, *j, k = a

print(i, j, k)          # 1 [10, 100] 1000

*i, j, k = a

print(i, j, k)          # [1, 10] 100 1000

*i, j = a

print(i, j)             # [1, 10, 100] 1000

i, *j = a

print(i, j)             # 1 [10, 100, 1000]

i, j, k, *l = a

print(i, j, k, l)       # 1 10 100 [1000]

i, j, k, l, *m = a

print(i, j, k, l, m)    # 1 10 100 1000 []``````

``````a, b, *
c = range(
1,
10)

print(a, b,
c)
a, b,
c = [
1,
10,
100]

print(a, b,
c)
a, *b,
c = 'hello'

print(a, b,
c)``````

``````def add(*args):
print(type(args), args)
total =
0

for
val
in args:
total +=
val

1,
10,
20)        # <

class '
tuple'> (
1,
10,
20)
1,
2,
3,
4,
5)    # <

class '
tuple'> (
1,
2,
3,
4,
5)``````

### 例子2：交换两个变量的值。

`a, b = b, a`

`a, b, c = b, c, a`

### 例子3：让函数返回多个值。

``````

def
find_max_and_min
(items):

"""找出列表中最大和最小的元素

:param items: 列表

:return: 最大和最小元素构成的二元组

"""
max_one, min_one = items[
0], items[
0]

for item
in items:

if item > max_one:
max_one = item

elif item < min_one:
min_one = item

return max_one, min_one``````

### 元组和列表的比较

• 元组是不可变类型， 不可变类型更适合多线程环境，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解多线程的时候为大家详细论述。
• 元组是不可变类型，通常 不可变类型在创建时间和占用空间上面都优于对应的可变类型。我们可以使用sys模块的getsizeof函数来检查保存相同元素的元组和列表各自占用了多少内存空间。我们也可以使用timeit模块的timeit函数来看看创建保存相同元素的元组和列表各自花费的时间，代码如下所示。
``````
import sys
import timeit

a = list(
range(
100000))
b = tuple(
range(
100000))

print(sys.getsizeof(a), sys.getsizeof(b))    #
900120
800056

print(timeit.timeit(
'[1, 2, 3, 4, 5, 6, 7, 8, 9]'))

print(timeit.timeit(
'(1, 2, 3, 4, 5, 6, 7, 8, 9)'))``````
• Python中的元组和列表是可以相互转换的，我们可以通过下面的代码来做到。
``````# 将元组转换成列表
info = (
'骆昊',
175, True,
'四川成都')

print(list(info))       # [
'骆昊',
175, True,
'四川成都']
# 将列表转换成元组
fruits = [
'apple',
'banana',
'orange']

print(tuple(fruits))    # (
'apple',
'banana',
'orange')``````

• 博文量
995
• 访问量
623088