Cómo encontrar los N elementos superiores en una lista de Python

Introducción

Las listas de Python son una estructura de datos fundamental que almacena colecciones ordenadas de elementos. Encontrar los N elementos superiores en una lista es una habilidad esencial para muchas tareas de análisis y procesamiento de datos. Ya sea que necesite identificar a los estudiantes con las puntuaciones más altas, los productos más populares o los valores más grandes en un conjunto de datos, saber cómo extraer estos elementos de manera eficiente es valioso.

En este laboratorio, aprenderá diferentes métodos para encontrar los N elementos superiores en una lista de Python. Explorará tanto funciones integradas como módulos especializados, y verá cómo aplicar estas técnicas a escenarios del mundo real. Al final de este laboratorio, tendrá una sólida comprensión de las técnicas de manipulación de listas de Python que mejorarán sus capacidades de procesamiento de datos.

Creación y comprensión de listas de Python

En este primer paso, aprenderá los conceptos básicos de las listas de Python y cómo crearlas. Las listas son estructuras de datos versátiles que pueden almacenar elementos de diferentes tipos, incluidos números, cadenas e incluso otras listas.

Creación de una lista

Comencemos creando una lista simple de números. En el WebIDE, cree un nuevo archivo Python llamado list_basics.py en el directorio /home/labex/project:

1. Haga clic en el menú "Archivo" (o en el icono de archivo en la barra lateral)
2. Seleccione "Nuevo archivo"
3. Ingrese el nombre list_basics.py
4. Agregue el siguiente código al archivo:

## Creación de una lista de números
numbers = [15, 7, 27, 9, 42, 8, 31, 17]

## Imprimir la lista original
print("Lista original:", numbers)

## Imprimir la longitud de la lista
print("Longitud de la lista:", len(numbers))

## Acceder a elementos por índice
print("Primer elemento:", numbers[0])
print("Último elemento:", numbers[-1])

## Segmentación de una lista (Slicing)
print("Primeros tres elementos:", numbers[:3])
print("Últimos tres elementos:", numbers[-3:])

Ahora, ejecute el código para ver la salida:

1. Abra una terminal en el WebIDE (si aún no está abierta)
2. Ejecute el script con el comando:

python3 list_basics.py

Debería ver una salida similar a esta:

Lista original: [15, 7, 27, 9, 42, 8, 31, 17]
Longitud de la lista: 8
Primer elemento: 15
Último elemento: 17
Primeros tres elementos: [15, 7, 27]
Últimos tres elementos: [8, 31, 17]

Modificación de listas

Ahora, modifiquemos nuestra lista. Agregue el siguiente código a list_basics.py:

## Agregar elementos a una lista
numbers.append(50)
print("Después de append:", numbers)

## Insertar un elemento en una posición específica
numbers.insert(2, 99)
print("Después de insert:", numbers)

## Eliminar elementos
numbers.remove(9)  ## Eliminar por valor
print("Después de remove:", numbers)

popped_value = numbers.pop()  ## Eliminar y devolver el último elemento
print("Valor extraído:", popped_value)
print("Después de pop:", numbers)

Ejecute el script nuevamente para ver cómo cambia la lista:

python3 list_basics.py

La salida ahora debería incluir:

Después de append: [15, 7, 27, 9, 42, 8, 31, 17, 50]
Después de insert: [15, 7, 99, 27, 9, 42, 8, 31, 17, 50]
Después de remove: [15, 7, 99, 27, 42, 8, 31, 17, 50]
Valor extraído: 50
Después de pop: [15, 7, 99, 27, 42, 8, 31, 17]

Esto demuestra cómo las listas de Python son mutables (se pueden cambiar) después de la creación, lo cual es una característica importante que las hace flexibles para la manipulación de datos.

Ordenamiento de listas en Python

Antes de encontrar los N elementos superiores, es importante comprender cómo ordenar listas en Python. El ordenamiento organiza los elementos en un orden específico, típicamente ascendente (de menor a mayor) o descendente (de mayor a menor).

Ordenamiento básico con sorted()

Cree un nuevo archivo llamado sorting_lists.py en el directorio del proyecto y agregue el siguiente código:

## Creación de una lista de números
scores = [85, 92, 78, 91, 88, 76, 94, 87]

## Ordenar en orden ascendente (por defecto)
sorted_scores = sorted(scores)
print("Puntuaciones originales:", scores)
print("Puntuaciones ordenadas (ascendente):", sorted_scores)

## Ordenar en orden descendente
desc_scores = sorted(scores, reverse=True)
print("Puntuaciones ordenadas (descendente):", desc_scores)

## La lista original permanece sin cambios
print("Puntuaciones originales después de ordenar:", scores)

Ejecute el script para ver las listas ordenadas:

python3 sorting_lists.py

Debería ver una salida similar a esta:

Puntuaciones originales: [85, 92, 78, 91, 88, 76, 94, 87]
Puntuaciones ordenadas (ascendente): [76, 78, 85, 87, 88, 91, 92, 94]
Puntuaciones ordenadas (descendente): [94, 92, 91, 88, 87, 85, 78, 76]
Puntuaciones originales después de ordenar: [85, 92, 78, 91, 88, 76, 94, 87]

Observe que la función sorted() devuelve una nueva lista ordenada mientras deja la lista original sin cambios.

Ordenamiento con el método sort()

Ahora, exploremos el método sort(), que modifica la lista in situ (en el lugar). Agregue el siguiente código a sorting_lists.py:

## Creación de otra lista
prices = [12.99, 8.50, 15.75, 9.99, 11.25]
print("\nPrecios originales:", prices)

## Ordenar la lista in situ (ascendente)
prices.sort()
print("Después de sort() (ascendente):", prices)

## Ordenar la lista in situ (descendente)
prices.sort(reverse=True)
print("Después de sort(reverse=True) (descendente):", prices)

Ejecute el script nuevamente:

python3 sorting_lists.py

La salida adicional debería ser:

Precios originales: [12.99, 8.5, 15.75, 9.99, 11.25]
Después de sort() (ascendente): [8.5, 9.99, 11.25, 12.99, 15.75]
Después de sort(reverse=True) (descendente): [15.75, 12.99, 11.25, 9.99, 8.5]

Ordenamiento con claves personalizadas

También puede ordenar listas en función de criterios específicos utilizando una función clave (key function). Agregue el siguiente código a sorting_lists.py:

## Lista de cadenas
names = ["Alice", "bob", "Charlie", "david", "Eva"]
print("\nNombres originales:", names)

## Ordenar alfabéticamente (sensible a mayúsculas y minúsculas)
print("Ordenado alfabéticamente (sensible a mayúsculas y minúsculas):", sorted(names))

## Ordenar alfabéticamente (sin distinción entre mayúsculas y minúsculas)
print("Ordenado alfabéticamente (sin distinción entre mayúsculas y minúsculas):", sorted(names, key=str.lower))

## Lista de tuplas (nombre, edad)
people = [("Alice", 25), ("Bob", 19), ("Charlie", 32), ("David", 22)]
print("\nPersonas originales:", people)

## Ordenar por edad (segundo elemento de cada tupla)
print("Ordenado por edad:", sorted(people, key=lambda person: person[1]))

## Ordenar por longitud del nombre
print("Ordenado por longitud del nombre:", sorted(people, key=lambda person: len(person[0])))

Ejecute el script una vez más:

python3 sorting_lists.py

La salida adicional demuestra cómo ordenar con criterios personalizados:

Nombres originales: ['Alice', 'bob', 'Charlie', 'david', 'Eva']
Ordenado alfabéticamente (sensible a mayúsculas y minúsculas): ['Alice', 'Charlie', 'Eva', 'bob', 'david']
Ordenado alfabéticamente (sin distinción entre mayúsculas y minúsculas): ['Alice', 'bob', 'Charlie', 'david', 'Eva']

Personas originales: [('Alice', 25), ('Bob', 19), ('Charlie', 32), ('David', 22)]
Ordenado por edad: [('Bob', 19), ('David', 22), ('Alice', 25), ('Charlie', 32)]
Ordenado por longitud del nombre: [('Bob', 19), ('Alice', 25), ('David', 22), ('Charlie', 32)]

Comprender estas técnicas de ordenamiento es esencial para encontrar los N elementos superiores en una lista, lo cual exploraremos en el siguiente paso.

Encontrar los N elementos superiores usando sorted()

Ahora que comprende las listas y el ordenamiento de Python, centrémonos en encontrar los N elementos superiores en una lista. El enfoque más directo es usar la función sorted() con el parámetro reverse=True y luego segmentar el resultado para obtener los primeros N elementos.

Cree un nuevo archivo llamado top_n_sorted.py en el directorio del proyecto y agregue el siguiente código:

## Encontrar los N elementos superiores usando sorted()

## Datos de muestra: Puntuaciones de estudiantes
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Puntuaciones de estudiantes:", student_scores)

## Encuentra las 3 puntuaciones más altas
top_3_scores = sorted(student_scores, reverse=True)[:3]
print("Las 3 puntuaciones más altas:", top_3_scores)

## Encuentra las 5 puntuaciones más altas
top_5_scores = sorted(student_scores, reverse=True)[:5]
print("Las 5 puntuaciones más altas:", top_5_scores)

Ejecute el script para ver los N elementos superiores:

python3 top_n_sorted.py

Debería ver una salida similar a esta:

Puntuaciones de estudiantes: [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
Las 3 puntuaciones más altas: [94, 93, 92]
Las 5 puntuaciones más altas: [94, 93, 92, 91, 89]

Encontrar los N elementos superiores con datos complejos

Extendamos nuestro ejemplo para trabajar con estructuras de datos más complejas. Agregue el siguiente código a top_n_sorted.py:

## Datos de muestra: Datos de ventas de productos (nombre del producto, unidades vendidas)
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("\nVentas de productos:", product_sales)

## Encuentra los 3 productos más vendidos
## Ordenamos en función de las unidades vendidas (segundo elemento de cada tupla)
top_3_products = sorted(product_sales, key=lambda x: x[1], reverse=True)[:3]
print("Los 3 productos más vendidos:")
for product, sales in top_3_products:
    print(f"  {product}: {sales} unidades")

## Datos de muestra: Registros de estudiantes (nombre, puntuaciones en diferentes materias)
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("\nRegistros de estudiantes:", student_records)

## Encuentra los 2 estudiantes superiores en función de la puntuación promedio
def average_score(student):
    return sum(student["scores"]) / len(student["scores"])

top_2_students = sorted(student_records, key=average_score, reverse=True)[:2]
print("Los 2 estudiantes superiores por puntuación promedio:")
for student in top_2_students:
    avg = average_score(student)
    print(f"  {student['name']}: {avg:.2f} promedio")

Ejecute el script nuevamente:

python3 top_n_sorted.py

La salida adicional demuestra cómo encontrar los N elementos superiores en estructuras de datos más complejas:

Ventas de productos: [('Product A', 1250), ('Product B', 870), ('Product C', 1100), ('Product D', 750), ('Product E', 940), ('Product F', 1300), ('Product G', 820), ('Product H', 980)]
Los 3 productos más vendidos:
  Product F: 1300 unidades
  Product A: 1250 unidades
  Product C: 1100 unidades

Registros de estudiantes: [{'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]}]
Los 2 estudiantes superiores por puntuación promedio:
  Diana: 93.75 promedio
  Alice: 90.00 promedio

La función sorted() con segmentación es un enfoque versátil para encontrar los N elementos superiores en una lista. Sin embargo, para conjuntos de datos grandes, existen métodos más eficientes, que exploraremos en el siguiente paso.

Encontrar los N elementos superiores usando heapq

Si bien la función sorted() funciona bien para la mayoría de los casos, el módulo heapq de Python proporciona métodos más eficientes para encontrar los N elementos superiores, especialmente para conjuntos de datos grandes. El módulo heapq implementa el algoritmo de cola de montón (heap queue algorithm), también conocido como el algoritmo de cola de prioridad (priority queue algorithm).

Cree un nuevo archivo llamado top_n_heapq.py en el directorio del proyecto y agregue el siguiente código:

## Encontrar los N elementos superiores usando heapq
import heapq

## Datos de muestra: Puntuaciones de estudiantes
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Puntuaciones de estudiantes:", student_scores)

## Encuentra las 3 puntuaciones más altas usando heapq.nlargest()
top_3_scores = heapq.nlargest(3, student_scores)
print("Las 3 puntuaciones más altas (usando heapq.nlargest()):", top_3_scores)

## Encuentra las 3 puntuaciones más bajas usando heapq.nsmallest()
bottom_3_scores = heapq.nsmallest(3, student_scores)
print("Las 3 puntuaciones más bajas (usando heapq.nsmallest()):", bottom_3_scores)

Ejecute el script para ver cómo funciona heapq:

python3 top_n_heapq.py

Debería ver una salida similar a esta:

Puntuaciones de estudiantes: [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
Las 3 puntuaciones más altas (usando heapq.nlargest()): [94, 93, 92]
Las 3 puntuaciones más bajas (usando heapq.nsmallest()): [76, 78, 85]

Usando heapq con datos complejos

El módulo heapq también puede funcionar con estructuras de datos complejas especificando una función clave (key function). Agregue el siguiente código a top_n_heapq.py:

## Datos de muestra: Datos de ventas de productos (nombre del producto, unidades vendidas)
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("\nVentas de productos:", product_sales)

## Encuentra los 3 productos más vendidos usando heapq.nlargest()
top_3_products = heapq.nlargest(3, product_sales, key=lambda x: x[1])
print("Los 3 productos más vendidos:")
for product, sales in top_3_products:
    print(f"  {product}: {sales} unidades")

## Datos de muestra: Registros de estudiantes (nombre, puntuaciones en diferentes materias)
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("\nRegistros de estudiantes:", student_records)

## Encuentra los 2 estudiantes superiores en función de la puntuación promedio usando 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("Los 2 estudiantes superiores por puntuación promedio:")
for student in top_2_students:
    avg = average_score(student)
    print(f"  {student['name']}: {avg:.2f} promedio")

Ejecute el script nuevamente:

python3 top_n_heapq.py

La salida adicional demuestra el uso de heapq con estructuras de datos complejas:

Ventas de productos: [('Product A', 1250), ('Product B', 870), ('Product C', 1100), ('Product D', 750), ('Product E', 940), ('Product F', 1300), ('Product G', 820), ('Product H', 980)]
Los 3 productos más vendidos:
  Product F: 1300 unidades
  Product A: 1250 unidades
  Product C: 1100 unidades

Registros de estudiantes: [{'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]}]
Los 2 estudiantes superiores por puntuación promedio:
  Diana: 93.75 promedio
  Alice: 90.00 promedio

Comparación de rendimiento: sorted() vs heapq

Comparemos el rendimiento de sorted() y heapq para encontrar los N elementos superiores en una lista grande. Agregue el siguiente código a top_n_heapq.py:

import time
import random

## Generar una lista grande de números aleatorios
print("\nComparando el rendimiento con una lista grande:")
large_list = [random.randint(1, 1000000) for _ in range(100000)]
print(f"Tamaño de la lista: {len(large_list)} elementos")

## Medir el tiempo del enfoque sorted()
start_time = time.time()
top_10_sorted = sorted(large_list, reverse=True)[:10]
sorted_time = time.time() - start_time
print(f"Tiempo empleado con sorted(): {sorted_time:.6f} segundos")

## Medir el tiempo del enfoque heapq
start_time = time.time()
top_10_heapq = heapq.nlargest(10, large_list)
heapq_time = time.time() - start_time
print(f"Tiempo empleado con heapq.nlargest(): {heapq_time:.6f} segundos")
print(f"Ganancia de rendimiento: {sorted_time / heapq_time:.2f}x más rápido")

## Verificar que ambos métodos dan el mismo resultado
print("Ambos métodos dan el mismo resultado:", sorted(top_10_sorted) == sorted(top_10_heapq))

Ejecute el script una última vez:

python3 top_n_heapq.py

La salida adicional demuestra los beneficios de rendimiento de usar heapq para conjuntos de datos grandes:

Comparando el rendimiento con una lista grande:
Tamaño de la lista: 100000 elementos
Tiempo empleado con sorted(): 0.034625 segundos
Tiempo empleado con heapq.nlargest(): 0.008976 segundos
Ganancia de rendimiento: 3.86x más rápido
Ambos métodos dan el mismo resultado: True

Para encontrar un pequeño número de los N elementos superiores en una lista grande, heapq.nlargest() es más eficiente que ordenar toda la lista y luego segmentarla. Esto se debe a que heapq.nlargest() mantiene un montón (heap) de tamaño N, mientras que sorted() ordena toda la lista.

Aplicaciones del mundo real

Ahora que ha aprendido diferentes técnicas para encontrar los N elementos superiores en una lista de Python, exploremos algunas aplicaciones del mundo real. En este paso, creará un script más completo que aplica estos conceptos a escenarios prácticos.

Cree un nuevo archivo llamado practical_applications.py en el directorio del proyecto y agregue el siguiente código:

## Aplicaciones del mundo real para encontrar los N elementos superiores
import heapq
from datetime import datetime

print("APLICACIONES PRÁCTICAS PARA ENCONTRAR LOS N ELEMENTOS SUPERIORES EN LISTAS DE PYTHON\n")

## Aplicación 1: Comercio electrónico - Análisis de ventas de productos
print("APLICACIÓN 1: COMERCIO ELECTRÓNICO - ANÁLISIS DE VENTAS DE PRODUCTOS")
print("==================================================")

## Datos de muestra de ventas de productos (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)
]

## Encuentra los 3 productos principales por unidades vendidas
top_sold_products = heapq.nlargest(3, product_sales, key=lambda x: x[2])
print("\nLos 3 productos más vendidos (por unidades vendidas):")
for product in top_sold_products:
    print(f"  {product[1]}: {product[2]} unidades vendidas a ${product[3]}")

## Encuentra los 3 productos principales por ingresos (unidades_vendidas * precio)
top_revenue_products = heapq.nlargest(3, product_sales, key=lambda x: x[2] * x[3])
print("\nLos 3 productos principales por ingresos:")
for product in top_revenue_products:
    revenue = product[2] * product[3]
    print(f"  {product[1]}: ${revenue:,.2f} de ingresos ({product[2]} unidades a ${product[3]})")

## Aplicación 2: Análisis de datos - Monitoreo de temperatura
print("\n\nAPLICACIÓN 2: ANÁLISIS DE DATOS - MONITOREO DE TEMPERATURA")
print("====================================================")

## Datos de muestra de temperatura (fecha, ciudad, temperatura)
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)
]

## Encuentra las ciudades con las temperaturas más altas
hottest_cities = heapq.nlargest(3, temperature_data, key=lambda x: x[2])
print("\nLas 3 ciudades más calientes:")
for city_data in hottest_cities:
    print(f"  {city_data[1]}: {city_data[2]}°C")

## Encuentra las ciudades con las temperaturas más bajas
coldest_cities = heapq.nsmallest(3, temperature_data, key=lambda x: x[2])
print("\nLas 3 ciudades más frías:")
for city_data in coldest_cities:
    print(f"  {city_data[1]}: {city_data[2]}°C")

## Aplicación 3: Redes sociales - Interacción del usuario
print("\n\nAPLICACIÓN 3: REDES SOCIALES - INTERACCIÓN DEL USUARIO")
print("=============================================")

## Datos de muestra de publicaciones en redes sociales (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 una función para calcular la puntuación de interacción (suma ponderada de me gusta, comentarios, compartidos)
def engagement_score(post):
    return post[2] + (post[3] * 2) + (post[4] * 3)  ## me gusta + (comentarios * 2) + (compartidos * 3)

## Encuentra las 3 publicaciones principales por puntuación de interacción
top_engaging_posts = heapq.nlargest(3, posts, key=engagement_score)
print("\nLas 3 publicaciones más interactivas:")
for post in top_engaging_posts:
    score = engagement_score(post)
    print(f"  ID de la publicación: {post[0]}")
    print(f"  Título: {post[1]}")
    print(f"  Puntuación de interacción: {score}")
    print(f"  (Me gusta: {post[2]}, Comentarios: {post[3]}, Compartidos: {post[4]})")
    print(f"  Publicado el: {post[5].strftime('%Y-%m-%d %H:%M')}")
    print()

## Encuentra las 3 publicaciones principales por me gusta
top_liked_posts = heapq.nlargest(3, posts, key=lambda x: x[2])
print("Las 3 publicaciones con más me gusta:")
for post in top_liked_posts:
    print(f"  {post[1]}: {post[2]} me gusta")

## Encuentra las 3 publicaciones principales por comentarios
top_commented_posts = heapq.nlargest(3, posts, key=lambda x: x[3])
print("\nLas 3 publicaciones con más comentarios:")
for post in top_commented_posts:
    print(f"  {post[1]}: {post[3]} comentarios")

Ejecute el script para ver estas aplicaciones prácticas:

python3 practical_applications.py

Debería ver una salida detallada que muestra cómo encontrar los N elementos superiores se puede aplicar en escenarios del mundo real:

APLICACIONES PRÁCTICAS PARA ENCONTRAR LOS N ELEMENTOS SUPERIORES EN LISTAS DE PYTHON

APLICACIÓN 1: COMERCIO ELECTRÓNICO - ANÁLISIS DE VENTAS DE PRODUCTOS
==================================================

Los 3 productos más vendidos (por unidades vendidas):
  Wireless Earbuds: 2100 unidades vendidas a $129.99
  Power Bank: 1900 unidades vendidas a $49.99
  Bluetooth Speaker: 1750 unidades vendidas a $79.99

Los 3 productos principales por ingresos:
  Smartphone X: $1,124,987.50 de ingresos (1250 unidades a $899.99)
  Laptop Pro: $1,156,991.10 de ingresos (890 unidades a $1299.99)
  Wireless Earbuds: $272,979.00 de ingresos (2100 unidades a $129.99)


APLICACIÓN 2: ANÁLISIS DE DATOS - MONITOREO DE TEMPERATURA
====================================================

Las 3 ciudades más calientes:
  Phoenix: 40.2°C
  Houston: 35.7°C
  Miami: 33.8°C

Las 3 ciudades más frías:
  Seattle: 22.4°C
  Boston: 27.9°C
  Los Angeles: 28.3°C


APLICACIÓN 3: REDES SOCIALES - INTERACCIÓN DEL USUARIO
=============================================

Las 3 publicaciones más interactivas:
  ID de la publicación: 1006
  Título: Interview with Celebrity
  Puntuación de interacción: 11560
  (Me gusta: 4200, Comentarios: 580, Compartidos: 2200)
  Publicado el: 2023-06-15 14:25

  ID de la publicación: 1005
  Título: Recipe: Delicious Desserts
  Puntuación de interacción: 8450
  (Me gusta: 3100, Comentarios: 450, Compartidos: 1500)
  Publicado el: 2023-06-14 11:10

  ID de la publicación: 1001
  Título: Breaking News: Major Announcement
  Puntuación de interacción: 8060
  (Me gusta: 3500, Comentarios: 420, Compartidos: 1200)
  Publicado el: 2023-06-10 12:30

Las 3 publicaciones con más me gusta:
  Interview with Celebrity: 4200 me gusta
  Breaking News: Major Announcement: 3500 me gusta
  Recipe: Delicious Desserts: 3100 me gusta

Las 3 publicaciones con más comentarios:
  Tutorial: Python Programming: 650 comentarios
  Interview with Celebrity: 580 comentarios
  DIY Home Improvement Projects: 520 comentarios

Estos ejemplos demuestran cómo las técnicas que ha aprendido se pueden aplicar a escenarios del mundo real, como el análisis de ventas de comercio electrónico, el análisis de datos meteorológicos y las métricas de interacción en redes sociales. En cada caso, la capacidad de encontrar eficientemente los N elementos superiores es crucial para extraer información valiosa de los datos.

Resumen

Felicitaciones por completar este laboratorio sobre cómo encontrar los N elementos superiores en listas de Python. Ha aprendido varias técnicas y conceptos importantes:

1. Operaciones básicas con listas: Exploró cómo crear, acceder y modificar listas de Python, que son estructuras de datos fundamentales en Python.

2. Técnicas de ordenamiento: Aprendió a ordenar listas usando tanto la función sorted() como el método sort(), incluyendo cómo ordenar en orden ascendente y descendente, y cómo usar claves de ordenamiento personalizadas.

3. Encontrar los N elementos superiores con sorted(): Descubrió cómo usar la función sorted() con segmentación (slicing) para encontrar los N elementos superiores en una lista.

4. Encontrar los N elementos superiores con heapq: Exploró el módulo heapq, que proporciona métodos más eficientes (nlargest() y nsmallest()) para encontrar los N elementos superiores e inferiores, especialmente para conjuntos de datos grandes.

5. Aplicaciones del mundo real: Aplicó estas técnicas a escenarios prácticos en comercio electrónico, análisis de datos y redes sociales, demostrando su versatilidad y utilidad.

Estas habilidades serán valiosas en muchas tareas de programación, desde el análisis y procesamiento de datos hasta la construcción de aplicaciones sofisticadas que necesitan priorizar o clasificar elementos. La capacidad de encontrar eficientemente los N elementos superiores es una herramienta poderosa en su conjunto de herramientas de programación en Python.

A medida que continúe su viaje en Python, encontrará que estas técnicas son útiles en muchos contextos, y puede basarse en ellas para resolver problemas más complejos.