1
resposta

[Desafio] Hora da prática (6-10)

Estou compartilhando as minhas resoluções da seção "Aplicando a projetos" para trocarmos ideias. Caso alguém tenha resolvido de uma forma diferente, deixem nos comentários!

  1. Análise de Desempenho de Estudantes

Criei a função retornando múltiplos valores de uma só vez (um recurso excelente do Python chamado desempacotamento de tuplas). Como o exercício não especificou a média de corte, assumi 6.0 como padrão para aprovação.

def analisa_estudante(notas):
    maior = max(notas)
    menor = min(notas)
    media = sum(notas) / len(notas)
    
    # Operador ternário para definir a situação em uma linha
    situacao = "Aprovado(a)" if media >= 6.0 else "Reprovado(a)"
    
    return maior, menor, media, situacao

notas_aluno = [5.5, 8.0, 6.5, 7.0]
maior_nota, menor_nota, media_aluno, status = analisa_estudante(notas_aluno)

print(f"O(a) estudante obteve uma média de {media_aluno:.1f}, com a sua maior nota de {maior_nota} pontos e a menor nota de {menor_nota} pontos e foi {status}.")

  1. Tratamento de Nomes com map()

Aqui o poder do map() com lambda brilha muito. A função capitalize() garante que apenas a primeira letra fique maiúscula, corrigindo perfeitamente as inconsistências da lista original.

nomes = ["joão", "MaRia", "JOSÉ"]
sobrenomes = ["SILVA", "souza", "Tavares"]

# O map aplica a função lambda iterando simultaneamente pelas duas listas
nomes_completos = list(map(lambda n, s: f"{n.capitalize()} {s.capitalize()}", nomes, sobrenomes))

for nome in nomes_completos:
    print(f"Nome completo: {nome}")

  1. Desempenho do Time de Futebol

Para percorrer as duas listas (marcados e sofridos) ao mesmo tempo sem precisar usar índices numéricos (i), a função zip() é a melhor escolha.

def calcula_pontos(marcados, sofridos):
    pontos = 0
    
    # O zip junta os elementos de mesmo índice das duas listas
    for m, s in zip(marcados, sofridos):
        if m > s:
            pontos += 3  # Vitória
        elif m == s:
            pontos += 1  # Empate
            
    pontuacao_maxima = len(marcados) * 3
    aproveitamento = (pontos / pontuacao_maxima) * 100
    
    return pontos, aproveitamento

gols_marcados = [2, 1, 3, 1, 0]
gols_sofridos = [1, 2, 2, 1, 3]

pontos_finais, aprov_final = calcula_pontos(gols_marcados, gols_sofridos)

print(f"A pontuação do time foi de {pontos_finais} e seu aproveitamento foi de {aprov_final:.1f}%")

  1. Calculadora de Viagens

Para organizar os dados, criei listas globais com as informações na mesma ordem (índice 0 = Salvador, índice 1 = Fortaleza, etc.). O método .index() permite encontrar rapidamente a posição da cidade escolhida para buscar seus respectivos valores.

# Dados base
cidades = ["Salvador", "Fortaleza", "Natal", "Aracaju"]
distancias = [850, 800, 300, 550] # km (apenas ida)
custo_passeios = [200, 400, 250, 300] # reais/dia

def gasto_hotel(dias):
    return dias * 150

def gasto_gasolina(cidade):
    idx = cidades.index(cidade)
    # Multiplicamos por 2 para considerar ida e volta
    distancia_total = distancias[idx] * 2
    litros_necessarios = distancia_total / 14
    return litros_necessarios * 5

def gasto_passeio(cidade, dias):
    idx = cidades.index(cidade)
    return custo_passeios[idx] * dias

# Simulando a viagem
destino = "Salvador"
dias_viagem = 3

total_hotel = gasto_hotel(dias_viagem)
total_gasolina = gasto_gasolina(destino)
total_passeio = gasto_passeio(destino, dias_viagem)

custo_total = total_hotel + total_gasolina + total_passeio

print(f"Com base nos gastos definidos, uma viagem de {dias_viagem} dias para {destino} saindo de Recife custaria R$ {custo_total:.2f}")

  1. Processamento de Linguagem Natural (NLP) e filter()

Para higienizar o texto, usei um laço rápido para substituir pontuações. Depois, o filter() aliado ao lambda extraiu apenas as palavras exigidas pela regra de negócio de forma muito eficiente.

frase = "Aprender Python aqui na Alura é muito bom"

# Tratamento da string (removendo pontuações indesejadas)
pontuacoes = [',', '.', '!', '?']
for p in pontuacoes:
    frase = frase.replace(p, ' ')

# Separando a frase em uma lista de palavras
palavras = frase.split()

# Filtrando palavras com 5 ou mais caracteres
palavras_filtradas = list(filter(lambda p: len(p) >= 5, palavras))

print("Palavras com 5 ou mais caracteres:")
print(palavras_filtradas)

Espero que esses códigos tragam bons insights para quem está estudando. Aprender a dominar esses recursos funcionais do Python economiza muitas linhas de código no futuro! Bons estudos!

1 resposta

Olá, Weriton. Como vai?

Parabéns por mais uma excelente rodada de soluções! Seus códigos demonstram uma maturidade técnica impressionante em Python. Você utilizou com maestria recursos avançados e elegantes como o desempacotamento de tuplas, operador ternário, map(), zip() e filter().

Compartilhar códigos com esse nível de organização e detalhamento metodológico eleva demais a qualidade do nosso fórum e ajuda muito os outros estudantes.

Analisando os seus algoritmos, separei algumas dicas e boas práticas para complementar ainda mais o seu aprendizado e trazer novas abordagens:

**1. Tratamento de Nomes com map()**
Sua aplicação de map() com múltiplos iteráveis foi perfeita! Pouca gente sabe que o map() consegue receber duas ou mais listas simultaneamente se a função lambda aceitar o mesmo número de argumentos.

  • Dica de Python Moderno: Como alternativa ao map(), a comunidade Python utiliza muito as List Comprehensions pela legibilidade. O mesmo resultado poderia ser alcançado assim:
nomes_completos = [f"{n.capitalize()} {s.capitalize()}" for n, s in zip(nomes, sobrenomes)]

2. Desempenho do Time de Futebol
O uso do zip() foi a escolha ideal para evitar o controle manual de índices com range(len(...)). Para deixar o seu código ainda mais enxuto e performático, você poderia substituir o laço for por uma soma direta de booleanos/valores, mas a sua estrutura atual está extremamente limpa e legível.

3. Calculadora de Viagens
Sua lógica de buscar o índice com .index() funciona muito bem! Contudo, manter listas paralelas e indexadas globalmente pode se tornar um problema em projetos maiores (por exemplo, se alguém alterar a ordem da lista de distâncias e esquecer de mudar a de cidades).

  • Sugestão de Boa Prática: Em cenários reais de engenharia e análise de dados, a estrutura ideal para esse problema seria um Dicionário, onde a cidade é a chave. Isso centraliza as informações e elimina a necessidade de buscar índices. Veja como ficaria:
destinos_info = {
    "Salvador": {"distancia": 850, "passeio": 200},
    "Fortaleza": {"distancia": 800, "passeio": 400},
    "Natal": {"distancia": 300, "passeio": 250},
    "Aracaju": {"distancia": 550, "passeio": 300}
}

def gasto_gasolina(cidade):
    distancia_total = destinos_info[cidade]["distancia"] * 2
    return (distancia_total / 14) * 5

**4. Processamento de Linguagem Natural (NLP) e filter()**
Muito bom o tratamento prévio para remover as pontuações antes do split(). Para projetos futuros de NLP, uma dica de ouro para limpar textos sem precisar fazer um laço for substituindo caractere por caractere é utilizar expressões regulares através da biblioteca nativa re:

import re
# Substitui qualquer pontuação por espaço em uma única linha
frase_limpa = re.sub(r'[.,!?]', ' ', frase)

Mais uma vez, parabéns pelo capricho nas resoluções e por continuar movimentando a comunidade com conteúdos tão ricos!

Espero que possa ter lhe ajudado!