python列表

# python列表

Python列表是一种有序的数据集合，可以存储任何类型的对象（数字、字符串、布尔值等）。列表用方括号 [] 表示，各个元素之间用逗号隔开。可以通过索引访问列表中的元素，并且支持增加、删除、修改等操作

## 列表的创建

```python
my_list = [1, "two", True, 3.14]
print(my_list[0])  # 输出：1
my_list.append("four")  # 添加一个新元素到末尾
my_list.remove(True)  # 删除一个元素
my_list[1] = 2  # 修改一个元素
```

列表的创建和创建变量类似，直接进行赋值。
```python
my_list = [1, "two", True, 3.14]
```

输出列表的值。
```python
print(my_list)
# 结果：
[1, 'two', True, 3.14]
```

列表元素表示，通过下标标识，从下标[0]开始,[-1]是最后一个。
```python
print(my_list[0])
print(my_list[1])
print(my_list[-1])
```

## 向列表中添加元素

- 使用append()方法添加元素。

append() 是 Python 列表对象的一个方法，用于在列表末尾添加一个新元素。它的语法是 list.append(item)，其中 list 是要修改的列表对象，item 是要添加到列表中的新元素。
```python
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]
```

- 使用extend()方法向列表末尾添加多个元素。

extend() 是 Python 列表对象的一个方法，用于将一个可迭代对象中的所有元素添加到列表末尾。它的语法是 list.extend(iterable)，其中 list 是要修改的列表对象，iterable 是一个可迭代对象（如列表、元组、字符串等）。
```python
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6]
```

- 使用insert()方法在指定位置插入元素。

insert() 是 Python 列表对象的一个方法，用于在指定位置插入一个新元素。它的语法是 list.insert(index, item)，其中 list 是要修改的列表对象，index 是要插入新元素的位置，item 是要插入到列表中的新元素。例如：
```python
my_list = [1, 2, 3]
my_list.insert(1, "hello")
print(my_list)  # 输出：[1, 'hello', 2, 3]
```

## 从列表中删除元素

- 使用remove()方法删除元素。

remove() 是 Python 列表对象的一个方法，用于删除列表中第一个匹配的指定元素。它的语法是 list.remove(item)，其中 list 是要修改的列表对象，item 是要删除的元素。例如：
```python
my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # 输出：[1, 3, 2]
```

- 使用del语句删除指定元素或整个列表。

del 是 Python 中的一个语句，用于删除对象。对于列表来说，可以使用 del 删除指定位置的元素或整个列表。例如：
```python
my_list = [1, 2, 3]
del my_list[1]  # 删除索引为1的元素
print(my_list)  # 输出：[1, 3]

del my_list  # 删除整个列表对象
```

- 使用pop()方法删除元素并返回。

pop() 是 Python 列表对象的一个方法，用于删除并返回指定位置的元素。它的语法是 list.pop([index])，其中 list 是要修改的列表对象，index 是要删除的元素的位置，如果不提供 index 参数，则默认删除最后一个元素。例如：
```python
my_list = [1, 2, 3]
removed_element = my_list.pop(1)
print(my_list)  # 输出：[1, 3]
print(removed_element)  # 输出：2
```

## 列表分片

在 Python 中，可以使用切片（slicing）操作来获取列表（list）的子集。切片操作可以返回一个新的列表，包含原始列表中指定范围内的元素。

切片操作使用以下语法：
```python
new_list = old_list[start:stop:step]
```
其中，start 表示切片的起始位置，stop 表示切片的结束位置，step 表示切片的步长。start 和 stop 都是可选参数，如果不指定，则表示从列表的开头或结尾开始切片。step 也是可选参数，如果不指定，则默认为 1。

以下是一些示例：

```python
# 定义一个列表
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取前三个元素
new_list = my_list[0:3]
print(new_list)  # 输出 [0, 1, 2]

# 获取第三个到第六个元素
new_list = my_list[2:6]
print(new_list)  # 输出 [2, 3, 4, 5]

# 获取从第三个元素开始到列表结尾的所有元素
new_list = my_list[2:]
print(new_list)  # 输出 [2, 3, 4, 5, 6, 7, 8, 9]

# 获取列表中的偶数元素
new_list = my_list[::2]
print(new_list)  # 输出 [0, 2, 4, 6, 8]

# 在这些示例中，我们使用了不同的切片操作，获取了原始列表的不同子集。需要注意的是，切片操作返回的是一个新的列表，而不是原始列表的视图。因此，对切片后的列表进行修改不会影响原始列表。
```

## 列表的常用操作符运用

使用+进行列表的拼接。
在 Python 中，可以使用加号运算符（+）将两个列表拼接成一个新的列表。具体来说，如果有两个列表 A 和 B，那么 A + B 将会返回一个包含 A 中所有元素和 B 中所有元素的新列表。

以下是一些示例：

```python
# 定义两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 将两个列表拼接成一个新列表
new_list = list1 + list2
print(new_list)  # 输出 [1, 2, 3, 4, 5, 6]

# 可以使用同样的方法拼接多个列表
list3 = [7, 8, 9]
new_list = list1 + list2 + list3
print(new_list)  # 输出 [1, 2, 3, 4, 5, 6, 7, 8, 9]
```
需要注意的是，拼接操作返回的是一个新的列表，而不是原始列表的视图。因此，对拼接后的列表进行修改不会影响原始列表。

使用in判断元素是否在列表中。
在 Python 中，可以使用 in 关键字来判断一个元素是否存在于列表中。具体来说，如果一个元素在列表中，那么 element in list 将返回 True，否则返回 False。

以下是一个示例：

```python
# 定义一个列表
my_list = [1, 2, 3, 4, 5]

# 判断 3 是否在列表中
if 3 in my_list:
    print("3 存在于列表中")
else:
    print("3 不存在于列表中")

# 判断 6 是否在列表中
if 6 in my_list:
    print("6 存在于列表中")
else:
    print("6 不存在于列表中")
输出结果为：
```

```python
3 存在于列表中
6 不存在于列表中
```
需要注意的是，判断元素是否在列表中是基于元素的值进行的，而不是基于元素的索引。因此，即使两个列表具有相同的元素，它们也被视为不同的对象。

## 常用列表操作方法

- append(),向列表末尾添加元素
- extend()，扩展列表
- insert()，在指定位置插入元素
- pop()，弹出最后一个元素
- remove()，删除指定元素

### count()方法
count() 方法是 Python 列表（list）对象提供的方法之一，用于返回列表中某个元素出现的次数。具体来说，它接收一个参数，即要统计的元素，返回该元素在列表中出现的次数。

以下是一个示例：

```python
# 定义一个列表
my_list = [1, 2, 3, 4, 5, 1, 2, 1]

# 统计元素 1 出现的次数
count = my_list.count(1)

# 输出结果
print(count)  # 输出 3
```

在上述示例中，my_list 是一个包含多个元素的列表，我们使用 count() 方法统计元素 1 出现的次数，最后输出结果为 3。

需要注意的是，如果要统计的元素在列表中不存在，count() 方法将返回 0。同时，如果列表中存在多个相同的元素，count() 方法只会返回其中一个元素的统计次数。

### index()方法
index() 方法是 Python 列表（list）对象提供的方法之一，用于返回某个元素在列表中首次出现的位置的索引。具体来说，它接收一个参数，即要查找的元素，返回该元素在列表中首次出现的位置的索引。如果该元素在列表中不存在，该方法会抛出 ValueError 异常。

以下是一个示例：

```python
# index()方法的格式
list.index(x[, start[, end]])
# 其中，list 是要查找的列表，x 是要查找的元素。start 和 end 是可选参数，用于指定查找的范围。具体来说，start 参数指定从哪个索引开始查找，默认为 0，即从列表头部开始查找；end 参数指定查找到哪个索引结束（但不包含该索引对应的元素），默认为列表的长度。

# 定义一个列表
my_list = ['apple', 'banana', 'orange', 'grape']

# 查找元素 banana 的位置
index = my_list.index('banana')

# 输出结果
print(index)  # 输出 1
```
在上述示例中，my_list 是一个包含多个字符串元素的列表，我们使用 index() 方法查找元素 banana 在列表中的位置，最后输出结果为 1。

需要注意的是，如果要查找的元素在列表中不存在，index() 方法会抛出 ValueError 异常。同时，如果列表中存在多个相同的元素，index() 方法只会返回其中一个元素的位置索引。

### reverse()方法
reverse() 方法用于将列表中的元素倒序排列。

reverse() 方法不返回新的列表，而是直接修改原有列表的元素顺序，所以使用时需要谨慎。

语法：

```python
list.reverse()
参数说明：

无参数。
```

```python
示例：
>>> a = [1, 2, 3, 4, 5]
>>> a.reverse()
>>> print(a)
[5, 4, 3, 2, 1]

```
上面的代码将列表 [1, 2, 3, 4, 5] 中的元素倒序排列，并将结果存储回原列表 a 中。

### sort()方法

sort() 方法用于对列表进行排序。它可以按升序或降序排序列表中的元素。
sort() 方法不返回新的列表，而是直接修改原有列表的元素顺序，所以使用时需要谨慎。

语法：

```python
list.sort(reverse=False)
```
参数说明：

reverse: 可选参数，表示排序顺序，为布尔值。默认为 False，表示升序排序；如果设置为 True，则表示降序排序。
示例：

```python
Copy code
>>> a = [5, 2, 1, 4, 3]
>>> a.sort()
>>> print(a)
[1, 2, 3, 4, 5]

>>> a = [5, 2, 1, 4, 3]
>>> a.sort(reverse=True)
>>> print(a)
[5, 4, 3, 2, 1]
```
上面的代码分别对列表 [5, 2, 1, 4, 3] 进行了升序排序和降序排序，并将结果存储回原列表 a 中。

### 使用len()函数查询列表的元素数量

在 Python 中，len() 是一个内置函数，用于返回一个对象（字符串、列表、元组等）的长度或元素的个数。

语法格式：

```python
len(object)
```
其中 object 表示要计算长度或元素个数的对象。

例如，对于一个字符串，可以使用 len() 函数返回其字符的数量：

```python
my_string = "Hello, World!"
print(len(my_string))  # 输出：13
```
对于一个列表，可以使用 len() 函数返回其中元素的数量：

```python
my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 输出：5
```
同样的，对于元组、集合等对象也可以使用 len() 函数计算其长度。