.jpg)
Seja muito bem-vindo à Academy Code Christ!
🌍 Academy Code Christ está disponível em vários idiomas.Fique à vontade para usar o tradutor na Barra lateral (Sidebar) e aprender no seu idioma.
Pytrhon 🐍 Etapa 05
Funções
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
🎯 Por que criar funções?
Imagine que você precise calcular a média de notas em diversos pontos do seu programa. Poderia simplesmente repetir o código:
media = (nota1 + nota2) / 2
Mas se amanhã quiser mudar o cálculo, precisaria atualizar
todas as repetições.
É aí que entram as funções: você define o cálculo uma única vez, e depois apenas o chama sempre que precisar.
As funções tornam o código:
● Mais organizado — cada função cumpre uma tarefa específica.
● Mais reutilizável — use em múltiplos pontos sem copiar e colar.
● Mais legível — ajuda a separar o raciocínio em blocos lógicos.
● Mais fácil de manter — se algo mudar, corrigir um único lugar já resolve tudo.
Criando sua primeira função
Em Python, definimos funções com a palavra‑chave def, seguida do nome da função e parênteses.
Veja um exemplo:
def saudacao():
print("Olá! Seja bem-vindo(a) ao mundo do Python!")
E para executar a função, basta chamá‑la:
saudacao()
Saída:
Olá! Seja bem-vindo(a) ao mundo do Python!
A função só é executada quando chamada — ou seja, o código dentro dela não roda automaticamente.
Parâmetros e argumentos
Nem sempre queremos uma mensagem fixa.
Podemos tornar as funções mais
flexíveis, aceitando valores externos (chamados de parâmetros).
def saudacao(nome):
print("Olá,", nome, "! Seja bem-vindo(a)!")
Ao chamar:
saudacao("Maria")
saudacao("João")
Temos:
Olá, Maria! Seja bem-vindo(a)!
Olá, João! Seja bem-vindo(a)!
Os valores passados ("Maria", "João") são chamados de argumentos.
Os nomes definidos entre parênteses (nome) são parâmetros.
Funções com retorno de valor
Algumas funções só executam ações (como imprimir mensagens), enquanto outras retornam resultados.
Para retornar algo, usamos return.
Exemplo:
def soma(a, b):
resultado = a + b
return resultado
Agora podemos salvar o resultado em uma variável:
total = soma(5, 3)
print("Resultado da soma:", total)
Saída:
Resultado da soma: 8
⚡ Dica: após o return, o Python encerra a execução da função.
Nada depois dele é lido.
Retornar múltiplos valores
Um diferencial de Python é que uma função pode retornar mais de um valor (usando tuplas):
def operacoes(a, b):
soma = a + b
sub = a - b
return soma, sub
x, y = operacoes(10, 5)
print("Soma:", x)
print("Subtração:", y)
Saída:
Soma: 15
Subtração: 5
Isso é ótimo quando precisamos calcular várias coisas relacionadas.
Argumentos com valores padrão
Podemos definir um valor padrão para parâmetros, tornando-os opcionais.
def saudacao(nome="convidado"):
print(f"Olá, {nome}!")
Chamadas:
saudacao("Alice")
saudacao()
Saída:
Olá, Alice!
Olá, convidado!
Se o argumento não for passado, o valor padrão é usado.
Parâmetros nomeados
Você pode chamar a função especificando o nome do parâmetro, em qualquer ordem:
def apresentar(nome, idade):
print(f"{nome} tem {idade} anos.")
Chamadas possíveis:
apresentar("Carlos", 30)
apresentar(idade=22, nome="Lucas")
Isso torna o código claro e fácil de entender, especialmente quando há muitos parâmetros.
Funções aninhadas e escopo de variáveis
Cada função tem sua própria área de atuação, chamada de
escopo.
Uma variável criada dentro de uma função
não existe fora dela.
Exemplo:
def exemplo():
mensagem = "Dentro da função"
print(mensagem)
exemplo()
print(mensagem) # ERRO! variável fora do escopo
Saída:
Dentro da função
NameError: name 'mensagem' is not defined
Se precisamos de uma variável que exista dentro e fora, definimos ela antes da função.
Escopo global e local
mensagem = "Global"
def exemplo():
mensagem = "Local"
print("Dentro da função:", mensagem)
exemplo()
print("Fora da função:", mensagem)
Saída:
Dentro da função: Local
Fora da função: Global
São variáveis diferentes com o mesmo nome, mas escopos
distintos.
Python sempre procura primeiro no
escopo local da função, depois nas variáveis globais.
⚠️ Evite depender de variáveis globais – prefira passar valores como parâmetros.
Funções anônimas (lambda)
Nem sempre precisamos nomear uma função.
Para casos simples e rápidos, existe a forma lambda — uma função compacta em uma linha.
dobro = lambda x: x * 2
print(dobro(5))
Saída:
10
Outros exemplos:
soma = lambda a, b: a + b
print(soma(3, 4)) # 7
As expressões lambda são ideais em filtros, ordenações e situações onde uma função simples é usada temporariamente.
Documentando funções (docstrings)
Boas funções devem ser documentadas para explicar suas
intenções.
O Python tem uma convenção chamada docstring, escrita entre três aspas.
def dividir(a, b):
"""
Retorna a divisão de a por b.
:param a: numerador
:param b: denominador (não pode ser zero)
:return: resultado da divisão
"""
if b == 0:
return "Erro: divisão por zero!"
return a / b
Podemos visualizar a documentação assim:
help(dividir)
Funções puras e reutilizáveis
Uma função pura:
● Depende apenas dos parâmetros passados.
● Não modifica variáveis externas.
● Sempre retorna o mesmo resultado para os mesmos dados.
Essas funções são ideais para cálculos, validações e transformações de dados, pois não têm efeitos colaterais.
Exemplo de função pura:
def area_quadrado(lado):
return lado * lado
Sempre que lado for o mesmo, o resultado será idêntico.
Exemplo completo: Calculadora modular
Vamos criar um pequeno sistema usando funções para organizar o código.
def somar(a, b):
return a + b
def subtrair(a, b):
return a - b
def multiplicar(a, b):
return a * b
def dividir(a, b):
if b == 0:
return "Erro: divisão por zero!"
return a / b
def menu():
print("\n=== Calculadora ===")
print("1. Somar")
print("2. Subtrair")
print("3. Multiplicar")
print("4. Dividir")
print("0. Sair")
while True:
menu()
opcao = input("Escolha uma opção: ")
if opcao == "0":
print("Encerrando...")
break
n1 = float(input("Primeiro número: "))
n2 = float(input("Segundo número: "))
if opcao == "1":
print("Resultado:", somar(n1, n2))
elif opcao == "2":
print("Resultado:", subtrair(n1, n2))
elif opcao == "3":
print("Resultado:", multiplicar(n1, n2))
elif opcao == "4":
print("Resultado:", dividir(n1, n2))
else:
print("Opção inválida.")
Observe como as funções deixam o código limpo e organizado — cada uma tem uma responsabilidade específica.
Funções dentro de funções
Você também pode definir funções internas (encapsuladas em outras), úteis quando uma função auxiliar só faz sentido dentro de um contexto.
Exemplo:
def saudacao_com_emoji(nome):
def emoji():
return "😊"
return f"Olá, {nome}! {emoji()}"
Chamando:
print(saudacao_com_emoji("Ana"))
Saída:
Olá, Ana! 😊
A função emoji() existe apenas dentro da função externa e não pode ser chamada fora dela.
Boas práticas ao criar funções
🔹 Escolha nomes claros e verbais
Prefira calcular_area() em vez de ca(); mostrar_resultado() em vez de mr().
🔹 Uma função deve fazer apenas uma coisa
Evite misturar muitas responsabilidades (cálculo, leitura e exibição).
🔹 Comente somente o necessário
Use docstrings para registrar o propósito real da função, não explique o óbvio.
🔹 Evite modificar variáveis globais
Sempre que possível, trabalhe com parâmetros e retornos.
🔹 Prefira funções pequenas
Funções curtas são mais fáceis de entender, testar e reaproveitar.
Desafios práticos
1. Conversor de temperatura
Crie funções celsius_para_fahrenheit() e fahrenheit_para_celsius().
2. Verificador de número primo
Crie uma função que retorne True se um número for primo,
False caso contrário.
3. Gerador de tabuada com função
Uma função que receba um número e
mostre a tabuada completa.
4. Função de maioridade
Retorne se uma pessoa, a partir da
idade informada, é maior de idade.
Resumo
Nesta etapa, você aprendeu:
✅ Como
definir e chamar funções (def).
✅ A diferença entre parâmetros
e argumentos.
✅ Como usar retornos (return) e valores
padrão.
✅ O conceito de escopo (local
e global).
✅ O uso de funções anônimas
(lambda).
✅ Documentar com docstrings e boas práticas.
✅ A estruturar programas com funções
modulares e reutilizáveis.
As funções são o que mais aproxima o pensamento humano do
raciocínio lógico computacional: dividir para conquistar.
A partir de agora, você tem as ferramentas para criar programas profissionais, organizados e evolutivos.
Na próxima etapa, entraremos em outro pilar fundamental da linguagem: as estruturas de dados — onde aprenderemos a manipular listas, tuplas, conjuntos e dicionários, dominando a arte de armazenar e trabalhar com grandes volumes de informações.
.png)
.png)
Postar um comentário