hello大家好，我是CodeNerd影，本次将带来python中列表的讲解，这篇文章是对列表知识点的整合，如果有不足还请各位旅行者见谅！！！祝各位十连双金！！！
目录
9.sort，sorted，reverse，reversed函数
一.列表的定义及创建列表
1.列表是什么及其作用
在 Python 中，列表（List）是一种有序、可变的数据结构。
它的功能也十分强大：
-
存储多个元素：列表可以存储任意数量的元素，这些元素可以是相同类型或不同类型的。
-
有序性：列表中的元素按照它们在列表中的位置有序排列，可以通过索引访问和操作特定位置的元素。
-
可变性：列表是可变的，可以通过添加、删除、修改元素来改变列表的内容。
-
便于遍历和操作：列表提供了丰富的操作方法，如索引访问、切片、追加、插入、删除、排序等，使得对列表进行遍历和操作变得方便。
-
数据结构的应用：列表常用于存储和处理一组相关的数据，例如存储学生名单、待办事项列表、坐标点集合等。
2.使用[ ]和list函数来创建列表
list1 = [] #建立了一个空列表，并将空列表赋值给list1
list2 = list() #使用list函数建立空列表，并将空列表赋值给list2空列表就建好啦！
什么？不想建空列表怎么办？这里给大家提供一个例子
二.列表元素的访问和切片
1.通过下标进行访问
列表中的所有元素都是有下标的从0开始这也就对应着列表的有序性，所以我们可以通过访问下标的方式来访问元素。
类似于字符串的索引（-1，-2也是）
注意：下标要存在，如果不存在怎会报错。
2.切片访问
切片的语法是 list[start:end:step]，其中 start 是起始索引（包含），end 是结束索引（不包含），step 是步长值。
fruits = ['apple', 'banana', 'orange', 'kiwi', 'grape']
# 获取索引为 1 和 2 的元素
slice1 = fruits[1:3]
print(slice1) # 输出 ['banana', 'orange']
# 获取索引为 0 到 3 的元素，步长为 2
slice2 = fruits[0:4:2]
print(slice2) # 输出 ['apple', 'orange']
# 获取索引为 2 之后的所有元素，步长为 1
slice3 = fruits[2::1]
print(slice3) # 输出 ['orange', 'kiwi', 'grape']
# 获取最后两个元素，步长为 1
slice4 = fruits[-2:]
print(slice4) # 输出 ['kiwi', 'grape']
# 获取从索引为 1 到倒数第二个元素之间的元素，步长为 -1
slice5 = fruits[1:-1:-1]
print(slice5) # 输出 []
# 获取整个列表的副本，步长为 -1
slice6 = fruits[::-1]
print(slice6) # 输出 ['grape', 'kiwi', 'orange', 'banana', 'apple']
在切片操作中，起始索引、结束索引和步长可以根据需要进行组合，以获取所需的子列表。切片操作返回的是一个新的列表，原始列表不受影响。这个后面在讲解copy函数和从copy.deepcopy函数时会着重讲解。
3.通过for循环进行访问
这里直接上例子
fruits = ['apple', 'banana', 'orange', 'kiwi', 'grape']
# 使用 for 循环遍历列表
for fruit in fruits:
print(fruit)
# 输出:
# apple
# banana
# orange
# kiwi
# grape
4.检查元素是否在列表中
要检查一个元素是否存在于列表中，可以使用 in 关键字。in 关键字用于检查某个值是否存在于可迭代对象（如列表）中，并返回一个布尔值（True 或 False）。
往往结合着条件if使用，举例子
fruits = ['apple', 'banana', 'orange', 'kiwi', 'grape']
# 检查 'banana' 是否在列表中
if 'banana' in fruits: #此时为True，符合条件，并执行条件
print('banana 存在于列表中')
else:
print('banana 不存在于列表中')5.列表的嵌套形式
列表可以包含其他列表作为其元素，形成嵌套的列表结构。这种嵌套的列表形式可以用于表示更复杂的数据结构，例如矩阵、树等。
matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
# 访问嵌套列表中的元素
print(matrix[0]) # 输出: [1, 2, 3]
print(matrix[1][2]) # 输出: 6
# 修改嵌套列表中的元素
matrix[2][1] = 10
print(matrix) # 输出: [[1, 2, 3], [4, 5, 6], [7, 10, 9]]
list[][]等类似的结构是访问的嵌套。
三.列表的所有内置函数及其操作
1.无需内置函数的列表操作
1.列表元素的替换
可以通过索引来访问并赋予新的值。列表的索引从 0 开始，可以使用索引来定位要替换的元素位置，并将新的值赋给该索引位置。
fruits = ['apple', 'banana', 'orange', 'kiwi', 'grape']
# 替换列表中的元素
fruits[1] = 'pear'
fruits[3] = 'melon'
print(fruits)
# 输出: ['apple', 'pear', 'orange', 'melon', 'grape']
聪明的旅行者可能想到了切片，没错切片操作也可以像这种形式对列表元素进行替换。
2.列表的“加和乘”
- 加法操作符
+：用于将两个列表连接在一起，生成一个新的列表。 - 乘法操作符
*：用于将列表重复多次，生成一个新的列表。
#加法运算
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print(result)
# 输出: [1, 2, 3, 4, 5, 6]
#乘法运算
list1 = [1, 2, 3]
result = list1 * 3
print(result)
# 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]
2.内置函数
准备好了吗，旅行者们，知识风暴来袭！！！
1.enumerate函数
enumerate()函数的基本语法如下：
enumerate(iterable, start=0)
iterable：要枚举的可迭代对象，通常是列表。start（可选）：指定索引的起始值，默认为0。
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
print(index, fruit)
#输出结果
0 apple
1 banana
2 orange
2.append函数
append()是列表对象的一个方法，用于在列表末尾添加新的元素。它的基本语法如下：
list.append(element)
list：要操作的列表对象。element：要添加到列表末尾的元素。
fruits = ['apple', 'banana', 'orange']
fruits.append('grape')
print(fruits)
#输出结果
['apple', 'banana', 'orange', 'grape']3.extend函数
extend()是列表对象的一个方法，用于将另一个可迭代对象中的元素逐个添加到列表的末尾。它的基本语法如下：
list.extend(iterable)
list：要操作的列表对象。iterable：包含要添加到列表末尾的元素的可迭代对象，通常是另一个列表。
fruits = ['apple', 'banana', 'orange']
more_fruits = ['grape', 'kiwi']
fruits.extend(more_fruits)
print(fruits)
#输出结果
['apple', 'banana', 'orange', 'grape', 'kiwi']与append()方法不同，extend()方法可以一次性添加多个元素，而不是将整个可迭代对象作为一个元素添加。
4.insert函数
insert()是列表对象的一个方法，用于在指定位置插入一个元素。它的基本语法如下：
list.insert(index, element)
list：要操作的列表对象。index：要插入元素的位置索引。element：要插入的元素。
fruits = ['apple', 'banana', 'orange']
fruits.insert(1, 'grape')
print(fruits)
#输出结果
['apple', 'grape', 'banana', 'orange']5.remove函数
remove()是列表对象的一个方法，用于删除列表中指定的元素。它的基本语法如下：
list.remove(element)
list：要操作的列表对象。element：要删除的元素。
fruits = ['apple', 'banana', 'orange']
fruits.remove('banana')
print(fruits)
#输出结果
['apple', 'orange']6.pop函数
pop()是列表对象的一个方法，用于移除并返回列表中指定位置的元素。它的基本语法如下：
list.pop(index)
list：要操作的列表对象。index：要移除的元素的位置索引。如果不提供索引，默认为移除并返回列表中的最后一个元素。
fruits = ['apple', 'banana', 'orange']
removed_element = fruits.pop(1)
print(fruits)
print(removed_element)
#输出结果
['apple', 'orange']
banana7.index函数
index()是列表对象的一个方法它会在列表中从左到右查找指定元素的第一个匹配项，并返回其位置索引。该方法的基本语法如下：
list.index(element, start, end)
list：要操作的列表对象。element：要查找的元素。start（可选）：搜索的起始位置索引（包含在搜索范围内）。如果未提供，则默认从列表的开头开始搜索。end（可选）：搜索的结束位置索引（不包含在搜索范围内）。如果未提供，则默认搜索到列表的末尾。
1.
fruits = ['apple', 'banana', 'orange', 'banana']
index = fruits.index('banana')
print(index)
#输出结果
1
2.
fruits = ['apple', 'banana', 'orange', 'banana']
index = fruits.index('banana', 2)
print(index)
#输出结果
3
3.
fruits = ['apple', 'banana', 'orange', 'banana']
index = fruits.index('banana', 2, 4)
print(index)
#输出结果
38.count函数
count() 是列表对象的一个方法，用于统计指定元素在列表中出现的次数。它的基本语法如下：
list.count(element)
list：要操作的列表对象。element：要统计出现次数的元素。
fruits = ['apple', 'banana', 'orange', 'banana']
count = fruits.count('banana')
print(count)
#输出结果
29.sort，sorted，reverse，reversed函数
sort() 方法用于原地对列表进行排序，即修改原始列表。它的基本语法如下：
list.sort(key=None, reverse=False)
list：要操作的列表对象。key（可选）：用于指定排序的关键字函数，可以根据元素的某个属性进行排序。reverse（可选）：指定是否进行逆序排序，默认为False。
numbers = [5, 2, 8, 1, 6]
numbers.sort()
print(numbers)
#输出结果
[1, 2, 5, 6, 8]sorted() 函数用于对列表进行排序，返回一个新的已排序的列表，不修改原始列表。它的基本语法如下：
sorted_list = sorted(list, key=None, reverse=False)
list：要排序的列表对象。key（可选）：用于指定排序的关键字函数，可以根据元素的某个属性进行排序。reverse（可选）：指定是否进行逆序排序，默认为False。
numbers = [5, 2, 8, 1, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)
#输出结果
[1, 2, 5, 6, 8]reverse() 方法用于原地反转列表中的元素顺序，即修改原始列表。它的基本语法如下：
list.reverse()numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)
#输出结果
[5, 4, 3, 2, 1]reversed() 函数用于返回一个迭代器，该迭代器按照逆序访问列表中的元素，不修改原始列表。如果需要使用列表形式，可以将返回的迭代器转换为列表。它的基本语法如下：
reversed_list = list(reversed(list))numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(reversed_numbers)
#输出结果
[5, 4, 3, 2, 1]其中，sort和sorted函数是可以加reverse函数的：
sort(reverse = True) #True表示的是从大到小来排序
sorted(list, reverse = False) #False表示的是从小到大来排序
10.copy，copy.deepcopy函数
copy() 函数用于创建浅拷贝，它会复制原始列表的元素，并创建一个新的列表对象，但是这些元素本身仍然是原始列表中的引用。这意味着对于可变对象，如嵌套列表或对象，更改副本中的元素会反映在原始列表中。
copy.deepcopy() 函数用于创建深拷贝，它会递归地复制原始列表的所有元素，包括嵌套的可变对象。这样，创建的副本将是完全独立的，对副本的修改不会影响原始列表。
1.对于copy函数
original_list = [1, 2, [3, 4]]
copied_list = original_list.copy()
# 修改副本中的元素
copied_list[0] = 5
copied_list[2][0] = 6
print("Original List:", original_list)
print("Copied List:", copied_list)
#输出结果：
Original List: [1, 2, [6, 4]]
Copied List: [5, 2, [6, 4]]
2.对于copy.deepcopy函数
original_list = [1, 2, [3, 4]]
deepcopied_list = copy.deepcopy(original_list)
# 修改副本中的元素
deepcopied_list[0] = 5
deepcopied_list[2][0] = 6
print("Original List:", original_list)
print("Deepcopied List:", deepcopied_list)
#输出结果
Original List: [1, 2, [3, 4]]
Deepcopied List: [5, 2, [6, 4]]11.clear， del函数
clear() 方法：是列表对象的一个方法，用于删除列表中的所有元素，使其变为空列表。
my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)
#输出结果
[]del 语句：用于删除对象。当您将 del 语句应用于列表时，它将删除整个列表对象。
my_list = [1, 2, 3, 4, 5]
del my_list
#直接讲列表删除12.len函数
len() 是一个内置函数：用于返回一个序列（如列表、字符串、元组等）或集合（如字典、集合等）的长度或元素个数。
my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)
#输出结果
513.max，min函数
max() 和 min() 是内置函数：用于获取序列（如列表、字符串、元组等）或集合（如字典、集合等）中的最大值和最小值。
对于列表，max() 函数将返回列表中的最大值，而 min() 函数将返回列表中的最小值。
my_list = [5, 2, 8, 1, 4]
maximum = max(my_list)
minimum = min(my_list)
print(maximum)
print(minimum)
#输出结果
8
114.sum函数
sum() 是一个内置函数：用于计算序列（如列表、元组等）中所有元素的总和。
my_list = [1, 2, 3, 4, 5]
total = sum(my_list)
print(total)
#输出结果
1515.join函数
my_list = ["Hello", "World", "!"]
result = " ".join(my_list)
print(result)
#输出结果
Hello World !注意：用join函数要确保列表中所有元素都是字符串，如果用数字要这么写：result = “”。join（map（str，list））
16.zip函数
zip() 是一个内置函数：用于将多个可迭代对象（如列表、元组等）中对应位置的元素打包成一个元组，然后返回由这些元组组成的迭代器。
numbers = [1, 2, 3]
letters = ['a', 'b', 'c']
zipped = zip(numbers, letters)
for item in zipped:
print(item)
#输出结果
(1, 'a')
(2, 'b')
(3, 'c')四.列表的比较运算符
1.相等运算符 ==
检查两个列表是否具有相同的元素和顺序。
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)
# 输出: True
list3 = [3, 2, 1]
print(list1 == list3)
# 输出: False
2.不等运算符 !=
检查两个列表是否不相等，即元素或顺序不同。
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 != list2)
# 输出: True
list3 = [1, 2, 3]
print(list1 != list3)
# 输出: False
3.大于运算符 > 和小于运算符 <
用于比较两个列表的字典顺序。它们会逐个比较列表中的元素，直到找到不同的元素或一个列表结束。
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 > list2)
# 输出: False
list3 = [1, 2, 3]
print(list1 < list3)
# 输出: False
list4 = [1, 2, 4]
print(list1 < list4)
# 输出: True
简单来说就是同时遍历两个列表并且比较两个字典序的大小，不相等就直接返回布尔值。
4.大于等于运算符 >= 和小于等于运算符 <=
用于比较两个列表的字典顺序，并检查是否大于等于或小于等于。
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 >= list2)
# 输出: False
list3 = [1, 2, 3]
print(list1 <= list3)
# 输出: True
list4 = [1, 2, 4]
print(list1 <= list4)
# 输出: True
注意：如果列表的元素是可比较的（例如数字或字符串），则比较运算符可以正常工作。但是，如果列表包含不可比较的元素（例如列表或字典），则会引发
TypeError异常。
五.结尾
多练！多练！多练！即使不菜也要多练！！！
今晚将会有力扣的双周赛，明天会有力扣的周赛。做完我会将自己的做出来的做题思路写一篇文章，欢迎各位过来指导。
十连双金！！！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
