Como encontrar os N elementos superiores em uma lista Python

Introdução

Listas Python são uma estrutura de dados fundamental que armazena coleções ordenadas de itens. Encontrar os N elementos superiores em uma lista é uma habilidade essencial para muitas tarefas de análise e processamento de dados. Seja para identificar os alunos com as maiores pontuações, os produtos mais populares ou os maiores valores em um conjunto de dados, saber como extrair esses elementos de forma eficiente é valioso.

Neste laboratório, você aprenderá diferentes métodos para encontrar os N elementos superiores em uma lista Python. Você explorará tanto funções embutidas quanto módulos especializados, e verá como aplicar essas técnicas a cenários do mundo real. Ao final deste laboratório, você terá uma sólida compreensão das técnicas de manipulação de listas Python que aprimorarão suas capacidades de processamento de dados.

Criando e Compreendendo Listas Python

Nesta primeira etapa, você aprenderá os fundamentos das listas Python e como criá-las. Listas são estruturas de dados versáteis que podem armazenar elementos de diferentes tipos, incluindo números, strings e até mesmo outras listas.

Criando uma Lista

Vamos começar criando uma lista simples de números. No WebIDE, crie um novo arquivo Python chamado list_basics.py no diretório /home/labex/project:

1. Clique no menu "File" (ou no ícone de arquivo na barra lateral)
2. Selecione "New File"
3. Insira o nome list_basics.py
4. Adicione o seguinte código ao arquivo:

## Criando uma lista de números
numbers = [15, 7, 27, 9, 42, 8, 31, 17]

## Imprime a lista original
print("Original list:", numbers)

## Imprime o comprimento da lista
print("List length:", len(numbers))

## Acessa elementos por índice
print("First element:", numbers[0])
print("Last element:", numbers[-1])

## Fatiando uma lista (Slicing)
print("First three elements:", numbers[:3])
print("Last three elements:", numbers[-3:])

Agora, execute o código para ver a saída:

1. Abra um terminal no WebIDE (se ainda não estiver aberto)
2. Execute o script com o comando:

python3 list_basics.py

Você deve ver uma saída semelhante a esta:

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]

Modificando Listas

Agora, vamos modificar nossa lista. Adicione o seguinte código a list_basics.py:

## Adicionando elementos a uma lista
numbers.append(50)
print("After append:", numbers)

## Inserindo um elemento em uma posição específica
numbers.insert(2, 99)
print("After insert:", numbers)

## Removendo elementos
numbers.remove(9)  ## Remove por valor
print("After remove:", numbers)

popped_value = numbers.pop()  ## Remove e retorna o último elemento
print("Popped value:", popped_value)
print("After pop:", numbers)

Execute o script novamente para ver como a lista muda:

python3 list_basics.py

A saída agora deve incluir:

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]

Isso demonstra como as listas Python são mutáveis (podem ser alteradas) após a criação, o que é uma característica importante que as torna flexíveis para manipulação de dados.

Ordenando Listas em Python

Antes de encontrar os N elementos superiores, é importante entender como ordenar listas em Python. A ordenação organiza os elementos em uma ordem específica, normalmente ascendente (do menor para o maior) ou descendente (do maior para o menor).

Ordenação Básica com sorted()

Crie um novo arquivo chamado sorting_lists.py no diretório do projeto e adicione o seguinte código:

## Criando uma lista de números
scores = [85, 92, 78, 91, 88, 76, 94, 87]

## Ordena em ordem ascendente (padrão)
sorted_scores = sorted(scores)
print("Original scores:", scores)
print("Sorted scores (ascending):", sorted_scores)

## Ordena em ordem descendente
desc_scores = sorted(scores, reverse=True)
print("Sorted scores (descending):", desc_scores)

## Lista original permanece inalterada
print("Original scores after sorting:", scores)

Execute o script para ver as listas ordenadas:

python3 sorting_lists.py

Você deve ver uma saída semelhante a esta:

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]

Observe que a função sorted() retorna uma nova lista ordenada, enquanto a lista original permanece inalterada.

Ordenando com o Método sort()

Agora, vamos explorar o método sort(), que modifica a lista no local. Adicione o seguinte código a sorting_lists.py:

## Criando outra lista
prices = [12.99, 8.50, 15.75, 9.99, 11.25]
print("\nOriginal prices:", prices)

## Ordena a lista no local (ascendente)
prices.sort()
print("After sort() (ascending):", prices)

## Ordena a lista no local (descendente)
prices.sort(reverse=True)
print("After sort(reverse=True) (descending):", prices)

Execute o script novamente:

python3 sorting_lists.py

A saída adicional deve ser:

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]

Ordenando com Chaves Personalizadas

Você também pode ordenar listas com base em critérios específicos usando uma função chave (key function). Adicione o seguinte código a sorting_lists.py:

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

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

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

## Lista de tuplas (nome, idade)
people = [("Alice", 25), ("Bob", 19), ("Charlie", 32), ("David", 22)]
print("\nOriginal people:", people)

## Ordena por idade (segundo elemento de cada tupla)
print("Sorted by age:", sorted(people, key=lambda person: person[1]))

## Ordena por comprimento do nome
print("Sorted by name length:", sorted(people, key=lambda person: len(person[0])))

Execute o script mais uma vez:

python3 sorting_lists.py

A saída adicional demonstra como ordenar com critérios personalizados:

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

Compreender essas técnicas de ordenação é essencial para encontrar os N elementos superiores em uma lista, o que exploraremos na próxima etapa.

Encontrando os N Elementos Superiores Usando sorted()

Agora que você entende as listas Python e a ordenação, vamos nos concentrar em encontrar os N elementos superiores em uma lista. A abordagem mais direta é usar a função sorted() com o parâmetro reverse=True e, em seguida, fatiar (slice) o resultado para obter os primeiros N elementos.

Crie um novo arquivo chamado top_n_sorted.py no diretório do projeto e adicione o seguinte código:

## Encontrando os N elementos superiores usando sorted()

## Dados de exemplo: Notas dos alunos
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Student scores:", student_scores)

## Encontre as 3 notas mais altas
top_3_scores = sorted(student_scores, reverse=True)[:3]
print("Top 3 scores:", top_3_scores)

## Encontre as 5 notas mais altas
top_5_scores = sorted(student_scores, reverse=True)[:5]
print("Top 5 scores:", top_5_scores)

Execute o script para ver os N elementos superiores:

python3 top_n_sorted.py

Você deve ver uma saída semelhante a esta:

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]

Encontrando os N Elementos Superiores com Dados Complexos

Vamos estender nosso exemplo para trabalhar com estruturas de dados mais complexas. Adicione o seguinte código a top_n_sorted.py:

## Dados de exemplo: Dados de vendas de produtos (nome do produto, 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("\nProduct sales:", product_sales)

## Encontre os 3 produtos mais vendidos
## Nós ordenamos com base nas unidades vendidas (segundo elemento de cada tupla)
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")

## Dados de exemplo: Registros de alunos (nome, notas em diferentes disciplinas)
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)

## Encontre os 2 alunos com base na média das notas
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")

Execute o script novamente:

python3 top_n_sorted.py

A saída adicional demonstra como encontrar os N elementos superiores em estruturas de dados mais complexas:

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

A função sorted() com fatiamento (slicing) é uma abordagem versátil para encontrar os N elementos superiores em uma lista. No entanto, para grandes conjuntos de dados, existem métodos mais eficientes, que exploraremos na próxima etapa.

Encontrando os N Elementos Superiores Usando heapq

Embora a função sorted() funcione bem para a maioria dos casos, o módulo heapq do Python fornece métodos mais eficientes para encontrar os N elementos superiores, especialmente para grandes conjuntos de dados. O módulo heapq implementa o algoritmo de fila de heap (heap queue algorithm), também conhecido como algoritmo de fila de prioridade (priority queue algorithm).

Crie um novo arquivo chamado top_n_heapq.py no diretório do projeto e adicione o seguinte código:

## Encontrando os N elementos superiores usando heapq
import heapq

## Dados de exemplo: Notas dos alunos
student_scores = [85, 92, 78, 91, 88, 76, 94, 87, 89, 93]
print("Student scores:", student_scores)

## Encontre as 3 notas mais altas usando heapq.nlargest()
top_3_scores = heapq.nlargest(3, student_scores)
print("Top 3 scores (using heapq.nlargest()):", top_3_scores)

## Encontre as 3 notas mais baixas usando heapq.nsmallest()
bottom_3_scores = heapq.nsmallest(3, student_scores)
print("Bottom 3 scores (using heapq.nsmallest()):", bottom_3_scores)

Execute o script para ver como heapq funciona:

python3 top_n_heapq.py

Você deve ver uma saída semelhante a esta:

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]

Usando heapq com Dados Complexos

O módulo heapq também pode funcionar com estruturas de dados complexas, especificando uma função chave (key function). Adicione o seguinte código a top_n_heapq.py:

## Dados de exemplo: Dados de vendas de produtos (nome do produto, 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("\nProduct sales:", product_sales)

## Encontre os 3 produtos mais vendidos usando 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")

## Dados de exemplo: Registros de alunos (nome, notas em diferentes disciplinas)
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)

## Encontre os 2 alunos com base na média das notas 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("Top 2 students by average score:")
for student in top_2_students:
    avg = average_score(student)
    print(f"  {student['name']}: {avg:.2f} average")

Execute o script novamente:

python3 top_n_heapq.py

A saída adicional demonstra o uso de heapq com estruturas de dados complexas:

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

Comparação de Desempenho: sorted() vs heapq

Vamos comparar o desempenho de sorted() e heapq para encontrar os N elementos superiores em uma lista grande. Adicione o seguinte código a top_n_heapq.py:

import time
import random

## Gere uma lista grande de números aleatórios
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")

## Meça o tempo da abordagem 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")

## Meça o tempo da abordagem 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")

## Verifique se ambos os métodos dão o mesmo resultado
print("Both methods give the same result:", sorted(top_10_sorted) == sorted(top_10_heapq))

Execute o script pela última vez:

python3 top_n_heapq.py

A saída adicional demonstra os benefícios de desempenho do uso de heapq para grandes conjuntos de dados:

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

Para encontrar um pequeno número de N elementos superiores em uma lista grande, heapq.nlargest() é mais eficiente do que ordenar a lista inteira e, em seguida, fatiá-la. Isso ocorre porque heapq.nlargest() mantém um heap (montículo) de tamanho N, enquanto sorted() ordena a lista inteira.

Aplicações do Mundo Real

Agora que você aprendeu diferentes técnicas para encontrar os N elementos superiores em uma lista Python, vamos explorar algumas aplicações do mundo real. Nesta etapa, você criará um script mais abrangente que aplica esses conceitos a cenários práticos.

Crie um novo arquivo chamado practical_applications.py no diretório do projeto e adicione o seguinte código:

## Aplicações do mundo real de encontrar os N elementos superiores
import heapq
from datetime import datetime

print("APLICAÇÕES PRÁTICAS DE ENCONTRAR OS N ELEMENTOS SUPERIORES EM LISTAS PYTHON\n")

## Aplicação 1: E-commerce - Analisando Vendas de Produtos
print("APLICAÇÃO 1: E-COMMERCE - ANALISANDO VENDAS DE PRODUTOS")
print("==================================================")

## Dados de exemplo de vendas de produtos (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)
]

## Encontre os 3 produtos principais por unidades vendidas
top_sold_products = heapq.nlargest(3, product_sales, key=lambda x: x[2])
print("\nTop 3 Produtos Mais Vendidos (por unidades vendidas):")
for product in top_sold_products:
    print(f"  {product[1]}: {product[2]} unidades vendidas a ${product[3]}")

## Encontre os 3 produtos principais por receita (unidades_vendidas * preço)
top_revenue_products = heapq.nlargest(3, product_sales, key=lambda x: x[2] * x[3])
print("\nTop 3 Produtos por Receita:")
for product in top_revenue_products:
    revenue = product[2] * product[3]
    print(f"  {product[1]}: ${revenue:,.2f} de receita ({product[2]} unidades a ${product[3]})")

## Aplicação 2: Análise de Dados - Monitoramento de Temperatura
print("\n\nAPLICAÇÃO 2: ANÁLISE DE DADOS - MONITORAMENTO DE TEMPERATURA")
print("====================================================")

## Dados de exemplo de temperatura (data, cidade, 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)
]

## Encontre as cidades com as temperaturas mais altas
hottest_cities = heapq.nlargest(3, temperature_data, key=lambda x: x[2])
print("\nTop 3 Cidades Mais Quentes:")
for city_data in hottest_cities:
    print(f"  {city_data[1]}: {city_data[2]}°C")

## Encontre as cidades com as temperaturas mais baixas
coldest_cities = heapq.nsmallest(3, temperature_data, key=lambda x: x[2])
print("\nTop 3 Cidades Mais Frias:")
for city_data in coldest_cities:
    print(f"  {city_data[1]}: {city_data[2]}°C")

## Aplicação 3: Mídias Sociais - Engajamento do Usuário
print("\n\nAPLICAÇÃO 3: MÍDIAS SOCIAIS - ENGAJAMENTO DO USUÁRIO")
print("=============================================")

## Dados de exemplo de postagens de mídia social (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))
]

## Defina uma função para calcular a pontuação de engajamento (soma ponderada de curtidas, comentários, compartilhamentos)
def engagement_score(post):
    return post[2] + (post[3] * 2) + (post[4] * 3)  ## curtidas + (comentários * 2) + (compartilhamentos * 3)

## Encontre as 3 postagens principais por pontuação de engajamento
top_engaging_posts = heapq.nlargest(3, posts, key=engagement_score)
print("\nTop 3 Postagens Mais Envolventes:")
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"  (Curtidas: {post[2]}, Comentários: {post[3]}, Compartilhamentos: {post[4]})")
    print(f"  Postado em: {post[5].strftime('%Y-%m-%d %H:%M')}")
    print()

## Encontre as 3 postagens principais por curtidas
top_liked_posts = heapq.nlargest(3, posts, key=lambda x: x[2])
print("Top 3 Postagens Mais Curtidas:")
for post in top_liked_posts:
    print(f"  {post[1]}: {post[2]} curtidas")

## Encontre as 3 postagens principais por comentários
top_commented_posts = heapq.nlargest(3, posts, key=lambda x: x[3])
print("\nTop 3 Postagens Mais Comentadas:")
for post in top_commented_posts:
    print(f"  {post[1]}: {post[3]} comentários")

Execute o script para ver essas aplicações práticas:

python3 practical_applications.py

Você deve ver uma saída detalhada mostrando como encontrar os N elementos superiores pode ser aplicado em cenários do mundo real:

APLICAÇÕES PRÁTICAS DE ENCONTRAR OS N ELEMENTOS SUPERIORES EM LISTAS PYTHON

APLICAÇÃO 1: E-COMMERCE - ANALISANDO VENDAS DE PRODUTOS
==================================================

Top 3 Produtos Mais 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

Top 3 Produtos por Receita:
  Smartphone X: $1,124,987.50 de receita (1250 unidades a $899.99)
  Laptop Pro: $1,156,991.10 de receita (890 unidades a $1299.99)
  Wireless Earbuds: $272,979.00 de receita (2100 unidades a $129.99)


APLICAÇÃO 2: ANÁLISE DE DADOS - MONITORAMENTO DE TEMPERATURA
====================================================

Top 3 Cidades Mais Quentes:
  Phoenix: 40.2°C
  Houston: 35.7°C
  Miami: 33.8°C

Top 3 Cidades Mais Frias:
  Seattle: 22.4°C
  Boston: 27.9°C
  Los Angeles: 28.3°C


APLICAÇÃO 3: MÍDIAS SOCIAIS - ENGAJAMENTO DO USUÁRIO
=============================================

Top 3 Postagens Mais Envolventes:
  Post ID: 1006
  Title: Interview with Celebrity
  Engagement Score: 11560
  (Curtidas: 4200, Comentários: 580, Compartilhamentos: 2200)
  Postado em: 2023-06-15 14:25

  Post ID: 1005
  Title: Recipe: Delicious Desserts
  Engagement Score: 8450
  (Curtidas: 3100, Comentários: 450, Compartilhamentos: 1500)
  Postado em: 2023-06-14 11:10

  Post ID: 1001
  Title: Breaking News: Major Announcement
  Engagement Score: 8060
  (Curtidas: 3500, Comentários: 420, Compartilhamentos: 1200)
  Postado em: 2023-06-10 12:30

Top 3 Postagens Mais Curtidas:
  Interview with Celebrity: 4200 curtidas
  Breaking News: Major Announcement: 3500 curtidas
  Recipe: Delicious Desserts: 3100 curtidas

Top 3 Postagens Mais Comentadas:
  Tutorial: Python Programming: 650 comentários
  Interview with Celebrity: 580 comentários
  DIY Home Improvement Projects: 520 comentários

Esses exemplos demonstram como as técnicas que você aprendeu podem ser aplicadas a cenários do mundo real, como análise de vendas de e-commerce, análise de dados meteorológicos e métricas de engajamento de mídia social. Em cada caso, a capacidade de encontrar eficientemente os N elementos superiores é crucial para extrair informações valiosas dos dados.

Resumo

Parabéns por concluir este laboratório sobre como encontrar os N elementos superiores em listas Python. Você aprendeu várias técnicas e conceitos importantes:

1. Operações Básicas de Lista: Você explorou como criar, acessar e modificar listas Python, que são estruturas de dados fundamentais em Python.

2. Técnicas de Ordenação: Você aprendeu como ordenar listas usando a função sorted() e o método sort(), incluindo como ordenar em ordem crescente e decrescente, e como usar chaves de ordenação personalizadas.

3. Encontrando os N Elementos Superiores com sorted(): Você descobriu como usar a função sorted() com fatiamento (slicing) para encontrar os N elementos superiores em uma lista.

4. Encontrando os N Elementos Superiores com heapq: Você explorou o módulo heapq, que fornece métodos mais eficientes (nlargest() e nsmallest()) para encontrar os N elementos superiores e inferiores, especialmente para grandes conjuntos de dados.

5. Aplicações do Mundo Real: Você aplicou essas técnicas a cenários práticos em e-commerce, análise de dados e mídias sociais, demonstrando sua versatilidade e utilidade.

Essas habilidades serão valiosas em muitas tarefas de programação, desde análise e processamento de dados até a construção de aplicações sofisticadas que precisam priorizar ou classificar itens. A capacidade de encontrar eficientemente os N elementos superiores é uma ferramenta poderosa em seu kit de ferramentas de programação Python.

À medida que você continua sua jornada em Python, você descobrirá que essas técnicas são úteis em muitos contextos, e você pode se basear nelas para resolver problemas mais complexos.