【Python】列表-优快云博客

在这里插入图片描述

个人主页：GUIQU.
归属专栏：Python

在这里插入图片描述

文章目录

1. 列表的创建
2. 列表的基本操作
3. 列表的高级操作
- 3.1 嵌套列表
- 3.2 列表推导式
4. 列表的内置方法
5. 列表的实际应用场景

正文

在 Python 编程中，列表（List）是一种极为常用且功能强大的数据结构。它可以存储任意数量、任意类型的数据，并且支持灵活的操作和高效的处理。本文将全面深入地探讨
Python 列表的各个方面，包括创建、基本操作、高级操作、内置方法以及实际应用场景等，并通过丰富的代码示例进行详细展示。

1. 列表的创建

在 Python 中，列表是用方括号 [] 来表示的，其中的元素可以是不同的数据类型，元素之间用逗号分隔。

1.1 空列表的创建

empty_list = []
print(empty_list)

这段代码创建了一个空列表 empty_list，并使用 print 函数输出该列表，结果为 []。

1.2 包含元素的列表创建

numbers = [1, 2, 3, 4, 5]
mixed_list = [1, 'apple', True, 3.14]
print(numbers)
print(mixed_list)

在上述代码中，numbers 列表包含了 5 个整数元素，mixed_list 列表包含了整数、字符串、布尔值和浮点数等不同类型的元素。运行代码后，会分别输出这两个列表的内容。

1.3 使用 `list()` 函数创建列表

list() 函数可以将其他可迭代对象（如字符串、元组等）转换为列表。

string_to_list = list('hello')
tuple_to_list = list((1, 2, 3))
print(string_to_list)
print(tuple_to_list)

这里，list('hello') 将字符串 'hello' 转换为一个包含每个字符的列表 ['h', 'e', 'l', 'l', 'o']，list((1, 2, 3)) 将元组 (1, 2, 3) 转换为列表 [1, 2, 3]。

2. 列表的基本操作

2.1 索引和切片

列表中的元素可以通过索引来访问，索引从 0 开始，也可以使用负索引从列表末尾开始访问。切片操作可以提取列表的一部分。

my_list = [10, 20, 30, 40, 50]
# 索引访问
first_element = my_list[0]
last_element = my_list[-1]
print(first_element)
print(last_element)

# 切片操作
sub_list = my_list[1:3]
print(sub_list)

在这段代码中，my_list[0] 访问列表的第一个元素，my_list[-1] 访问列表的最后一个元素。my_list[1:3] 进行切片操作，提取从索引 1 到索引 2 的元素，结果为 [20, 30]。

2.2 列表拼接和重复

使用 + 操作符可以拼接两个列表，使用 * 操作符可以重复列表中的元素。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2
repeated_list = list1 * 3
print(concatenated_list)
print(repeated_list)

这里，list1 + list2 将两个列表拼接成一个新的列表 [1, 2, 3, 4, 5, 6]，list1 * 3 将列表 list1 中的元素重复 3 次，得到 [1, 2, 3, 1, 2, 3, 1, 2, 3]。

2.3 列表元素的修改

可以通过索引直接修改列表中的元素。

my_list = [10, 20, 30]
my_list[1] = 25
print(my_list)

在这个例子中，将列表 my_list 中索引为 1 的元素从 20 修改为 25，最终输出 [10, 25, 30]。

3. 列表的高级操作

3.1 嵌套列表

列表中可以包含其他列表，形成嵌套列表。

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested_list[1][2])

这里创建了一个嵌套列表 nested_list，nested_list[1][2] 表示访问嵌套列表中第二个子列表的第三个元素，输出结果为 6。

3.2 列表推导式

列表推导式是一种简洁的创建列表的方式，可以根据已有的列表或其他可迭代对象快速生成新的列表。

squares = [x ** 2 for x in range(1, 6)]
print(squares)

这段代码使用列表推导式生成了一个包含 1 到 5 的平方的列表 [1, 4, 9, 16, 25]。还可以在列表推导式中添加条件语句。

even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers)

这里通过添加 if x % 2 == 0 条件，生成了一个包含 1 到 10 之间所有偶数的列表 [2, 4, 6, 8, 10]。

4. 列表的内置方法

4.1 添加元素的方法

append() 方法：用于在列表末尾添加一个元素。

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

运行这段代码后，列表 my_list 变为 [1, 2, 3, 4]。

extend() 方法：用于将一个可迭代对象中的元素添加到列表末尾。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)

这里将列表 list2 中的元素添加到 list1 末尾，list1 变为 [1, 2, 3, 4, 5, 6]。

insert() 方法：用于在指定索引位置插入一个元素。

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

在这个例子中，在索引为 2 的位置插入元素 3，列表变为 [1, 2, 3, 4]。

4.2 删除元素的方法

remove() 方法：用于删除列表中第一个匹配的元素。

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

运行代码后，列表中第一个 2 被删除，结果为 [1, 3, 2]。

pop() 方法：用于删除并返回指定索引位置的元素，如果不指定索引，则默认删除并返回最后一个元素。

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

这里删除并返回索引为 1 的元素 2，列表变为 [1, 3]。

clear() 方法：用于清空列表中的所有元素。

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

运行后，列表变为空列表 []。

4.3 其他常用方法

index() 方法：用于返回指定元素在列表中第一次出现的索引。

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

这里返回元素 2 第一次出现的索引 1。

count() 方法：用于统计指定元素在列表中出现的次数。

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

结果为 2，表示元素 2 在列表中出现了 2 次。

sort() 方法：用于对列表中的元素进行排序，默认是升序排序。

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

列表排序后变为 [1, 2, 3]。还可以通过传递 reverse=True 参数实现降序排序。

my_list = [3, 1, 2]
my_list.sort(reverse=True)
print(my_list)

此时列表变为 [3, 2, 1]。

reverse() 方法：用于反转列表中的元素顺序。

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

列表反转后变为 [3, 2, 1]。

5. 列表的实际应用场景

5.1 数据存储和处理

列表可以用来存储和处理大量的数据，例如存储学生的成绩、员工的工资等。

scores = [85, 90, 78, 92, 88]
average_score = sum(scores) / len(scores)
print(f"Average score: {average_score}")

这段代码使用列表 scores 存储学生的成绩，并计算了平均成绩。

5.2 循环遍历和操作

列表常用于循环遍历，对列表中的每个元素进行操作。

words = ['apple', 'banana', 'cherry']
for word in words:
    print(word.upper())

这里通过 for 循环遍历列表 words，并将每个单词转换为大写后输出。

5.3 模拟栈和队列

列表可以模拟栈（后进先出，LIFO）和队列（先进先出，FIFO）的数据结构。

# 模拟栈
stack = []
stack.append(1)
stack.append(2)
stack.append(3)
popped = stack.pop()
print(popped)

# 模拟队列
queue = []
queue.append(1)
queue.append(2)
queue.append(3)
dequeued = queue.pop(0)
print(dequeued)