小白python入门 - 9. Python 列表2 ——从基础操作到高级应用

一. 列表的方法

列表是Python中最基础且强大的数据结构之一，它提供了丰富的方法来操作数据。列表方法的调用语法遵循object.method()的模式，这种面向对象的语法允许我们直接对列表执行各种操作。

添加和删除元素

列表作为可变容器，支持动态添加、删除和修改元素。以下是最常用的操作方法：

创建初始列表
languages = ['Python', 'Java', 'C++']
 
追加元素到末尾 
languages.append('JavaScript')
print(languages)  # 输出: ['Python', 'Java', 'C++', 'JavaScript']
 
在索引位置1插入新元素
languages.insert(1, 'SQL')
print(languages)  # 输出: ['Python', 'SQL', 'Java', 'C++', 'JavaScript']
 
安全删除元素（先检查存在性）
if 'Java' in languages:
    languages.remove('Java')
print(languages)  # 输出: ['Python', 'SQL', 'C++', 'JavaScript']
 
删除并返回最后一个元素 
last_item = languages.pop()
print(f"被删除的元素: {last_item}, 剩余列表: {languages}")  # 输出: 被删除的元素: JavaScript, 剩余列表: ['Python', 'SQL', 'C++']
 
删除并返回指定索引位置的元素
second_item = languages.pop(1)
print(f"被删除的元素: {second_item}, 剩余列表: {languages}")  # 输出: 被删除的元素: SQL, 剩余列表: ['Python', 'C++']
 
清空整个列表
languages.clear()
print(languages)  # 输出: []

关键注意事项：

1. 使用remove()前应检查元素是否存在，避免ValueError异常
2. pop()方法默认删除最后一个元素，也可指定索引位置
3. 当列表中有重复元素时，remove()只删除第一个匹配项
4. 使用del关键字可直接删除指定索引元素（性能略优但无返回值）

元素位置和频次

items = ['Python', 'Java', 'Java', 'C++', 'Kotlin', 'Python']
 
查找元素首次出现的位置 
print(items.index('Python'))  # 输出: 0 
 
从索引1开始查找'Python'
print(items.index('Python', 1))  # 输出: 5 
 
统计元素出现次数
print(items.count('Python'))  # 输出: 2 
print(items.count('Kotlin'))  # 输出: 1 
print(items.count('Swift'))   # 输出: 0 
 
尝试查找不存在的元素（会引发异常）
try:
    print(items.index('Java', 3))  # 从索引3开始查找'Java'
except ValueError as e:
    print(f"错误: {e}")  # 输出: 错误: 'Java' is not in list 

元素排序和反转

languages = ['Python', 'Java', 'C++', 'Kotlin', 'Swift']
 
默认升序排序（按字母顺序）
languages.sort()
print(languages)  # 输出: ['C++', 'Java', 'Kotlin', 'Python', 'Swift']
 
降序排序 
languages.sort(reverse=True)
print(languages)  # 输出: ['Swift', 'Python', 'Kotlin', 'Java', 'C++']
 
反转列表顺序（不排序，仅倒置）
languages.reverse()
print(languages)  # 输出: ['C++', 'Java', 'Kotlin', 'Python', 'Swift']

列表生成式

列表生成式提供了一种简洁高效的创建列表方式，比传统循环更优雅且性能更优。

基础生成式示例

创建1-99中能被3或5整除的数字列表
divisible = [i for i in range(1, 100) if i % 3 == 0 or i % 5 == 0]
print(divisible[:10])  # 输出: [3, 5, 6, 9, 10, 12, 15, 18, 20, 21]
 
计算整数列表中各元素的平方 
nums1 = [35, 12, 97, 64, 55]
squares = [num  2 for num in nums1]
print(squares)  # 输出: [1225, 144, 9409, 4096, 3025]
 
筛选大于50的元素 
large_nums = [num for num in nums1 if num > 50]
print(large_nums)  # 输出: [97, 64, 55]

性能对比分析

import timeit
 
传统循环方式
def traditional_way():
    result = []
    for i in range(1, 10000):
        if i % 2 == 0:
            result.append(i * 2)
    return result
 
列表生成式方式 
def list_comprehension_way():
    return [i * 2 for i in range(1, 10000) if i % 2 == 0]
 
性能测试
traditional_time = timeit.timeit(traditional_way, number=1000)
comprehension_time = timeit.timeit(list_comprehension_way, number=1000)
 
print(f"传统循环耗时: {traditional_time:.5f}秒")
print(f"生成式耗时: {comprehension_time:.5f}秒")
print(f"性能提升: {((traditional_time - comprehension_time)/traditional_time)*100:.2f}%")

说明 ：列表生成式性能优势源于Python解释器对LIST_APPEND指令的优化处理，避免了传统循环中方法调用的开销

嵌套列表

嵌套列表（列表中包含列表）适合表示表格数据或多维结构：

5个学生的3门课程成绩 
scores = [
    [95, 83, 92],
    [80, 75, 82],
    [92, 97, 90],
    [80, 78, 69],
    [65, 66, 89]
]
 
访问第一个学生的成绩 
print(scores[0])  # 输出: [95, 83, 92]
 
访问第一个学生的第二门课成绩
print(scores[0][1])  # 输出: 83
 
计算所有学生的平均分 
total = 0 
count = 0
for student in scores:
    for score in student:
        total += score
        count += 1
print(f"平均分: {total/count:.2f}")  # 输出: 平均分: 82.07

动态创建嵌套列表

手动输入方式创建
scores_manual = []
for i in range(3):  # 3个学生 
    student_scores = []
    print(f"请输入第{i+1}个学生的3门课成绩:")
    for j in range(3):
        score = int(input(f"课程{j+1}: "))
        student_scores.append(score)
    scores_manual.append(student_scores)
print("手动输入的成绩表:", scores_manual)
 
随机生成方式创建 
import random 
scores_random = [[random.randint(60, 100) for _ in range(3)] for _ in range(5)]
print("随机生成的成绩表:", scores_random)

列表的应用：双色球选号系统

下面是一个完整的双色球选号程序，包含多个功能版本：

"""
双色球随机选号程序 - 多版本实现 
 
功能说明：
1. 基础版：使用pop随机选择红球
2. 优化版：使用sample和choice方法 
3. 批量版：支持生成多注号码 
4. 增强版：使用rich库美化输出 
 
Author: lennon 
Version: 2.0
"""
import random
from rich.console import Console 
from rich.table import Table 
 
def base_version():
    """基础版本：使用pop方法随机选择红球"""
    red_balls = list(range(1, 34))
    selected_balls = []
    
    # 选择6个红球 
    for _ in range(6):
        index = random.randrange(len(red_balls))
        selected_balls.append(red_balls.pop(index))
    
    selected_balls.sort()
    blue_ball = random.randint(1, 16)
    
    # 输出结果
    print("基础版选号结果:")
    for ball in selected_balls:
        print(f"\033[031m{ball:02d}\033[0m", end=' ')
    print(f"\033[034m{blue_ball:02d}\033[0m")
 
def optimized_version():
    """优化版本：使用sample和choice方法"""
    red_balls = list(range(1, 34))
    blue_balls = list(range(1, 17))
    
    selected_balls = random.sample(red_balls, 6)
    selected_balls.sort()
    blue_ball = random.choice(blue_balls)
    
    # 输出结果 
    print("优化版选号结果:")
    for ball in selected_balls:
        print(f"\033[031m{ball:02d}\033[0m", end=' ')
    print(f"\033[034m{blue_ball:02d}\033[0m")
 
def batch_version(n=5):
    """批量版本：生成多注号码"""
    red_balls = list(range(1, 34))
    blue_balls = list(range(1, 17))
    
    print(f"\n批量生成{n}注号码:")
    for i in range(n):
        selected_balls = random.sample(red_balls, 6)
        selected_balls.sort()
        blue_ball = random.choice(blue_balls)
        
        print(f"第{i+1}注: ", end='')
        for ball in selected_balls:
            print(f"\033[031m{ball:02d}\033[0m", end=' ')
        print(f"\033[034m{blue_ball:02d}\033[0m")
 
def enhanced_version(n=5):
    """增强版本：使用rich库美化输出"""
    console = Console()
    red_balls = list(range(1, 34))
    blue_balls = list(range(1, 17))
    
    # 创建表格 
    table = Table(title="双色球选号结果", show_header=True, header_style="bold magenta")
    table.add_column("序号", justify="center")
    table.add_column("红球", justify="center")
    table.add_column("蓝球", justify="center")
    
    # 生成多注号码
    for i in range(n):
        selected_balls = random.sample(red_balls, 6)
        selected_balls.sort()
        blue_ball = random.choice(blue_balls)
        
        # 格式化红球输出
        red_display = " ".join([f"[red]{ball:02d}[/red]" for ball in selected_balls])
        table.add_row(str(i+1), red_display, f"[blue]{blue_ball:02d}[/blue]")
    
    # 输出表格
    console.print(table)
 
# 测试不同版本 
if __name__ == "__main__":
    print("="*50)
    print("双色球选号系统".center(50))
    print("="*50)
    
    base_version()
    optimized_version()
    batch_version(3)
    
    # 需要安装rich库: pip install rich
    try:
        enhanced_version(5)
    except ImportError:
        print("\n未安装rich库，无法显示增强版效果")
        print("请使用命令: pip install rich 安装后重试")

列表的底层原理与最佳实践

技术原理

• 动态数组：Python列表基于动态数组实现，自动管理内存空间
• 随机访问：O(1)时间复杂度访问任意元素（连续内存存储）
• 动态扩容：当空间不足时，自动分配更大内存块（通常按~1.125倍增长）

操作复杂度

操作	时间复杂度	说明
索引访问	O(1)	直接通过偏移量访问
append()	O(1)	平均时间复杂度
insert()	O(n)	需要移动后续元素
pop()	O(1)	移除末尾元素
pop(i)	O(n)	移除指定位置元素
成员检查	O(n)	需要遍历整个列表
切片	O(k)	k为切片长度

最佳实践指南

优先选择生成式 ：创建新列表时首选列表生成式，兼顾简洁与性能
批量操作原则：

• 添加多个元素时使用extend()而非多次append()
• 使用切片赋值替代逐个元素修改

内存管理技巧：

# 预分配空间优化 
size = 10000 
optimized_list = [None] * size  # 预分配内存 
for i in range(size):
    optimized_list[i] = i * 2 

# 传统方式（较慢）
regular_list = []
for i in range(size):
    regular_list.append(i * 2)

浅拷贝与深拷贝：

import copy

original = [[1, 2], [3, 4]]
shallow_copy = original.copy()      # 浅拷贝：嵌套列表共享引用
deep_copy = copy.deepcopy(original) # 深拷贝：完全独立副本 

original[0][0] = 99 
print(shallow_copy[0][0])  # 输出: 99 
print(deep_copy[0][0])     # 输出: 1

总结

Python列表作为核心数据结构，具有以下关键特性：

1. 动态可变：支持运行时增删改元素
2. 类型灵活：可存储异构数据类型（包括嵌套列表）
3. 丰富API：提供20+内置方法满足各种操作需求
4. 高效创建：列表生成式兼具简洁性与高性能
5. 广泛应用：从简单数据存储到复杂算法实现

掌握列表的底层原理（动态数组实现）和最佳实践（预分配空间、批量操作等），能显著提升Python程序性能和代码质量。列表作为Python编程基石，其灵活性和强大功能使其成为解决实际问题的首选工具。

深入建议：当处理超大规模数据（>100万元素）时，可考虑：

• 使用NumPy数组（固定类型、连续内存）
• 应用生成器表达式（惰性求值节省内存）
• 采用分块处理策略（减少单次操作数据量）