列表知识点整理

最新推荐文章于 2024-07-31 14:30:10 发布

zhjx0903

最新推荐文章于 2024-07-31 14:30:10 发布

阅读量810

点赞数 16

文章标签： python 开发语言

本文链接：https://blog.csdn.net/zhjx0903/article/details/140349033

版权

列表添加元素

一、在列表最后添加一个元素：

使用append（）函数，向列表list的末尾添加一个元素。这个元素可以是任何数据类型，包括：数字、字符串、另一个列表、字典等。

`append()`的基本使用方法：

例如：

# 创建一个列表
my_list = [1, 2, 3]

# 向列表末尾添加一个元素
my_list.append(4)

# 打印列表，查看添加后的结果
print(my_list)  # 输出: [1, 2, 3, 4]

在上面的例子中，我们首先创建了一个包含三个元素的列表my_list。然后，我们使用append()方法想这个列表的末尾添加了一个元素4。最后，我们打印的末尾，可以看到新添加的元素4已经被添加到了列表的末尾。

注意 :

append()方法只能向列表的末尾添加一个元素,如果你需要向列表中添加多个元素，不可以使用append()的方法实现！

# 创建一个列表
my_list = [1, 2, 3]

# 尝试使用append()添加多个元素
my_list.append([4, 5, 6])

# 打印列表，查看添加后的结果
print(my_list)   # 输出: [1, 2, 3, [4, 5, 6]]

运行过程中是将列表[4,5,6]视为一个元素，将这个元素添加到列表中。

二、在列表末尾添加多个元素：

使用extend（）函数，向列表list的末尾添加多个元素。这些元素可以是任何数据类型，包括：数字、字符串、另一个列表、字典等。

方法一：`extend()`的基本使用方法：

例如：

# 创建一个列表
my_list = [1, 2, 3]

# 使用extend()方法添加多个元素
my_list.extend([4, 5, 6])

# 打印列表，查看添加后的结果
print(my_list)   # 输出: [1, 2, 3, 4, 5, 6]

一次性添加多个元素，使用extend()函数的方法，extend()函数可以接受一个迭代对象（如：列表、元组等），并将其中的元素逐个添加大奥原列表中。

在上面的例子中，首先我们任然是创建了一个my_list的列表，然后使用extend()函数，将列表[4,5,6]中的元素逐个添加到原有的列表my_list中。最后，我们打印的末尾，可以看到新添加的元素4,5,6已经被添加到了列表的末尾。

方法二：使用`+`运算符添加多个元素到列表中

例如：

# 创建一个列表
my_list = [1, 2, 3]

# 使用extend()方法添加多个元素
my_list.extend([4, 5, 6])

# 打印列表，查看添加后的结果
print(my_list)   # 输出: [1, 2, 3, 4, 5, 6]

在这个例子中，+运算符将列表[4,5,6]连接到my_list的末尾，创建了一个新的列表，并打印出新的列表。最后，我们打印的末尾，可以看到新添加的元素4,5,6已经被添加到了列表的末尾。

三、在列表中间添加一个元素

在Python中，列表(list)是一种可变的数据结构，这意味着你可以修改列表的内容。然而，列表的索引是固定的，你不能直接在列表中间“插入”元素，因为这会改变列表中其他元素的索引。不过，你可以通过以下几种方式来实现类似的效果：

方法一：使用`insert()`的方法。

使用insert()，可以在列表的指定位置插入一个元素，你需要制定的元素的索引位置和要插入的元素。

例如：

my_list = [1, 2, 3, 4]            # 创建一个列表[1,2,3,4,]
my_list.insert(2, 'new_element')  # 在索引2的位置插入元素,“new_element”为需要插入的元素。
print(my_list)                    # 输出: [1, 2, 'new_element', 3, 4]

在这个例子中，insert(2,'new_element')在索引2的位置插入了字符串“new_element”。如果加入的元素是数字，可以不要用引号。

方法二：切片赋值

使用切片赋值：你可以使用切片赋值的方式来在列表的中间插入一个元素。这涉及到创建一个新列表，并将原列表的相应部分替换为这个新列表。

例如：

my_list = [1, 2, 3, 4]
my_list[2:1] = ['new_element1']  # 在索引2的位置插入一个个元素
print(my_list)  # 输出: [1, 2, 'new_element1', 3, 4]

在这个例子中，第二行代码中，2，表示在索引2的位置插入一个元素；1表示插入元素的个数。

所以，将1改为其他的数，便可以实现在列表中插入多个元素了。

在列表中间插入多个元素

使用切片赋值：你可以使用切片赋值的方式来在列表的中间插入多个元素。这涉及到创建一个新列表，并将原列表的相应部分替换为这个新列表。

my_list = [1, 2, 3, 4]
my_list[2:2] = ['new_element1', 'new_element2']  # 在索引2的位置插入两个元素
print(my_list)  # 输出: [1, 2, 'new_element1', 'new_element2', 3, 4]

在这个例子中， my_list[2:2] = ['new_element1', 'new_element2'] 在索引2的位置插入了两个元素。

注意：

使用切片赋值时，你需要确保新插入的元素列表与原列表的长度相匹配，否则可能会导致列表的长度发生变化。

切片赋值

切片赋值的原理：

基于Python中的切片操作和赋值操作的结合。切片操作允许你获取列表的一部分，而赋值操作则允许你将一个值或一个序列赋给列表的某个切片。当这两个操作结合使用时，可以实现将一个序列插入到列表的指定位置。

切片赋值的基本形式：

my_list[start:stop] = sequence

这里的 my_list 是原始列表，start 和 stop 是切片操作的起始和结束索引， sequence 是你想要插入到列表中的序列（可以是单个元素、列表、元组等）。

切片操作的原理可以分为几个步骤：

1、切片获取：

首先，根据提供的start中获取的一个切片,这个切片是一个新的列表,包含了原始列表中从start到stop(不包含stop)索引之间的所有元素。

2、序列插入：

然后，将提供的sequence插入到原始列表的start索引位置,如果sequence是一个列表或元组，它会被展开成多个元素插入到原始列表中。

3、元素替换：

最后，原始列表中从 start 到 stop 索引之间的元素会被 sequence 替换掉。如果 sequence 的长度与切片的长度不同，列表的长度也会相应地增加或减少。

例如：

my_list = [1, 2, 3, 4, 5]
my_list[2:2] = ['a', 'b']  # 在索引2的位置插入两个元素
print(my_list)  # 输出: [1, 2, 'a', 'b', 3, 4, 5]

在这个例子中，my_list[2:2] 获取了一个空切片（因为起始索引和结束索引相同），然后将 ['a', 'b'] 插入到索引2的位置，替换掉了空切片，从而在列表的中间插入了两个新元素。

切片赋值是一种非常灵活的操作，可以用来在列表的任意位置插入或替换元素，而不会影响列表中其他元素的索引。

替换列表中的元素

一、替换列表中的某个元素：

1、列表的元素索引是静态的：

在Python中，替换列表中的某个元素非常简单，你只需要通过索引直接访问并赋值即可。列表是可变的数据结构，这意味着你可以修改列表中的元素

例如：(直接赋值)

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 假设我们想要替换索引为2的元素（即第3个元素，因为索引从0开始）
my_list[2] = 'new_value'

# 打印列表，查看替换后的结果
print(my_list)   # 输出: [1, 2, 'new_value', 4, 5]

在这个例子中，我们通过索引2访问量列表 my_list 中的第三个元素,并将其替换为了字符串 new_value 。

2、列表中的索引是动态的：

方法：如果你想要替换的元素的索引是动态的，你可以使用变量来存储这个索引。

例如：

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 假设我们想要替换索引为i的元素
i = 2
my_list[i] = 'new_value'

# 打印列表，查看替换后的结果
print(my_list)   # 输出: [1, 2, 'new_value', 4, 5]

在上面这个例子中，我们使用变量 i 来存储我们想要替换的元素的索引。

注意：

如果你尝试访问或替换一个不存在的索引，将会抛出一个 IndexError 异常。

例如：

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 尝试访问一个不存在的索引
my_list[10] = 'new_value'   # 这将抛出IndexError异常

在这个例子中，我们尝试访问索引 10 ，但是列表 my_list 只有5个元素，所以会抛出 IndexError 异常。确保在替换元素时使用的索引是有效的，以避免运行时错误。

二、替换列表中的多个元素：

使用切片赋值的方式来替换列表中的多个元素。切片赋值允许你将一个序列（可以是列表、元组或其他可迭代对象）赋值给列表的一个切片。这样，你可以一次性替换列表中的一段连续元素。

1、想要替换的元素数量与替换的序列长度_相等_ ：

例如：

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 假设我们想要替换索引从1到3的元素（即第2个到第4个元素）
my_list[1:4] = ['new_value1', 'new_value2', 'new_value3']

# 打印列表，查看替换后的结果
print(my_list)    # 输出: [1, 'new_value1', 'new_value2', 'new_value3', 5]

在这个例子中，我们使用 my_list[1:4] 来获取索引从1到3的切片，然后将这个切片替换为一个新的列表 ['new_value1', 'new_value2', 'new_value3'] 。这样，原始列表中的第2个到第4个元素就被替换了。

2、想要替换的元素数量与替换序列的长度_不等_ ：

例如：

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 假设我们想要替换索引从1到3的元素，并且替换的序列更长
my_list[1:4] = ['new_value1', 'new_value2', 'new_value3', 'new_value4']

# 打印列表，查看替换后的结果
print(my_list)    # 输出: [1, 'new_value1', 'new_value2', 'new_value3', 'new_value4', 5]

在这个例子中，替换的序列比原始切片的长度长，因此列表的长度增加了。如果是短了，长度就会是减少。

删除列表中的元素

删除列表中的元素可以通过几种不同的方法来实现，具体取决于你想要删除元素的方式。以下是几种常见的删除列表元素的方法：

方法一、使用 `del()` 语句：

一、`del()`语句的简介：

del 语句用于删除对象的引用。它不是用来删除对象本身，而是删除对对象的引用，从而减少对象的引用计数。当一个对象的引用计数降到0时，该对象会被Python的垃圾回收机制自动回收。

del 语句也可以用来删除列表中的元素或者字典中的键值对.

二、基本用法：

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 删除对列表的引用
del my_list

# 现在尝试访问my_list会导致NameError，因为my_list已经不存在了
# print(my_list)  # 这行代码会引发NameError

三、删除列表中的元素或者字典中的键值对：

# 删除列表中的元素
my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为2的元素，即数字3
print(my_list)  # 输出: [1, 2, 4, 5]


# 删除字典中的键值对
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']  # 删除键为'b'的键值对
print(my_dict)  # 输出: {'a': 1, 'c': 3}

四、使用`del()`语句和切片的方式，一次删除几个元素。

 my_list = [1, 2, 3, 4, 5]
del my_list[1:3]  # 删除索引从1到2的元素（即第二个和第三个元素）
print(my_list)    # 输出: [1, 4, 5]

在这个例子中删除了，索引1到2对应的两个元素。删除的元素是连续的。

五、使用`del()`语句和切片的方式，一次删除几个相同的元素。

如果你需要一次性移除列表中的多个元素，你需要使用其他方法，比如循环结合 del 语句。

例如：

my_list = [1, 2, 3, 4, 3, 5, 3]

# 使用循环和 del 语句移除所有值为3的元素
for value in my_list[:]:   # 创建列表的副本，避免在遍历时修改列表
    if value == 3:
        my_list.remove(value)

print(my_list)   # 输出: [1, 2, 4, 5]

my_list = [1, 2, 3, 4, 3, 5, 3]
for i in range(len(my_list) - 1, -1, -1):  # 从后往前遍历，避免索引变化问题
    if my_list[i] == 3:
        del my_list[i]
print(my_list)  # 输出: [1, 2, 4, 5]

也可以通过，列表推导式实现。

例如：

my_list = [1, 2, 3, 4, 3, 5, 3]
my_list = [value for value in my_list if value != 3]
print(my_list)   # 输出: [1, 2, 4, 5]

这两种方法都可以用来移除列表中的多个元素，但它们的效率和适用场景可能有所不同。

六、注意 :

1、del 语句不能用于删除不存在的变量或对象。
2、del 语句删除的是变量的引用，而不是变量本身。如果变量在删除后再次被使用，会引发错误。
3、del 语句可以用于删除容器中的元素，但不能用于删除容器本身。如果需要删除整个容器，应该使用 clear() 方法。

方法二：使用`remove()`方法：

一、`remove()`简介：

在Python语言中， remove() 是一个列表(list)对象的方法，用于移除列表中第一个匹配项的元素。如果列表中有多个相同的元素， remove() 方法只会移除第一个找到的元素。（不可以一次移除多个元素。）

二、基本用法：

list_name.remove(value)

这里的list_name是要从移除元素的列表，而 value 是要移除的元素的值。

如果列表中不存在要移除的元素，Python解释器会抛出一个 valueError的异常。

三、使用`remove()`删除列表中的元素：

例如：

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 移除列表中的元素 3
my_list.remove(3)

# 打印列表，查看结果
print(my_list)  # 输出: [1, 2, 4, 5]

在这个例子中，列表 my_list 中的元素 3 被移除了。如果该列表中哟多个3 这个元素，也只会移除第一个该元素。

四、注意：

remove() 方法是直接在原列表上进行操作的，它不会返回一个新的列表，而是修改原列表。如果你需要保留原列表不变，可以先复制列表，然后在副本上进行移除操作。

# 创建一个列表
my_list = [1, 2, 3, 4, 5]

# 复制列表
new_list = my_list.copy()

# 在副本上移除元素
new_list.remove(3)

# 打印原列表和副本，查看结果
print(my_list)  # 输出: [1, 2, 3, 4, 5]
print(new_list)  # 输出: [1, 2, 4, 5]

在这个例子中， my_list 保持不变，而 new_list 是移除了元素 3 的副本。

方法三：使用 `pop()`方法

一、简介：

pop() 是 Python 列表的一个内置方法，用于移除列表中的一个元素（默认为最后一个元素），并返回该元素的值。

1、移除并返回指定索引位置的元素：

例如：

# 创建一个为 my_list 的列表
my_list = [1,2,3,4,5]
# 使用pop()
removed_element = my_list.pop(2)  # 删除索引为2的元素（，也就是第三个元素）。
print(removed_element)   # 输出 3
print(my_list)           # 输出：[1,2,4,5]

2、移除并返回最后一个元素：（默认行为）

例如：

my_list = [1, 2, 3, 4, 5]
removed_element = my_list.pop()  # 删除并返回最后一个元素
print(removed_element)  # 输出: 5
print(my_list)          # 输出: [1, 2, 3, 4]

二、基本用法：

pop() 方法通过实现栈（LIFO）数据结构，其中元素按照后进先出（Last in.First Out）的顺序被移除。

三、出现异常：

使用 pop() 方法从一个空格列表中移除一个元素，将会抛出一个异常 IndexError 异常，因为此时在列表中没有元素可以移除。

防止程序出现异常，我们可以在调用 pop() 方法之前，检查列表是否为空。

方法四：使用 `clear()` 方法：

简介：

在Python语言中，clear() 方法通常用于清空容器中的所有元素。这个方法是某些内置容器类型的方法，比如列表（list）和集合（set）。

基本用法：

1、对于列表（list）：

例如：

# 首先创建一个名为 my_list 的列表，列表是使用英文下的中括号
my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)  # 输出: []

在这个例子中，clear() 方法清空了列表 my_list 中的所有元素，使得列表变为空。

2、对于集合（set）：

例如：

my_set = {1, 2, 3, 4, 5}  # 集合是大括号
my_set.clear()
print(my_set)  # 输出: set()

同样地，clear() 方法清空了集合 my_set 中的所有元素，使得集合变为空。

注意：clear()` 方法是就地操作，它不会返回任何值，而是直接修改原容器。

3、对于字典：

对于其他类型的容器，比如字典（dict），也有类似的清空方法，但通常使用 clear() 方法来清空字典中的所有键值对：

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict)  # 输出: {}

在使用 clear() 方法时，确保你了解它会清空容器中的所有元素，并且**这个操作是不可逆的**。如果你需要保留原始数据，可以先复制一份容器，然后再对副本使用 clear() 方法。

使用 `del` `pop` `remove` 删除元素时的注意点:

1、确保你不会尝试删除不存在的元素，

2、对于 del 和 pop() 或 ValueError ，否则会抛出 IndexError 。

3、对于 remove() 异常，则会抛出 ValueError 。

4、使用 pop() 方法并尝试访问一个空列表，抛出 IndexError 异常。

`del()` `pop()` `remove()` ，使用时的相同与不同：

一、相同

用于从列表中移除元素

二、不同：

del() 语句：
- del() 是一个语句，不是方法，因此它不包含括号。
- del() 可以用来删除列表中的单个元素、切片或整个列表。
- 使用 del() 删除元素时，你必须指定要删除元素的索引或切片。
- 如果指定的索引不存在，del() 不会抛出异常，但会引发 NameError（如果在函数外部使用）或 UnboundLocalError（如果在函数内部使用）。

del() 也可以用来删除变量，不仅仅是列表元素。

my_list = [1, 2, 3, 4, 5]
del my_list[2]   # 删除索引为2的元素
del my_list[1:3] # 删除索引从1到2的元素
del my_list      # 删除整个列表

pop() 方法：
- pop() 是列表的一个方法，用于移除列表中的一个元素（默认为最后一个元素）并返回该元素的值。
- 如果提供了索引参数，pop() 将移除并返回指定索引处的元素。
- 如果尝试使用 pop() 从一个空列表中移除元素，将会抛出 IndexError 异常。

pop() 方法通常用于实现栈（LIFO）数据结构，其中元素按照后进先出（Last In, First Out）的顺序被移除。

my_list = [1, 2, 3, 4, 5]
last_element = my_list.pop()   # 默认移除并返回最后一个元素
first_element = my_list.pop(0) # 移除并返回索引为0的元素

remove() 方法：
- remove() 是列表的一个方法，用于移除列表中第一个匹配给定值的元素。
- 如果列表中存在多个相同的值，只会移除第一个匹配的元素。
- 如果列表中不存在指定的值，将会抛出 ValueError 异常。

remove() 方法不返回被移除的元素。

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)    # 移除值为3的元素

总结：

del() 用于删除列表中的元素或整个列表，也可以删除变量。
pop() 用于移除并返回列表中的一个元素，通常用于栈操作。
remove() 用于移除列表中第一个匹配给定值的元素。

运用过程中，根据自己的需求进行合理选择。

反转列表

反转一个给定的列表。
以[1,2,3,4,5]列表为例，对该列表进行翻转，并输出打印反转后的列表。

你可以使用多种方法来反转列表。以下是一些常见的方法：

方法一：使用切片操作

#首先，创建一个列表 my_list 用来存放列表。
my_list = [1, 2, 3, 4, 5]
reversed_list = []
# 利用列表切片，将元素逆序添加到新的列表中
# 切片的语法为[start:stop:step]，其中start为起始索引，stop为结束索引，step为步长

reversed_list = my_list[::-1]  # 切片的步长为-1，逆序切片
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

利用列表切片，将元素逆序添加到新的列表中

切片的语法为[start:stop:step]，其中start为起始索引，stop为结束索引，step为步长

方法二：用内置函数`reversed()`

my_list = [1, 2, 3, 4, 5]
reversed_list = list(reversed(my_list))
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

方法三：使用循环

my_list = [1, 2, 3, 4, 5]
reversed_list = []
# 利用列表的insert方法，将元素逆序添加到新的列表中
# 使用for循环，将元素逆序添加到新的列表中
for i in my_list:
    # insert方法的第一个参数为索引，第二个参数为元素
    reversed_list.insert(0, i)  # 逆序添加元素，索引为0
    # 有元素之后还在零除添加元素，即在现有元素的前面，所以索引为0

print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

方法四：使用`collections.deque`：

from collections import deque   # 导入deque模块

my_list = [1, 2, 3, 4, 5]

reversed_list = deque(my_list)  # 将列表转换为deque对象
reversed_list.reverse()  # 使用reverse()方法逆序列表元素
reversed_list = list(reversed_list)  # 将deque对象转换为列表
print(reversed_list)  # 输出: [5, 4, 3, 2, 1]

方法五：使用`list.reverse()`方法：

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

注意，list.reverse()方法会直接修改原始列表，而其他方法会返回一个新的列表。根据你的需求选择合适的方法。可以先对原有列表进行拷贝，然后对副本进行操作。

对列表中的元素进行排序：

升序：

1.`sort()`方法：

会直接在原列表上进行排序，不返回新列表。

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

2.`sorted()`函数：

会返回一个新的已排序列表，原列表保持不变。

my_list = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(my_list)
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

降序：

可以通过在升序的基础上加入 reverse=True参数来实现降序。

1.`sort()`方法：

my_list.sort(reverse=True)
print(my_list)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

2.`sorted()` 函数：

sorted_list = sorted(my_list, reverse=True)
print(sorted_list)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

zhjx0903

关注

16
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
列表知识点整理

列表相关知识点整理，基础。
复制链接

扫一扫

列表知识点整理

列表添加元素

一、在列表最后添加一个元素：

append()的基本使用方法：

二、在列表末尾添加多个元素：

方法一：extend()的基本使用方法：

方法二：使用+运算符添加多个元素到列表中

三、在列表中间添加一个元素

方法一：使用insert()的方法。

方法二：切片赋值

在列表中间插入多个元素

切片赋值

切片赋值的原理：

切片赋值的基本形式：

切片操作的原理可以分为几个步骤：

1、切片获取：

2、序列插入：

3、元素替换：

替换列表中的元素

一、替换列表中的某个元素：

1、列表的元素索引是静态的：

2、列表中的索引是动态的：

注意 ：

二、替换列表中的多个元素：

1、想要替换的元素数量与替换的序列长度_相等_ ：

2、想要替换的元素数量与替换序列的长度_不等_ ：

删除列表中的元素

方法一、使用 del() 语句：

一、del()语句的简介：

二、基本用法：

三、删除列表中的元素或者字典中的键值对：

四、使用del()语句和切片的方式，一次删除几个元素。

五、使用del()语句和切片的方式，一次删除几个相同的元素。

六、注意 :

方法二：使用remove()方法：

一、remove()简介：

二、基本用法：

三、使用remove()删除列表中的元素：

四、注意：

方法三：使用 pop()方法

一、简介：

1、移除并返回指定索引位置的元素：

2、移除并返回最后一个元素：（默认行为）

二、基本用法：

三、出现异常：

方法四：使用 clear() 方法：

简介：

基本用法：

1、对于列表（list）：

2、对于集合（set）：

3、对于字典：

使用 del pop remove 删除元素时的注意点:

del() pop() remove() ，使用时的相同与不同：

一、相同

二、不同：

反转列表

方法一：使用切片操作

方法二：用内置函数reversed()

方法三：使用循环

方法四：使用collections.deque：

方法五：使用list.reverse()方法：

对列表中的元素进行排序：

升序：

1.sort()方法：

2.sorted()函数：

降序：

1.sort()方法：

2.sorted() 函数：

`append()`的基本使用方法：

方法一：`extend()`的基本使用方法：

方法二：使用`+`运算符添加多个元素到列表中

方法一：使用`insert()`的方法。

注意：

方法一、使用 `del()` 语句：

一、`del()`语句的简介：

四、使用`del()`语句和切片的方式，一次删除几个元素。

五、使用`del()`语句和切片的方式，一次删除几个相同的元素。

方法二：使用`remove()`方法：

一、`remove()`简介：

三、使用`remove()`删除列表中的元素：

方法三：使用 `pop()`方法

方法四：使用 `clear()` 方法：

使用 `del` `pop` `remove` 删除元素时的注意点:

`del()` `pop()` `remove()` ，使用时的相同与不同：

方法二：用内置函数`reversed()`

方法四：使用`collections.deque`：

方法五：使用`list.reverse()`方法：

1.`sort()`方法：

2.`sorted()`函数：

1.`sort()`方法：

2.`sorted()` 函数：