Linux运维基础Python 列表学习教程

一、列表的基本概念

1.1 什么是列表？

列表（List）是 Python 中最常用的数据结构之一，用于存储有序的元素集合。列表是可变的（mutable），意味着可以修改其内容。

1.2 列表的特点

• 有序性：元素按插入顺序排列

• 可变性：可以修改、添加、删除元素

• 异构性：可以存储不同类型的元素

• 可嵌套：列表中可以包含其他列表

• 动态大小：会根据需要自动调整大小

1.3 列表的定义

# 空列表
empty_list= []
empty_list2=list()

# 包含元素的列表
numbers= [1, 2, 3, 4, 5]
fruits= ["apple", "banana", "cherry"]
mixed= [1, "apple", 3.14, True, [1, 2, 3]]  # 异构列表

二、列表的访问和索引

2.1 索引访问

列表中的每个元素都有一个索引，从 0 开始：

fruits= ["apple", "banana", "cherry"]
print(fruits[0])    # 输出: apple
print(fruits[1])    # 输出: banana
print(fruits[2])    # 输出: cherry

# 负索引（从末尾开始）
print(fruits[-1])   # 输出: cherry
print(fruits[-2])   # 输出: banana
print(fruits[-3])   # 输出: apple

2.2 切片操作

切片语法：list[start:end:step]

• start：起始索引（包含）

• end：结束索引（不包含）

• step：步长（默认为 1）

numbers= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[0:5])      # 输出: [0, 1, 2, 3, 4]
print(numbers[5:])       # 输出: [5, 6, 7, 8, 9]
print(numbers[:5])       # 输出: [0, 1, 2, 3, 4]
print(numbers[::2])      # 输出: [0, 2, 4, 6, 8] (步长为 2)
print(numbers[::-1])     # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (反转列表)
print(numbers[1:8:2])    # 输出: [1, 3, 5, 7] (从索引1到8，步长为2)

2.3 嵌套列表访问

nested= [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested[0])       # 输出: [1, 2, 3]
print(nested[1][1])    # 输出: 5
print(nested[2][0])    # 输出: 7

三、列表的基本操作

3.1 列表长度

fruits= ["apple", "banana", "cherry"]
length=len(fruits)  # 输出: 3

3.2 列表拼接

list1= [1, 2, 3]
list2= [4, 5, 6]
combined=list1+list2# 输出: [1, 2, 3, 4, 5, 6]

3.3 列表重复

list1= [1, 2, 3]
repeated=list1*3# 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]

3.4 成员检查

fruits= ["apple", "banana", "cherry"]
print("apple"infruits)     # 输出: True
print("orange"infruits)    # 输出: False
print("banana"notinfruits) # 输出: False

3.5 列表比较

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [1, 2, 4]

print(list1 == list2)  # 输出: True
print(list1 == list3)  # 输出: False
print(list1 < list3)   # 输出: True (按元素逐个比较)

四、列表的修改操作

4.1 修改元素

fruits = ["apple", "banana", "cherry"]
fruits[1] = "orange"  # 修改索引1处的元素
print(fruits)  # 输出: ["apple", "orange", "cherry"]

4.2 添加元素

• append()：在列表末尾添加元素

• insert()：在指定位置插入元素

• extend()：扩展列表，添加多个元素

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

# append()
fruits.append("orange")
print(fruits)  # 输出: ["apple", "banana", "cherry", "orange"]

# insert()
fruits.insert(1, "grape")
print(fruits)  # 输出: ["apple", "grape", "banana", "cherry", "orange"]

# extend()
fruits.extend(["mango", "pineapple"])
print(fruits)  # 输出: ["apple", "grape", "banana", "cherry", "orange", "mango", "pineapple"]

4.3 删除元素

• remove()：删除指定值的元素

• pop()：删除指定索引的元素并返回

• del：删除指定索引或切片的元素

• clear()：清空列表

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

# remove()
fruits.remove("banana")  # 删除第一个匹配的元素
print(fruits)  # 输出: ["apple", "cherry", "banana", "orange"]

# pop()
popped = fruits.pop(1)  # 删除索引1处的元素
print(popped)  # 输出: cherry
print(fruits)  # 输出: ["apple", "banana", "orange"]

# del
del fruits[0]  # 删除索引0处的元素
print(fruits)  # 输出: ["banana", "orange"]

del fruits[0:2]  # 删除切片
print(fruits)  # 输出: []

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

五、列表方法

5.1 查找方法

• index()：返回指定值第一次出现的索引

• count()：返回指定值出现的次数

numbers = [1, 2, 3, 2, 1, 2, 3]
print(numbers.index(2))    # 输出: 1 (第一次出现的位置)
print(numbers.count(2))    # 输出: 3 (出现的次数)

5.2 排序方法

• sort()：原地排序

• sorted()：返回排序后的新列表

• reverse()：原地反转列表

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

# sort()
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 6, 5, 4, 3, 2, 1, 1]

# 自定义排序
fruits = ["banana", "apple", "cherry", "date"]
fruits.sort(key=len)  # 按长度排序
print(fruits)  # 输出: ["date", "apple", "cherry", "banana"]

# sorted()
numbers = [3, 1, 4, 1, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 3, 4, 5]
print(numbers)         # 输出: [3, 1, 4, 1, 5] (原列表不变)

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

5.3 其他方法

• copy()：创建列表的浅拷贝

• copy() vs 切片拷贝：两种创建浅拷贝的方法

# copy()
original = [1, 2, 3, [4, 5]]
copy = original.copy()
print(copy)  # 输出: [1, 2, 3, [4, 5]]

# 修改原列表的嵌套列表
original[3][0] = 99
print(original)  # 输出: [1, 2, 3, [99, 5]]
print(copy)      # 输出: [1, 2, 3, [99, 5]] (浅拷贝，嵌套对象共享)

# 切片拷贝
original = [1, 2, 3]
copy = original[:]
print(copy)  # 输出: [1, 2, 3]

六、列表的高级特性

6.1 列表推导式

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

# 基本语法: [expression for item in iterable if condition]

# 示例1: 创建平方列表
squares = [x**2 for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 示例2: 带条件的列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出: [0, 4, 16, 36, 64]

# 示例3: 嵌套列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 示例4: 复杂表达式
fruits = ["apple", "banana", "cherry"]
uppercase_fruits = [fruit.upper() for fruit in fruits]
print(uppercase_fruits)  # 输出: ["APPLE", "BANANA", "CHERRY"]

6.2 列表与函数

• map()：对列表中的每个元素应用函数

• filter()：过滤列表中的元素

• reduce()：对列表中的元素进行累积操作

# map()
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

# filter()
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # 输出: [2, 4, 6, 8, 10]

# reduce()
from functools import reduce
numbers = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, numbers)
print(sum)  # 输出: 15

6.3 列表的深浅拷贝

• 浅拷贝：只复制列表的顶层元素，嵌套对象共享

• 深拷贝：递归复制所有元素，包括嵌套对象

import copy

# 浅拷贝
original = [1, 2, 3, [4, 5]]
shallow = copy.copy(original)
original[3][0] = 99
print(original)  # 输出: [1, 2, 3, [99, 5]]
print(shallow)   # 输出: [1, 2, 3, [99, 5]] (嵌套列表被修改)

# 深拷贝
original = [1, 2, 3, [4, 5]]
deep = copy.deepcopy(original)
original[3][0] = 99
print(original)  # 输出: [1, 2, 3, [99, 5]]
print(deep)      # 输出: [1, 2, 3, [4, 5]] (嵌套列表未被修改)

6.4 列表的迭代

• for 循环：遍历列表元素

• enumerate()：同时获取索引和值

• zip()：同时遍历多个列表

# for 循环
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# enumerate()
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

# zip()
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

七、列表的性能优化

7.1 列表操作的时间复杂度

7.2 性能优化技巧

• 预分配列表大小：如果知道列表最终大小，使用 [None] * size 预分配

• 使用列表推导式：比传统循环更高效

• 避免频繁插入/删除中间元素：考虑使用 collections.deque 对于频繁的中间插入/删除

• 使用生成器：对于大型数据集，使用生成器表达式减少内存使用

• 选择合适的方法：根据操作的时间复杂度选择合适的方法

# 预分配列表
size = 1000000
# 低效
lst = []
for i in range(size):
    lst.append(i)

# 高效
lst = [None] * size
for i in range(size):
    lst[i] = i

# 生成器表达式 (内存更高效)
gen = (x**2 for x in range(1000000))
# 转换为列表时才会计算
lst = list(gen)

7.3 内存优化

• 列表压缩：对于大型列表，考虑使用更紧凑的数据结构

• 垃圾回收：及时删除不再需要的列表引用

• 使用适当的数据类型：对于特定类型的数据，使用更高效的类型（如 array 模块）

# 使用 array 模块存储同类型数据
import array
# 存储整数，比列表更节省内存
int_array = array.array('i', [1, 2, 3, 4, 5])

八、列表的实际应用

8.1 数据存储和处理

# 存储学生信息
students = [
    {"name": "Alice", "age": 25, "grade": "A"},
    {"name": "Bob", "age": 22, "grade": "B"},
    {"name": "Charlie", "age": 23, "grade": "A"}
]

# 按年龄排序
students.sort(key=lambda x: x["age"])
print(students)

# 过滤出成绩为 A 的学生
a_students = [student for student in students if student["grade"] == "A"]
print(a_students)

8.2 算法实现

# 实现冒泡排序
def bubble_sort(lst):
    n = len(lst)
    for i in range(n):
        for j in range(0, n-i-1):
            if lst[j] > lst[j+1]:
 lst[j], lst[j+1] = lst[j+1], lst[j]
    return lst

numbers = [64, 34, 25, 12, 22, 11, 90]
sorted_numbers = bubble_sort(numbers)
print(sorted_numbers)  # 输出: [11, 12, 22, 25, 34, 64, 90]

8.3 矩阵操作

# 创建和操作矩阵
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问元素
print(matrix[1][1])  # 输出: 5

# 转置矩阵
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transposed)  # 输出: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# 矩阵加法
matrix1 = [[1, 2], [3, 4]]
matrix2 = [[5, 6], [7, 8]]
result = [[matrix1[i][j] + matrix2[i][j] for j in range(len(matrix1[0]))] for i in range(len(matrix1))]
print(result)  # 输出: [[6, 8], [10, 12]]

8.4 字符串处理

# 处理字符串列表
words = ["apple", "banana", "cherry", "date", "elderberry"]

# 按长度排序
words.sort(key=len)
print(words)  # 输出: ["date", "apple", "banana", "cherry", "elderberry"]

# 过滤出长度大于 5 的单词
long_words = [word for word in words if len(word) > 5]
print(long_words)  # 输出: ["banana", "cherry", "elderberry"]

# 生成首字母大写的单词列表
capitalized = [word.capitalize() for word in words]
print(capitalized)  # 输出: ["Date", "Apple", "Banana", "Cherry", "Elderberry"]

九、总结

Python 列表是一种功能强大、灵活多变的数据结构，是 Python 编程中最常用的工具之一。本教程涵盖了列表的基本概念、操作、方法、高级特性、性能优化和实际应用等方面。

通过学习本教程，你应该已经掌握了 Python 列表的核心知识点，包括：

• 列表的定义和基本特性

• 列表的访问和切片操作

• 列表的基本操作（拼接、重复、长度等）

• 列表的修改操作（添加、删除、修改元素）

• 列表的各种方法（查找、排序、反转等）

• 列表的高级特性（列表推导式、函数式编程、深浅拷贝）

• 列表的性能优化技巧

• 列表的实际应用场景