【深度学习】 Python 和 NumPy 系列教程（三）：Python容器：1、列表List详解（初始化、索引、切片、更新、删除、常用函数、拆包、遍历）

目录

一、前言

二、实验环境

三、Python容器（Containers）

0、容器介绍

1、列表（List）

[1. 初始化](#1. 初始化)

[a. 创建空列表](#a. 创建空列表)

[b. 使用现有元素初始化列表](#b. 使用现有元素初始化列表)

[c. 使用列表生成式](#c. 使用列表生成式)

[d. 复制列表](#d. 复制列表)

[2. 索引和切片](#2. 索引和切片)

[a. 索引](#a. 索引)

[b. 负数索引](#b. 负数索引)

[c. 切片](#c. 切片)

[3. 常用操作（更新、删除）](#3. 常用操作（更新、删除）)

[a. 更新单个元素](#a. 更新单个元素)

[b. 更新切片](#b. 更新切片)

[c. 删除单个元素](#c. 删除单个元素)

[d. 删除切片](#d. 删除切片)

[e. 增量更新](#e. 增量更新)

[f. 复制更新](#f. 复制更新)

[4. 常用函数](#4. 常用函数)

append(element)：将元素添加到列表的末尾。

extend(iterable)：将可迭代对象的元素添加到列表的末尾。

[insert(index, element)：在指定的索引位置插入元素。](#insert(index, element)：在指定的索引位置插入元素。)

remove(element)：从列表中移除第一个匹配的元素。

pop(index)：移除并返回指定索引位置的元素。

index(element)：返回指定元素首次出现的索引。

count(element)：返回指定元素在列表中出现的次数。

sort()：对列表进行就地排序，按升序排列。

reverse()：对列表进行就地反转。

copy()：返回列表的浅拷贝。

[5. 拆包](#5. 拆包)

[a. 基本拆包](#a. 基本拆包)

[b. 扩展拆包](#b. 扩展拆包)

[6. 遍历](#6. 遍历)

[a. 使用for循环](#a. 使用for循环)

[b. 使用while循环和索引](#b. 使用while循环和索引)

[c. 使用enumerate()函数](#c. 使用enumerate()函数)

---

一、前言

Python是一种高级编程语言，由Guido van Rossum于1991年创建。它以简洁、易读的语法而闻名，并且具有强大的功能和广泛的应用领域。Python具有丰富的标准库和第三方库，可以用于开发各种类型的应用程序，包括Web开发、数据分析、人工智能、科学计算、自动化脚本等。

Python本身是一种伟大的通用编程语言，在一些流行的库（numpy，scipy，matplotlib）的帮助下，成为了科学计算的强大环境。本系列将介绍Python编程语言和使用Python进行科学计算的方法，主要包含以下内容：

• Python：基本数据类型、容器（列表、元组、集合、字典）、函数、类
• Numpy：数组、数组索引、数据类型、数组数学、广播
• Matplotlib：绘图，子图，图像
• IPython：创建笔记本，典型工作流程

二、实验环境

Python 3.7

运行下述命令检查Python版本

 python --version 

三、Python容器（Containers）

0、容器介绍

Python中的容器是用于存储和组织数据的对象。常见的容器包括列表（List）、元组（Tuple）、集合（Set）和字典（Dictionary）。

• 列表是有序的可变容器，可以包含不同类型的元素，使用方括号（[]）来创建。

my_list = [1, 2, 3, 'a', 'b', 'c']

• 元组是有序的不可变容器，也可以包含不同类型的元素，使用圆括号（()）来创建。

my_tuple = (1, 2, 3, 'a', 'b', 'c')

• 集合是无序且不重复的容器，用于存储唯一的元素，使用大括号（{}）或者set()函数来创建。

my_set = {1, 2, 3, 'a', 'b', 'c'}

• 字典是无序的键值对容器，用于存储具有唯一键的值，使用花括号（{}）或者dict()函数来创建。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

这些容器都提供了不同的方法和操作，用于对数据进行存储、访问和处理。可以根据具体的需求选择适合的容器类型。

1、列表（List）

最常用的序列类型，创建后可以随意被修改，可以灵活地进行各类操作。

1. 初始化

a. 创建空列表

要创建一个空列表，可以使用空的方括号[]或者list()函数来初始化。

empty_list = []
empty_list = list()

b. 使用现有元素初始化列表

可以在创建列表时提供初始元素。初始元素可以是常量、变量或表达式。

numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']

c. 使用列表生成式

列表生成式是一种快速创建列表的方法，它可以根据特定的规则和表达式生成列表中的元素。

squares = [x**2 for x in range(1, 6)]  # 生成包含1到5的平方的列表

d. 复制列表

要复制一个列表，可以使用切片操作或copy()方法。例如：

original_list = [1, 2, 3]
copied_list = original_list[:]  # 使用切片操作复制列表
# 或
copied_list = original_list.copy()  # 使用copy()方法复制列表

2. 索引和切片

列表的索引和切片是访问和获取列表元素的常用技巧。索引用于获取单个元素，而切片用于获取列表的子集。

a. 索引

列表中的每个元素都有一个对应的索引，索引从0开始，表示元素在列表中的位置。可以使用索引来获取列表中特定位置的元素。

my_list = ['apple', 'banana', 'orange']
print(my_list[0])  # 输出：'apple'
print(my_list[1])  # 输出：'banana'

b. 负数索引

列表还支持负数索引，负数索引从列表的末尾开始计数，-1表示最后一个元素，-2表示倒数第二个元素，以此类推。

my_list = ['apple', 'banana', 'orange']
print(my_list[-1])  # 输出：'orange'
print(my_list[-2])  # 输出：'banana'

c. 切片

切片用于获取列表的子集，通过指定起始索引和结束索引来实现。切片操作返回一个新的列表，包含指定范围内的元素。

my_list = ['apple', 'banana', 'orange', 'grape', 'mango']
print(my_list[1:4])     # 输出：['banana', 'orange', 'grape']
print(my_list[1:])      # 输出：['banana', 'orange', 'grape', 'mango']
print(my_list[1:-2])    # 输出：['banana', 'orange']
print(my_list[-1:-2])   # 输出：[]

3. 常用操作（更新、删除）

列表的更新和删除操作可以用来修改列表中的元素或删除特定的元素

a. 更新单个元素

my_list = ['apple', 'banana', 'orange']
my_list[1] = 'grape'
print(my_list)  # 输出：['apple', 'grape', 'orange']

b. 更新切片

要更新列表中的一个切片，可以使用切片操作符和赋值语句来将新的元素列表赋值给指定的切片位置。

my_list = ['apple', 'banana', 'orange', 'grape', 'mango']
my_list[1:4] = ['kiwi', 'watermelon']
print(my_list)  # 输出：['apple', 'kiwi', 'watermelon', 'mango']

c. 删除单个元素

要删除列表中的单个元素，可以使用del关键字和要删除的元素的索引。

my_list = ['apple', 'banana', 'orange']
del my_list[1]
print(my_list)  # 输出：['apple', 'orange']

d. 删除切片

要删除列表中的一个切片，可以使用切片操作符和del关键字。

my_list = ['apple', 'banana', 'orange', 'grape', 'mango']
del my_list[1:4]
print(my_list)  # 输出：['apple', 'mango']

e. 增量更新

列表还支持增量更新操作，通过使用+=运算符将新的列表与原始列表合并。

my_list = ['apple', 'banana']
my_list += ['orange', 'grape']
print(my_list)  # 输出：['apple', 'banana', 'orange', 'grape']

f. 复制更新

original_list = ['apple', 'banana', 'orange']
original_list *= 2
print(original_list) # 输出：['apple', 'banana', 'orange', 'apple', 'banana', 'orange']

4. 常用函数

append(element)：将元素添加到列表的末尾。

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

extend(iterable)：将可迭代对象的元素添加到列表的末尾。

my_list = [1, 2, 3]
another_list = [4, 5, 6]
my_list.extend(another_list)
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

insert(index, element)：在指定的索引位置插入元素。

my_list = [1, 2, 3]
my_list.insert(1, 4)
print(my_list)  # 输出: [1, 4, 2, 3]

remove(element)：从列表中移除第一个匹配的元素。

my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # 输出: [1, 3, 2]

pop(index)：移除并返回指定索引位置的元素。

my_list = [1, 2, 3]
removed_element = my_list.pop(1)
print(removed_element)  # 输出: 2
print(my_list)  # 输出: [1, 3]

index(element)：返回指定元素首次出现的索引。

my_list = [1, 2, 3, 2]
index = my_list.index(2)
print(index)  # 输出: 1

count(element)：返回指定元素在列表中出现的次数。

my_list = [1, 2, 3, 2]
count = my_list.count(2)
print(count)  # 输出: 2

sort()：对列表进行就地排序，按升序排列。

my_list = [3, 1, 2]
my_list.sort()
print(my_list)  # 输出: [1, 2, 3]

reverse()：对列表进行就地反转。

my_list = [1, 2, 3]
my_list.reverse()
print(my_list)  # 输出: [3, 2, 1]

copy()：返回列表的浅拷贝。

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # 输出: [1, 2, 3]

5. 拆包

列表拆包是一种将列表中的元素解压并赋值给多个变量的技术。通过列表拆包，可以方便地将列表中的元素分配给单独的变量，以便进一步处理。下面是关于列表拆包的详细说明：

a. 基本拆包

my_list = ['apple', 'banana', 'orange']
fruit1, fruit2, fruit3 = my_list
print(fruit1)  # 输出：'apple'
print(fruit2)  # 输出：'banana'
print(fruit3)  # 输出：'orange'

在上述示例中，通过将列表中的元素赋值给变量，实现了拆包操作。拆包时，变量的数量必须与列表中的元素数量相匹配。

b. 扩展拆包

如果列表的长度超过了变量的数量，可以使用扩展拆包运算符（*）将剩余的元素赋值给一个变量。例如：

my_list = ['apple', 'banana', 'orange', 'grape', 'mango']
fruit1, fruit2, *remaining_fruits = my_list
print(fruit1)           # 输出：'apple'
print(fruit2)           # 输出：'banana'
print(remaining_fruits) # 输出：['orange', 'grape', 'mango']

在上述示例中，`remaining_fruits`变量通过扩展拆包运算符接收了剩余的元素，形成一个新的列表。

6. 遍历

a. 使用for循环

使用for循环可以遍历列表中的所有元素。例如：

my_list = ['apple', 'banana', 'orange']
for fruit in my_list:
    print(fruit)

b. 使用while循环和索引

使用while循环结合索引可以实现对列表的遍历。例如：

my_list = ['apple', 'banana', 'orange']
index = 0
while index < len(my_list):
    print(my_list[index])
    index += 1

c. 使用enumerate()函数

使用enumerate()函数可以同时获取元素的索引和值。例如：

my_list = ['apple', 'banana', 'orange']
for index, fruit in enumerate(my_list):
    print(index, fruit)