Funções, Fechamentos e Lambda
Defina funções auxiliares reutilizáveis, use argumentos padrão e aplique expressões lambda à ordenação e a padrões funcionais em problemas de entrevistas.
Funções, Fechamentos e Lambda é uma aula grátis de Coding Interview Prep no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Coding Interview Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Coding Interview Prep inclui 4 aulas no total.
Definindo funções no Python
As funções são elementos de primeira classe no Python: você pode passá-las como valores, retorná-las e armazená-las. Funções auxiliares com bons nomes tornam o código de entrevistas legível. Trate primeiro os casos extremos.
def is_palindrome(s: str) -> bool:
'''Return True if s reads the same forwards and backwards.'''
s = s.lower()
return s == s[::-1]
print(is_palindrome('Racecar')) # True
print(is_palindrome('hello')) # False
# Functions as values
checks = [is_palindrome]
print(checks[0]('level')) # TrueArgumentos padrão e nomeados
Valores padrão permitem que quem chama a função omita argumentos. Mas nunca use um valor padrão mutável, como uma lista — todas as chamadas o compartilham. A solução é usar None como padrão e criar a lista dentro da função. Consulte o código.
# WRONG: shared mutable default
def bad_append(val, lst=[]):
lst.append(val)
return lst
print(bad_append(1)) # [1]
print(bad_append(2)) # [1, 2] surprise!
# CORRECT: use None sentinel
def good_append(val, lst=None):
if lst is None:
lst = []
lst.append(val)
return lst
print(good_append(1)) # [1]
print(good_append(2)) # [2]*args e **kwargs
*args reúne argumentos posicionais extras em uma tupla; **kwargs reúne argumentos nomeados extras em um dicionário. O * também desempacota uma sequência quando você chama uma função.
def total(*args):
return sum(args)
print(total(1, 2, 3)) # 6
print(total(1, 2, 3, 4)) # 10
# Unpack a list as positional args
point = [3, 7]
print(max(*point)) # 7
# **kwargs
def greet(**kwargs):
name = kwargs.get('name', 'World')
return f'Hello, {name}!'
print(greet(name='Alice')) # Hello, Alice!Expressões lambda
Uma lambda é uma função pequena de uma linha: lambda params: expression. É perfeita como uma key rápida em sorted ou max. Para algo maior, um def nomeado é mais claro.
# Lambda as sort key
pairs = [(1, 3), (2, 1), (3, 2)]
sorted_by_second = sorted(pairs, key=lambda p: p[1])
print(sorted_by_second) # [(2,1),(3,2),(1,3)]
# Lambda with map
double = list(map(lambda n: n * 2, [1, 2, 3]))
print(double) # [2, 4, 6]
# Named function is clearer for complex logic
def sort_key(p):
return (p[1], -p[0]) # secondary sort
print(sorted(pairs, key=sort_key))Funções aninhadas e fechamentos
Um fechamento é uma função que se lembra das variáveis da função que a envolve. Defina uma função auxiliar dentro de outra função, e ela poderá usar as variáveis externas — algo útil para DFS.
def make_counter(start=0):
count = [start] # list to allow mutation
def increment():
count[0] += 1
return count[0]
return increment
counter = make_counter()
print(counter()) # 1
print(counter()) # 2
# Alternative: nonlocal keyword
def make_counter2():
count = 0
def increment():
nonlocal count
count += 1
return count
return incrementFechamentos em DFS recursivo
Um padrão comum: defina uma função auxiliar dfs dentro da função principal e permita que ela acumule resultados em uma variável externa. A função interna é um fechamento sobre esse escopo.
def max_depth(root):
'''Closure pattern for tree DFS.'''
max_d = [0] # mutable container for closure
def dfs(node, depth):
if node is None:
return
max_d[0] = max(max_d[0], depth)
dfs(node.left, depth + 1)
dfs(node.right, depth + 1)
dfs(root, 1)
return max_d[0]
# This pattern avoids a class or global state.functools.lru_cache para memoização
lru_cache (ou @cache a partir da versão 3.9) memoriza os resultados de uma função com base em seus argumentos, transformando o Fibonacci ingênuo de O(2^n) em O(n). Os argumentos precisam ser hasheáveis, portanto use tuplas.
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
print(fib(40)) # 102334155 fast!
print(fib.cache_info()) # hits, misses, sizeFunções de ordem superior
Uma função de ordem superior recebe ou retorna uma função. sorted, map e filter se enquadram nessa categoria. Escrever suas próprias funções permite abstrair padrões repetidos. O código mostra composição.
def apply_twice(f, x):
return f(f(x))
print(apply_twice(lambda n: n * 2, 3)) # 12 (3*2*2)
# Composing transformations
def compose(f, g):
return lambda x: f(g(x))
double = lambda n: n * 2
add_one = lambda n: n + 1
double_then_add = compose(add_one, double)
print(double_then_add(5)) # 11 ((5*2)+1)Recursão com funções auxiliares
Muitas soluções combinam uma função externa, que cuida da preparação e dos casos extremos, com uma função auxiliar interna, que executa a recursão. API pública organizada e lógica isolada. Consulte o código.
def flatten(nested):
'''Flatten an arbitrarily nested list.'''
result = []
def _flatten(lst):
for item in lst:
if isinstance(item, list):
_flatten(item)
else:
result.append(item)
_flatten(nested)
return result
print(flatten([1, [2, [3, 4], 5], 6]))
# [1, 2, 3, 4, 5, 6]Funções parciais com functools.partial
functools.partial preenche alguns argumentos antecipadamente e devolve um novo objeto chamável. É útil quando uma API exige uma função sem argumentos, mas você precisa fixar um parâmetro.
from functools import partial
def power(base, exp):
return base ** exp
square = partial(power, exp=2)
cube = partial(power, exp=3)
print(square(5)) # 25
print(cube(3)) # 27
print(list(map(square, [1, 2, 3, 4]))) # [1, 4, 9, 16]Lambda para comparadores personalizados
O Python 3 removeu os comparadores de dois argumentos, mas cmp_to_key permite usá-los novamente em ordenações complexas — como organizar números para que sua concatenação seja a maior possível. Consulte o código.
from functools import cmp_to_key
def largest_number(nums):
def compare(a, b):
if a + b > b + a: return -1
if a + b < b + a: return 1
return 0
strs = list(map(str, nums))
strs.sort(key=cmp_to_key(compare))
result = ''.join(strs)
return '0' if result[0] == '0' else result
print(largest_number([3, 30, 34, 5, 9])) # '9534330'Verificação rápida
Verificação rápida — é hora de mostrar o que você aprendeu sobre funções, fechamentos e lambdas. Respire fundo e comece. 🚀
Recapitulação da lição
Recapitulação: nunca use valores padrão mutáveis (use None), os fechamentos permitem que funções auxiliares internas alcancem variáveis externas para DFS, e ferramentas de functools como lru_cache possibilitam soluções rápidas.
Perguntas Frequentes
A aula “Funções, Fechamentos e Lambda” é grátis?
Sim — o texto completo de “Funções, Fechamentos e Lambda” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Coding Interview Prep, atualize para CoddyKit PRO. O curso de Coding Interview Prep inclui 4 aulas no total.
O que vou aprender em “Funções, Fechamentos e Lambda”?
Defina funções auxiliares reutilizáveis, use argumentos padrão e aplique expressões lambda à ordenação e a padrões funcionais em problemas de entrevistas. Você pratica Coding Interview Prep com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Coding Interview Prep?
Nenhuma experiência prévia é necessária. Coding Interview Prep no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Funções, Fechamentos e Lambda”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Coding Interview Prep?
Sim. Cada aula de Coding Interview Prep inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Listas, Tuplas e Fatiamento
- Dicionários e Conjuntos em Python
- Compreensões e Funções Integradas
- Funções, Fechamentos e Lambda