python 基本数据结构 列表(list)

列表（List）是一种有序的可变序列，可以存储任意类型的数据，包括数字、字符串、布尔值、甚至是其他列表等等。列表用方括号 [ ] 表示，其中的元素用逗号分隔

my_list = [1, 'two', 3.0, True, [4, 5, 6]]

上面的列表中包含了整数、字符串、浮点数、布尔值以及另一个列表。其中，元素的位置是有序的，即第一个元素是索引为0的位置，第二个元素是索引为1的位置，以此类推

list可以用于存储和处理各种类型的数据

(1)创建列表

可以使用方括号 [] 来创建一个空列表，或者在方括号中填充一些元素来创建一个有元素的列表

my_list = []

使用 list() 函数来创建一个列表，该函数接受一个可迭代对象（例如字符串、元组、集合等）作为参数，并将其转换为列表

my_str = 'abc'
my_list = list(my_str)
print(my_list)  # 输出 [a, b, c]

(2)删除列表

使用关键字来删除列表

del mylist

(3)访问列表中的元素

<1>索引

可以通过下标（索引）来访问列表中的元素。列表中的每个元素都有一个唯一的索引，从0开始递增

my_list = [10, 20, 30, 40, 50]
print(my_list[1])   # 输出 20，访问第二个元素
print(my_list[3])   # 输出 40，访问第四个元素

可以使用负数索引来访问列表中的倒数元素

my_list = [10, 20, 30, 40, 50]
print(my_list[-1])   # 输出 50，访问最后一个元素
print(my_list[-2])   # 输出 40，访问倒数第二个元素

需要注意的是，如果访问不存在的索引，会触发IndexError异常。因此，在访问列表元素时应该确保索引值在合法的范围内

<2>切片

使用切片（slice）操作访问列表的一部分。切片操作可以提取列表中的一段连续元素，返回一个新的列表。切片操作的语法是my_list[start:end]，其中start表示起始索引，end表示结束索引（不包括该索引处的元素）

my_list = [10, 20, 30, 40, 50]
print(my_list[0:3])   # 输出 [10, 20, 30]，访问前三个元素

注意，切片操作返回的是一个新列表，原始列表不受影响

<3>循环

使用循环遍历列表中的所有元素。可以使用for循环语句遍历列表中的每个元素，并执行相应的操作

my_list = [10, 20, 30, 40, 50]
for element in my_list:
    print(element)

<4>函数

使用内置函数访问列表的元素。Python内置了许多函数可以用来操作列表，例如len()函数可以返回列表中元素的个数，min()和max()函数可以分别返回列表中的最小值和最大值，sum()函数可以计算列表中所有元素的和等等

<5>成员运算符

可以使用in和not in运算符判断某个元素是否在列表中出现过

(4)新增元素

<1>append()方法：在列表末尾添加一个新元素

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

<2>extend()方法：在列表末尾添加一个可迭代对象中的所有元素

my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list) # [1, 2, 3, 4, 5]

append()和extend()方法都是向列表末尾添加新元素的方法，不同之处在于append()方法只能添加一个新元素，而extend()方法可以添加一个可迭代对象中的所有元素

<3>insert()方法：在指定位置插入一个新元素

my_list = [1, 2, 3]
my_list.insert(1, 'a')
print(my_list) # [1, 'a', 2, 3]

<4>+

如果需要同时添加多个元素，也可以使用+运算符来将两个列表拼接成一个新的列表

my_list = [1, 2, 3]
new_elements = [4, 5]
my_list += new_elements
print(my_list) # [1, 2, 3, 4, 5]

(5)更新元素

<1>直接使用索引赋值：可以通过索引直接将列表中的元素更新为新的值

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

<2>pop()方法：可以弹出指定位置的元素，并返回该元素的值。可以使用这个方法来更新指定位置的元素

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

<3>切片赋值：可以使用切片赋值来更新多个元素的值

my_list = [1, 2, 3, 4, 5]
my_list[1:4] = ['a', 'b', 'c']
print(my_list) # [1, 'a', 'b', 'c', 5]

使用切片赋值时，等号两侧的序列长度可以不相等。如果切片赋值的长度大于切片的长度，会插入新的元素，如果切片赋值的长度小于切片的长度，则会删除一部分元素

(6)删除元素

<1>使用 del 语句：可以使用 del 语句删除列表中的指定元素

my_list = [1, 2, 3]
del my_list[1]
print(my_list) # [1, 3]

<2>pop() 方法：可以使用 pop() 方法弹出指定位置的元素，并返回该元素的值

my_list = [1, 2, 3]
my_list.pop(1)
print(my_list) # [1, 3]

<3>remove() 方法：可以使用 remove() 方法删除列表中的指定元素

my_list = [1, 2, 3]
my_list.remove(2)
print(my_list) # [1, 3]

<4>切片赋值：可以使用切片赋值来删除指定位置的元素

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

del 语句是最常用的方法，可以删除列表中的指定元素。

pop() 方法可以弹出指定位置的元素，并返回该元素的值，可以利用这个方法来删除指定位置的元素

remove() 方法可以删除列表中的指定元素，但只会删除第一个匹配的元素

切片赋值则是一种比较灵活的方式，可以删除指定位置的元素。需要注意的是，使用切片赋值时，等号两侧的序列长度可以不相等。如果切片赋值的长度大于切片的长度，会插入新的元素，如果切片赋值的长度小于切片的长度，则会删除一部分元素

(7)其他对列表本身的函数

index()

index() 函数用于查找指定元素在列表中第一次出现的位置。它的语法如下：

list.index(x[, start[, end]])

参数说明：
x: 要查找的元素值。
start（可选）：查找起始位置，默认为 0。
end（可选）：查找结束位置，默认为列表末尾。
该函数会返回列表中第一个匹配的元素的索引值。如果列表中不存在要查找的元素，则会抛出 ValueError 异常。需要注意的是，index() 函数只返回第一个匹配的元素的索引值，如果列表中有多个匹配的元素，它只返回第一个匹配的位置。
下面是一个示例，演示如何使用 index() 函数查找列表中的元素：

a = [1, 2, 3, 4, 5, 4]
a.index(4)
3
a.index(4, 4)  # 从索引4开始查找
5
a.index(6)     # 抛出ValueError异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 6 is not in list

sort()

sort() 函数用于对列表进行排序，它可以按照升序或降序对列表中的元素进行排序，默认是按升序排列。该函数会直接修改原始列表，并返回 None。
sort() 函数的语法如下：

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

参数说明：
key（可选）：用于指定排序时比较元素的函数。该参数必须是一个可调用的函数或 lambda 表达式。如果不指定该参数，则默认按照元素的大小进行排序。
reverse（可选）：用于指定排序时元素的排列顺序。如果设置为 True，则按降序排列；否则按升序排列。
下面是一个示例，演示如何使用 sort() 函数对列表进行排序：

a = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
a.sort()    # 默认按升序排列
print(a)    # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

a.sort(reverse=True)  # 按降序排列
print(a)    # [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

a = ["apple", "banana", "cherry", "orange"]
a.sort(key=lambda x: len(x))  # 按字符串长度进行排序
print(a)    # ['apple', 'cherry', 'banana', 'orange']

需要注意的是，sort() 函数会直接修改原始列表，而不会返回一个新的排序后的列表。如果需要保留原始列表的副本，可以使用切片操作来复制列表

clear()

用于清空列表中的所有元素。调用该方法后，列表将变为空列表，不返回任何值。
clear() 方法的语法如下：

list.clear()

# 示例如下：

fruits = ['apple', 'banana', 'cherry', 'orange']
fruits.clear()
print(fruits)   # 输出 []

需要注意的是，该方法会直接修改原始列表，而不会返回任何值。如果需要保留原始列表的副本，可以使用切片操作来复制列表

copy()

用于创建一个列表副本。该方法会复制列表中的所有元素，并将它们放到一个新的列表中。新列表的元素与原列表的元素是相同的，但它们在内存中的位置不同。
copy() 方法的语法如下：

new_list = list.copy()

示例如下：

fruits = ['apple', 'banana', 'cherry']
new_fruits = fruits.copy()
print(new_fruits)   # 输出 ['apple', 'banana', 'cherry']

需要注意的是，copy() 方法创建的是一个浅拷贝。如果列表中包含其他可变对象（例如嵌套的列表、字典等），则新列表中的元素仍然引用原始对象。这意味着，在新列表中修改嵌套对象的属性时，原始对象也会受到影响。
示例如下：

# 创建原始列表
a = [[1, 2], [3, 4]]
# 创建副本列表
b = a.copy()

# 修改副本列表中的元素
b[0][0] = 5

# 输出两个列表
print(a)  # 输出 [[5, 2], [3, 4]]
print(b)  # 输出 [[5, 2], [3, 4]]

在上面的代码中，我们创建了一个包含两个子列表的原始列表 a，并使用 copy() 方法创建了一个副本列表 b。然后，我们修改了副本列表中的第一个子列表的第一个元素。最后，我们打印了原始列表和副本列表，发现它们的第一个子列表都被修改了。
如果要创建一个深拷贝，可以使用 copy 模块中的 deepcopy() 函数

count()

用于统计列表中某个元素出现的次数。它接收一个参数，即要统计的元素，返回该元素在列表中出现的次数。

fruits = ["apple", "banana", "orange", "apple", "kiwi"]
print(fruits.count("apple")) # 输出：2
print(fruits.count("kiwi")) # 输出：1
print(fruits.count("pear")) # 输出：0，因为列表中没有"pear"这个元素

需要注意的是，如果要统计的元素不在列表中，count()方法会返回0

reverse()

用于反转列表中的元素顺序。该方法没有返回值，而是直接修改了原列表。

fruits = ["apple", "banana", "orange", "kiwi"]
fruits.reverse()
print(fruits) # 输出：['kiwi', 'orange', 'banana', 'apple']

需要注意的是，reverse()方法会直接修改原列表，而不是创建一个新列表。如果需要创建一个反转后的列表，可以先使用[::-1]切片创建一个新列表，例如：

fruits = ["apple", "banana", "orange", "kiwi"]
reversed_fruits = fruits[::-1]
print(reversed_fruits) # 输出：['kiwi', 'orange', 'banana', 'apple']

(8)列表之间的操作

<1>列表的拼接：使用加号+将两个列表拼接成一个新的列表。

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c) # 输出：[1, 2, 3, 4, 5, 6]

<2>列表的重复：使用乘号*将列表重复多次。

a = [1, 2, 3]
b = a * 3
print(b) # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]

<3>列表的比较：使用运算符==或!=对两个列表进行比较，返回布尔值。

a = [1, 2, 3]
b = [1, 2, 3]
c = [4, 5, 6]
print(a == b) # 输出：True
print(a == c) # 输出：False
print(a != c) # 输出：True

需要注意的是，当进行拼接、重复等操作时，会创建一个新的列表对象。如果需要在原列表上进行修改，可以使用列表的extend()方法来实现拼接，使用乘号*来实现重复。例如：
 

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b) # 将b的元素添加到a中，修改了a的值
print(a) # 输出：[1, 2, 3, 4, 5, 6]