Funções em Python: guia completo para concursos

Seja para as carreiras de Tecnologia da Informação ou para cargos que exigem Ciência de Dados, Python deixou de ser um diferencial para se tornar um requisito básico. É necessário conhecer diversos aspectos da linguagem. Funções lambda, o escopo de variáveis e a recursão estão entre os tópicos mais cobrados nas questões sobre Python nos concursos públicos mais recentes. 

Neste artigo, vamos abordar:

• O que são funções em Python e como criá-las com def
• Funções recursivas e a condição de parada
• Funções anônimas (lambda) e seus usos com filter(), map() e sorted()
• Escopo de variáveis: local, global e a regra LEGB
• Parâmetros padrão mutáveis: a pegadinha clássica das provas

Criando funções com def

Em Python, funções são criadas com a palavra reservada def, seguida do nome, dos parâmetros entre parênteses e de dois-pontos. O corpo da função é delimitado pela indentação — e não por chaves, como ocorre em C ou Java.

def saudacao(nome):
    return f”Olá, {nome}!”

print(saudacao(“Maria”))  # Olá, Maria!

Esse detalhe é frequentemente explorado pelas bancas. Parece trivial, mas já foi perguntado diretamente: “Em Python, qual instrução cria uma função?”, sendo a resposta correta o def. Confundir com function (do JavaScript) ou lambda (usado para funções anônimas) é o erro mais comum.

Funções recursivas

Uma função recursiva é aquela que chama a si mesma durante a execução. Para que o código não entre em loop infinito, toda função recursiva precisa de uma condição de parada — também chamada de caso base.

O exemplo mais clássico é o cálculo do fatorial:

def fatorial(n):
    if n == 0:       # condição de parada
        return 1

    return n * fatorial(n – 1)
print(fatorial(5))  # 120

Nas provas, é comum encontrar afirmações incorretas sobre o tema. Uma questão recente afirmou que “uma função recursiva tem uma função definida escrita dentro do corpo de outra função” — o que está errado. Recursão é quando a função chama a si mesma; funções aninhadas são um conceito distinto.

Funções lambda: a função anônima

As funções lambda permitem criar funções de uma única expressão, sem precisar nomeá-las. A sintaxe é:

lambda parâmetros: expressão

Exemplo direto:

soma = lambda x, y: x + y
print(soma(3, 5))  # 8

Não há explicitamente uma instrução de retorno, pois elas sempre retornam um valor. Lambdas são especialmente úteis como argumentos em funções de ordem superior (função que recebe outra função como parâmetro), e esse é exatamente o contexto que mais aparece nos concursos públicos.

Funções lambda com sorted()

notas = [{“aluno”: “Ana”, “nota”: 8}, {“aluno”: “João”, “nota”: 5}]
ordenadas = sorted(notas, key=lambda x: x[“nota”])
# Resultado: [{“aluno”: “João”, “nota”: 5}, {“aluno”: “Ana”, “nota”: 8}]

Aqui, a lambda define o critério de ordenação. Esse padrão é recorrente em questões recentes.

Funções lambda com filter()

aux = [10, 9, 8, 7, 6, 5, 6, 4, 3, 2, 1]
pares = list(filter(lambda x: x % 2 == 0, aux))
print(pares)  # [10, 8, 6, 6, 4, 2]

Uma questão apresentou exatamente esse trecho e exigia identificar a saída correta. O ponto de atenção: filter() retorna um objeto iterável — por isso, o list() é necessário para exibir o resultado como lista.

A armadilha da lista de lambdas

Veja este código cobrado em uma questão:

nums = [1, 2, 3]
res = [lambda n: n * 2 for n in nums]
print(res[0], res[1], res[2])

Nesse caso, res é uma lista de funções, não de valores. Imprimir res[0] sem chamá-la exibe o objeto função — e não o número 2. Para obter os valores calculados, seria necessário chamar cada função: res[0](1), res[1](2), res[2](3).

Escopo de variáveis

O escopo de uma variável determina onde ela pode ser acessada no código. Em Python, essa hierarquia segue a regra LEGB:

Escopo	Sigla	Descrição
Local	L	Dentro da função atual
Enclosing	E	Funções aninhadas externas
Global	G	Nível do módulo (arquivo)
Built-in	B	Funções nativas do Python

Uma variável declarada dentro de uma função é local por padrão e não pode ser acessada fora dela. Para modificar uma variável global de dentro de uma função, usa-se a palavra-chave global:

contador = 0

def incrementar():
    global contador
    contador += 1

incrementar()
print(contador)  # 1

Uma questão recente abordou esse ponto ao afirmar que “variáveis globais podem ser modificadas dentro de uma função através da palavra-chave global“ — o que é correto. O erro clássico nas provas é afirmar que variáveis locais podem ser acessadas fora da função, o que não é verdade.

Parâmetros padrão mutáveis: a pegadinha clássica

Este é, provavelmente, o comportamento mais inesperado de Python para quem está começando. Quando um parâmetro padrão é mutável — como uma lista —, ele é criado uma única vez e reutilizado em todas as chamadas seguintes.

def adicionar(item, lista=[]):
    lista.append(item)
    return lista

print(adicionar(“X”))    # [‘X’]
print(adicionar(“Y”))    # [‘X’, ‘Y’]  ← atenção!
print(adicionar(“Z”))    # [‘X’, ‘Y’, ‘Z’]  ← atenção!

A saída não é [‘X’], depois [‘Y’], depois [‘Z’]. A lista padrão é compartilhada entre as chamadas. 

A solução correta é usar None como padrão e criar a lista internamente:

def adicionar(item, lista=None):
    if lista is None:
        lista = []
    lista.append(item)

    return lista

Conclusão

Os tópicos de funções lambda Python, recursão, escopo e parâmetros padrão formam um conjunto coeso e com alto índice de cobrança nas provas de TI. Dominar a sintaxe do def e do lambda, entender a regra LEGB e reconhecer a armadilha dos parâmetros mutáveis são diferenciais importantes para acertar questões.

https://www.w3schools.com/python/python_functions.asp

https://cs.stanford.edu/people/nick/py/python-function.html

https://www.datacamp.com/tutorial/python-lambda-functions

Concursos Abertos

Concursos 2026