Python do Zero: funções — def, return e escopo
Organize seu código em blocos reutilizáveis com funções em Python.
O que são funções e por que usar
Uma função é um bloco de código que executa uma tarefa específica e pode ser reutilizado quantas vezes você quiser. Em vez de repetir as mesmas linhas em vários lugares do programa, você agrupa tudo dentro de uma função e simplesmente a chama pelo nome.
As principais vantagens de usar funções são:
- Reutilização: escreva uma vez, use quantas vezes precisar.
- Organização: seu código fica dividido em blocos com responsabilidades claras.
- Manutenção: se precisar corrigir algo, você altera em um único lugar.
Criando funções com def
Para criar uma função em Python, usamos a palavra-chave def, seguida do nome da função e parênteses:
def saudacao():
print("Ola, seja bem-vindo!")
# Chamando a funcao
saudacao()
saudacao()
Repare que o código dentro da função só é executado quando a chamamos. Você pode chamá-la quantas vezes quiser.
Parâmetros e argumentos
Funções ficam muito mais úteis quando recebem dados de entrada. Esses dados são chamados de parâmetros (na definição) e argumentos (na chamada):
def saudacao_pessoal(nome):
print(f"Ola, {nome}! Tudo bem?")
saudacao_pessoal("Ana")
saudacao_pessoal("Carlos")
Você pode ter quantos parâmetros precisar, separados por vírgula:
def soma(a, b):
resultado = a + b
print(f"{a} + {b} = {resultado}")
soma(3, 7)
soma(10, 20)
return vs print
Muitos iniciantes confundem print com return. O print apenas exibe algo na tela; o return devolve um valor para quem chamou a função, permitindo que você use esse valor depois:
def dobro_print(n):
print(n * 2) # so exibe, nao retorna nada
def dobro_return(n):
return n * 2 # devolve o valor
# Com print, nao da pra usar o resultado
resultado1 = dobro_print(5) # exibe 10
print(resultado1) # None
# Com return, voce pode armazenar e reutilizar
resultado2 = dobro_return(5)
print(resultado2) # 10
print(resultado2 + 3) # 13
Sempre que a função precisar produzir um valor que será usado em outra parte do código, prefira return.
Valores padrão em parâmetros
Você pode definir valores padrão para parâmetros. Assim, se o argumento não for passado na chamada, o valor padrão será utilizado:
def apresentar(nome, linguagem="Python"):
print(f"{nome} esta aprendendo {linguagem}")
apresentar("Julia") # Julia esta aprendendo Python
apresentar("Pedro", "JavaScript") # Pedro esta aprendendo JavaScript
Um detalhe importante: parâmetros com valor padrão devem vir depois dos parâmetros obrigatórios.
args e *kwargs
Às vezes você não sabe quantos argumentos a função vai receber. Para isso, Python oferece *args e **kwargs.
O *args recebe múltiplos argumentos posicionais como uma tupla:
def somar_tudo(*args):
total = 0
for numero in args:
total += numero
return total
print(somar_tudo(1, 2, 3)) # 6
print(somar_tudo(10, 20, 30, 40)) # 100
O **kwargs recebe argumentos nomeados como um dicionário:
def ficha_cadastro(**kwargs):
for chave, valor in kwargs.items():
print(f"{chave}: {valor}")
ficha_cadastro(nome="Ana", idade=28, cidade="Curitiba")
Você pode combinar os dois na mesma função, sempre nesta ordem: parâmetros normais, *args, **kwargs.
Escopo de variáveis
O escopo determina onde uma variável pode ser acessada. Uma variável criada dentro de uma função existe apenas ali — é o chamado escopo local. Uma variável criada fora de qualquer função tem escopo global:
mensagem = "Eu sou global"
def mostrar():
mensagem_local = "Eu sou local"
print(mensagem) # funciona: acessa a global
print(mensagem_local) # funciona: acessa a local
mostrar()
# print(mensagem_local) # ERRO: variavel local nao existe aqui fora
Se você criar uma variável com o mesmo nome dentro da função, ela será uma variável nova, diferente da global:
contador = 0
def incrementar():
contador = 10 # cria uma variavel LOCAL, nao altera a global
print(f"Dentro: {contador}")
incrementar()
print(f"Fora: {contador}") # continua 0
Para modificar a variável global de dentro da função, use global — mas evite isso sempre que possível, pois dificulta a manutenção do código.
Funções como objetos
Em Python, funções são objetos de primeira classe. Isso significa que você pode armazená-las em variáveis, colocá-las em listas e até passá-las como argumento para outras funções:
def aplicar(funcao, valor):
return funcao(valor)
def quadrado(n):
return n ** 2
def cubo(n):
return n ** 3
print(aplicar(quadrado, 4)) # 16
print(aplicar(cubo, 3)) # 27
Esse padrão é muito utilizado em Python, especialmente com funções como map, filter e sorted.
Exemplo prático: validador de senha
Vamos juntar tudo o que aprendemos em um exemplo real — um validador de senha com regras configuráveis:
def tem_tamanho_minimo(senha, minimo=8):
return len(senha) >= minimo
def tem_numero(senha):
for caractere in senha:
if caractere.isdigit():
return True
return False
def tem_letra_maiuscula(senha):
for caractere in senha:
if caractere.isupper():
return True
return False
def validar_senha(senha, *regras):
erros = []
for regra in regras:
if not regra(senha):
erros.append(regra.__name__)
return erros
# Definindo as regras e testando
senha_teste = "abc123"
problemas = validar_senha(
senha_teste,
tem_tamanho_minimo,
tem_numero,
tem_letra_maiuscula,
)
if not problemas:
print("Senha valida!")
else:
print(f"Senha invalida. Falhou em: {problemas}")
# Senha invalida. Falhou em: ['tem_tamanho_minimo', 'tem_letra_maiuscula']
Nesse exemplo usamos várias técnicas: funções com return, valores padrão, *args, e funções passadas como argumento. Cada regra de validação é uma função independente, o que facilita adicionar ou remover regras sem mexer no validador principal.
Resumo
Funções são a base para escrever código limpo e organizado em Python. Neste artigo você aprendeu a:
- Criar funções com
def - Usar parâmetros, argumentos e valores padrão
- Diferenciar
returndeprint - Trabalhar com
*argse**kwargs - Entender escopo local e global
- Passar funções como argumento
No próximo artigo da série, vamos explorar estruturas de dados em Python: listas, tuplas, dicionários e conjuntos. Até lá, pratique criando suas próprias funções!