Professor Maxwell Gomes

1
Estrutura da Explicação para Cada Função

Para cada função, seguirei este formato para garantir clareza e completude:

1. Nome da Função: O nome da função conforme aparece no material.

2. O que é?: Uma explicação simples do propósito da função.
3. Variáveis: As variáveis usadas na função (parâmetros e internas) e o que elas
representam.
4. Termos: Explicação dos termos técnicos ou palavras-chave envolvidos (ex.: parâmetros,
retorno, decoradores).
5. O que faz?: O que a função realiza, em linguagem acessível.
6. Como usar?: Como chamar a função, com exemplos práticos.
7. O que retorna?: O valor que a função devolve ao ser executada.
8. Lógica: Como a função funciona internamente, passo a passo.
9. Como aplicar?: Como usar a função em outros contextos ou programas.
10. Exemplo prático: Um exemplo completo com código e saída.
11. Dicas para iniciantes: Boas práticas e cuidados para quem está aprendendo.

1. Função: quadrado

O que é?

A função quadrado calcula o quadrado de um número, ou seja, multiplica o número por ele mesmo
(ex.: 5² = 5 * 5 = 25). É um exemplo de função modular, simples e reutilizável.

Variáveis

• Parâmetro: numero (tipo float) – O número que será elevado ao quadrado.

• Variáveis internas: Nenhuma, pois a função apenas usa o parâmetro numero.

Termos

• Parâmetro: Um valor que você passa para a função quando a chama (neste caso,
numero).
• Retorno: O resultado que a função devolve após calcular (aqui, numero * numero).
• Tipo float: Indica que o número pode ser inteiro (ex.: 5) ou decimal (ex.: 5.5).
• Docstring: A descrição """Calcula o quadrado de um número.""", que explica o propósito
da função.

O que faz?

Pega um número (inteiro ou decimal) e retorna o resultado de multiplicá-lo por ele mesmo.

Como usar?

Você chama a função passando um número como argumento:

resultado = quadrado(5) # Calcula 5 * 5

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
2

print(resultado) # Saída: 25

O que retorna?

Um número (tipo float) que é o quadrado do número fornecido.

Lógica

1. A função recebe um número (numero).

2. Multiplica numero por ele mesmo (numero * numero).
3. Devolve o resultado com return.

Como aplicar?

• Use em qualquer programa que precise calcular quadrados, como em cálculos

geométricos (área de um quadrado), estatísticas, ou jogos.
• Pode ser combinada com outras funções ou usada em laços para calcular quadrados de
vários números.

Exemplo prático

def quadrado(numero: float) -> float:

"""Calcula o quadrado de um número."""
return numero * numero

# Usando a função
print(quadrado(5)) # Saída: 25
print(quadrado(3.5)) # Saída: 12.25

Dicas para iniciantes

• Sempre passe um número como argumento, ou a função pode dar erro (ex.:
quadrado("texto") não funciona).
• Use nomes claros para parâmetros, como numero, para facilitar a leitura.
• Teste a função com diferentes valores (positivos, negativos, decimais) para entender como
ela se comporta.

2. Função: saudar

O que é?

A função saudar cria uma mensagem de saudação personalizada, como "Olá, Ana!" ou "Oi, Bob!".
Ela usa um argumento padrão para tornar a saudação flexível.

Variáveis

• Parâmetros:

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
3
o nome (tipo str) – O nome da pessoa a ser saudada.
o saudacao (tipo str, padrão "Olá") – A saudação a ser usada (ex.: "Olá", "Oi").
• Variáveis internas: Nenhuma, apenas usa os parâmetros.

Termos

• Argumento padrão: Um valor predefinido para um parâmetro, usado se o chamador não

fornecer um valor (aqui, saudacao="Olá").
• String (str): Um tipo de dado que representa texto (ex.: "Olá", "Ana").
• f-string: Uma forma de formatar texto em Python, como f"{saudacao}, {nome}!", que
combina variáveis em uma string.

O que faz?

Combina uma saudação com um nome para criar uma mensagem personalizada. Se você não
fornecer uma saudação, usa "Olá" por padrão.

Como usar?

print(saudar("Ana")) # Usa o padrão "Olá"

print(saudar("Ana", "Oi")) # Especifica a saudação

O que retorna?

Uma string com a saudação completa (ex.: "Olá, Ana!").

Lógica

1. Recebe nome e, opcionalmente, saudacao (se não fornecida, usa "Olá").

2. Cria uma string combinando saudacao, uma vírgula, nome e um ponto de exclamação.
3. Retorna a string resultante.

Como aplicar?

• Útil em programas que interagem com usuários, como sistemas de login, chatbots ou
jogos.
• Pode ser adaptada para diferentes idiomas ou formatos de mensagem.

Exemplo prático

def saudar(nome: str, saudacao: str = "Olá") -> str:

"""Retorna uma saudação personalizada."""
return f"{saudacao}, {nome}!"

# Usando a função
print(saudar("Ana")) # Saída: Olá, Ana!
print(saudar("Bob", "Oi")) # Saída: Oi, Bob!

Dicas para iniciantes

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
4
• Evite passar valores que não sejam texto para nome ou saudacao.
• Use argumentos padrão para tornar a função mais fácil de usar, mas escolha valores que
façam sentido (ex.: "Olá" é uma saudação comum).
• Experimente diferentes saudações para entender a flexibilidade.

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
5
3. Função: aplicar_funcao

O que é?

A função aplicar_funcao é uma função de ordem superior que aplica uma função fornecida a todos
os elementos de uma lista, retornando uma nova lista com os resultados.

Variáveis

• Parâmetros:
o funcao – Uma função que será aplicada a cada elemento (ex.: a função quadrado).
o valores (tipo list) – A lista de valores aos quais a função será aplicada.
• Variáveis internas: Nenhuma, mas usa uma compreensão de lista internamente.

Termos

• Função de ordem superior: Uma função que recebe outra função como argumento ou
retorna uma função.
• Compreensão de lista: Uma forma concisa de criar listas aplicando uma operação a cada
elemento (aqui, [funcao(x) for x in valores]).
• Iterável: Qualquer objeto que pode ser percorrido em um laço, como uma lista.

O que faz?

Pega uma função e uma lista, aplica a função a cada elemento da lista e retorna uma nova lista
com os resultados.

Como usar?

def quadrado(x):
return x * x

valores = [1, 2, 3, 4]
resultado = aplicar_funcao(quadrado, valores)
print(resultado) # Saída: [1, 4, 9, 16]

O que retorna?

Uma lista contendo os resultados da aplicação da função a cada elemento da lista de entrada.

Lógica

1. Recebe uma função (funcao) e uma lista (valores).

2. Usa uma compreensão de lista para aplicar funcao a cada elemento x em valores.
3. Retorna a nova lista com os resultados.

Como aplicar?

• Use para aplicar qualquer transformação a uma lista de valores, como dobrar números,
converter textos, ou processar dados.
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
6
• Combina bem com funções como map() ou funções lambda para maior flexibilidade.

Exemplo prático

def aplicar_funcao(funcao, valores: list) -> list:

"""Aplica uma função a uma lista de valores."""
return [funcao(x) for x in valores]

def quadrado(x):
return x * x

valores = [1, 2, 3, 4]
print(aplicar_funcao(quadrado, valores)) # Saída: [1, 4, 9, 16]
print(aplicar_funcao(lambda x: x * 2, valores)) # Saída: [2, 4, 6, 8]

Dicas para iniciantes

• Certifique-se de que a função passada como argumento aceita um único valor e retorna
algo válido.
• Teste com funções simples (como quadrado) antes de usar funções complexas ou
lambdas.
• Use com listas pequenas para entender o comportamento antes de aplicá-la a dados
grandes.

4. Função: medir_tempo

O que é?

A função medir_tempo é um decorador que mede quanto tempo uma função leva para executar,
imprimindo o tempo decorrido. É útil para analisar o desempenho de funções.

Variáveis

• Parâmetro: funcao – A função que será decorada (ex.: calcular_fatorial).

• Variáveis internas:
o [Link] – Um contador para rastrear chamadas recursivas.
o inicio – O tempo inicial (em segundos) antes da execução.
o fim – O tempo final após a execução.
o resultado – O valor retornado pela função decorada.
o *args e **kwargs – Argumentos posicionais e nomeados passados para a função
decorada.

Termos

• Decorador: Uma função que modifica o comportamento de outra função (aqui, adiciona
medição de tempo).

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
7
• Wrapper: A função interna (wrapper) que "embrulha" a função original, adicionando lógica
extra.
• @[Link]: Preserva os metadados (nome, descrição) da função original.
• [Link](): Função que retorna o tempo atual em segundos.

O que faz?

Envolve uma função para medir o tempo de sua execução, imprimindo o nome da função e o
tempo decorrido (em segundos). Para funções recursivas, mede apenas a chamada principal.

Como usar?

Aplique o decorador com @medir_tempo acima da função que deseja medir:

@medir_tempo
def somar_lento(a, b):
[Link](1) # Simula demora
return a + b

print(somar_lento(3, 4)) # Saída: somar_lento levou 1.0023 segundos \n 7

O que retorna?

O mesmo valor retornado pela função decorada, sem alterá-lo.

Lógica

1. Define uma função interna wrapper que aceita qualquer argumento (*args, **kwargs).
2. Verifica se é a chamada principal (usando [Link]).
3. Se for a chamada principal:
o Registra o tempo inicial (inicio).
o Executa a função original e armazena o resultado.
o Registra o tempo final (fim).
o Imprime o tempo decorrido (fim - inicio).
o Decrementa o contador de nível.
4. Se for uma chamada recursiva, apenas executa a função sem medir o tempo.
5. Retorna o resultado da função original.

Como aplicar?

• Use para medir o desempenho de funções em projetos, como comparar soluções

recursivas e iterativas.
• Aplique a qualquer função que queira analisar, especialmente operações demoradas.

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
8
Exemplo prático

import time
import functools

def medir_tempo(funcao):
@[Link](funcao)
def wrapper(*args, **kwargs):
if not hasattr(wrapper, 'nivel') or [Link] == 0:
[Link] = 0
[Link] += 1
inicio = [Link]()
try:
resultado = funcao(*args, **kwargs)
fim = [Link]()
print(f"{funcao.__name__} levou {fim - inicio:.4f} segundos")
return resultado
finally:
[Link] -= 1
else:
return funcao(*args, **kwargs)
return wrapper

@medir_tempo
def somar_lento(a: int, b: int) -> int:
[Link](1)
return a + b

print(somar_lento(3, 4)) # Saída: somar_lento levou 1.0023 segundos \n 7

Dicas para iniciantes

• Use @[Link] para evitar problemas com o nome da função.

• Teste com funções simples antes de aplicar a funções complexas ou recursivas.
• Verifique se o tempo impresso faz sentido (operações rápidas podem mostrar 0.0000
segundos).

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
9
5. Função: calcular_fatorial

O que é?

A função calcular_fatorial calcula o fatorial de um número (ex.: 5! = 5 * 4 * 3 * 2 * 1 = 120) usando

recursividade.

Variáveis

• Parâmetro: n (tipo int) – O número cujo fatorial será calculado.

• Variáveis internas: Nenhuma, apenas usa o parâmetro n.

Termos

• Recursividade: A função chama a si mesma com um argumento menor (n-1).

• Caso base: A condição que encerra a recursão (aqui, n == 0).
• Fatorial: O produto de um número por todos os números inteiros positivos menores que
ele até 1.

O que faz?

Calcula o fatorial de um número inteiro não negativo, multiplicando o número por todos os
números menores até 1.

Como usar?

print(calcular_fatorial(5)) # Saída: 120

O que retorna?

Um inteiro representando o fatorial de n.

Lógica

1. Verifica o caso base: se n == 0, retorna 1.

2. Caso contrário, calcula n * calcular_fatorial(n - 1), chamando a si mesma com n-1.
3. A recursão continua até atingir o caso base, depois combina os resultados.

Como aplicar?

• Use em cálculos matemáticos, como combinações ou estatísticas.

• Pode ser combinada com decoradores (como medir_tempo) para análise de desempenho.

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
10
Exemplo prático

def calcular_fatorial(n: int) -> int:

"""Calcula o fatorial de um número."""
return 1 if n == 0 else n * calcular_fatorial(n - 1)

print(calcular_fatorial(5)) # Saída: 120

Dicas para iniciantes

• Sempre inclua um caso base para evitar loops infinitos.

• Teste com números pequenos (0, 1, 2) para entender a recursão.
• Valide que n seja não negativo, ou adicione uma verificação para evitar erros.

6. Função: cubo

O que é?

A função cubo calcula o cubo de um número, ou seja, multiplica o número por ele mesmo duas
vezes (ex.: 3³ = 3 * 3 * 3 = 27).

Variáveis

• Parâmetro: numero (tipo float) – O número que será elevado ao cubo.

• Variáveis internas: Nenhuma.

Termos

• Exponenciação: Elevar um número a uma potência (aqui, numero ** 3 é o mesmo que

numero * numero * numero).
• Retorno: O resultado do cálculo (um número).

O que faz?

Pega um número e retorna seu cubo.

Como usar?

print(cubo(3)) # Saída: 27

O que retorna?

Um número (tipo float) que é o cubo do número fornecido.

Lógica

1. Recebe numero.
2. Calcula numero ** 3.
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
11
3. Retorna o resultado.

Como aplicar?

• Útil em cálculos geométricos (ex.: volume de um cubo), física ou estatísticas.

• Pode ser usada em laços ou com outras funções para processar listas de números.

Exemplo prático

def cubo(numero: float) -> float:

"""Calcula o cubo de um número."""
return numero ** 3

print(cubo(3)) # Saída: 27
print(cubo(2.5)) # Saída: 15.625

Dicas para iniciantes

• Use ** para exponenciação em vez de multiplicar várias vezes, pois é mais claro.
• Teste com números negativos e decimais para ver como a função se comporta.
• Combine com outras funções (ex.: aplicar_funcao) para processar listas.

7. Função: fibonacci

O que é?

A função fibonacci calcula o n-ésimo número da sequência de Fibonacci (0, 1, 1, 2, 3, 5, 8, ...) de

forma recursiva, sem otimizações.

Variáveis

• Parâmetro: n (tipo int) – O índice do número na sequência de Fibonacci.

• Variáveis internas: Nenhuma.

Termos

• Sequência de Fibonacci: Cada número é a soma dos dois anteriores (ex.: F(n) = F(n-1) +
F(n-2)).
• Recursividade: A função chama a si mesma duas vezes por chamada não base.
• Caso base: Condições que encerram a recursão (aqui, n <= 1).

O que faz?

Calcula o número na posição n da sequência de Fibonacci.

Como usar?

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
12

print(fibonacci(6)) # Saída: 8

O que retorna?

Um inteiro, o n-ésimo número da sequência de Fibonacci.

Lógica

1. Verifica o caso base: se n <= 1, retorna n.

2. Caso contrário, calcula fibonacci(n - 1) + fibonacci(n - 2).
3. A recursão forma uma árvore de chamadas, que pode ser lenta para n grande.

Como aplicar?

• Use para entender recursividade, mas evite para n grande devido à ineficiência.
• Combine com memoização (como fibonacci_cache) para melhorar o desempenho.

Exemplo prático

def fibonacci(n: int) -> int:

"""Calcula o n-ésimo número de Fibonacci recursivamente."""
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(6)) # Saída: 8

Dicas para iniciantes

• Teste com números pequenos (0 a 6) para evitar lentidão.

• Entenda a árvore de chamadas para visualizar a recursividade.
• Considere usar fibonacci_cache ou fibonacci_iterativo para melhor desempenho.

8. Função: fibonacci_cache

O que é?

A função fibonacci_cache calcula o n-ésimo número de Fibonacci usando recursividade, mas com
memoização via @lru_cache para evitar cálculos redundantes.

Variáveis

• Parâmetro: n (tipo int) – O índice do número na sequência de Fibonacci.

• Variáveis internas: Nenhuma, mas o decorador @lru_cache mantém um cache interno.

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
13
Termos

• Memoização: Armazenar resultados de chamadas anteriores para reutilizá-los.

• @lru_cache: Decorador que cria um cache para armazenar resultados com base nos
argumentos.
• Cache: Uma tabela que associa argumentos a resultados para acesso rápido.

O que faz?

Calcula o número de Fibonacci na posição n, armazenando resultados para evitar recalcular

valores repetidos.

Como usar?

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_cache(n: int) -> int:
if n <= 1:
return n
return fibonacci_cache(n - 1) + fibonacci_cache(n - 2)

print(fibonacci_cache(30)) # Saída: 832040

O que retorna?

Um inteiro, o n-ésimo número da sequência de Fibonacci.

Lógica

1. Verifica o caso base: se n <= 1, retorna n.

2. Para outros casos, calcula fibonacci_cache(n - 1) + fibonacci_cache(n - 2).
3. O decorador @lru_cache armazena cada resultado, então chamadas repetidas (ex.:
fibonacci_cache(3)) retornam o valor do cache.

Como aplicar?

• Use para calcular números de Fibonacci grandes de forma eficiente.

• Aplique @lru_cache a outras funções recursivas com chamadas redundantes.

Exemplo prático

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_cache(n: int) -> int:
"""Calcula Fibonacci com cache."""
if n <= 1:
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
14

return n
return fibonacci_cache(n - 1) + fibonacci_cache(n - 2)

print(fibonacci_cache(30)) # Saída: 832040

Dicas para iniciantes

• Use @lru_cache para funções recursivas lentas, mas apenas se os argumentos forem
"hasháveis" (como inteiros).
• Teste com e sem @lru_cache para ver a diferença de desempenho.
• Evite usar em funções com efeitos colaterais (ex.: impressão, escrita em arquivo).

9. Função: fibonacci_iterativo

O que é?

A função fibonacci_iterativo calcula o n-ésimo número de Fibonacci usando um laço, sem

recursividade, para maior eficiência.

Variáveis

• Parâmetro: n (tipo int) – O índice do número na sequência de Fibonacci.

• Variáveis internas:
o a – Armazena o número atual da sequência.
o b – Armazena o próximo número.
o _ – Variável de loop não usada (convenção para ignorar o índice).

Termos

• Iteração: Uso de laços para repetir operações, sem empilhar chamadas.

• Atribuição múltipla: a, b = b, a + b atualiza duas variáveis ao mesmo tempo.

O que faz?

Calcula o número de Fibonacci na posição n iterando pela sequência, sem chamadas recursivas.

Como usar?

print(fibonacci_iterativo(6)) # Saída: 8

O que retorna?

Um inteiro, o n-ésimo número da sequência de Fibonacci.

Lógica

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
15
1. Inicializa a = 0 e b = 1 (os dois primeiros números de Fibonacci).
2. Itera n vezes, atualizando a e b para gerar o próximo número.
3. Retorna a, o n-ésimo número.

Como aplicar?

• Use para calcular números de Fibonacci grandes, pois é mais rápido e não consome a
pilha.
• Aplique o conceito de iteração a outros problemas sequenciais.

Exemplo prático

def fibonacci_iterativo(n: int) -> int:

"""Calcula Fibonacci iterativamente."""
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a

print(fibonacci_iterativo(6)) # Saída: 8

Dicas para iniciantes

• Entenda como a, b = b, a + b mantém a sequência (experimente escrever os passos no

papel).
• Use para n grande, pois é mais eficiente que a recursividade sem cache.
• Valide que n seja não negativo para evitar erros.

10. Função: listar_quadrados

O que é?

A função listar_quadrados cria uma lista com os quadrados dos primeiros n números inteiros (de 1
a n).

Variáveis

• Parâmetro: n (tipo int) – O número de elementos a incluir na lista.

• Variáveis internas: Nenhuma, usa uma compreensão de lista.

Termos

• Compreensão de lista: Uma forma concisa de criar listas (aqui, [quadrado(i) for i in
range(1, n + 1)]).
• Função auxiliar: A função quadrado é chamada dentro da compreensão.

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
16
O que faz?

Gera uma lista contendo os quadrados dos números de 1 a n.

Como usar?

print(listar_quadrados(5)) # Saída: [1, 4, 9, 16, 25]

O que retorna?

Uma lista de inteiros com os quadrados.

Lógica

1. Usa uma compreensão de lista para iterar de 1 a n.

2. Para cada número i, chama a função quadrado(i).
3. Coleta os resultados em uma lista.

Como aplicar?

• Use para gerar listas de quadrados para cálculos ou visualizações.

• Adapte para outras transformações, como cubos ou raízes.

Exemplo prático

def quadrado(numero: float) -> float:

return numero * numero

def listar_quadrados(n: int) -> list:

"""Lista os quadrados dos primeiros n números."""
return [quadrado(i) for i in range(1, n + 1)]

print(listar_quadrados(5)) # Saída: [1, 4, 9, 16, 25]

Dicas para iniciantes

• Reutilize funções existentes (como quadrado) para evitar repetir código.

• Teste com n pequeno para entender a saída.
• Use nomes claros para a função e parâmetros.

11. Função: quadrados_pares

O que é?

A função quadrados_pares cria uma lista com os quadrados dos números pares até n.

Variáveis
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
17
• Parâmetro: n (tipo int) – O limite superior para os números considerados.
• Variáveis internas: Nenhuma, usa uma compreensão de lista.

Termos

• Compreensão de lista com filtro: Inclui apenas elementos que satisfazem uma condição
(aqui, x % 2 == 0).
• range(2, n + 1, 2): Gera números pares de 2 até n, pulando de 2 em 2.

O que faz?

Gera uma lista com os quadrados dos números pares de 2 até n.

Como usar?

print(quadrados_pares(10)) # Saída: [4, 16, 36, 64]

O que retorna?

Uma lista de inteiros com os quadrados dos números pares.

Lógica

1. Usa uma compreensão de lista para iterar sobre números pares de 2 a n.

2. Calcula o quadrado de cada número (x**2).
3. Retorna a lista de quadrados.

Como aplicar?

• Use para filtrar e transformar dados (ex.: quadrados de números pares em estatísticas).
• Adapte para outros filtros, como números ímpares ou divisíveis por 3.

Exemplo prático

def quadrados_pares(n: int) -> list:

"""Lista quadrados de números pares até n."""
return [x**2 for x in range(2, n + 1, 2)]

print(quadrados_pares(10)) # Saída: [4, 16, 36, 64]

Dicas para iniciantes

• Entenda como range(2, n + 1, 2) gera apenas números pares.

• Teste com diferentes valores de n para ver como a lista muda.
• Use compreensões de lista para manter o código curto e claro.

12. Função: contar_ate

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
18
O que é?

A função contar_ate cria uma lista com os números de 1 até n usando um laço while.

Variáveis

• Parâmetro: n (tipo int) – O número limite para a contagem.

• Variáveis internas:
o resultado – Lista que armazena os números.
o i – Contador que vai de 1 até n.

Termos

• while: Um laço que continua enquanto uma condição é verdadeira.

• append: Método que adiciona um elemento ao final de uma lista.

O que faz?

Gera uma lista com os números inteiros de 1 a n.

Como usar?

print(contar_ate(5)) # Saída: [1, 2, 3, 4, 5]

O que retorna?

Uma lista de inteiros de 1 a n.

Lógica

1. Inicializa uma lista vazia (resultado).

2. Inicializa i = 1.
3. Enquanto i <= n, adiciona i à lista e incrementa i.
4. Retorna a lista.

Como aplicar?

• Use para criar sequências de números em programas simples.

• Adapte para contar com diferentes intervalos ou condições.

Exemplo prático

def contar_ate(n: int) -> list:

"""Conta até n usando while."""
resultado = []
i=1
while i <= n:
[Link](i)
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
19

i += 1
return resultado

print(contar_ate(5)) # Saída: [1, 2, 3, 4, 5]

Dicas para iniciantes

• Certifique-se de incrementar i para evitar loops infinitos.

• Teste com n = 0 ou números negativos para entender o comportamento.
• Considere usar range com for para uma solução mais concisa.

13. Função: primeiros_impares

O que é?

A função primeiros_impares cria uma lista com os primeiros n números ímpares.

Variáveis

• Parâmetro: n (tipo int) – Quantidade de números ímpares desejados.

• Variáveis internas:
o resultado – Lista que armazena os números ímpares.
o i – Contador que verifica números a partir de 1.

Termos

• continue: Pula para a próxima iteração do laço, ignorando o código restante.

• Módulo (%): Operador que verifica se um número é divisível por outro (ex.: i % 2 == 0 testa
se i é par).

O que faz?

Gera uma lista com os primeiros n números ímpares (1, 3, 5, ...).

Como usar?

print(primeiros_impares(5)) # Saída: [1, 3, 5, 7, 9]

O que retorna?

Uma lista de n números ímpares.

Lógica

1. Inicializa uma lista vazia (resultado).

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
20
2. Inicializa i = 1.
3. Enquanto a lista tiver menos de n elementos:
o Se i for par (i % 2 == 0), pula para a próxima iteração.
o Se i for ímpar, adiciona i à lista.
o Incrementa i.
4. Retorna a lista.

Como aplicar?

• Use para gerar sequências de números ímpares, como em estatísticas ou padrões.

• Adapte para outros filtros, como números primos ou divisíveis por outro valor.

Exemplo prático

def primeiros_impares(n: int) -> list:

"""Lista os primeiros n números ímpares."""
resultado = []
i=1
while len(resultado) < n:
if i % 2 == 0:
i += 1
continue
[Link](i)
i += 1
return resultado

print(primeiros_impares(5)) # Saída: [1, 3, 5, 7, 9]

Dicas para iniciantes

• Entenda como continue pula números pares.

• Teste com n = 0 para verificar o comportamento.
• Use print dentro do laço para depurar e ver como i e resultado mudam.

14. Função: combinar_listas

O que é?

A função combinar_listas combina duas listas, retornando uma lista de tuplas com índices e
elementos correspondentes.
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
21
Variáveis

• Parâmetros:
o lista1 (tipo list) – Primeira lista a combinar.
o lista2 (tipo list) – Segunda lista a combinar.
• Variáveis internas: Nenhuma, usa uma compreensão de lista com enumerate e zip.

Termos

• enumerate: Adiciona índices aos elementos de um iterável.

• zip: Combina elementos de múltiplos iteráveis em tuplas.
• Tupla: Um tipo de dado que armazena valores imutáveis (ex.: (0, 1, 'a')).

O que faz?

Cria uma lista de tuplas, onde cada tupla contém o índice e os elementos correspondentes de
lista1 e lista2.

Como usar?

print(combinar_listas([1, 2], ['a', 'b'])) # Saída: [(0, 1, 'a'), (1, 2, 'b')]

O que retorna?

Uma lista de tuplas, cada uma com (índice, elemento_lista1, elemento_lista2).

Lógica

1. Usa zip(lista1, lista2) para combinar elementos das duas listas em pares.
2. Usa enumerate para adicionar índices aos pares.
3. Cria uma lista de tuplas (i, x, y) usando uma compreensão de lista.
4. Retorna a lista resultante.

Como aplicar?

• Use para combinar dados de múltiplas fontes, como em relatórios ou análises.

• Adapte para mais listas ou diferentes formatos de saída.

Exemplo prático

def combinar_listas(lista1: list, lista2: list) -> list:

"""Combina duas listas com zip e enumerate."""
return [(i, x, y) for i, (x, y) in enumerate(zip(lista1, lista2))]

print(combinar_listas([1, 2], ['a', 'b'])) # Saída: [(0, 1, 'a'), (1, 2, 'b')]

Dicas para iniciantes

• Verifique se as listas têm o mesmo tamanho, ou zip usará a menor.

• Teste com listas vazias para entender o comportamento.
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
22
• Use print para ver o que enumerate e zip produzem separadamente.

15. Função: gerar_quadrados

O que é?

A função gerar_quadrados é um gerador que produz os quadrados dos números de 1 a n, um de

cada vez, economizando memória.

Variáveis

• Parâmetro: n (tipo int) – O limite superior para os números.

• Variáveis internas: i – Contador do laço for.

Termos

• Gerador: Uma função que usa yield para produzir valores sob demanda.
• yield: Retorna um valor e pausa a execução, retomando na próxima chamada.
• Iterável: Um objeto que pode ser percorrido, como um gerador.

O que faz?

Gera os quadrados dos números de 1 a n, retornando um valor por vez.

for q in gerar_quadrados(5):
print(q) # Saída: 1, 4, 9, 16, 25
# Ou como lista:
print(list(gerar_quadrados(5))) # Saída: [1, 4, 9, 16, 25]

O que retorna?

Um objeto gerador que produz números (os quadrados).

Lógica

1. Itera de 1 a n com um laço for.

2. Para cada i, usa yield i**2 para produzir o quadrado.
3. Pausa após cada yield, retomando na próxima iteração.

Como aplicar?

• Use para processar grandes sequências sem armazenar tudo na memória.

• Adapte para gerar outras sequências, como cubos ou números primos.

Exemplo prático

def gerar_quadrados(n: int):

"""Gera quadrados até n."""
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
23

for i in range(1, n + 1):

yield i**2

print(list(gerar_quadrados(5))) # Saída: [1, 4, 9, 16, 25]

Dicas para iniciantes

• Use geradores para economizar memória em listas grandes.

• Lembre-se que um gerador só pode ser consumido uma vez.
• Teste com next(gerar_quadrados(5)) para obter o primeiro valor.

Resumo Geral para Iniciantes

• Funções são como receitas: Cada uma faz uma tarefa específica e pode ser reutilizada.
• Variáveis são caixas: Armazenam dados (como números ou texto) para usar na função.
• Parâmetros são entradas: Você passa valores para a função trabalhar.
• Retorno é a saída: O que a função devolve após processar.
• Lógica é o passo a passo: Entenda como a função resolve o problema.
• Teste e experimente: Use valores diferentes e veja o que acontece.
• Reutilize código: Coloque funções em módulos (arquivos .py) para usar em outros
programas.

[Link]/in/mxyconsulting
 Professor Maxwell Gomes
24

import time
import functools

def quadrado(numero: float) -> float:

"""Calcula o quadrado de um número."""
return numero * numero

def saudar(nome: str, saudacao: str = "Olá") -> str:

"""Retorna uma saudação personalizada."""
return f"{saudacao}, {nome}!"

def aplicar_funcao(funcao, valores: list) -> list:

"""Aplica uma função a uma lista de valores."""
return [funcao(x) for x in valores]

def medir_tempo(funcao):
"""Decorador para medir o tempo de execução apenas da chamada principal."""
@[Link](funcao)
def wrapper(*args, **kwargs):
if not hasattr(wrapper, 'nivel') or [Link] == 0:
[Link] = 0
[Link] += 1
inicio = [Link]()
try:
resultado = funcao(*args, **kwargs)
fim = [Link]()
print(f"{funcao.__name__} levou {fim - inicio:.4f} segundos")
return resultado
finally:
[Link] -= 1
else:
return funcao(*args, **kwargs)
return wrapper

@medir_tempo
def calcular_fatorial(n: int) -> int:
"""Calcula o fatorial de um número."""
return 1 if n == 0 else n * calcular_fatorial(n - 1)

def cubo(numero: float) -> float:

"""Calcula o cubo de um número."""
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
25

return numero ** 3

def fibonacci(n: int) -> int:

"""Calcula o n-ésimo número de Fibonacci recursivamente."""
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)

@lru_cache(maxsize=None)
def fibonacci_cache(n: int) -> int:
"""Calcula Fibonacci com cache."""
if n <= 1:
return n
return fibonacci_cache(n - 1) + fibonacci_cache(n - 2)

def fibonacci_iterativo(n: int) -> int:

"""Calcula Fibonacci iterativamente."""
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a

def listar_quadrados(n: int) -> list:

"""Lista os quadrados dos primeiros n números."""
return [quadrado(i) for i in range(1, n + 1)]

def quadrados_pares(n: int) -> list:

"""Lista quadrados de números pares até n."""
return [x**2 for x in range(2, n + 1, 2)]

def contar_ate(n: int) -> list:

"""Conta até n usando while."""
resultado = []
i=1
while i <= n:
[Link](i)
i += 1
return resultado

def primeiros_impares(n: int) -> list:

"""Lista os primeiros n números ímpares."""
[Link]/in/mxyconsulting
 Professor Maxwell Gomes
26

resultado = []
i=1
while len(resultado) < n:
if i % 2 == 0:
i += 1
continue
[Link](i)
i += 1
return resultado

def combinar_listas(lista1: list, lista2: list) -> list:

"""Combina duas listas com zip e enumerate."""
return [(i, x, y) for i, (x, y) in enumerate(zip(lista1, lista2))]

def gerar_quadrados(n: int):

"""Gera quadrados até n."""
for i in range(1, n + 1):
yield i**2

[Link]/in/mxyconsulting