5_ Python的列表：创建、访问和常见操作

Python中的列表是一种非常常用的数据类型，可以存储多个相同或不同的元素。在本文章中，将介绍Python中的列表相关知识点，包括如何创建、访问、修改和删除列表中的元素，以及如何使用一些常用的列表方法。

一、创建列表

要创建一个列表，可以使用方括号 [] 括起来的多个元素，每个元素之间用逗号分隔。例如，创建一个包含整数的列表：

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

此外，Python中的列表可以存储不同类型的元素，如下所示：

my_list = [1, 'Hello', 3.14, True]

二、访问列表元素

可以使用索引来获取列表中的单个元素，其中第一个元素的索引为0。例如，要获取numbers列表中的第二个元素，可以使用以下代码：

my_list = [1, 2, 3, 4, 5]
print(my_list[0])  # 输出：1
print(my_list[-1])  #输出： 5

三、列表的数据操作

Python中的列表是可变的，这意味着我们可以对列表的进行各种数据操作，一般包含增、删、改、查四个方面。

（一）添加元素

Python 中添加元素到列表的常用方法有以下几种：

1. append()：将元素添加到列表末尾。例如：

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

注意：

• append()是List的方法，用于将一个元素添加到列表的末尾。
• 它接受一个参数，即要添加到列表的元素。
• append()不会改变原始列表，而是返回一个新列表。

2. insert()：在指定位置插入元素。例如：

my_list = [1, 2, 3]  
my_list.insert(1, 4)  # 在索引为 1 的位置插入元素 4  
print(my_list)  # 输出：[1, 4, 2, 3]

注意：

• insert()也是List的方法，用于在指定位置插入一个元素。
• 它接受两个参数，第一个参数是要插入的元素的索引位置，第二个参数是要插入的元素。
• insert()会改变原始列表，并且在指定的位置插入新的元素。

3. extend()：将一个可迭代对象中的元素添加到列表末尾 。例如：

my_list = [1, 2, 3]  
my_list.extend([4, 5])  # 将列表 [4, 5] 中的元素添加到 my_list 末尾  
print(my_list)  # 输出：[1, 2, 3, 4, 5]

注意：

• extend()也是List的方法，用于将一个可迭代对象中的元素添加到列表的末尾。
• 它接受一个参数，即要添加到列表的可迭代对象。
• extend()会改变原始列表，并且将可迭代对象中的所有元素添加到列表的末尾。

总结：

• append()用于向列表末尾添加一个元素，不接受多个参数。
• insert()用于在指定位置插入一个元素，接受两个参数，可以指定插入位置。
• extend()用于向列表末尾添加多个元素，接受一个可迭代对象的参数，可迭代对象中的所有元素都会被添加到列表末尾。

注：什么是可迭代对象？
在Python中，可迭代对象是指具有一个或多个元素的对象，并且可以通过迭代来访问这些元素。可迭代对象包括列表、元组、集合、字典、字符串等。

当一个函数或方法接受一个可迭代对象的参数时，它表示可以接受上述这些类型的对象作为参数，并且可以在函数或方法内部通过循环或其他方式来遍历和操作这些元素。

例如，列表的append()方法接受一个可迭代对象的参数，可以将该对象中的所有元素添加到列表末尾。例如：

my_list = [1, 2, 3]  
my_tuple = (4, 5, 6)  
my_list.append(my_tuple)  # 将my_tuple中的所有元素添加到my_list末尾  
print(my_list)  # 输出：[1, 2, 3, (4, 5, 6)]

在这个例子中，append()方法接受一个可迭代对象my_tuple作为参数，并将其中的三个元素添加到列表my_list的末尾。

（二）删除元素

Python 中删除列表元素有多种方法，以下是其中常用的几种：

1. remove() ：可以删除列表中的特定元素，但是只能删除第一次出现的该元素。例如：

my_list = [1, 2, 3, 2, 4]  
my_list.remove(2)  # 删除第一个出现的值为 2 的元素  
print(my_list)  # 输出：[1, 3, 2, 4]

注意：
使用 remove() 方法时，如果列表中包含多个要删除的元素，只会删除第一个出现的该元素。如果要删除的元素不在列表中，会抛出 ValueError 异常。

2. pop() 方法：可以删除并返回列表中的特定元素，也可以指定要删除的索引。例如：

# 删除并返回第三个元素  
my_list = [1, 2, 3, 4, 5]  
elem = my_list.pop(2)  # 删除并返回第三个元素  
print(elem)  # 3  
print(my_list)  # 输出：[1, 2, 4, 5]

注意：
使用 pop() 方法时，如果不指定索引，会将最后一个元素删除并返回。如果指定的索引超出范围，会抛出 IndexError 异常。

3. del 语句：可以删除列表中的特定元素，也可以删除整个列表。例如：

# 删除特定元素  
my_list = [1, 2, 3, 4, 5]  
del my_list[2]  # 删除第三个元素  
print(my_list)  # 输出： [1, 2, 4, 5]  
  
# 删除整个列表  
del my_list  # 删除 my_list 变量指向的列表对象

注意：
使用 del 语句删除特定元素时，会直接将该元素从列表中删除，不会留下空穴。如果要删除整个列表，需要使用 del 语句删除变量名所指向的列表对象。

“空穴”可以理解为由于删除元素而留下的空位或间隙。当使用del语句删除列表中的元素时，Python会将要删除的元素与列表中其他元素向前移动，以填补被删除元素的位置。这样做的结果是，列表中的元素不会因为删除操作而留下空隙或间隙。

4. clear() ：用于清空列表的方法，它会将列表中的所有元素删除，使其变为空列表。例如：

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

注意：
与其他方法相比，clear() 方法的主要区别在于它不会删除整个列表对象，而是只删除列表中的所有元素。这意味着，使用 clear() 方法后，列表对象仍然存在，但是其中不包含任何元素。

5. 切片赋值：使用切片赋值：可以删除并替换列表中的一段元素。例如：

my_list = [1, 2, 3, 4, 5]  
my_list[1:3] = ['a', 'b']  # 删除并替换第二到第四个元素  
print(my_list)  # 输出： [1, 'a', 'b', 'd', 5]

注意：
使用切片赋值可以删除并替换列表中的一段元素。通过使用切片赋值，将原列表中指定范围内的元素删除，并替换为新的元素。如果新元素的数量不足或超出范围，会引发异常。与其他方法不同，切片赋值可以一次删除多个连续的元素，并且可以替换为新的元素。

总结

• del 语句：del 是Python中的关键字，用于删除变量或对象。通过使用 del语句，可以删除列表中的特定元素，也可以删除整个列表。与其他方法不同，del语句不会在列表中留下空穴，而是将元素直接从列表中删除。如果要删除整个列表，需要使用 del 语句删除变量名所指向的列表对象。
• remove() 方法：remove()方法用于删除列表中的特定元素，但是只能删除第一次出现的该元素。如果列表中包含多个要删除的元素，只会删除第一个出现的该元素。如果要删除的元素不在列表中，会抛出 ValueError 异常。与其他方法不同，remove() 方法不会返回被删除的元素，因为它只删除第一个匹配的元素。
• pop() 方法：pop()方法用于删除并返回列表中的特定元素，也可以指定要删除的索引。如果不指定索引，会将最后一个元素删除并返回。如果指定的索引超出范围，会抛出IndexError 异常。与其他方法不同，pop() 方法会返回被删除的元素，并且可以指定要删除的索引。
• clear() 方法的主要区别在于它不会删除整个列表对象，而是只删除列表中的所有元素。这意味着，使用 clear() 方法后，列表对象仍然存在，但是其中不包含任何元素。
• 切片赋值：使用切片赋值可以删除并替换列表中的一段元素。通过使用切片赋值，将原列表中指定范围内的元素删除，并替换为新的元素。如果新元素的数量不足或超出范围，会引发异常。与其他方法不同，切片赋值可以一次删除多个连续的元素，并且可以替换为新的元素。

（三）修改元素

1. 通过索引直接修改：使用索引访问列表中的元素，并将其赋值为新的值。例如：

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

这种修改方式适用于修改单个元素或少数几个元素。

2. 使用切片赋值修改：使用切片操作符 [:] 将一个或多个元素替换为新的值。例如：

my_list = [1, 2, 3, 4, 5]  
my_list[1:3] = [6, 7]  
print(my_list)  # 输出： [1, 6, 7, 4, 5]

这种修改方式适用于批量修改元素，可以同时修改多个元素。

除此之外，还可以用append(),extend()等方法来对元素进行修改。

（四）查找元素

在 Python 中，可以使用以下方法来查找列表中的元素：

1. index()方法返回列表中第一个匹配元素的索引。如果未找到匹配的元素，则抛出ValueError异常。例如：

fruits = ['apple', 'banana', 'orange', 'banana']  
print(fruits.index('banana'))  # 输出 1，因为第一个'banana'在列表中的索引是1

2. in关键字：使用in关键字可以检查一个元素是否在列表中。例如：

fruits = ['apple', 'banana', 'orange']  
if 'apple' in fruits:  
    print('苹果在列表中')  
else:  
    print('苹果不在列表中')  # 输出 '苹果在列表中'

四、列表的其他常见操作

Python中的列表还有许多其他常见操作，如计算列表长度、排序列表等等。

（一）计算列表长度

可以使用len()函数计算列表的长度，例如：

my_list = [1, 2, 3, 4, 5]  
length = len(my_list)  
print(length) # 输出：5

（二）排序列表

排序列表：可以使用sort()方法对列表进行排序，例如：

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

（三）反转列表

反转列表：可以使用reverse()方法反转列表的顺序，例如：

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

（四）列表的切片

列表的切片是指从列表中选择一部分元素并创建一个新的列表。使用切片操作符（[]）来指定要选择的元素范围。例如：

numbers = [1, 2, 3, 4, 5]  
# 选择前三个元素  
first_three = numbers[:3]  
print(first_three)  # 输出: [1, 2, 3]  
# 选择后两个元素  
last_two = numbers[-2:]  
print(last_two)  # 输出: [4, 5]  
# 选择第2到第4个元素（不包括第4个元素）  
middle_three = numbers[2:-1]  
print(middle_three)  # 输出: [3, 4]

在上面的示例中，: 前面的数字表示开始位置，如果省略则从列表的开头开始；: 后面的数字表示结束位置（不包括该位置），如果省略则到列表的末尾。如果使用负数，则表示从列表的末尾开始计数。例如，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推

（五）列表的遍历

在 Python 中，可以使用 for 循环来遍历列表中的每个元素。例如：

numbers = [1, 2, 3, 4, 5]  
for number in numbers:  
    print(number, end=' ')		# 输出： 1 2 3 4 5 

（六）列表的嵌套

列表可以嵌套，即一个列表中可以包含另一个列表。例如，以下代码创建了一个包含两个子列表的父列表：

parent_list = [[1, 2, 3], [4, 5, 6]]

可以使用 for 循环来遍历父列表中的每个子列表，并使用嵌套的 for 循环来遍历每个子列表中的每个元素。例如，以下代码可以遍历父列表中的每个子列表，并打印每个元素：

for sublist in parent_list:  
    for element in sublist:  
        print(element, end='')		# 输出：1 2 3 4 5 6

（七）列表推导式

列表推导式是一种简洁的方式来创建新列表的方法。它使用一行代码来基于现有列表或表达式创建新列表。例如，以下代码使用列表推导式来创建一个新列表，其中每个元素都是原始列表中元素的平方：

numbers = [1, 2, 3, 4, 5]  
squared_numbers = [x ** 2 for x in numbers]		# 输出：[1, 4, 9, 16, 25]

（八）列表的复制

在 Python 中，复制一个对象通常分为浅拷贝和深拷贝两种方式。

浅拷贝会创建一个新的对象，但是新对象中的元素是原对象中元素的引用，也就是说，原对象和新对象的某些元素可能指向同一个内存地址，因此对新对象的操作也会影响原对象。浅拷贝可以使用 copy() 方法来实现。

深拷贝则会创建一个新的对象，并且新对象中的所有元素都是原对象的副本，也就是说，原对象和新对象的所有元素都指向不同的内存地址，因此对新对象的操作不会影响原对象。深拷贝可以使用 copy.deepcopy() 方法来实现。

下面是一个浅拷贝和深拷贝的示例：

import copy  
  
# 创建一个包含可变对象的列表  
original_list = [1, [2, 3], 4]  
  
# 浅拷贝  
new_list_1 = copy.copy(original_list)  
  
# 对新对象的第二个元素进行修改  
new_list_1[1][0] = 'a'  
  
# 输出结果：原对象和新对象的第二个元素都发生了变化  
print(original_list)  # 输出：[1, ['a', 3], 4]  
print(new_list_1)     # 输出：[1, ['a', 3], 4]  
  
# 深拷贝  
new_list_2 = copy.deepcopy(original_list)  
  
# 对新对象的第二个元素进行修改  
new_list_2[1][0] = 'b'  
  
# 输出结果：原对象和新对象的第二个元素都没有发生变化  
print(original_list)  # 输出： [1, ['a', 3], 4]  
print(new_list_2)     # 输出：[1, ['b', 3], 4]

在这段代码中，我们创建了一个包含可变对象的列表 original_list ，然后使用 copy.copy() 方法和 copy.deepcopy() 方法分别创建了原对象的浅拷贝 new_list_1 和深拷贝 new_list_2 。接着，我们分别修改了 new_list_1 和 new_list_2 中的第二个元素，并输出了 original_list 和 new_list_1 、 new_list_2 的内容。由于浅拷贝会共享可变对象的内存地址，所以当我们修改 new_list_1 中的可变对象时， original_list 中的相应元素也会发生变化。而深拷贝则会完全复制所有可变对象，因此修改 new_list_2 中的可变对象不会影响 original_list 中的相应元素。

总结：

浅拷贝只复制对象本身，而深拷贝复制整个对象及其所有子对象（包括嵌套的对象）。因此，深拷贝需要更多的时间和空间，但可以确保对象的完整性和独立性。

需要注意的是，如果对象中包含对其他对象的引用，那么即使进行了深拷贝，新对象和原对象仍然可能指向相同的内存地址。因此，如果需要对对象进行完全独立的拷贝，需要确保对象中没有任何对其他对象的引用。