python列表知识点总结(详细讲解)

列表

1、列表的创建

第一种采用直接方法：

list = [1,2,3]

第二种使用函数：

list = list()

range()函数的用法

range(start,end,step)
start ：起始的值
end：到end -1 结束
step：相邻两个数之间相差step个

2、python的切片操作

一个完整的切片表达式包含两个“:”，用于分隔三个参数（start_index、end_index、step），当只有一个“:”时，默认第三个参数step=1。

切片操作基本表达式：object[start_index : end_index : step]
step：正负数均可，其绝对值大小决定了切取数据时的“步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以增量1取值。

start_index：表示起始索引（包含该索引本身）；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。

end_index：表示终止索引（不包含该索引本身）；该参数省略时，表示一直取到数据”端点“，至于是到”起点“还是到”终点“，同样由step参数的正负决定，step为正时到”终点“，为负时到”起点“。

list = [1,2,3,4,5,6,7,8,9]

print(list[:4])  #[1,2,3]   没有start就默认从0开始。

print(list[4:]  #[5,6,7,8,9]   没有end，就从start后全部取出

运算符	说明
+	列表连接，合并两个列表
*	复制列表元素
[]	索引列表中的元素
[ : ]	对列表进行切片
in	如果列表中包含给定元素，返回True
not in	如果列表中包含给定元素，返回False

3、列表元素的修改

直接使用下标对列表中的元素进行修改

list[5] = 0

列表元素的增加

函数	说明
append(obj)	在列表末尾添加元素obj
extend(seq)	在列表末尾添加多个值，使用extend()函数，seq是一个可迭代对象，否则报错。
insert(index,obj)	将元素obj添加到列表的index位置处。

这里的extend(seq)中seq的可迭代对象包括但不限于以下类型：

1. 序列类型：如列表（list）、元组（tuple）、字符串（str）等。

2. 集合类型：如集合（set）、冻结集合（frozenset）等。

3. 映射类型：如字典（dict）。

4. 生成器（generator）和生成器表达式。

5. 自定义对象：通过实现__iter__()方法来使其成为可迭代对象。

   下面写了一个例子：

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

my_list.extend(other_list)
print(my_list)  # 输出：[1, 2, 3, 4, 5, 6]

列表中的函数删除

函数	说明
pop(index = -1)	删除列表中index处的元素（默认index = -1），并且返回该元素的值。
remove(obj)	删除列表中第一次出现的obj元素
clear()	删除列表中所有元素

查找元素位置：

index()函数：

从列表中查找元素第一次出现的位置

index(obj,start = 0 , end = -1)
 obj：要查找的元素
 start：表示查找的起始位置。
 end：表示查找的范围的结束处（不包含此位置）。

list1 = [1,2,3,4,5]
print(list1.index(3))  # 2

元素排序

sort()和sorted()函数

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sort()方法语法：

list.sort(cmp=None, key=None, reverse=False)

cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，**reverse = True** 降序， **reverse = False** 升序（默认）。

该方法没有返回值，但是会对列表的对象进行排序。

sorted 语法：

sorted(iterable, cmp=None, key=None, reverse=False)

参数说明：

• iterable – 可迭代对象。
• cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

python列表函数&方法

len()函数

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

具体来说，len() 函数的作用取决于它所作用的对象类型：

• 对于字符串，len() 返回字符串中字符的个数。
• 对于列表、元组或其他序列类型，len() 返回序列中元素的个数。
• 对于字典，len() 返回字典中键值对的个数。
• 对于集合，len() 返回集合中元素的个数

# 对字符串使用 len()
my_string = "Hello, World!"
print(len(my_string))  # 输出 13，因为字符串包含了 13 个字符

# 对列表使用 len()
my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 输出 5，因为列表包含了 5 个元素

# 对字典使用 len()
my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))  # 输出 3，因为字典包含了 3 个键值对

max()和min()函数

max() 函数是Python中的一个内置函数，用于返回给定参数的最大值。max() 函数可以接受多个参数，也可以接受一个可迭代对象（如列表、元组等）作为参数，并返回其中最大的元素。

同理min() 函数是Python中的一个内置函数，用于返回给定参数的最小值。min() 函数可以接受多个参数，也可以接受一个可迭代对象（如列表、元组等）作为参数，并返回其中最小的元素。

实例方法：

# 求取数字的最大值
print(max(5, 10, 3))  # 输出 10

# 求取字符串的最大值
print(max("apple", "banana", "orange"))  # 输出 "orange"

# 求取列表中元素的最大值
my_list = [7, 2, 9, 1, 5]
print(max(my_list))  # 输出 9

# 使用关键字参数 key 指定比较规则
my_list_tuples = [(1, 'apple'), (3, 'banana'), (2, 'orange')]
print(max(my_list_tuples, key=lambda x: x[0]))  # 输出 (3, 'banana')，根据元组第一个元素进行比较

list()函数

list() 函数是Python中的一个内置函数，用于将可迭代对象（如元组、字符串、列表、字典、集合等）转换为一个列表。当我们调用 list() 函数并传入一个可迭代对象作为参数时，它会返回一个由可迭代对象中的元素构成的新列表。

运用实例：

1、将字符串转换为列表：

my_string = "hello"
my_list = list(my_string)
print(my_list)  # 输出 ['h', 'e', 'l', 'l', 'o']

2、将元组转换为列表：

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出 [1, 2, 3]

3、将集合转换为列表：

my_set = {4, 5, 6}
my_list = list(my_set)
print(my_list)  # 输出 [4, 5, 6]

**attention：**4、将字典的键转换为列表：

my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_list = list(my_dict.keys())
print(keys_list)  # 输出 ['a', 'b', 'c']

index()函数

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

remove()函数

list.remove(obj)

移除列表中某个值的第一个匹配项

统计元素个数

count()函数可以统计元素出现的个数。

list1 = [1,2,3,4,1,2,1,2,1]
x = list1.count(1)
print(x)   #4

列表推导式

for

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

list2 = [nums ** 2 for nums in list1]

print(list2)   #[1, 4, 9, 16, 25]

for … if

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

list2 = [nums ** 2 for nums in list1 if nums > 2]

print(list2)  #[9, 16, 25]

列表的深拷贝和浅拷贝

浅拷贝：

浅拷贝：对原对象的值的拷贝，地址仍是一个指针指向原对象的地址，浅拷贝或者原对象的值发生变化，那原对象和浅拷贝对象的值都会随着被改变。

深拷贝：对原对象的地址的拷贝，新拷贝了一份与原对象不同的地址的对象，修改对象中的任何值，都不会改变深拷贝的对象的值。

列表的浅拷贝：

original_list = [1, 2, 3, [4, 5]]
copy_list = original_list[:]#copy_list = copy.copy(original_list)
copy_list[3][0]=10
#输出是：[1, 2, 3, [10, 5]]

在这个例子中，copy_list是original_list的浅拷贝，尽管元素本身被复制，但是嵌套列表的内的引用仍然是相同的。所以这里的话copy_list内容修改会影响到original_list的内容，但是有一点要注意，在浅拷贝的时候修改的一定是可修改序列。比如下面这两种情况。

original_list = [1, 2, 3, (4, 5)]
copy_list = original_list[:]
copy_list[3] = (10,20)
print(original_list)
print(copy_list)
#输出结果是：[1, 2, 3, (4, 5)]
#		   [1, 2, 3, (10, 20)]

original_list = [1, 2, 3, (4, 5)]
copy_list = original_list[:]
copy_list[2] = 5
print(original_list)
print(copy_list)
#输出结果是：[1, 2, 3, (4, 5)]
#		   [1, 2, 5, (4, 5)]

如果修改的不是可修改序列，那么原序列也不会改变。

字典的浅拷贝可以通过dict()构造函数或copy模块的copy()方法实现，与列表类似。

深拷贝：

深拷贝确保了原始对象及其所有嵌套对象都是独立的，对深拷贝后的对象进行修改不会影响原始对象。python中的copy模块提供的deepcopy()函数可以实现深拷贝。

import copy
original_list = [1, 2, 3, [4, 5]]
copy_list = copy.deepcopy(original_list)
copy_list[3][0] =10 
print(original_list)
print(copy_list)
#输出结果是：[1, 2, 3, [4, 5]]
#		   [1, 2, 3, [10, 5]]

由此可见深拷贝后的对象不会影响原始对象。