Python编程思想（6）：列表和元组的基础知识

骑猪看日落 2023-02-11 10:10 25阅读 0赞

[《Python编程思想》总目录][Python]

**目录**

1. 序列

2. 创建列表和元组

3. 通过索引访问元素

4. 分片与子序列

5. 加法

6. 乘法

7.  in 运算符

8.  长度、最大值和最小值

--------------------

列表（list）、 元组（tuple） 和字典（dict）是Python中非常常用的三种集合类型数据结构，这三种数据结构都可用于保存多个数据项，这对于编程而言是非常重要的。这是因为程序不仅需要使用单个变量来保存数据，还需要使用多种数据结构来保存大量数据，而列表、元组和字典就可满足保存大量数据的需求。

列表和元组的功能类似，它们都按顺序保存元素，每个元素都有自己的索引，因此列表和元组都可通过索引访问元素。二者的区别在于元组是不可修改的，但列表是可修改的。字典则以key-value的形式保存数据。这三种数据结构各有特色，它们都是Python编程中必不可少的内容。

本文主要介绍列表和元组的使用方法，在下一篇文章中，会详细介绍字典的使用方法。

## **1. 序列** ##

在深入讲解列表和字典之前，先讲一下序列。

所谓序列，指的是一种包含多项数据的数据结构，序列包含的多个数据项按顺序排列，可通过索引来访问成员。

Python语言中常见序列包括字符串、列表和元组等。在前文中介绍过的字符串，其实就是一种常见的序列，可以通过索引访问字符串中的任意字符。

本文再介绍两种序列，这就是列表和元组，这两种类型看起来非常相似，它们最主要的区别在于：元组是只读的，也就是说，元组一旦初始化完，其中的所有元素都是不可更改的（不可增加、删除和修改元素的值），其实这种特性与字符串类似，字符串中的每一个字符，只能通过索引读取，不能修改，也不能删除；但列表是可变的，程序可以修改列表中所包含的元素。

在实际的应用场景中，如果只是需要保存和检索数据，并不需要修改它们，此时就应该使用元组；反之，就应该使用列表。此外，在某些时候，程序需要使用不可变的对象，比如Python要求字典的key必须是不可变的，此时程序就只能使用元组了。

## **2. 创建列表和元组** ##

创建列表和元组的语法类似，区别只是创建列表时使用一对方括号，创建元组时使用一对圆括号，并在括号中指定元组中的元素，如果有多个元素，中间用逗号分隔。

创建列表的语法格式如下：

[element1, element2, element3,...,elementn]

创建元组的语法格式如下：

(element1, element2, element3,...,elementn)

下面代码演示了如何在程序中创建列表和元组：

# 使用方括号定义列表
    my_list = ['Python', 100, 'Java']
    print(my_list)
    # 使用圆括号定义元组
    my_tuple = ('Python', 100, 'Java')
    print(my_tuple)

输出结果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70][]

## **3. 通过索引访问元素** ##

列表和元组都可通过索引来访问元素，它们的索引都是从0开始的，第1个元素的索引为0，第2个元素的索引为1...，依此类推。它们也支持将负数作为索引，倒数第1个元素的索引为-1，倒数第2个元素的索引为-2...，依此类推。

列表的元素可以单独进行处理，可以像一个变量一样，既可使用它的值，也可对元素赋值。元组的元素则相当于一个常量，程序只能使用它的值，不能对它重新赋值。本节只介绍访问元素的基本方法，更高级的用法会在后面详细介绍。

如下代码示范了使用列表和元组的元素。

源代码文件：**使用索引的基本方法.py**

my_tuple = ('I', 123, True, 'love', 'Python',12.54)
    print(my_tuple)
    # 访问第1个元素
    print(my_tuple[0])      # I
    # 访问第2个元素
    print(my_tuple[1])      #  123
    # 访问倒数第1个元素
    print(my_tuple[-1])     # 12.54
    # 访问倒数第3个元素
    print(my_tuple[-3])     # love

显示效果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70 1][]

## **4. 分片与子序列** ##

与字符串类似，列表和元组同样也可使用索引获取一段子列表，这种用法被称为切片，英文称为slice。切片 的完整语法格式如下：

[start:end:step]

上面语法中start和end 两个索引值都可使用正数或负数，其中正数表示从开始往后数，负数表示从结尾开始往前数。该语法表示从start索引的元素开始（包含），到end索引的元素结束（不包含）的所有元素。step表示步长，因此step使用负数没有意义，但step仍然可以是负数。效果与字符串一样，将列表或元组中的元素倒序。

下面的代码演示了切片的完整用法：

my_tuple = ('公众号', 123, 543.12, '极客起源', 'Python','编程思想')
    # 访问从第2、3个元素
    print(my_tuple[1: 3])   # (123, 543.12)
    # 访问第1个，第4个元素
    print(my_tuple[0::3])  # ('公众号', '极客起源')
    # 访问最后两个元素
    print(my_tuple[-2:])    # ('Python', '编程思想')
    # 访问倒数第3个到第5个
    print(my_tuple[-4: -1]) # (543.12, '极客起源', 'Python')
    
    
    my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
    # 访问从第4个到第9个（不包含）、间隔为2的所有元素
    print(my_tuple[3: 8: 2]) # (4, 6, 8)
    # 访问从第3个到第9个（不包含）、间隔为3的所有元素
    print(my_tuple[2: 8: 3]) # (3, 6)
    # 访问从第3个到倒数第2个（不包含）、间隔为3的所有元素
    print(my_tuple[2: -2: 2]) # (3, 5, 7)

## 5. 加法 ##

列表和元组支持加法运算，加法的和就是两个列表或元组所包含的元素首尾相接。需要注意的是，列表只能和列表相加；元组只能和元组相加；元组不能直接和列表相加。下面的代码演示了列表和元组的加法运算。

a_tuple = ('Python' , 20, -10.2)
    b_tuple = (127, 'Java', 'Test', True)
    # 计算元组相加
    sum_tuple = a_tuple + b_tuple
    print(sum_tuple)    #  ('Python', 20, -10.2, 127, 'Java', 'Test', True)
    print(a_tuple)      # a_tuple并没有改变
    print(b_tuple)      # b_tuple并没有改变
    # 两个元组相加
    print(a_tuple + (-220 , -130))      # ('Python', 20, -10.2, -220, -130)
    # 下面代码报错：元组和列表不能直接相加
    #print(a_tuple + [-20 , -30])
    a_list = [204, 301, 150, 100]
    b_list = ['a', 'b', 'c']
    # 计算列表相加
    sum_list = a_list + b_list
    print(sum_list) # [204, 301, 150, 100, 'a', 'b', 'c']
    print(a_list + ['Ruby']) # [204, 301, 150, 100, 'Ruby']

运行结果如下图所示：

![format_png][]

## **6. 乘法** ##

列表和元组可以和整数执行乘法运算，列表和元组乘法的作用就是把列表或元组中的元素重复N次，并且首尾相接。

下面的代码演示了列表和元组的乘法。

源代码：**乘法.py**

a_tuple = ('Python编程思想' , 20)
    # 执行乘法
    mul_tuple = a_tuple * 3
    # ('Python编程思想', 20, 'Python编程思想', 20, 'Python编程思想', 20)
    print(mul_tuple)
    a_list = [12, '公众号：极客起源', 4]
    mul_list = a_list * 2
    # [12, '公众号：极客起源', 4, 12, '公众号：极客起源', 4]
    print(mul_list)

程序运行结果如下图所示：

![20200522200133255.gif][]![20200522200713953.png][]

## **7.  in 运算符** ##

in运算符用于判断列表或元组是否包含某个元素，例子代码如下：

源代码：in运算符.py

a_tuple = ('Python' , 20, -11.5) 
    print(20 in a_tuple) # True
    print(1.2 in a_tuple) # False
    print('Python' not in a_tuple) # False

## **8.  长度、最大值和最小值** ##

Python提供了内建的len()、max()和min()函数来获取元组或列表的长度、最大值和最小值。由于max()和min()函数要对元组、列表中的元素值比较大小，因此程序要求传给max()和min()函 数的元组、列表的元素必须是相同类型且可以比较大小。

例子代码：**长度、最大值和最小值.py**

# 元素都是数值的元组
    a_tuple = (13, 40, -12, 15.2, 152, 10)
    # 计算最大值
    print(max(a_tuple)) # 152
    # 计算最小值
    print(min(a_tuple)) # -12
    # 计算长度
    print(len(a_tuple)) # 6
    # 元素都是字符串的列表
    b_list = ['Python', 'Java', 'Ruby', 'Swift']
    # 计算最大值（依次比较每个字符的ASCII码值，先比较第1个字符，若相同，继续比较第2个字符，以此类推）
    print(max(b_list)) # Swift
    # 计算最小值
    print(min(b_list)) # Java 
    # 计算长度
    print(len(b_list)) # 4

在上面代码中，首先使用3个函数对元素都是数值的元组进行处理，可以看到程序获取元组的最大值、最小值和长度。程序后半部分使用3个函数对元素都是字符串的列表进行处理，也可以看到程序获取列表的最大值、最小值和长度，这说明Python的字符串也是可比较大小，比较的规则是Python 依次按字符串中每个字符对应的编码来比较字符串的大小。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70 2][]

[Python]: https://blog.csdn.net/nokiaguy/article/details/106227459
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200522200301578.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200522200414161.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5,size_16,color_FFFFFF,t_70
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9VT2ljQmljZDl4dG4zZldHdXNpYmI2WXA4ZnR4V3htSnFUYVhpYWZsWFg5Mk1XSWtlSTZUdFRZTDRRUDVOM2syMUE1YWJ4WWdTSUJ4NTJRTjFObDR2S3BBekEvNjQw?x-oss-process=image/format,png
[20200522200133255.gif]: https://img-blog.csdnimg.cn/20200522200133255.gif
[20200522200713953.png]: https://img-blog.csdnimg.cn/20200522200713953.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200522201142543.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25va2lhZ3V5,size_16,color_FFFFFF,t_70