Wie man die obersten N Elemente in einer Python-Liste findet

Introduction

Python lists are a fundamental data structure that store ordered collections of items. Finding the top N elements in a list is an essential skill for many data analysis and processing tasks. Whether you need to identify the highest-scoring students, the most popular products, or the largest values in a dataset, knowing how to efficiently extract these elements is valuable.

In this lab, you will learn different methods to find the top N elements in a Python list. You will explore both built-in functions and specialized modules, and you will see how to apply these techniques to real-world scenarios. By the end of this lab, you will have a solid understanding of Python list manipulation techniques that will enhance your data processing capabilities.

Skills Graph

Creating and Understanding Python Lists

In this first step, you will learn the basics of Python lists and how to create them. Lists are versatile data structures that can store elements of different types, including numbers, strings, and even other lists.

Creating a List

Let's start by creating a simple list of numbers. In the WebIDE, create a new Python file named list_basics.py in the /home/labex/project directory:

1. Click on the "File" menu (or the file icon in the sidebar)
2. Select "New File"
3. Enter the name list_basics.py
4. Add the following code to the file:

## Creating a list of numbers
numbers = [15, 7, 27, 9, 42, 8, 31, 17]

## Print the original list
print("Original list:", numbers)

## Print the length of the list
print("List length:", len(numbers))

## Access elements by index
print("First element:", numbers[0])
print("Last element:", numbers[-1])

## Slicing a list
print("First three elements:", numbers[:3])
print("Last three elements:", numbers[-3:])

Now, run the code to see the output:

1. Open a terminal in the WebIDE (if not already open)
2. Run the script with the command:

python3 list_basics.py

You should see output similar to this:

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]

Modifying Lists

Now, let's modify our list. Add the following code to list_basics.py:

## Adding elements to a list
numbers.append(50)
print("After append:", numbers)

## Inserting an element at a specific position
numbers.insert(2, 99)
print("After insert:", numbers)

## Removing elements
numbers.remove(9)  ## Remove by value
print("After remove:", numbers)

popped_value = numbers.pop()  ## Remove and return the last element
print("Popped value:", popped_value)
print("After pop:", numbers)

Run the script again to see how the list changes:

python3 list_basics.py

The output should now include:

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]

This demonstrates how Python lists are mutable (can be changed) after creation, which is an important characteristic that makes them flexible for data manipulation.

Sorting Lists in Python

Before finding the top N elements, it is important to understand how to sort lists in Python. Sorting arranges elements in a specific order, typically ascending (smallest to largest) or descending (largest to smallest).

Basic Sorting with sorted()

Create a new file named sorting_lists.py in the project directory and add the following code:

## Creating a list of numbers
scores = [85, 92, 78, 91, 88, 76, 94, 87]

## Sort in ascending order (default)
sorted_scores = sorted(scores)
print("Original scores:", scores)
print("Sorted scores (ascending):", sorted_scores)

## Sort in descending order
desc_scores = sorted(scores, reverse=True)
print("Sorted scores (descending):", desc_scores)

## Original list remains unchanged
print("Original scores after sorting:", scores)

Run the script to see the sorted lists:

python3 sorting_lists.py

You should see output similar to this:

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]

Notice that the sorted() function returns a new sorted list while leaving the original list unchanged.

Sorting with the sort() Method

Now, let's explore the sort() method, which modifies the list in place. Add the following code to sorting_lists.py:

## Creating another list
prices = [12.99, 8.50, 15.75, 9.99, 11.25]
print("\nOriginal prices:", prices)

## Sort the list in place (ascending)
prices.sort()
print("After sort() (ascending):", prices)

## Sort the list in place (descending)
prices.sort(reverse=True)
print("After sort(reverse=True) (descending):", prices)

Run the script again:

python3 sorting_lists.py

The additional output should be:

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 with Custom Keys

You can also sort lists based on specific criteria using a key function. Add the following code to sorting_lists.py:

## List of strings
names = ["Alice", "bob", "Charlie", "david", "Eva"]
print("\nOriginal names:", names)

## Sort alphabetically (case-sensitive)
print("Sorted alphabetically (case-sensitive):", sorted(names))

## Sort alphabetically (case-insensitive)
print("Sorted alphabetically (case-insensitive):", sorted(names, key=str.lower))

## List of tuples (name, age)
people = [("Alice", 25), ("Bob", 19), ("Charlie", 32), ("David", 22)]
print("\nOriginal people:", people)

## Sort by age (second element of each tuple)
print("Sorted by age:", sorted(people, key=lambda person: person[1]))

## Sort by name length
print("Sorted by name length:", sorted(people, key=lambda person: len(person[0])))

Run the script once more:

python3 sorting_lists.py

The additional output demonstrates how to sort with custom criteria:

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)]

Understanding these sorting techniques is essential for finding the top N elements in a list, which we will explore in the next step.

Finding Top N Elements Using sorted()

Now that you understand Python lists and sorting, let's focus on finding the top N elements in a list. The most straightforward approach is to use the sorted() function with the reverse=True parameter and then slice the result to get the first N elements.

Create a new file named top_n_sorted.py in the project directory and add the following code:

## Finding top N elements using sorted()

## Sample data: Student scores
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Student scores:", student_scores)

## Find the top 3 scores
top_3_scores = sorted(student_scores, reverse=True)[:3]
print("Top 3 scores:", top_3_scores)

## Find the top 5 scores
top_5_scores = sorted(student_scores, reverse=True)[:5]
print("Top 5 scores:", top_5_scores)

Run the script to see the top N elements:

python3 top_n_sorted.py

You should see output similar to this:

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]

Finding Top N Elements with Complex Data

Let's extend our example to work with more complex data structures. Add the following code to top_n_sorted.py:

## Sample data: Product sales data (product name, units sold)
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)

## Find the top 3 best-selling products
## We sort based on the units sold (second element of each tuple)
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")

## Sample data: Student records (name, scores in different subjects)
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)

## Find the top 2 students based on average score
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")

Run the script again:

python3 top_n_sorted.py

The additional output demonstrates how to find top N elements in more complex data structures:

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

The sorted() function with slicing is a versatile approach to finding the top N elements in a list. However, for large datasets, there are more efficient methods, which we will explore in the next step.

Finding Top N Elements Using heapq

While the sorted() function works well for most cases, Python's heapq module provides more efficient methods for finding the top N elements, especially for large datasets. The heapq module implements the heap queue algorithm, also known as the priority queue algorithm.

Create a new file named top_n_heapq.py in the project directory and add the following code:

## Finding top N elements using heapq
import heapq

## Sample data: Student scores
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Student scores:", student_scores)

## Find the top 3 scores using heapq.nlargest()
top_3_scores = heapq.nlargest(3, student_scores)
print("Top 3 scores (using heapq.nlargest()):", top_3_scores)

## Find the bottom 3 scores using heapq.nsmallest()
bottom_3_scores = heapq.nsmallest(3, student_scores)
print("Bottom 3 scores (using heapq.nsmallest()):", bottom_3_scores)

Run the script to see how heapq works:

python3 top_n_heapq.py

You should see output similar to this:

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]

Using heapq with Complex Data

The heapq module can also work with complex data structures by specifying a key function. Add the following code to top_n_heapq.py:

## Sample data: Product sales data (product name, units sold)
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)

## Find the top 3 best-selling products using heapq.nlargest()
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")

## Sample data: Student records (name, scores in different subjects)
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)

## Find the top 2 students based on average score using heapq.nlargest()
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")

Run the script again:

python3 top_n_heapq.py

The additional output demonstrates using heapq with complex data structures:

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

Performance Comparison: sorted() vs heapq

Let's compare the performance of sorted() and heapq for finding the top N elements in a large list. Add the following code to top_n_heapq.py:

import time
import random

## Generate a large list of random numbers
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")

## Time the sorted() approach
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")

## Time the heapq approach
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")

## Verify both methods give the same result
print("Both methods give the same result:", sorted(top_10_sorted) == sorted(top_10_heapq))

Run the script a final time:

python3 top_n_heapq.py

The additional output demonstrates the performance benefits of using heapq for large datasets:

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

For finding a small number of top N elements in a large list, heapq.nlargest() is more efficient than sorting the entire list and then slicing it. This is because heapq.nlargest() maintains a heap of size N, while sorted() sorts the entire list.

Real-World Applications

Now that you have learned different techniques to find the top N elements in a Python list, let's explore some real-world applications. In this step, you will create a more comprehensive script that applies these concepts to practical scenarios.

Create a new file named practical_applications.py in the project directory and add the following code:

## Real-world applications of finding top N elements
import heapq
from datetime import datetime

print("PRACTICAL APPLICATIONS OF FINDING TOP N ELEMENTS IN PYTHON LISTS\n")

## Application 1: E-commerce - Analyzing Product Sales
print("APPLICATION 1: E-COMMERCE - ANALYZING PRODUCT SALES")
print("==================================================")

## Sample product sales data (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)
]

## Find top 3 products by units sold
top_sold_products = heapq.nlargest(3, product_sales, key=lambda x: x[2])
print("\nTop 3 Best-Selling Products (by units sold):")
for product in top_sold_products:
    print(f"  {product[1]}: {product[2]} units sold at ${product[3]}")

## Find top 3 products by revenue (units_sold * price)
top_revenue_products = heapq.nlargest(3, product_sales, key=lambda x: x[2] * x[3])
print("\nTop 3 Products by Revenue:")
for product in top_revenue_products:
    revenue = product[2] * product[3]
    print(f"  {product[1]}: ${revenue:,.2f} revenue ({product[2]} units at ${product[3]})")

## Application 2: Data Analysis - Temperature Monitoring
print("\n\nAPPLICATION 2: DATA ANALYSIS - TEMPERATURE MONITORING")
print("====================================================")

## Sample temperature data (date, city, temperature)
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)
]

## Find cities with highest temperatures
hottest_cities = heapq.nlargest(3, temperature_data, key=lambda x: x[2])
print("\nTop 3 Hottest Cities:")
for city_data in hottest_cities:
    print(f"  {city_data[1]}: {city_data[2]}°C")

## Find cities with lowest temperatures
coldest_cities = heapq.nsmallest(3, temperature_data, key=lambda x: x[2])
print("\nTop 3 Coldest Cities:")
for city_data in coldest_cities:
    print(f"  {city_data[1]}: {city_data[2]}°C")

## Application 3: Social Media - User Engagement
print("\n\nAPPLICATION 3: SOCIAL MEDIA - USER ENGAGEMENT")
print("=============================================")

## Sample social media post data (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))
]

## Define a function to calculate engagement score (weighted sum of likes, comments, shares)
def engagement_score(post):
    return post[2] + (post[3] * 2) + (post[4] * 3)  ## likes + (comments * 2) + (shares * 3)

## Find top 3 posts by engagement score
top_engaging_posts = heapq.nlargest(3, posts, key=engagement_score)
print("\nTop 3 Most Engaging Posts:")
for post in top_engaging_posts:
    score = engagement_score(post)
    print(f"  Post ID: {post[0]}")
    print(f"  Title: {post[1]}")
    print(f"  Engagement Score: {score}")
    print(f"  (Likes: {post[2]}, Comments: {post[3]}, Shares: {post[4]})")
    print(f"  Posted on: {post[5].strftime('%Y-%m-%d %H:%M')}")
    print()

## Find top 3 posts by likes
top_liked_posts = heapq.nlargest(3, posts, key=lambda x: x[2])
print("Top 3 Most Liked Posts:")
for post in top_liked_posts:
    print(f"  {post[1]}: {post[2]} likes")

## Find top 3 posts by comments
top_commented_posts = heapq.nlargest(3, posts, key=lambda x: x[3])
print("\nTop 3 Most Commented Posts:")
for post in top_commented_posts:
    print(f"  {post[1]}: {post[3]} comments")

Run the script to see these practical applications:

python3 practical_applications.py

You should see detailed output showing how finding top N elements can be applied in real-world scenarios:

PRACTICAL APPLICATIONS OF FINDING TOP N ELEMENTS IN PYTHON LISTS

APPLICATION 1: E-COMMERCE - ANALYZING PRODUCT SALES
==================================================

Top 3 Best-Selling Products (by units sold):
  Wireless Earbuds: 2100 units sold at $129.99
  Power Bank: 1900 units sold at $49.99
  Bluetooth Speaker: 1750 units sold at $79.99

Top 3 Products by Revenue:
  Smartphone X: $1,124,987.50 revenue (1250 units at $899.99)
  Laptop Pro: $1,156,991.10 revenue (890 units at $1299.99)
  Wireless Earbuds: $272,979.00 revenue (2100 units at $129.99)


APPLICATION 2: DATA ANALYSIS - TEMPERATURE MONITORING
====================================================

Top 3 Hottest Cities:
  Phoenix: 40.2°C
  Houston: 35.7°C
  Miami: 33.8°C

Top 3 Coldest Cities:
  Seattle: 22.4°C
  Boston: 27.9°C
  Los Angeles: 28.3°C


APPLICATION 3: SOCIAL MEDIA - USER ENGAGEMENT
=============================================

Top 3 Most Engaging Posts:
  Post ID: 1006
  Title: Interview with Celebrity
  Engagement Score: 11560
  (Likes: 4200, Comments: 580, Shares: 2200)
  Posted on: 2023-06-15 14:25

  Post ID: 1005
  Title: Recipe: Delicious Desserts
  Engagement Score: 8450
  (Likes: 3100, Comments: 450, Shares: 1500)
  Posted on: 2023-06-14 11:10

  Post ID: 1001
  Title: Breaking News: Major Announcement
  Engagement Score: 8060
  (Likes: 3500, Comments: 420, Shares: 1200)
  Posted on: 2023-06-10 12:30

Top 3 Most Liked Posts:
  Interview with Celebrity: 4200 likes
  Breaking News: Major Announcement: 3500 likes
  Recipe: Delicious Desserts: 3100 likes

Top 3 Most Commented Posts:
  Tutorial: Python Programming: 650 comments
  Interview with Celebrity: 580 comments
  DIY Home Improvement Projects: 520 comments

These examples demonstrate how the techniques you've learned can be applied to real-world scenarios such as e-commerce sales analysis, weather data analysis, and social media engagement metrics. In each case, the ability to efficiently find the top N elements is crucial for extracting valuable insights from data.

Summary

Congratulations on completing this lab on finding the top N elements in Python lists. You have learned several important techniques and concepts:

1. Basic List Operations: You explored how to create, access, and modify Python lists, which are fundamental data structures in Python.

2. Sorting Techniques: You learned how to sort lists using both the sorted() function and the sort() method, including how to sort in ascending and descending order, and how to use custom sorting keys.

3. Finding Top N Elements with sorted(): You discovered how to use the sorted() function with slicing to find the top N elements in a list.

4. Finding Top N Elements with heapq: You explored the heapq module, which provides more efficient methods (nlargest() and nsmallest()) for finding the top and bottom N elements, especially for large datasets.

5. Real-World Applications: You applied these techniques to practical scenarios in e-commerce, data analysis, and social media, demonstrating their versatility and usefulness.

These skills will be valuable in many programming tasks, from data analysis and processing to building sophisticated applications that need to prioritize or rank items. The ability to efficiently find the top N elements is a powerful tool in your Python programming toolkit.

As you continue your Python journey, you will find these techniques useful in many contexts, and you can build upon them to solve more complex problems.