当前位置：
  1. 首页
  2. 软件开发
  3. python
  4. 正文

Python列表操作完全指南

python 0 0

1. Python列表基础

Python中的列表（List）是一种有序、可变的数据集合，可以包含任意类型的元素。列表是Python中最常用的数据结构之一，它非常灵活，功能强大。在本教程中，我们将全面介绍Python列表的各种操作。

2. 创建列表

创建列表的基本方法是使用方括号[]，并用逗号分隔其中的元素：

# 创建一个空列表
empty_list = []

# 创建一个包含相同类型元素的列表
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "cherry"]

# 创建一个包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, True, [1, 2, 3]]

# 使用list()函数从其他可迭代对象创建列表
string_list = list("hello")  # ['h', 'e', 'l', 'l', 'o']
tuple_list = list((1, 2, 3))  # [1, 2, 3]

# 使用列表推导式创建列表
squares = [x**2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]

3. 访问列表元素

列表是有序的，可以通过索引访问其中的元素。Python中的索引从0开始：

fruits = ["apple", "banana", "cherry", "date", "elderberry"]

# 使用正数索引（从0开始）
first_fruit = fruits[0]  # 'apple'
second_fruit = fruits[1]  # 'banana'

# 使用负数索引（从-1开始，表示最后一个元素）
last_fruit = fruits[-1]  # 'elderberry'
second_last_fruit = fruits[-2]  # 'date'

# 访问不存在的索引会引发IndexError
try:
    non_existent = fruits[10]  # 抛出IndexError
except IndexError as e:
    print(f"错误：{e}")

4. 修改列表元素

列表是可变的，这意味着我们可以修改列表中的元素：

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

# 修改特定索引处的元素
numbers[0] = 10  # [10, 2, 3, 4, 5]
numbers[-1] = 50  # [10, 2, 3, 4, 50]

# 修改多个元素
numbers[1:3] = [20, 30]  # [10, 20, 30, 4, 50]
numbers[3:] = [40, 50, 60]  # [10, 20, 30, 40, 50, 60]

5. 列表切片

列表切片允许我们获取列表的子集。切片的基本语法是list[start:stop:step]：

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

# 基本切片
subset = numbers[2:5]  # [2, 3, 4]

# 省略start或stop
start_to_4 = numbers[:5]  # [0, 1, 2, 3, 4]
5_to_end = numbers[5:]  # [5, 6, 7, 8, 9]

# 使用步长
every_second = numbers[::2]  # [0, 2, 4, 6, 8]
reverse = numbers[::-1]  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 组合使用
subset_with_step = numbers[1:8:2]  # [1, 3, 5, 7]

# 切片不会引发IndexError，即使索引超出范围
safe_slice = numbers[5:20]  # [5, 6, 7, 8, 9]

6. 添加元素

有多种方法可以向列表添加元素：

fruits = ["apple", "banana", "cherry"]

# 使用append()在列表末尾添加单个元素
fruits.append("date")  # ['apple', 'banana', 'cherry', 'date']

# 使用insert()在指定位置插入元素
fruits.insert(1, "blueberry")  # ['apple', 'blueberry', 'banana', 'cherry', 'date']

# 使用extend()在列表末尾添加多个元素
more_fruits = ["elderberry", "fig"]
fruits.extend(more_fruits)  # ['apple', 'blueberry', 'banana', 'cherry', 'date', 'elderberry', 'fig']

# 使用+运算符合并两个列表（创建一个新列表）
berries = ["strawberry", "raspberry"]
all_fruits = fruits + berries  # ['apple', 'blueberry', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'strawberry', 'raspberry']

# 使用*运算符重复列表（创建一个新列表）
repeated_fruits = fruits * 2  # ['apple', 'blueberry', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'apple', 'blueberry', 'banana', 'cherry', 'date', 'elderberry', 'fig']

7. 删除元素

同样有多种方法可以从列表中删除元素：

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

# 使用remove()删除特定值的第一个匹配项
numbers.remove(5)  # [0, 1, 2, 3, 4, 6, 7, 8, 9]

# 使用pop()删除并返回指定索引处的元素（默认是最后一个）
last_element = numbers.pop()  # 返回9，列表变为[0, 1, 2, 3, 4, 6, 7, 8]
first_element = numbers.pop(0)  # 返回0，列表变为[1, 2, 3, 4, 6, 7, 8]

# 使用del语句删除指定索引或切片处的元素
del numbers[0]  # 删除第一个元素，变为[2, 3, 4, 6, 7, 8]
del numbers[1:3]  # 删除从索引1到2的元素，变为[2, 6, 7, 8]

# 使用clear()删除所有元素
numbers.clear()  # []

8. 列表排序

Python提供了多种排序方法：

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

# 使用sort()方法对列表进行原地排序（升序）
numbers.sort()  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用reverse=True参数进行降序排序
numbers.sort(reverse=True)  # [9, 8, 7, 6, 5, 4, 3, 2, 1]

# 使用sorted()函数返回排序后的新列表（原列表不变）
unsorted_numbers = [5, 2, 8, 1, 9, 3, 7, 4, 6]
sorted_numbers = sorted(unsorted_numbers)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# unsorted_numbers仍然是[5, 2, 8, 1, 9, 3, 7, 4, 6]

# 使用key参数进行自定义排序
words = ["apple", "Banana", "cherry", "Date"]
# 默认排序（基于ASCII码，大写字母排在小写字母前面）
default_sorted = sorted(words)  # ['Banana', 'Date', 'apple', 'cherry']

# 忽略大小写排序
case_insensitive_sorted = sorted(words, key=str.lower)  # ['apple', 'Banana', 'cherry', 'Date']

# 使用lambda函数进行自定义排序
students = [
    {"name": "Alice", "age": 20},
    {"name": "Bob", "age": 18},
    {"name": "Charlie", "age": 22}
]

# 按年龄排序
students_by_age = sorted(students, key=lambda x: x["age"])
# [{'name': 'Bob', 'age': 18}, {'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 22}]

9. 列表推导式

列表推导式是Python中创建列表的一种简洁方法：

# 基本语法：[expression for item in iterable]
squares = [x**2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]

# 带条件的列表推导式
even_numbers = [x for x in range(1, 11) if x % 2 == 0]  # [2, 4, 6, 8, 10]

# 多条件
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_numbers = [x for x in numbers if x > 3 if x < 8]  # [4, 5, 6, 7]

# if-else条件
parity = ["even" if x % 2 == 0 else "odd" for x in range(1, 6)]  # ['odd', 'even', 'odd', 'even', 'odd']

# 多重循环
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [x for row in matrix for x in row]  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用函数转换
words = ["hello", "world", "python"]
upper_words = [word.upper() for word in words]  # ['HELLO', 'WORLD', 'PYTHON']

10. 列表常用方法

Python列表提供了许多内置方法：

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

# len()返回列表长度
length = len(numbers)  # 10

# count()返回指定元素的出现次数
count_of_5 = numbers.count(5)  # 2

# index()返回指定元素的索引
index_of_3 = numbers.index(3)  # 2
# 可以指定搜索范围
index_of_second_3 = numbers.index(3, 3)  # 7

# reverse()反转列表（原地操作）
numbers.reverse()  # [1, 2, 3, 4, 5, 5, 4, 3, 2, 1]

# copy()创建列表的浅拷贝
numbers_copy = numbers.copy()

# 使用list()构造函数也可以创建副本
another_copy = list(numbers)

# 使用切片创建副本
slice_copy = numbers[:]

# 使用copy模块的copy()函数创建浅拷贝
import copy
module_copy = copy.copy(numbers)

# 对于包含嵌套对象的列表，使用copy.deepcopy()创建深拷贝
nested_list = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(nested_list)

11. 列表与字符串的转换

列表和字符串之间经常需要转换：

# 字符串转换为列表
text = "Hello, World!"

# 使用list()将字符串转换为字符列表
char_list = list(text)  # ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']

# 使用split()将字符串按分隔符转换为单词列表
word_list = text.split()  # ['Hello,', 'World!']
word_list_custom = text.split(", ")  # ['Hello', 'World!']

# 列表转换为字符串
words = ["Hello", "World"]

# 使用join()将列表元素连接为字符串
joined_string = " ".join(words)  # "Hello World"
custom_joined = "-".join(words)  # "Hello-World"

# 将数字列表转换为字符串
numbers = [1, 2, 3, 4, 5]
# 需要先转换为字符串列表
str_numbers = [str(num) for num in numbers]
numbers_string = ", ".join(str_numbers)  # "1, 2, 3, 4, 5"

12. 多维列表

列表可以嵌套其他列表，形成多维列表（类似于其他语言中的数组）：

# 创建二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问二维列表元素
element = matrix[1][2]  # 6 (第二行第三列)

# 修改二维列表元素
matrix[0][0] = 10  # 修改第一行第一列元素为10

# 创建3x3的二维列表，初始值都为0
rows, cols = 3, 3
zero_matrix = [[0 for _ in range(cols)] for _ in range(rows)]

# 使用嵌套循环遍历二维列表
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(f"matrix[{i}][{j}] = {matrix[i][j]}")

# 使用列表推导式转置矩阵
transposed = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]

# 创建三维列表
tensor = [
    [
        [1, 2, 3],
        [4, 5, 6]
    ],
    [
        [7, 8, 9],
        [10, 11, 12]
    ]
]

# 访问三维列表元素
element_3d = tensor[1][0][2]  # 9 (第二层第一行第三列)

13. 列表性能考虑

在使用列表时，需要注意一些性能相关的问题：

# 1. 列表的append()操作在平均情况下是O(1)时间复杂度
import time
big_list = []
start_time = time.time()
for i in range(100000):
    big_list.append(i)
end_time = time.time()
print(f"Append 100,000 elements: {end_time - start_time:.5f} seconds")

# 2. 列表的insert(0, item)操作是O(n)时间复杂度，因为需要移动所有元素
big_list = []
start_time = time.time()
for i in range(10000):  # 减少数量因为insert(0)很慢
    big_list.insert(0, i)
end_time = time.time()
print(f"Insert at beginning 10,000 elements: {end_time - start_time:.5f} seconds")

# 3. 列表的pop()操作
# pop()从末尾弹出元素是O(1)
big_list = list(range(100000))
start_time = time.time()
for _ in range(10000):
    big_list.pop()
end_time = time.time()
print(f"Pop from end 10,000 elements: {end_time - start_time:.5f} seconds")

# pop(0)从开头弹出元素是O(n)
big_list = list(range(10000))  # 减少数量因为pop(0)很慢
start_time = time.time()
for _ in range(1000):  # 只弹出1000次
    big_list.pop(0)
end_time = time.time()
print(f"Pop from beginning 1,000 elements: {end_time - start_time:.5f} seconds")

# 4. 列表的查找操作是O(n)
big_list = list(range(10000))
start_time = time.time()
for _ in range(1000):
    9999 in big_list  # 查找最后一个元素
end_time = time.time()
print(f"Search for last element 1,000 times: {end_time - start_time:.5f} seconds")

# 5. 如果需要频繁的在列表两端添加或删除元素，考虑使用collections.deque
from collections import deque
dq = deque()
start_time = time.time()
for i in range(100000):
    dq.appendleft(i)  # 在deque的开头添加元素是O(1)
end_time = time.time()
print(f"deque appendleft 100,000 elements: {end_time - start_time:.5f} seconds")

14. 总结

Python列表是一种功能强大且灵活的数据结构，是Python中最常用的数据类型之一。在本教程中，我们详细介绍了列表的各种操作，包括：

创建列表的不同方法

访问和修改列表元素

使用列表切片获取子集

添加和删除列表元素的各种方法

对列表进行排序

使用列表推导式创建和转换列表

列表常用方法及其用法

列表与字符串之间的转换

多维列表的创建和操作

列表操作的性能考虑

掌握了这些列表操作，你将能够在Python编程中更加高效地处理集合数据。记住，选择合适的数据结构和操作方法对程序的性能和可读性都有重要影响。随着你的Python编程经验不断增长，你会发现自己能够越来越熟练地运用列表来解决各种问题。

上一篇 Jenkins自动化构建详细技术教程
下一篇 Python字符串处理技巧详解

相关文章

发表回复

后才能评论