第五章 序列

        在数学领域里，序列也称为数列，是一列有序的数。在程序设计中，序列是一类数据结构，用来存储一组有序排列的元素，并提供各种读写操作接口。

5.1 认识序列

        在python中，序列主要包括列表list，元组tuple，对象range、字符串str、字节串bytes、字节数组bytearray。大多数序列类型，包括可变类型和不可变类型支持下表的通用操作

5.2 操作序列

5.2.1 索引

        序列是以非负整数作为索引的有限有序集。内置函数len(squence),可以获取一个序列的条目数量。当一个序列的长度为n时候，它的索引集就包括：0，1，2，3，4.....，n-1。

        序列的条目也称元素，序列的索引也称下标。序列a的条目i可以通过a[i]选择。读写的语法如下：

        variable=a[i]    #读取第一个元素的值，赋给variable

        a[i]=value        #把一个值赋给a[i]

        使用index（）的方法可以获取指定条目的索引，语法格式如下：

        sequence.index（value）

        我们举个例子看一下：

list=[1,2,3,4]
print(len(list))
print(list[1])
list[1]=100
print(list[1])

5.2.2 切片

        序列还支持切片操作。使用索引可以操作单个条目，而使用切片可以操作指定范围内的多个条目。切片使用中括号表示，在一对中括号中包括1个或2个冒号，并分隔2个或3个整数来表示，基本语法如下：

        sequence[start_index:end_index:step]

5.2.3 四则运算

        1.加法

        加法是将两个字符串拼接：直接用加号连接即可。

list_1=[1,2,3,4]
list_2=[5,6,7,8]
list=list_1+list_2
print(list)

        2.乘法

        一个序列乘以一个整数n，表示重复合并序列n次。如果n为负数，则当作0处理，生成一个同类型的空序列。

list_1=[1,2,3,4]
list_2=[5,6,7,8]
list=list_2*3
print(list)
list=[list]*3
list[0].append(0)
print(list)

        3.全局函数

        max（）、min（）、sum（）

 5.2.4 成员检测

        

a=[1,2,3]
print(1 in a)
b=[[1],[2],[3]]
print(1 in b)
str="Python"
print( "y" not in str)

这里也有一些全局函数：

any( )、all( )

5.2.5 压缩和解压缩

        使用zip（）函数可以将多个可迭代对象压缩为一个对象，多个对象中的元素根据对应索引位置组成一个元组，然后返回由这些元组组成的可迭代对象。语法格式如下：

        zip[literable,...]

        参数literable是一个或者多个迭代器。返回一个可迭代的zip对象，使用list函数可以把zip对象转化为列表。如果参数iterable的元素个数不一致，则返回zip对象的长度与最短的literable对象相同。

        使用*运算还可以对zip对象解压缩，语法结构如下：

        zip（*zip）

        我们来看及几个实例：

• 示例1 把a，b两个列表对象压缩为一个zip对象，然后使用list函数转化列表显示。

a=[1,2,3,4]
b=[5,6,7,8]
print(list(zip(a,b)))

• 示例2 把a1，a2，a3，三个列表对象压缩为一个zip对象，然后使用zip（*）函数解压显示。

  a1=[1,2,3]
  a2=[1,2,3]
  a3=[1,2,3]
  print(list(zip(a1,a2,a3)))
  c1,c2,c3=zip(*zip(a1,a2,a3))
  print(list(c1))

  5.2.6 枚举函数

        使用enumerate（）函数可以将一个序列对象组合为一个索引序列，常用在for循环中。语法格式如下：

        enumerate（squence，[start=0]）

        参数sequence表示一个序列、迭代器，或者其他支持迭代的对象；start表示下标起始位置。enumerate（）函数返回一个枚举对象。

list1=['a','b','c','d']
print(list(enumerate(list1)))

list1=['a','b','c','d']
for index in enumerate(list1):
    list1[index[0]]=list1[index[0]].upper()
print(list1)

        对于第二个程序，我们存在以下两种其他的表达。

list1 = ['a', 'b', 'c', 'd']
for index, value in enumerate(list1):
    list1[index] = value.upper()
print(list1)

list1 = ['a', 'b', 'c', 'd']
for i in range(len(list1)):
    list1[i] = list1[i].upper()
print(list1)

这里有一个可能疑惑的点：

list1 = ['a', 'b', 'c']
for index, value in enumerate(list1):
    print(f"索引: {index}, 值: {value}")

• enumerate(list1) 返回的迭代器产生的元组类似 (0, 'a')、(1, 'b')、(2, 'c') 等。
• 在每次循环时，for 循环会把当前元组中的第一个元素（即索引）赋值给变量 index，第二个元素（即列表中的元素）赋值给变量 value。所以第一次循环时，index 为 0，value 为 'a'；第二次循环时，index 为 1，value 为 'b'，依此类推。

5.2.7 排序

        Python提供了四种方法用于对序列条目进行排序，具体说明如下：

• sequence.reserve（）:翻转顺序。直接在调用对象上改动，没有返回值，因此不可变对象不能调用。
• reserved(sequence):翻转顺序。返回翻转后的序列对象。
• sequence.sort（）：自定义排序。直接在调用对象上改动，没有返回值，因此不可变对象不能调用。
• sorted（sequence）：自定义排序。返回排序后的序列后的序列对象。

        1.倒序

a=[1,2,3,4,5]
print(list(reversed(a)))
a.reverse
print(a)

        使用切片的方法也可以实现倒序：

a=[1,2,3,4,5]
b=a[::-1]
print(b)

        2.排序

list.sort(key=None, reverse=False)
sorted(iterable, key=None, reverse=False)

str1="This is a test string from Andrew"
str2=sorted(str1.split())
str3=sorted(str1.split(),key=str.lower,reverse=True)
print(str2)
print(str3)

5.3 range对象

        在 Python 中，range 是一个内置函数，常用于生成不可变的整数序列，通常在 for 循环中被广泛使用，以控制循环的执行次数。下面为你详细介绍 range 函数的使用方法和相关特性。

        基本语法

range 函数有三种不同的调用方式：

1. range(stop)

• 参数说明：stop 是一个整数，表示生成序列的结束值（不包含该值），序列从 0 开始，步长为 1。
• 示例代码：

for i in range(5):
    print(i)

• 代码解释：这段代码会生成一个从 0 到 4 的整数序列，因为 range(5) 表示生成的序列为 [0, 1, 2, 3, 4]，所以 for 循环会依次打印出这些数字。

2. range(start, stop)

• 参数说明：start 是一个整数，表示序列的起始值（包含该值）；stop 是序列的结束值（不包含该值），步长默认为 1。
• 示例代码：

for i in range(2, 7):
    print(i)

• 代码解释：这里 range(2, 7) 会生成一个从 2 到 6 的整数序列，即 [2, 3, 4, 5, 6]，for 循环会将这些数字依次打印出来。

3. range(start, stop, step)

• 参数说明：start 是起始值（包含该值），stop 是结束值（不包含该值），step 是步长，表示相邻两个元素之间的差值，可以是正数、负数，但不能为 0。
• 示例代码：

# 步长为正数
for i in range(1, 11, 2):
    print(i)

# 步长为负数
for i in range(5, 0, -1):
    print(i)

• 代码解释：
  • 第一个 for 循环中，range(1, 11, 2) 会生成一个从 1 开始，每次增加 2，到 11 之前结束的整数序列，即 [1, 3, 5, 7, 9]，并将这些数字依次打印。
  • 第二个 for 循环中，range(5, 0, -1) 会生成一个从 5 开始，每次减少 1，到 0 之前结束的整数序列，即 [5, 4, 3, 2, 1]，然后依次打印这些数字。

注意事项

• range 函数返回的是一个 range 对象，它是一种不可变的序列类型，并不是一个列表。如果需要将其转换为列表，可以使用 list() 函数，例如：

numbers = list(range(5))
print(numbers)  # 输出: [0, 1, 2, 3, 4]

• 由于 range 对象是惰性生成的，它在内存使用上更高效，尤其是当需要生成一个很大的序列时。只有在需要访问具体元素时，才会计算生成相应的值。

5.4 认识列表

        在 Python 中，列表（list）是一种非常常用且重要的数据结构，它是可变的、有序的，能够存储任意类型的元素。

5.5 定义列表

5.5.1 列表字面值

        列表的字面值语法格式如下：

[元素1，元素2，元素3.....，元素n]

5.5.2 构造列表

        使用list构造器可以将可迭代对象转化为列表。

        创造空列表：list（）

        创造与iterable（）相同的值与顺序的列表：lis（literable）

5.5.3 定义列表推导式

        推导式又称解析式，是可以从一个数据容器构建另一个新的数据容器的结构体，它具有语法简洁、运行速度快等优点，性能比循环好，主要用于初始化一个列表、集合和字典，是python独有的特性。Python有三种推导式:

•         列表推导式
•         字典推导式
•         集合推导式

列表推导式：

[expr for value in iterable if condition]

这段语句的意思与下面的是等价的：        

result=[]
for value in iterable:
    if condition:
        result.append(expression)

a=[x**2 for x in range(10) if (x**2)<10]
print(a)

在此基础上，我们可以通过条件语句if......else定义新的形式：

• for循环前面加上if...else。可以根据循环的结果使用不同的表达式。
• for后加if只要满足if的元素。
• 嵌套for

[expression for outer_item in outer_iterable for inner_item in inner_iterable]

letters = ['a', 'b', 'c']
numbers = [1, 2, 3]
pairs = [(letter, number) for letter in letters for number in numbers]
print(pairs)

5.6 操作列表

5.6.1 访问元素

        list[index]

下面列举几个常用函数的使用例子:

list=[1,2,3,4,4,5,6,577,56,66]
print(len(list))
print(list[len(list)-1])
for i in range (len(list)-1):
    print(i)
print(list.count(4))
print(list.index(4,4,10))

5.6.2 遍历元素

        遍历循环使用while，for

        for item in iterable

        while i

list1=['a','b','c']
for i in list1:
    list1[list1.index(i)]=i.upper()
print(list1)

list1=['a','b','c']
for index,Value in enumerate(list1):
    list1[index]= Value.upper()
print(list1)

5.6.3 添加元素

        使用append、extend、insert、切片 都可以实现添加元素的操作。

1. append 方法

append 方法用于在列表的末尾添加一个元素。该方法直接修改原列表，并且只会添加一个元素。

语法：

list.append(item)

其中，list 是要操作的列表，item 是要添加到列表末尾的元素。

示例：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

2. extend 方法

 

extend 方法用于将一个可迭代对象（如列表、元组、字符串等）中的所有元素添加到列表的末尾。该方法会将可迭代对象中的元素逐个添加到原列表中，而不是将整个可迭代对象作为一个元素添加

语法：

list.extend(iterable)

 

其中，list 是要操作的列表，iterable 是要添加到列表末尾的可迭代对象。

示例

3. insert 方法

insert 方法用于在列表的指定位置插入一个元素。该方法会将指定位置及之后的元素依次向后移动一位。

语法：

list.insert(index, item)

其中，list 是要操作的列表，index 是要插入元素的位置索引，item 是要插入的元素。

示例：

my_list = [1, 2, 3]
my_list.insert(1, 4)
print(my_list)

4. 切片操作

切片操作可以用于在列表的指定位置插入多个元素。通过将切片赋值给一个可迭代对象，可以实现插入元素的效果。

语法：

list[start:stop] = iterable

其中，list 是要操作的列表，start 和 stop 是切片的起始和结束位置，iterable 是要插入的可迭代对象。

示例：

my_list = [1, 2, 3]
new_elements = [4, 5, 6]
my_list[1:1] = new_elements
print(my_list)

5.6.4 删除元素

del、pop、remove、clear、切片

### 1. `del` 语句
`del` 是 Python 的一个关键字，它可以用来删除列表中的指定元素或切片，也可以删除整个列表变量。

#### 删除列表中的指定元素
```python
my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为 2 的元素
print(my_list)
```
**输出结果**：
```
[1, 2, 4, 5]
```

#### 删除列表中的切片
```python
my_list = [1, 2, 3, 4, 5]
del my_list[1:3]  # 删除索引 1 到 2 的元素
print(my_list)
```
**输出结果**：
```
[1, 4, 5]
```

#### 删除整个列表变量
```python
my_list = [1, 2, 3]
del my_list
# 此时再访问 my_list 会报错，因为变量已被删除
# print(my_list) 
```

### 2. `pop` 方法
`pop` 方法用于移除列表中指定位置的元素，并返回该元素。如果不指定位置，默认移除并返回列表的最后一个元素。

#### 移除指定位置的元素
```python
my_list = [1, 2, 3, 4, 5]
element = my_list.pop(2)  # 移除索引为 2 的元素
print(f"移除的元素是: {element}")
print(my_list)
```
**输出结果**：
```
移除的元素是: 3
[1, 2, 4, 5]
```

#### 移除最后一个元素
```python
my_list = [1, 2, 3]
last_element = my_list.pop()  # 移除最后一个元素
print(f"移除的最后一个元素是: {last_element}")
print(my_list)
```
**输出结果**：
```
移除的最后一个元素是: 3
[1, 2]
```

### 3. `remove` 方法
`remove` 方法用于移除列表中第一个匹配指定值的元素。如果列表中不存在该值，会抛出 `ValueError` 异常。

```python
my_list = [1, 2, 3, 2, 4]
my_list.remove(2)  # 移除第一个值为 2 的元素
print(my_list)
```
**输出结果**：
```
[1, 3, 2, 4]
```

### 4. `clear` 方法
`clear` 方法用于清空列表，即移除列表中的所有元素，使列表变为空列表。

```python
my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)
```
**输出结果**：
```
[]
```

### 5. 切片操作删除元素
通过切片赋值为空列表，可以删除列表中指定范围的元素。

```python
my_list = [1, 2, 3, 4, 5]
my_list[1:3] = []  # 删除索引 1 到 2 的元素
print(my_list)
```
**输出结果**：
```
[1, 4, 5]
```

### 总结
- **`del`**：功能强大，可以删除列表元素、切片甚至整个列表变量，基于索引操作。
- **`pop`**：移除指定位置元素并返回该元素，常用于需要获取并移除元素的场景，默认操作最后一个元素。
- **`remove`**：根据元素的值来移除第一个匹配的元素，不关心元素的位置。
- **`clear`**：简单直接地清空整个列表。
- **切片操作**：可以灵活地删除列表中指定范围的元素。  

5.6.5 复制列表

list1 = [1, [2, 3], 4]
list2 = list1[:]
list2[0] = 100  # 修改不可变对象
print(list1)  # 输出: [1, [2, 3], 4]
print(list2)  # 输出: [100, [2, 3], 4]

list2[1][0] = 200  # 修改可变对象
print(list1)  # 输出: [1, [200, 3], 4]
print(list2)  # 输出: [100, [200, 3], 4]

import copy

list1 = [1, [2, 3], 4]
list2 = list1.copy()
list2[0] = 100
print(list1)  # 输出: [1, [2, 3], 4]
print(list2)  # 输出: [100, [2, 3], 4]

list2[1][0] = 200
print(list1)  # 输出: [1, [200, 3], 4]
print(list2)  # 输出: [100, [200, 3], 4]

import copy

list1 = [1, [2, 3], 4]
list2 = copy.deepcopy(list1)
list2[0] = 100
print(list1)  # 输出: [1, [2, 3], 4]
print(list2)  # 输出: [100, [2, 3], 4]

list2[1][0] = 200
print(list1)  # 输出: [1, [2, 3], 4]
print(list2)  # 输出: [100, [200, 3], 4]

 

 

5.6.6 删除列表

my_list = [1, 2, 3]
del my_list
# 以下代码会报错，因为 my_list 已被删除
# print(my_list)