
Passo 1 de 6
Distinguir a função do resultado da chamada
Veja como um nome pode se referir à própria função — sem executá-la — e como os parênteses mudam essa ação.
Trilha de aprendizado · Nível 9 · Tutorial 1
Ao concluir, você será capaz de receber funções como parâmetros para variar o comportamento de uma operação e personalizar a ordenação de listas.
Distinguir a função do resultado da chamada
Veja como um nome pode se referir à própria função — sem executá-la — e como os parênteses mudam essa ação. 2 min
Receber uma função para variar o comportamento
Use uma função recebida como parâmetro para variar uma operação sem reescrever sua estrutura. 3 min
Fornecer os argumentos que a função espera
Verifique se a função recebida aceita exatamente a chamada que a função receptora fará. 3 min
Escolher entre sorted e list.sort
Compare as duas formas de ordenar listas e escolha a que preserva ou altera a lista original conforme o requisito. 3 min
Usar uma função nomeada como chave
Personalize a ordenação de tarefas com uma função nomeada passada para key. 4 min
Aplicação final: ordenar tarefas por critérios diferentes
Integre funções recebidas como critérios de ordenação e compare uma nova lista ordenada com a ordenação feita na própria lista. 4 min

Passo 1 de 6
Veja como um nome pode se referir à própria função — sem executá-la — e como os parênteses mudam essa ação.
Depois de definir uma função, seu nome representa a própria função. Portanto, ele pode ser atribuído a outro nome, assim como um número ou uma string.
Em mensagem = saudacao, não há parênteses: Python associa mensagem à função já criada. O corpo da função não é executado nesse momento.
A atribuição cria outra referência para a mesma função.

Sem parênteses, os dois nomes apontam para a função. Com parênteses, ocorre uma chamada.
Execute este código e observe as duas saídas.
def saudacao():
print("Executando o corpo")
return "Olá!"
mensagem = saudacao
print(mensagem)
print(mensagem())mensagem = saudacao associa outro nome à função, sem imprimir nada.
print(mensagem) mostra uma representação do objeto função, parecida com <function saudacao at ...>; o endereço varia.
Já mensagem() chama a função: primeiro ela imprime Executando o corpo e depois produz o retorno "Olá!", que o print externo exibe.
Dica
Use o nome sem () quando quiser se referir à função. Use () quando quiser executá-la e obter seu retorno.
Considere que saudacao já é uma função. Relacione cada expressão à sua ação.
Toque em um item e depois no par correspondente.
def dobrar(numero):
return numero * 2
calcular = dobrar
resultado = calcular(7)
print(resultado)Considerando o código, o que será exibido?

Passo 2 de 6
Use uma função recebida como parâmetro para variar uma operação sem reescrever sua estrutura.
Uma função pode receber outra função como argumento. Ela é chamada de função de alta ordem.
No exemplo, aplicar recebe operacao. Dentro de aplicar, o nome operacao passa a se referir à função que foi fornecida na chamada. Os parênteses em operacao(valor) são o que executam a função recebida.
def aplicar(operacao, valor):
resultado = operacao(valor)
return resultado
A receptora escolhe quando chamar a função recebida, qual valor enviar e o que devolver.
Ao chamar aplicar, passe o nome da função sem parênteses. Assim, dobrar ou formatar_preco é entregue como valor para operacao.
A mesma receptora funciona com as duas funções porque ela chama a função recebida usando o valor definido em seu próprio corpo.
def aplicar(operacao, valor):
return operacao(valor)
def dobrar(numero):
return numero * 2
def formatar_preco(numero):
return f"R$ {numero:.2f}"
print(aplicar(dobrar, 8))
print(aplicar(formatar_preco, 8))Exemplo
aplicar(dobrar, 8) devolve 16.
aplicar(formatar_preco, 8) devolve 'R$ 8.00'.
O corpo de aplicar não mudou. O comportamento mudou porque a função fornecida mudou.
Complete o corpo para executar a função recebida com valor e devolver seu resultado:
def transformar(acao, valor):
return ______Considere:
def aplicar(operacao, valor):
return operacao(valor)
def mensagem(nome):
return f"Olá, {nome}!"
resultado = aplicar(mensagem, "Ana")Qual é o valor de resultado?

Passo 3 de 6
Verifique se a função recebida aceita exatamente a chamada que a função receptora fará.
Passar uma função como valor é apenas o primeiro passo. A função receptora também precisa chamá-la de uma forma que ela aceite.
Observe a expressão de chamada dentro da receptora: ela define quantos argumentos serão enviados e se eles serão posicionais ou nomeados. A função recebida precisa ser compatível com essa expressão.
Compare a chamada feita por aplicar com os parâmetros de cada função possível.

A compatibilidade depende da chamada que a receptora realmente executa.
A receptora sempre chama operacao com numero e percentual.
def aplicar(numero, percentual, operacao):
return operacao(numero, percentual)
def aumentar(valor, percentual):
return valor * (1 + percentual / 100)
resultado = aplicar(200, 10, aumentar)
print(resultado) # 220.0Nesta versão, aplicar continua enviando dois argumentos. Porém, dobrar aceita somente um parâmetro. O erro só acontece quando aplicar tenta executar operacao(numero, percentual).
def aplicar(numero, percentual, operacao):
return operacao(numero, percentual)
def dobrar(valor):
return valor * 2
resultado = aplicar(200, 10, dobrar)
# TypeError: dobrar() takes 1 positional argument but 2 were givenAtenção
aplicar(200, 10, dobrar) pode receber a função dobrar como valor. Isso não garante que dobrar aceite os argumentos usados depois pela receptora. Leia a chamada interna para encontrar a causa do TypeError.
Se a receptora usa argumentos nomeados, os nomes da chamada precisam corresponder aos parâmetros da função fornecida. Além disso, os valores necessários precisam estar disponíveis na receptora para serem encaminhados.
calcular_desconto usa os mesmos nomes escolhidos pela chamada interna.
def aplicar_desconto(preco, taxa, operacao):
return operacao(valor=preco, percentual=taxa)
def calcular_desconto(valor, percentual):
return valor * (1 - percentual / 100)
print(aplicar_desconto(80, 25, calcular_desconto)) # 60.0Exemplo
Se a função fosse definida como def calcular_desconto(preco, percentual):, a chamada operacao(valor=preco, percentual=taxa) falharia: valor não é um nome de parâmetro aceito. Uma correção simples é mudar o parâmetro para valor ou chamar a operação com preco=preco.
Considere:
def executar(mensagem, acao):
return acao(mensagem)Qual função pode ser passada como acao sem alterar executar?
Analise o código:
def usar(valor, funcao):
return funcao(valor)
def adicionar(numero, incremento):
return numero + incrementoExplique por que usar(10, adicionar) falha e descreva uma correção simples. Não use recursos de adaptação automática.
Escreva pelo menos 40 caracteres (0/40).

Passo 4 de 6
Compare as duas formas de ordenar listas e escolha a que preserva ou altera a lista original conforme o requisito.
Python oferece duas formas comuns de ordenar uma lista. A escolha depende do que deve acontecer com a lista que você já tem:
sorted(lista) cria e devolve uma nova lista em ordem crescente. A lista original continua como estava.lista.sort() reorganiza a própria lista em ordem crescente e devolve None.Portanto, use sorted quando precisar manter a ordem original disponível. Use sort quando a própria lista deve passar a ficar ordenada.
Observe que os mesmos valores levam a resultados diferentes quanto à lista original e ao retorno.
![Diagrama comparando sorted e list.sort: uma lista inicial [8, 3, 5]; sorted gera uma nova lista [3, 5, 8] e preserva a inicial; list.sort transforma a lista inicial em [3, 5, 8] e retorna None.](https://cursa-json-routes.s3.amazonaws.com/learning-paths/pt/python/b730454e0225/level-09/tutorial-01/step-04/screen-01/item-02.webp)
sorted devolve outra lista; list.sort muda a lista usada na chamada e devolve None.
Execute este código no seu editor para confirmar os valores impressos.
numeros = [8, 3, 5]
ordenados = sorted(numeros)
print(numeros) # [8, 3, 5]
print(ordenados) # [3, 5, 8]
outros_numeros = [8, 3, 5]
retorno = outros_numeros.sort()
print(outros_numeros) # [3, 5, 8]
print(retorno) # NoneExemplo
Não atribua o retorno de sort() esperando receber uma lista:
nomes = ["Bia", "Ana", "Caio"]
ordenados = nomes.sort()
print(ordenados) # None
print(nomes) # ['Ana', 'Bia', 'Caio']A lista ordenada está em nomes, pois foi ela que sort() alterou.
Dica
Se precisar usar tanto a ordem de entrada quanto a ordem ordenada, escolha sorted. Se não precisar preservar a ordem anterior e quer atualizar a mesma lista, escolha sort.
Por padrão, as duas operações ordenam em ordem crescente. Para inverter a direção, passe o argumento nomeado reverse=True.
Esse argumento não muda a diferença principal: sorted continua devolvendo uma nova lista, enquanto sort continua alterando a lista existente.
Compare o resultado e o estado das listas.
pontuacoes = [12, 30, 18]
ranking = sorted(pontuacoes, reverse=True)
print(pontuacoes) # [12, 30, 18]
print(ranking) # [30, 18, 12]
tentativas = [12, 30, 18]
tentativas.sort(reverse=True)
print(tentativas) # [30, 18, 12]Você recebeu a lista registros e precisa exibir uma versão em ordem decrescente, mas depois ainda usará registros exatamente na ordem em que foi recebida. Qual expressão atende ao requisito?

Passo 5 de 6
Personalize a ordenação de tarefas com uma função nomeada passada para key.
Em key, passe a função, sem parênteses. Durante a ordenação, Python chama essa função uma vez para cada elemento e usa o retorno para decidir a posição.
A função de chave recebe um elemento por vez; ela não compara dois elementos diretamente.
Cada dicionário continua inteiro. Apenas o valor retornado pela função é usado como chave de comparação.

As durações determinam a ordem; os dicionários de tarefa são preservados no resultado.
Dica
O retorno da função de chave precisa poder ser comparado com os demais retornos. Por exemplo, durações numéricas podem ser ordenadas entre si.
Execute este código no seu editor para observar os registros completos em uma nova lista.
tarefas = [
{"titulo": "Enviar relatório", "duracao": 45},
{"titulo": "Responder e-mails", "duracao": 15},
{"titulo": "Revisar orçamento", "duracao": 30},
]
def duracao(tarefa):
return tarefa["duracao"]
por_duracao = sorted(tarefas, key=duracao)
por_duracao_decrescente = sorted(tarefas, key=duracao, reverse=True)
print(por_duracao)
print(por_duracao_decrescente)
print(tarefas)Exemplo
duracao recebe, em chamadas separadas, cada dicionário da lista e devolve 45, 15 ou 30. Em por_duracao, a ordem dos títulos é: Responder e-mails, Revisar orçamento, Enviar relatório.
Os itens de por_duracao ainda são dicionários completos. Como foi usado sorted, tarefas mantém a ordem inicial. Para alterar a própria lista, use tarefas.sort(key=duracao, reverse=True); o método retorna None.
Complete a chamada para ordenar uma nova lista pela duração:
ordenadas = sorted(tarefas, key=_____)
Considere o código:
tarefas = [
{"titulo": "Preparar apresentação", "prioridade": 3},
{"titulo": "Planejar reunião", "prioridade": 1},
{"titulo": "Corrigir relatório", "prioridade": 2},
]
def prioridade(tarefa):
return tarefa["prioridade"]
ordenadas = sorted(tarefas, key=prioridade)Qual será a ordem dos títulos em ordenadas? Por que o resultado contém dicionários completos, em vez de somente 1, 2 e 3?
Escreva pelo menos 40 caracteres (0/40).

Passo 6 de 6
Integre funções recebidas como critérios de ordenação e compare uma nova lista ordenada com a ordenação feita na própria lista.
A função ordenar_tarefas recebe três valores: a lista, a função que define o critério e a direção da ordem. Ela encaminha criterio para key sem parênteses, pois sorted é quem chamará essa função uma vez para cada tarefa.
As funções por_titulo e por_duracao recebem uma tarefa e devolvem, respectivamente, o título ou a duração. Trocar apenas a função fornecida muda o critério sem alterar ordenar_tarefas.

A função de critério extrai valores para comparação; o resultado continua contendo os dicionários completos.
Crie um arquivo Python com este código e execute-o no seu computador.
def por_titulo(tarefa):
return tarefa["titulo"]
def por_duracao(tarefa):
return tarefa["duracao"]
def ordenar_tarefas(tarefas, criterio, decrescente=False):
return sorted(tarefas, key=criterio, reverse=decrescente)
tarefas = [
{"titulo": "Revisar relatório", "duracao": 45},
{"titulo": "Enviar e-mail", "duracao": 10},
{"titulo": "Planejar reunião", "duracao": 30},
]
por_nome = ordenar_tarefas(tarefas, por_titulo)
por_tempo = ordenar_tarefas(tarefas, por_duracao, decrescente=True)
assert [tarefa["titulo"] for tarefa in por_nome] == [
"Enviar e-mail",
"Planejar reunião",
"Revisar relatório",
]
assert [tarefa["duracao"] for tarefa in por_tempo] == [45, 30, 10]
assert tarefas[0]["titulo"] == "Revisar relatório"
print("Por título:", por_nome)
print("Por duração decrescente:", por_tempo)
print("Lista original:", tarefas)A função acima usa sorted, portanto cria e devolve uma lista nova. A variável tarefas continua na ordem em que foi criada.
Se o requisito for reordenar a própria lista, use list.sort. Nesse caso, a chamada altera a lista e o retorno é None. Não atribua o retorno de .sort() a uma variável esperando receber uma lista.
Acrescente este trecho após o código anterior. A cópia permite comparar os dois efeitos sem perder a lista original.
tarefas_para_atualizar = tarefas.copy()
retorno = tarefas_para_atualizar.sort(key=por_duracao, reverse=True)
assert retorno is None
assert [tarefa["duracao"] for tarefa in tarefas_para_atualizar] == [45, 30, 10]
assert tarefas[0]["titulo"] == "Revisar relatório"
print("Retorno de sort:", retorno)
print("Lista atualizada:", tarefas_para_atualizar)
print("Original preservada:", tarefas)Dica
Use sorted(...) quando precisa preservar a ordem da lista recebida e obter outra lista. Use .sort(...) quando é desejável atualizar a lista existente. Nas duas formas, passe por_titulo ou por_duracao para key sem ().
No seu computador, execute os dois trechos. Depois, relate:
ordenar_tarefas em ordem decrescente..sort() e o estado de tarefas_para_atualizar.por_duracao foi passada sem parênteses e por quê.Escreva pelo menos 180 caracteres (0/180).
Resumo
key=criterio, a função é passada sem parênteses; a ordenação a chama para cada elemento.sorted devolve uma nova lista; list.sort altera a lista existente e devolve None.Parabéns! Você concluiu: Passar funções como argumentos
Milhares de cursos online em vídeo, ebooks e áudiobooks.
Para testar seus conhecimentos no decorrer dos cursos online
Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail
Baixe nosso aplicativo pelo QR Code ou pelos links abaixo:.
+ de 10 milhões
de alunos
Certificado grátis e
válido em todo o Brasil
60 mil exercícios
gratuitos
4,8/5 classificação
nas lojas de apps
Cursos gratuitos em
vídeo, ebooks e audiobooks