Python Funções (def)

Você já usou várias funções sem perceber: print(), input(), len(), type(). Cada uma é um pedaço de código que alguém escreveu, deu um nome e deixou pronto para usar. Nesta aula você vai fazer o mesmo: criar os seus próprios comandos. Você junta algumas linhas, dá um nome a elas, e depois basta escrever esse nome para que todas rodem de novo, quantas vezes quiser.

Você vai aprender

O que é uma função, com a comparação da receita de bolo.
A criar uma função com def, e o que é cada parte da primeira linha.
A diferença entre definir e chamar uma função (definir não roda nada).
Em que ordem o Python executa um programa que tem funções.
Uma função chamando outra, e o pass para a função que ainda vai ser escrita.
Os erros reais: esquecer os parênteses, chamar antes de definir, esquecer os dois-pontos ou a indentação.

A ideia: uma receita com nome

A Ana anotou no caderno a receita do bolo de milho da avó. Escrever a receita não faz bolo nenhum: é só uma lista de passos guardada com um título, "Bolo de milho". O bolo só aparece quando alguém pega o caderno e segue a receita. E a mesma receita serve para fazer um bolo hoje, outro no sábado, outro no aniversário: ninguém reescreve os passos a cada vez.

Uma função é isso: um grupo de linhas de código guardado com um nome. São dois momentos diferentes:

Na cozinha	No Python	O que acontece
Escrever a receita no caderno	Definir a função, com `def`	O Python guarda os passos com um nome. Nada é executado ainda
Fazer o bolo seguindo a receita	Chamar a função: `nome()`	O Python executa os passos guardados, um por um

"Função", em programação, não tem a ver com a função da matemática da escola (aquela do f(x)), pelo menos por enquanto: pense nela como uma receita com nome.

1. Definindo a primeira função

Toda manhã, o programa da Ana mostra duas mensagens. Vamos guardá-las numa função chamada bom_dia:

def bom_dia():
    print("Bom dia, Ana!")
    print("O café está pronto.")

def: Abreviação de define ("definir"). Avisa ao Python: "vou criar uma função".
bom_dia: O nome da função, escolhido por você. Segue as mesmas regras dos nomes de variáveis (aula Nomes de Variáveis): letras minúsculas, palavras separadas por _, sem espaços.
(): Os parênteses são obrigatórios, mesmo vazios. Mais adiante, eles vão guardar as informações que a função recebe (aula Parâmetros e Argumentos).
:: Os dois-pontos encerram a primeira linha, como no if e no for: "agora vem o bloco".
as linhas recuadas: O corpo da função: os passos da receita. Todas as linhas com 4 espaços a mais pertencem à função (aula Sintaxe e Indentação). A primeira linha sem esse recuo já está fora dela.

Agora rode o programa:

$ python3 so_definir.py
$                                                  « nenhuma linha de saída

Não apareceu nada. E está certo: o programa só definiu a função. É a receita escrita no caderno. O Python leu as linhas, guardou-as com o nome bom_dia, chegou ao fim do arquivo e terminou. Ninguém pediu o bolo.

2. Chamando a função

Para executar os passos guardados, você chama a função: escreve o nome dela seguido de parênteses, na margem esquerda, fora do bloco do def.

def bom_dia():
    print("Bom dia, Ana!")
    print("O café está pronto.")


bom_dia()

$ python3 bom_dia.py
Bom dia, Ana!
O café está pronto.

bom_dia: O nome da função que você quer executar.
(): Os parênteses são o "faça agora!". Sem eles, o Python não executa nada (você vai ver isso em Quando dá errado). É o mesmo jeito de chamar o print(): nome e parênteses.

Duas linhas em branco

Repare nas duas linhas em branco entre o fim da função e a chamada. O Python não exige, mas é o costume da comunidade (o guia de estilo PEP 8, aula Estilo de Código): elas deixam claro, de longe, onde a função termina.

Uma receita, vários bolos

A vantagem aparece quando você chama a função mais de uma vez. Cada chamada executa o corpo inteiro de novo:

def bom_dia():
    print("Bom dia, Ana!")
    print("O café está pronto.")


bom_dia()
bom_dia()
bom_dia()

$ python3 tres_vezes.py
Bom dia, Ana!
O café está pronto.
Bom dia, Ana!
O café está pronto.
Bom dia, Ana!
O café está pronto.

Três chamadas, seis linhas de saída: duas linhas por chamada.

Missão: crie uma função chamada despedida que mostre Até amanhã!. Depois, chame-a duas vezes. (A função bom_dia está aí de modelo.)

def bom_dia():
    print("Bom dia, Ana!")


bom_dia()

def bom_dia():
    print("Bom dia, Ana!")


def despedida():
    print("Até amanhã!")


bom_dia()
despedida()
despedida()

3. Em que ordem o programa roda

Quem está começando costuma achar que o Python executa tudo de cima para baixo, inclusive o que está dentro do def. Os números nas mensagens abaixo mostram a ordem de verdade:

print("1. Começou o programa")


def bom_dia():
    print("3. Dentro da função")


print("2. A função foi definida, mas ainda não rodou")
bom_dia()
print("4. A função terminou, o programa continua")

$ python3 ordem.py
1. Começou o programa
2. A função foi definida, mas ainda não rodou
3. Dentro da função
4. A função terminou, o programa continua

O Python executa a linha 1 e mostra a mensagem 1.
Encontra o def: guarda o corpo da função com o nome bom_dia e pula para depois dele, sem executar o print de dentro.
Mostra a mensagem 2.
Encontra a chamada bom_dia(): entra na função e executa o corpo dela (mensagem 3).
Quando o corpo acaba, volta para a linha logo depois da chamada e mostra a mensagem 4.

É como a Ana cozinhando: ela está arrumando a cozinha, para, abre o caderno, faz o bolo seguindo a receita e, quando acaba, volta a arrumar a cozinha de onde parou.

4. Para que serve: escrever uma vez, mudar num lugar só

A padaria do bairro imprime um cabeçalho em cada nota. Sem função, as cinco linhas do cabeçalho apareceriam repetidas no programa a cada nota. Com uma função:

def cabecalho():
    print("=" * 30)
    print("   PADARIA PÃO QUENTE")
    print("   Rua das Flores, 120")
    print("=" * 30)


cabecalho()
print("Pão francês  x10   R$ 8,00")
print("Leite        x1    R$ 5,50")
print()
cabecalho()
print("Bolo de milho x1   R$ 18,00")

$ python3 padaria.py
==============================
   PADARIA PÃO QUENTE
   Rua das Flores, 120
==============================
Pão francês  x10   R$ 8,00
Leite        x1    R$ 5,50

==============================
   PADARIA PÃO QUENTE
   Rua das Flores, 120
==============================
Bolo de milho x1   R$ 18,00

(O "=" * 30 repete o sinal de igual 30 vezes, como na aula Juntar e Repetir Textos; o print() vazio pula uma linha.)

No dia em que a padaria mudar de endereço, a Ana corrige uma linha, dentro da função, e todas as notas saem certas. Com o cabeçalho copiado e colado, ela teria de achar e corrigir cada cópia, e bastaria esquecer uma para uma nota sair com o endereço velho.

Vantagem	Por quê
Não repetir código	Os passos são escritos uma vez e usados quantas vezes for preciso
Mudar num lugar só	Corrigir a função corrige todas as chamadas
Dar nome às coisas	`cabecalho()` diz o que acontece; cinco `print` soltos, não
Dividir um problema grande	Um programa grande vira várias funções pequenas, cada uma com uma tarefa

5. Uma função chamando outra

Dentro do corpo de uma função você pode escrever qualquer coisa que escreveria fora dela, inclusive a chamada de outra função:

def linha():
    print("-" * 20)


def aviso():
    linha()
    print("Loja fechada às 18h")
    linha()


aviso()

$ python3 aviso.py
--------------------
Loja fechada às 18h
--------------------

O programa chama aviso(); o aviso chama linha(), que mostra os tracinhos e volta; o aviso mostra a mensagem; chama linha() de novo; e termina. Cada chamada volta exatamente para o ponto de onde saiu.

6. A função que ainda vai ser escrita: `pass`

Às vezes você já sabe o nome da função, mas ainda não escreveu o corpo. Um corpo só com um comentário não vale: o Python ignora os comentários, então para ele o corpo está vazio, e isso é erro (veja em Quando dá errado). Para isso existe o pass (em inglês, "passar"), um comando que não faz nada:

def relatorio():
    pass  # ainda vou escrever


relatorio()
print("Fim")

$ python3 rascunho.py
Fim

A chamada relatorio() funcionou e não mostrou nada, porque o corpo só tem o pass. É um lugar reservado: depois a Ana troca o pass pelas linhas de verdade.

Formas diferentes de repetir as mesmas linhas

As três versões abaixo mostram "Bom dia, Ana!" três vezes:

print("Bom dia, Ana!")
print("Bom dia, Ana!")
print("Bom dia, Ana!")

for vez in range(3):
    print("Bom dia, Ana!")

def bom_dia():
    print("Bom dia, Ana!")


bom_dia()
bom_dia()
bom_dia()

As três dão a mesma saída:

$ python3 forma1.py
Bom dia, Ana!
Bom dia, Ana!
Bom dia, Ana!
$ python3 forma2.py
Bom dia, Ana!
Bom dia, Ana!
Bom dia, Ana!
$ python3 forma3.py
Bom dia, Ana!
Bom dia, Ana!
Bom dia, Ana!

Forma	Quando usar
Copiar e colar as linhas	Só quando é uma linha curta, usada uma ou duas vezes. Cada cópia é mais um lugar para corrigir depois
Um laço (`for`, aula for)	Quando as repetições vêm seguidas, uma atrás da outra
Uma função (`def`)	Quando o mesmo grupo de linhas aparece em lugares diferentes do programa (o cabeçalho antes de cada nota), ou quando dar um nome deixa o programa mais claro

Laço e função se combinam: dá para chamar uma função dentro de um for, e escrever um for dentro de uma função.

Quando dá errado

Esquecer os parênteses na chamada: nada acontece

def bom_dia():
    print("Bom dia, Ana!")


bom_dia
print("Fim do programa")

$ python3 sem_parenteses.py
Fim do programa

Nenhum erro, e nenhum "Bom dia". Sem parênteses, bom_dia é só o nome da função, como apontar para a receita no caderno sem cozinhar. O Python olhou para ela e seguiu em frente. É o erro mais traiçoeiro desta aula, justamente porque não reclama.

No modo interativo (aula O Modo Interativo) dá para ver o que o nome sozinho é:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def bom_dia():
...     print("Bom dia, Ana!")
...
>>> bom_dia
<function bom_dia at 0x7f6a39ecb530>
>>> bom_dia()
Bom dia, Ana!
>>> type(bom_dia)
<class 'function'>
>>> exit()

Sem parênteses, o Python responde <function bom_dia at 0x7f6a39ecb530>: "isto é a função bom_dia, guardada no endereço 0x7f6a… da memória". Com parênteses, ele executa. E type(bom_dia) confirma: uma função também é um valor, do tipo function.

O mesmo texto aparece quando alguém escreve print(bom_dia) em vez de bom_dia(). O endereço é diferente a cada execução, porque o Python guarda a função num lugar diferente da memória cada vez:

def bom_dia():
    print("Bom dia, Ana!")


print(bom_dia)

$ python3 mostrar_funcao.py
<function bom_dia at 0x7f890c12b530>
$ python3 mostrar_funcao.py
<function bom_dia at 0x7f434c70b530>

(No editor do guia, que roda o Python no navegador, o endereço sai mais curto, algo como 0x1887f78. O sentido é o mesmo.)

Como consertar: se você viu <function … at 0x…> na saída, ou se a função "não fez nada", procure a chamada e confira os parênteses: bom_dia().

Chamar a função antes de definir

bom_dia()


def bom_dia():
    print("Bom dia, Ana!")

$ python3 antes.py
Traceback (most recent call last):
  File "/home/ana/antes.py", line 1, in <module>
    bom_dia()
    ^^^^^^^
NameError: name 'bom_dia' is not defined

Linha por linha:

Traceback (most recent call last):: "Rastro (a chamada mais recente por último)": o Python vai mostrar o caminho até o erro.
File "/home/ana/antes.py", line 1, in <module>: O erro foi no arquivo antes.py, na linha 1. O <module> quer dizer "no programa principal", fora de qualquer função.
bom_dia(): A linha culpada, com ^^^^^^^ embaixo do pedaço exato que deu problema: o nome bom_dia.
NameError: name 'bom_dia' is not defined: "Erro de nome: o nome 'bom_dia' não está definido". Na linha 1, o Python ainda não tinha chegado ao def, então ainda não conhecia esse nome.

Lembre da ordem do programa: o def só cria a função quando o Python passa por ele. É como pedir o bolo de milho antes de a receita ter sido escrita no caderno. Como consertar: coloque as funções no começo do arquivo e as chamadas depois delas.

Errar o nome na chamada

def bom_dia():
    print("Bom dia, Ana!")


bom_dai()

$ python3 nome_errado.py
Traceback (most recent call last):
  File "/home/ana/nome_errado.py", line 5, in <module>
    bom_dai()
    ^^^^^^^
NameError: name 'bom_dai' is not defined. Did you mean: 'bom_dia'?

O mesmo NameError, agora com uma dica no fim: Did you mean: 'bom_dia'? ("Você quis dizer 'bom_dia'?"). O Python percebeu que existe uma função com um nome quase igual. Como consertar: escreva o nome exatamente como no def; maiúsculas e minúsculas também contam (Bom_dia é outro nome).

Esquecer os dois-pontos

def bom_dia()
    print("Bom dia, Ana!")


bom_dia()

$ python3 dois_pontos.py
  File "/home/ana/dois_pontos.py", line 1
    def bom_dia()
                 ^
SyntaxError: expected ':'

SyntaxError: expected ':': "erro de sintaxe: esperava :". O ^ aponta para o fim da linha 1, exatamente onde os dois-pontos faltam. Repare que não há Traceback nem nenhum "Bom dia": com erro de sintaxe, o Python recusa o arquivo inteiro antes de executar a primeira linha. Como consertar: def bom_dia():.

Esquecer o recuo do corpo

def bom_dia():
print("Bom dia, Ana!")


bom_dia()

$ python3 indentacao.py
  File "/home/ana/indentacao.py", line 2
    print("Bom dia, Ana!")
    ^^^^^
IndentationError: expected an indented block after function definition on line 1

IndentationError: expected an indented block after function definition on line 1: "erro de indentação: esperava um bloco recuado depois da definição de função da linha 1". Depois do def …:, o Python exige pelo menos uma linha recuada. Como consertar: coloque 4 espaços antes de cada linha do corpo.

A mesma mensagem aparece quando o corpo tem só um comentário, porque o comentário não conta como código:

def relatorio():
    # ainda vou escrever


print("Fim")

$ python3 vazia.py
  File "/home/ana/vazia.py", line 5
    print("Fim")
    ^^^^^
IndentationError: expected an indented block after function definition on line 1

Aqui o Python só percebeu o problema na linha 5, a primeira linha de código depois do def. Como consertar: use o pass (seção 6).

Uma linha que escapou da função

def bom_dia():
    print("Bom dia, Ana!")
print("O café está pronto.")


bom_dia()

$ python3 metade.py
O café está pronto.
Bom dia, Ana!

Sem erro, mas na ordem errada. A linha do café ficou sem recuo, então não faz parte da função: ela é executada logo, quando o Python passa por ela, antes mesmo da chamada. Só o "Bom dia" estava guardado na função. Como consertar: recue a linha do café com 4 espaços, como a de cima.

Missão: o programa da padaria deveria mostrar as boas-vindas e, logo depois, o horário de funcionamento. Mas ele tem dois erros desta aula. Rode, leia a mensagem e conserte.

mostrar_horario()


def mostrar_horario():
    print("Horário da padaria:")
    print("Seg a sáb: 6h às 20h")
    print("Domingo: 7h às 12h")


print("Bem-vindo à Padaria Pão Quente!")
mostrar_horario

def mostrar_horario():
    print("Horário da padaria:")
    print("Seg a sáb: 6h às 20h")
    print("Domingo: 7h às 12h")


print("Bem-vindo à Padaria Pão Quente!")
mostrar_horario()

Referência rápida

Escrita	O que faz
`def nome():` + corpo recuado	Define (cria e guarda) uma função. Não executa o corpo
`nome()`	Chama a função: executa o corpo e depois volta para a linha seguinte
`nome` (sem parênteses)	Só o nome da função, sem executar. No modo interativo, mostra `<function nome at 0x…>`
`pass`	Não faz nada; serve de corpo provisório
Duas linhas em branco depois da função	Costume (PEP 8) para separar as funções do resto

Sintoma	Causa provável
A função "não fez nada", sem erro	Faltaram os parênteses na chamada, ou a função nunca foi chamada
`<function nome at 0x…>` na saída	`print(nome)` no lugar de `nome()`
`NameError: name '…' is not defined`	Chamada antes do `def`, ou nome escrito errado (veja a dica `Did you mean`)
`SyntaxError: expected ':'`	Faltaram os dois-pontos no fim da linha do `def`
`IndentationError: expected an indented block after function definition`	Corpo sem recuo, ou só com comentários (use `pass`)
Uma linha roda antes da hora, fora da ordem	A linha ficou sem recuo e saiu da função

Exercícios

1. Criando a função

Complete a palavra que cria uma função:

mostrar_menu():
print("Café, pão e bolo")

2. Chamando a função

Complete a linha que executa a função do exercício anterior:

mostrar_menu

3. Um arquivo tem só a definição de uma função, com dois print dentro, e nenhuma chamada. O que aparece quando você roda o programa?

As duas mensagens dos print Nada: definir não executa o corpo Um NameError Um SyntaxError, porque toda função precisa ser chamada

4. A saída de um programa mostrou <function bom_dia at 0x7f434c70b530> no lugar do "Bom dia, Ana!". Qual é o erro mais provável?

A função foi chamada antes de ser definida Faltaram os dois-pontos no def Alguém escreveu print(bom_dia) em vez de bom_dia() O corpo da função não tem recuo

5. Qual é a ordem das mensagens deste programa?

def b():
    print("B")


print("A")
b()
print("C")

A, B, C B, A, C A, C, B A, C

6. Você quer criar a função agora e escrever o corpo amanhã. O que vai no corpo para o programa não dar erro?

Um comentário: # depois Nada, uma linha em branco Os parênteses: () pass

Missão final: o cardápio do café da manhã

Missão: a padaria mostra o cardápio duas vezes, e as linhas estão repetidas. Guarde as três linhas numa função chamada cardapio e troque as repetições por duas chamadas. A saída tem de continuar igual.

print("CARDÁPIO")
print("Café: R$ 4,00")
print("Pão na chapa: R$ 6,00")
print("CARDÁPIO")
print("Café: R$ 4,00")
print("Pão na chapa: R$ 6,00")

def cardapio():
    print("CARDÁPIO")
    print("Café: R$ 4,00")
    print("Pão na chapa: R$ 6,00")


cardapio()
cardapio()

Agora mude o preço do café dentro da função e rode de novo: as duas cópias do cardápio mudam juntas.

Resumo

Uma função é um grupo de linhas guardado com um nome: uma receita.
Definir (def nome(): + corpo recuado) só guarda a receita; não executa nada.
Chamar (nome()) executa o corpo e, no fim, volta para a linha seguinte. Dá para chamar quantas vezes quiser.
O def tem de vir antes da chamada; senão, NameError: name '…' is not defined.
Sem parênteses, nada acontece: nome é só a função, que aparece como <function nome at 0x…> (o endereço muda a cada execução).
Faltou : → SyntaxError: expected ':'. Faltou recuo → IndentationError. Corpo provisório → pass.
Funções evitam repetição e deixam corrigir num lugar só. Na próxima aula, elas passam a receber informações: Parâmetros e Argumentos.

Python Funções (def)

A ideia: uma receita com nome

1. Definindo a primeira função

2. Chamando a função

Uma receita, vários bolos

3. Em que ordem o programa roda

4. Para que serve: escrever uma vez, mudar num lugar só

5. Uma função chamando outra

6. A função que ainda vai ser escrita: pass

Formas diferentes de repetir as mesmas linhas

Quando dá errado

Referência rápida

Exercícios

1. Criando a função

2. Chamando a função

Missão final: o cardápio do café da manhã

Resumo

6. A função que ainda vai ser escrita: `pass`