07列表

## 概念

列表（list）是由一系列特定顺序排序的元素组成，不仅可以创建包含字母表中的所有字母和数字[0-9]，还可以将任何东西加入到列表中，列表之间的元素可以没有任何关系，列表通常包含多个元素。

## 操作

### 创建

使用方括号[]包裹元素，元素之间用英文的逗号,分隔。

```python
>>> empty_list = []
>>> print(empty_list)
[]
>>> numbers = [1, 2, 3, 4, 5]
>>> fruits = ["apple", "banana", "orange"]
>>> print(numbers)
[1, 2, 3, 4, 5]
>>> print(fruits)
['apple', 'banana', 'orange']
>>> mixed = [10, "hello", True, 3.14]
>>> print(mixed)
[10, 'hello', True, 3.14]
```

**list()**方法创建列表，list()是 Python 的内置方法，可将其他 “可迭代对象”（如字符串、range 对象等）转换为列表。

```python
>>> str_list = list("Python")
>>> print(str_list)
['P', 'y', 't', 'h', 'o', 'n']
```

**嵌套列表**

列表的元素可以是另一个列表，形成 “嵌套列表”（类似二维数组），常用于表示表格、矩阵等结构化数据。

```python
>>> matrix = [
...     [1, 2],
...     [3, 4],
...     [5, 6]
... ]
>>> students = [
...     ["张三", 90],
...     ["李四", 85]
... ]
>>> print(matrix)
[[1, 2], [3, 4], [5, 6]]
>>> print(students)
[['张三', 90], ['李四', 85]]

```

**数值列表**

range()方法可以轻松的生成一系列的数，例如：
```python
>>> int_list = list(range(5))
>>> print(int_list)
[0, 1, 2, 3, 4]
>>> int_list = list(range(1,5))
>>> print(int_list)
[1, 2, 3, 4]
>>> int_list = list(range(0,10,2))
>>> print(int_list)
[0, 2, 4, 6, 8]
```

对数值列表进行简单的运算：

```python
>>> int_list = list(range(10))
>>> print(int_list)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> min(int_list)
0
>>> max(int_list)
9
>>> sum(int_list)
45
```

### 遍历

遍历是指 “逐个访问列表中的元素”，最常用的方式是用for循环。

for 循环的作用是：**按照指定的范围或序列，逐个取出元素并执行相同的操作**。

生活中的类比：比如你有一个水果篮（列表），想逐个检查每个水果（元素），这个 “逐个检查” 的过程就可以用 for 循环实现。

for 循环的核心是 “遍历一个可迭代对象”（可迭代对象：能依次取出元素的对象，如列表、字符串、range 对象等）。

基本语法：
```python
for 变量 in 可迭代对象:
    循环体（要重复执行的代码）
```

- **变量**：每次循环时，从 “可迭代对象” 中取出的一个元素会赋值给这个变量（变量名可自定义，见名知意即可）。
- **可迭代对象**：要遍历的序列（如列表、字符串、range 等）。
- **循环体**：缩进的代码块（通常用 4 个空格），每次循环都会执行一次。

例如：
```python
>>> fruits = ["apple", "banana", "orange"]
... for fruit in fruits:
...     print(f"I like {fruit}")
...
I like apple
I like banana
I like orange
```

注意：在 Python 中，f"xxx{}xxx" 是一种特殊的字符串格式，称为 f-string（格式化字符串字面值），是 Python 3.6 及以上版本引入的便捷字符串格式化方式。它的核心作用是在字符串中嵌入变量或表达式，并自动替换为对应的值，让字符串拼接和格式化变得简洁直观。

```python
squares = []
for value in range(1,11):
	squares.append(value ** 2)
    
print(squares)

>>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
```

可以简写为：

```python
squares = [value**2 for value in range(1,11)]
print(squares)

>>>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
```

这样简写的方式叫做**列表推导式（list comprehension）**。

### 访问

列表中的元素有明确的 “位置顺序”，每个元素都有对应的**索引**（位置编号），可以通过索引精确访问元素。

- 索引从**0 开始**（第一个元素索引为 0，第二个为 1，以此类推）；
- 支持**负数索引**（最后一个元素索引为 - 1，倒数第二个为 - 2，以此类推）。

```python
>>> fruits = ["apple", "banana", "orange"]
>>> print(fruits[0])
apple
>>> print(fruits[2])
orange
>>> print(fruits[3])
Traceback (most recent call last):
  File "<python-input-31>", line 1, in <module>
    print(fruits[3])
          ~~~~~~^^^
IndexError: list index out of range
>>> print(fruits[-1])
orange
>>> print(fruits[-2])
banana
>>> print(fruits[-3])
apple
```

### 修改

与字符串的 “不可变性” 不同，列表是**可修改的**：可以直接修改某个元素的值、添加新元素、删除已有元素，而无需创建新列表。

```python
>>> numbers = [1, 2, 3]
>>> numbers[1] = 200
>>> print(numbers)
[1, 200, 3]
```

### 添加

**在列表末尾添加元素**

使用append()方法实现。

```python
>>> num = [1,2,3]
>>> print(num)
[1, 2, 3]
>>> print(num.append(4))
None
>>> print(num)
[1, 2, 3, 4]
```

**在列表中插入元素**

使用insert()方法实现，需要指定新元素的索引和值。

```python
>>> print(num)
[1, 2, 3, 4]
>>> num.insert(1,11)
>>> print(num)
[1, 11, 2, 3, 4]
>>> num.insert(3,"22")
>>> print(num)
[1, 11, 2, '22', 3, 4]
```

**将可迭代对象的元素逐个添加到末尾**

可以使用extend()方法。

```python
>>> numbers = [1, 2, 3]
>>> cars = ["bmw","audi","toyota","subaru"]
>>> print(numbers)
[1, 2, 3]
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> numbers.extend(cars)
>>> print(numbers)
[1, 2, 3, 'bmw', 'audi', 'toyota', 'subaru']
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> numbers.extend(["maolin101"])
>>> print(numbers)
[1, 2, 3, 'bmw', 'audi', 'toyota', 'subaru', 'maolin101']
```

**将两个列表合并为一个新列表**

可以使用+号，实现拼接。

```python
>>> print(numbers)
[1, 2, 3, 'bmw', 'audi', 'toyota', 'subaru', 'maolin101']
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> new_cars = cars + numbers
>>> print(new_cars)
['bmw', 'audi', 'toyota', 'subaru', 1, 2, 3, 'bmw', 'audi', 'toyota', 'subaru', 'maolin101']
```

### 删除

如果知道要删除元素在列表中的位置（索引值），可以使用del语句实现。

```python
>>> print(num)
[1, 11, 2, '22', 3, 4]
>>> del num[3]
>>> print(num)
[1, 11, 2, 3, 4]
```

如果要将元素从列表中删除，但是想要继续使用元素的值，可以用pop()方法。

```python
>>> print(num)
[1, 11, 2, 3, 4]
>>> num_int = num.pop()
>>> print(num)
[1, 11, 2, 3]
>>> print(num_int)
4

>>> num_int = num.pop(1)
>>> print(num)
[1, 2, 3]
>>> print(num_int)
11
```

如果想要根据元素的值删除元素，可以使用remove()方法。

```python
>>> print(num)
[1, 2, 3]
>>> num.remove(3)
>>> print(num)
[1, 2]
```

### 排序

使用sort()方法可以对列表进行排序。

```python
>>> cars = ["bmw","audi","toyota","subaru"]
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> cars.sort()
>>> print(cars)
['audi', 'bmw', 'subaru', 'toyota']
```

如果只是对列表进行临时排序，可以使用sorted()函数。

```python
>>> cars = ["bmw","audi","toyota","subaru"]
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
>>> sorted(cars)
['audi', 'bmw', 'subaru', 'toyota']
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
```

### 反向打印列表

reverse()方法可以反转列表元素的排列顺序。

```python
>>> cars = ["bmw","audi","toyota","subaru"]
>>> cars.reverse()
>>> print(cars)
['subaru', 'toyota', 'audi', 'bmw']
>>> cars.reverse()
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
```

### 列表长度

可以使用len()函数输出列表长度。

```python
>>> cars = ["bmw","audi","toyota","subaru"]
>>> len(cars)
4
```

### 切片

和字符串类似，列表也支持切片操作，用于截取部分元素，语法：**列表名[start: end:step]**。

- start：起始索引（包含，默认 0）；
- end：结束索引（不包含，默认列表长度）；
- step：步长（每隔几个元素取一次，默认 1，负数表示反向截取）。

```python
>>> numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(numbers[1:4])
[1, 2, 3]
>>> print(numbers[:5])
[0, 1, 2, 3, 4]
>>> print(numbers[5:])
[5, 6, 7, 8, 9]
>>> print(numbers[0:9:2])
[0, 2, 4, 6, 8]
>>> print(numbers[::-1])
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> print(numbers[:])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

### 复制

```python
>>> numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> new_numbers = numbers[:]
>>> print(new_numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> numbers[9] = 10
>>> print(new_numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 10]
```

```python
>>> n_numbers = numbers
>>> print(n_numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 10]
>>> print(numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 10]
>>> numbers[9] = 9
>>> print(numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(n_numbers)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

由此可见，n_numbers = numbers只是将两个变量指向了同一个列表，而new_numbers = numbers[:]则是完全将numbers的列表赋值给了new_numbers变量。

### 成员判断

判断元素是否在列表中可以使用int或者not in。

```python
>>> numbers = [1, 2, 3,4,5]
>>> print(2 in numbers)
True
>>> print(4 not in numbers)
False
>>> print(6 not in numbers)
True
```

## 总结

列表是 Python 中最灵活的数据结构之一，核心特点是：

- **有序**：元素有明确索引，可通过索引访问；
- **可变**：可直接修改、添加、删除元素；
- **多类型**：可包含任意类型的元素，支持嵌套。