Python 列表是一种基本的数据结构，用于存储有序的项集合。在列表中找到前 N 个元素是许多数据分析和处理任务中的一项基本技能。无论你需要识别得分最高的学生、最受欢迎的产品，还是数据集中最大的值，了解如何有效地提取这些元素都非常有用。
在这个实验（Lab）中，你将学习不同的方法来查找 Python 列表中前 N 个元素。你将探索内置函数和专门的模块，并且你将看到如何将这些技术应用于现实世界的场景。通过完成这个实验，你将对 Python 列表操作技术有一个扎实的理解，这将增强你的数据处理能力。
在第一步中，你将学习 Python 列表的基础知识以及如何创建它们。列表是通用的数据结构，可以存储不同类型的元素，包括数字、字符串，甚至其他列表。
让我们从创建一个简单的数字列表开始。在 WebIDE 中，在 /home/labex/project 目录下创建一个名为 list_basics.py 的新 Python 文件：
list_basics.py## 创建一个数字列表
numbers = [15, 7, 27, 9, 42, 8, 31, 17]
## 打印原始列表
print("Original list:", numbers)
## 打印列表的长度
print("List length:", len(numbers))
## 通过索引访问元素
print("First element:", numbers[0])
print("Last element:", numbers[-1])
## 切片列表
print("First three elements:", numbers[:3])
print("Last three elements:", numbers[-3:])现在，运行代码以查看输出：
python3 list_basics.py你应该看到类似于以下的输出：
Original list: [15, 7, 27, 9, 42, 8, 31, 17]
List length: 8
First element: 15
Last element: 17
First three elements: [15, 7, 27]
Last three elements: [8, 31, 17]现在，让我们修改我们的列表。将以下代码添加到 list_basics.py：
## 向列表中添加元素
numbers.append(50)
print("After append:", numbers)
## 在特定位置插入一个元素
numbers.insert(2, 99)
print("After insert:", numbers)
## 移除元素
numbers.remove(9) ## 按值移除
print("After remove:", numbers)
popped_value = numbers.pop() ## 移除并返回最后一个元素
print("Popped value:", popped_value)
print("After pop:", numbers)再次运行脚本以查看列表如何变化：
python3 list_basics.py输出现在应该包括：
After append: [15, 7, 27, 9, 42, 8, 31, 17, 50]
After insert: [15, 7, 99, 27, 9, 42, 8, 31, 17, 50]
After remove: [15, 7, 99, 27, 42, 8, 31, 17, 50]
Popped value: 50
After pop: [15, 7, 99, 27, 42, 8, 31, 17]这演示了 Python 列表在创建后是可变的（可以更改）的，这是一个重要的特性，使其在数据操作方面具有灵活性。
在找到前 N 个元素之前，了解如何在 Python 中对列表进行排序非常重要。排序将元素按特定顺序排列，通常是升序（从小到大）或降序（从大到小）。
在项目目录中创建一个名为 sorting_lists.py 的新文件，并添加以下代码：
## 创建一个数字列表
scores = [85, 92, 78, 91, 88, 76, 94, 87]
## 按升序排序（默认）
sorted_scores = sorted(scores)
print("Original scores:", scores)
print("Sorted scores (ascending):", sorted_scores)
## 按降序排序
desc_scores = sorted(scores, reverse=True)
print("Sorted scores (descending):", desc_scores)
## 原始列表保持不变
print("Original scores after sorting:", scores)运行脚本以查看排序后的列表：
python3 sorting_lists.py你应该看到类似于以下的输出：
Original scores: [85, 92, 78, 91, 88, 76, 94, 87]
Sorted scores (ascending): [76, 78, 85, 87, 88, 91, 92, 94]
Sorted scores (descending): [94, 92, 91, 88, 87, 85, 78, 76]
Original scores after sorting: [85, 92, 78, 91, 88, 76, 94, 87]请注意，sorted() 函数返回一个新的排序列表，而原始列表保持不变。
现在，让我们探索 sort() 方法，该方法会就地修改列表。将以下代码添加到 sorting_lists.py：
## 创建另一个列表
prices = [12.99, 8.50, 15.75, 9.99, 11.25]
print("\nOriginal prices:", prices)
## 就地排序列表（升序）
prices.sort()
print("After sort() (ascending):", prices)
## 就地排序列表（降序）
prices.sort(reverse=True)
print("After sort(reverse=True) (descending):", prices)再次运行脚本：
python3 sorting_lists.py额外的输出应该是：
Original prices: [12.99, 8.5, 15.75, 9.99, 11.25]
After sort() (ascending): [8.5, 9.99, 11.25, 12.99, 15.75]
After sort(reverse=True) (descending): [15.75, 12.99, 11.25, 9.99, 8.5]你还可以使用键函数根据特定条件对列表进行排序。将以下代码添加到 sorting_lists.py：
## 字符串列表
names = ["Alice", "bob", "Charlie", "david", "Eva"]
print("\nOriginal names:", names)
## 按字母顺序排序（区分大小写）
print("Sorted alphabetically (case-sensitive):", sorted(names))
## 按字母顺序排序（不区分大小写）
print("Sorted alphabetically (case-insensitive):", sorted(names, key=str.lower))
## 元组列表（姓名，年龄）
people = [("Alice", 25), ("Bob", 19), ("Charlie", 32), ("David", 22)]
print("\nOriginal people:", people)
## 按年龄排序（每个元组的第二个元素）
print("Sorted by age:", sorted(people, key=lambda person: person[1]))
## 按姓名长度排序
print("Sorted by name length:", sorted(people, key=lambda person: len(person[0])))再次运行脚本：
python3 sorting_lists.py额外的输出演示了如何使用自定义条件进行排序：
Original names: ['Alice', 'bob', 'Charlie', 'david', 'Eva']
Sorted alphabetically (case-sensitive): ['Alice', 'Charlie', 'Eva', 'bob', 'david']
Sorted alphabetically (case-insensitive): ['Alice', 'bob', 'Charlie', 'david', 'Eva']
Original people: [('Alice', 25), ('Bob', 19), ('Charlie', 32), ('David', 22)]
Sorted by age: [('Bob', 19), ('David', 22), ('Alice', 25), ('Charlie', 32)]
Sorted by name length: [('Bob', 19), ('Alice', 25), ('David', 22), ('Charlie', 32)]理解这些排序技术对于在列表中找到前 N 个元素至关重要，我们将在下一步中进行探讨。
现在你已经了解了 Python 列表和排序，让我们专注于在列表中找到前 N 个元素。最直接的方法是使用 sorted() 函数，并使用 reverse=True 参数，然后对结果进行切片以获取前 N 个元素。
在项目目录中创建一个名为 top_n_sorted.py 的新文件，并添加以下代码：
## 使用 sorted() 查找前 N 个元素
## 样本数据：学生分数
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Student scores:", student_scores)
## 找到前 3 名的分数
top_3_scores = sorted(student_scores, reverse=True)[:3]
print("Top 3 scores:", top_3_scores)
## 找到前 5 名的分数
top_5_scores = sorted(student_scores, reverse=True)[:5]
print("Top 5 scores:", top_5_scores)运行脚本以查看前 N 个元素：
python3 top_n_sorted.py你应该看到类似于以下的输出：
Student scores: [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
Top 3 scores: [94, 93, 92]
Top 5 scores: [94, 93, 92, 91, 89]让我们扩展我们的示例以处理更复杂的数据结构。将以下代码添加到 top_n_sorted.py：
## 样本数据：产品销售数据（产品名称，销售数量）
product_sales = [
("Product A", 1250),
("Product B", 870),
("Product C", 1100),
("Product D", 750),
("Product E", 940),
("Product F", 1300),
("Product G", 820),
("Product H", 980)
]
print("\nProduct sales:", product_sales)
## 找到销量前 3 名的产品
## 我们根据销售数量（每个元组的第二个元素）进行排序
top_3_products = sorted(product_sales, key=lambda x: x[1], reverse=True)[:3]
print("Top 3 best-selling products:")
for product, sales in top_3_products:
print(f" {product}: {sales} units")
## 样本数据：学生记录（姓名，不同科目的分数）
student_records = [
{"name": "Alice", "scores": [92, 88, 95, 85]},
{"name": "Bob", "scores": [78, 82, 79, 75]},
{"name": "Charlie", "scores": [85, 90, 88, 92]},
{"name": "Diana", "scores": [95, 97, 93, 90]},
{"name": "Eva", "scores": [88, 84, 89, 86]}
]
print("\nStudent records:", student_records)
## 根据平均分数找到前 2 名学生
def average_score(student):
return sum(student["scores"]) / len(student["scores"])
top_2_students = sorted(student_records, key=average_score, reverse=True)[:2]
print("Top 2 students by average score:")
for student in top_2_students:
avg = average_score(student)
print(f" {student['name']}: {avg:.2f} average")再次运行脚本：
python3 top_n_sorted.py额外的输出演示了如何在更复杂的数据结构中找到前 N 个元素：
Product sales: [('Product A', 1250), ('Product B', 870), ('Product C', 1100), ('Product D', 750), ('Product E', 940), ('Product F', 1300), ('Product G', 820), ('Product H', 980)]
Top 3 best-selling products:
Product F: 1300 units
Product A: 1250 units
Product C: 1100 units
Student records: [{'name': 'Alice', 'scores': [92, 88, 95, 85]}, {'name': 'Bob', 'scores': [78, 82, 79, 75]}, {'name': 'Charlie', 'scores': [85, 90, 88, 92]}, {'name': 'Diana', 'scores': [95, 97, 93, 90]}, {'name': 'Eva', 'scores': [88, 84, 89, 86]}]
Top 2 students by average score:
Diana: 93.75 average
Alice: 90.00 average使用切片的 sorted() 函数是查找列表中前 N 个元素的通用方法。但是，对于大型数据集，还有更有效的方法，我们将在下一步中进行探讨。
虽然 sorted() 函数在大多数情况下都能很好地工作，但 Python 的 heapq 模块提供了更有效的方法来查找前 N 个元素，尤其是在大型数据集的情况下。heapq 模块实现了堆队列算法，也称为优先级队列算法。
在项目目录中创建一个名为 top_n_heapq.py 的新文件，并添加以下代码：
## 使用 heapq 查找前 N 个元素
import heapq
## 样本数据：学生分数
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Student scores:", student_scores)
## 使用 heapq.nlargest() 找到前 3 名的分数
top_3_scores = heapq.nlargest(3, student_scores)
print("Top 3 scores (using heapq.nlargest()):", top_3_scores)
## 使用 heapq.nsmallest() 找到后 3 名的分数
bottom_3_scores = heapq.nsmallest(3, student_scores)
print("Bottom 3 scores (using heapq.nsmallest()):", bottom_3_scores)运行脚本以查看 heapq 的工作方式：
python3 top_n_heapq.py你应该看到类似于以下的输出：
Student scores: [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
Top 3 scores (using heapq.nlargest()): [94, 93, 92]
Bottom 3 scores (using heapq.nsmallest()): [76, 78, 85]heapq 模块也可以通过指定键函数来处理复杂的数据结构。将以下代码添加到 top_n_heapq.py：
## 样本数据：产品销售数据（产品名称，销售数量）
product_sales = [
("Product A", 1250),
("Product B", 870),
("Product C", 1100),
("Product D", 750),
("Product E", 940),
("Product F", 1300),
("Product G", 820),
("Product H", 980)
]
print("\nProduct sales:", product_sales)
## 使用 heapq.nlargest() 找到销量前 3 名的产品
top_3_products = heapq.nlargest(3, product_sales, key=lambda x: x[1])
print("Top 3 best-selling products:")
for product, sales in top_3_products:
print(f" {product}: {sales} units")
## 样本数据：学生记录（姓名，不同科目的分数）
student_records = [
{"name": "Alice", "scores": [92, 88, 95, 85]},
{"name": "Bob", "scores": [78, 82, 79, 75]},
{"name": "Charlie", "scores": [85, 90, 88, 92]},
{"name": "Diana", "scores": [95, 97, 93, 90]},
{"name": "Eva", "scores": [88, 84, 89, 86]}
]
print("\nStudent records:", student_records)
## 使用 heapq.nlargest() 根据平均分数找到前 2 名学生
def average_score(student):
return sum(student["scores"]) / len(student["scores"])
top_2_students = heapq.nlargest(2, student_records, key=average_score)
print("Top 2 students by average score:")
for student in top_2_students:
avg = average_score(student)
print(f" {student['name']}: {avg:.2f} average")再次运行脚本：
python3 top_n_heapq.py额外的输出演示了如何将 heapq 用于复杂的数据结构：
Product sales: [('Product A', 1250), ('Product B', 870), ('Product C', 1100), ('Product D', 750), ('Product E', 940), ('Product F', 1300), ('Product G', 820), ('Product H', 980)]
Top 3 best-selling products:
Product F: 1300 units
Product A: 1250 units
Product C: 1100 units
Student records: [{'name': 'Alice', 'scores': [92, 88, 95, 85]}, {'name': 'Bob', 'scores': [78, 82, 79, 75]}, {'name': 'Charlie', 'scores': [85, 90, 88, 92]}, {'name': 'Diana', 'scores': [95, 97, 93, 90]}, {'name': 'Eva', 'scores': [88, 84, 89, 86]}]
Top 2 students by average score:
Diana: 93.75 average
Alice: 90.00 average让我们比较 sorted() 和 heapq 在大型列表中查找前 N 个元素的性能。将以下代码添加到 top_n_heapq.py：
import time
import random
## 生成一个大型的随机数列表
print("\nComparing performance with a large list:")
large_list = [random.randint(1, 1000000) for _ in range(100000)]
print(f"List size: {len(large_list)} elements")
## 计时 sorted() 方法
start_time = time.time()
top_10_sorted = sorted(large_list, reverse=True)[:10]
sorted_time = time.time() - start_time
print(f"Time taken with sorted(): {sorted_time:.6f} seconds")
## 计时 heapq 方法
start_time = time.time()
top_10_heapq = heapq.nlargest(10, large_list)
heapq_time = time.time() - start_time
print(f"Time taken with heapq.nlargest(): {heapq_time:.6f} seconds")
print(f"Performance gain: {sorted_time / heapq_time:.2f}x faster")
## 验证两种方法给出相同的结果
print("Both methods give the same result:", sorted(top_10_sorted) == sorted(top_10_heapq))最后一次运行脚本：
python3 top_n_heapq.py额外的输出演示了使用 heapq 处理大型数据集的性能优势：
Comparing performance with a large list:
List size: 100000 elements
Time taken with sorted(): 0.034625 seconds
Time taken with heapq.nlargest(): 0.008976 seconds
Performance gain: 3.86x faster
Both methods give the same result: True对于在大型列表中查找少量前 N 个元素，heapq.nlargest() 比对整个列表进行排序然后进行切片更有效。这是因为 heapq.nlargest() 维护一个大小为 N 的堆，而 sorted() 对整个列表进行排序。
现在你已经学习了不同的技术来查找 Python 列表中前 N 个元素，让我们探索一些实际应用。在这一步中，你将创建一个更全面的脚本，将这些概念应用于实际场景。
在项目目录中创建一个名为 practical_applications.py 的新文件，并添加以下代码：
## 查找前 N 个元素的实际应用
import heapq
from datetime import datetime
print("查找 Python 列表中前 N 个元素的实际应用\n")
## 应用 1：电子商务 - 分析产品销售额
print("应用 1：电子商务 - 分析产品销售额")
print("==================================================")
## 样本产品销售数据（product_id，product_name，units_sold，price）
product_sales = [
(101, "Smartphone X", 1250, 899.99),
(102, "Wireless Earbuds", 2100, 129.99),
(103, "Laptop Pro", 890, 1299.99),
(104, "Smart Watch", 1450, 249.99),
(105, "Tablet Mini", 1050, 399.99),
(106, "Bluetooth Speaker", 1750, 79.99),
(107, "Gaming Console", 780, 499.99),
(108, "Digital Camera", 550, 349.99),
(109, "Power Bank", 1900, 49.99),
(110, "Fitness Tracker", 1350, 129.99)
]
## 按销量查找前 3 名产品
top_sold_products = heapq.nlargest(3, product_sales, key=lambda x: x[2])
print("\n销量前 3 名的产品（按销量）：")
for product in top_sold_products:
print(f" {product[1]}：售出 {product[2]} 件，单价 ${product[3]}")
## 按收入（units_sold * price）查找前 3 名产品
top_revenue_products = heapq.nlargest(3, product_sales, key=lambda x: x[2] * x[3])
print("\n收入前 3 名的产品：")
for product in top_revenue_products:
revenue = product[2] * product[3]
print(f" {product[1]}：${revenue:,.2f} 收入（{product[2]} 件，单价 ${product[3]}）")
## 应用 2：数据分析 - 温度监测
print("\n\n应用 2：数据分析 - 温度监测")
print("====================================================")
## 样本温度数据（日期，城市，温度）
temperature_data = [
("2023-06-15", "New York", 32.5),
("2023-06-15", "Los Angeles", 28.3),
("2023-06-15", "Chicago", 30.1),
("2023-06-15", "Houston", 35.7),
("2023-06-15", "Phoenix", 40.2),
("2023-06-15", "Miami", 33.8),
("2023-06-15", "Denver", 29.6),
("2023-06-15", "Seattle", 22.4),
("2023-06-15", "Boston", 27.9),
("2023-06-15", "Atlanta", 31.5)
]
## 查找温度最高的城市
hottest_cities = heapq.nlargest(3, temperature_data, key=lambda x: x[2])
print("\n前 3 个最热的城市：")
for city_data in hottest_cities:
print(f" {city_data[1]}:{city_data[2]}°C")
## 查找温度最低的城市
coldest_cities = heapq.nsmallest(3, temperature_data, key=lambda x: x[2])
print("\n前 3 个最冷的城市：")
for city_data in coldest_cities:
print(f" {city_data[1]}:{city_data[2]}°C")
## 应用 3：社交媒体 - 用户参与度
print("\n\n应用 3：社交媒体 - 用户参与度")
print("=============================================")
## 样本社交媒体帖子数据（post_id，title，likes，comments，shares，timestamp）
posts = [
(1001, "Breaking News: Major Announcement", 3500, 420, 1200, datetime(2023, 6, 10, 12, 30)),
(1002, "Product Review: Latest Gadget", 2200, 380, 900, datetime(2023, 6, 11, 15, 45)),
(1003, "Tutorial: Python Programming", 1800, 650, 750, datetime(2023, 6, 12, 9, 15)),
(1004, "Travel Tips for Summer Vacation", 2700, 320, 1100, datetime(2023, 6, 13, 18, 20)),
(1005, "Recipe: Delicious Desserts", 3100, 450, 1500, datetime(2023, 6, 14, 11, 10)),
(1006, "Interview with Celebrity", 4200, 580, 2200, datetime(2023, 6, 15, 14, 25)),
(1007, "Health and Fitness Guide", 1500, 280, 600, datetime(2023, 6, 16, 8, 40)),
(1008, "Movie Review: Latest Blockbuster", 2900, 410, 950, datetime(2023, 6, 17, 20, 30)),
(1009, "Tech News: Industry Updates", 2000, 300, 800, datetime(2023, 6, 18, 13, 15)),
(1010, "DIY Home Improvement Projects", 1700, 520, 700, datetime(2023, 6, 19, 16, 50))
]
## 定义一个函数来计算参与度得分（点赞、评论、分享的加权总和）
def engagement_score(post):
return post[2] + (post[3] * 2) + (post[4] * 3) ## 点赞 + (评论 * 2) + (分享 * 3)
## 按参与度得分查找前 3 名帖子
top_engaging_posts = heapq.nlargest(3, posts, key=engagement_score)
print("\n参与度最高的前 3 名帖子：")
for post in top_engaging_posts:
score = engagement_score(post)
print(f" 帖子 ID：{post[0]}")
print(f" 标题：{post[1]}")
print(f" 参与度得分：{score}")
print(f" （点赞：{post[2]}，评论：{post[3]}，分享：{post[4]}）")
print(f" 发布于：{post[5].strftime('%Y-%m-%d %H:%M')}")
print()
## 按点赞数查找前 3 名帖子
top_liked_posts = heapq.nlargest(3, posts, key=lambda x: x[2])
print("点赞数最高的前 3 名帖子：")
for post in top_liked_posts:
print(f" {post[1]}：{post[2]} 个点赞")
## 按评论数查找前 3 名帖子
top_commented_posts = heapq.nlargest(3, posts, key=lambda x: x[3])
print("\n评论数最高的前 3 名帖子：")
for post in top_commented_posts:
print(f" {post[1]}：{post[3]} 条评论")运行脚本以查看这些实际应用：
python3 practical_applications.py你应该看到详细的输出，展示了如何将你学到的技术应用于实际场景：
查找 Python 列表中前 N 个元素的实际应用
应用 1：电子商务 - 分析产品销售额
==================================================
销量前 3 名的产品（按销量）：
Wireless Earbuds：售出 2100 件，单价 $129.99
Power Bank：售出 1900 件，单价 $49.99
Bluetooth Speaker：售出 1750 件，单价 $79.99
收入前 3 名的产品：
Smartphone X：$1,124,987.50 收入（1250 件，单价 $899.99）
Laptop Pro：$1,156,991.10 收入（890 件，单价 $1299.99）
Wireless Earbuds：$272,979.00 收入（2100 件，单价 $129.99）
应用 2：数据分析 - 温度监测
====================================================
前 3 个最热的城市：
Phoenix：40.2°C
Houston：35.7°C
Miami：33.8°C
前 3 个最冷的城市：
Seattle：22.4°C
Boston：27.9°C
Los Angeles：28.3°C
应用 3：社交媒体 - 用户参与度
=============================================
参与度最高的前 3 名帖子：
帖子 ID：1006
标题：Interview with Celebrity
参与度得分：11560
（点赞：4200，评论：580，分享：2200）
发布于：2023-06-15 14:25
帖子 ID：1005
标题：Recipe: Delicious Desserts
参与度得分：8450
（点赞：3100，评论：450，分享：1500）
发布于：2023-06-14 11:10
帖子 ID：1001
标题：Breaking News: Major Announcement
参与度得分：8060
（点赞：3500，评论：420，分享：1200）
发布于：2023-06-10 12:30
点赞数最高的前 3 名帖子：
Interview with Celebrity：4200 个点赞
Breaking News: Major Announcement：3500 个点赞
Recipe: Delicious Desserts：3100 个点赞
评论数最高的前 3 名帖子：
Tutorial: Python Programming：650 条评论
Interview with Celebrity：580 条评论
DIY Home Improvement Projects：520 条评论这些示例演示了你所学到的技术如何应用于实际场景，例如电子商务销售分析、天气数据分析和社交媒体参与度指标。在每种情况下，有效地找到前 N 个元素对于从数据中提取有价值的见解至关重要。
祝贺你完成了关于在 Python 列表中查找前 N 个元素的这个实验。你已经学习了几项重要的技术和概念：
基本列表操作：你探索了如何创建、访问和修改 Python 列表，它们是 Python 中的基本数据结构。
排序技术：你学习了如何使用 sorted() 函数和 sort() 方法对列表进行排序，包括如何按升序和降序排序，以及如何使用自定义排序键。
使用 sorted() 查找前 N 个元素：你发现了如何使用 sorted() 函数和切片来查找列表中前 N 个元素。
使用 heapq 查找前 N 个元素：你探索了 heapq 模块，它提供了更有效的方法（nlargest() 和 nsmallest()）来查找前 N 个和后 N 个元素，尤其适用于大型数据集。
实际应用：你将这些技术应用于电子商务、数据分析和社交媒体的实际场景中，展示了它们的通用性和实用性。
这些技能在许多编程任务中都将非常有用，从数据分析和处理到构建需要优先排序或对项目进行排名的复杂应用程序。能够有效地找到前 N 个元素是你的 Python 编程工具包中的一个强大工具。
在你继续你的 Python 之旅时，你会发现这些技术在许多情况下都很有用，并且你可以基于它们来解决更复杂的问题。
