
Passo 1 de 7
Colocar a docstring no lugar certo
Reconheça a posição que faz uma string ser tratada como documentação interna de uma função.
Trilha de aprendizado · Nível 4 · Tutorial 5
Descreva o uso de uma função com documentação interna e anotações simples que esclareçam suas entradas, saídas e condições de uso.
Colocar a docstring no lugar certo
Reconheça a posição que faz uma string ser tratada como documentação interna de uma função. 2 min
Descrever como usar a função
Organize uma docstring com resumo, parâmetros, retorno, condição de uso e exemplo breve. 2 min
Registrar efeitos além do retorno
Documente separadamente a alteração feita em uma lista recebida e o valor retornado pela função. 2 min
Anotar entradas e saídas com tipos básicos
Aprenda a indicar os tipos esperados dos parâmetros e do retorno sem alterar os valores padrão nem a implementação da função. 3 min
Entender o que as anotações não fazem
Compare os tipos descritos na assinatura com os valores realmente usados durante a execução. 2 min
Consultar e conferir com help
Use help para ler a assinatura e a docstring de uma função e compare essas informações com o resultado de uma chamada manual. 2 min
Aplicar e revisar a documentação
Documente duas funções, consulte help e confira se assinatura, docstring e comportamento comunicam a mesma coisa. 3 min

Passo 1 de 7
Reconheça a posição que faz uma string ser tratada como documentação interna de uma função.
Uma docstring é uma string literal colocada como a primeira instrução do corpo da função. Ela fica indentada e pode usar aspas triplas duplas (""") ou simples (''').
As aspas triplas permitem escrever uma ou várias linhas. No resumo inicial, diga o que a função faz — não narre cada linha da implementação.
A string aparece imediatamente depois da assinatura e tem a mesma indentação das demais instruções do corpo.
def dobrar(numero):
"""Retorna o dobro do número recebido."""
return numero * 2
A docstring ocupa a primeira posição dentro do corpo indentado da função.
Um comentário iniciado por # pode explicar o código, mas não é uma docstring. Da mesma forma, uma string colocada depois de outra instrução não é a docstring da função.
Portanto, confira dois pontos: é uma string literal e é a primeira instrução do corpo.
Somente caso_correto contém uma docstring reconhecida como documentação da função.
def caso_correto(valor):
"""Retorna o valor recebido."""
return valor
def caso_com_comentario(valor):
# Retorna o valor recebido.
return valor
def caso_com_string_atrasada(valor):
resultado = valor
"""Esta string apareceu tarde demais."""
return resultadoEscolha o único trecho em que Python reconhece a string como docstring da função.

Passo 2 de 7
Organize uma docstring com resumo, parâmetros, retorno, condição de uso e exemplo breve.
Comece a docstring com um resumo direto da finalidade da função. Depois de uma linha em branco, registre somente os detalhes necessários para usá-la corretamente:
Esses rótulos em português formam uma organização simples; você não precisa adotar um padrão externo.
A docstring pode ser lida como um conjunto de blocos, começando por uma visão geral e avançando para os detalhes de uso.

O resumo vem primeiro; os demais blocos esclarecem como chamar a função e interpretar o resultado.
A documentação explica as unidades, o valor padrão, a condição esperada e o significado do resultado.
def calcular_custo_medio(total, quantidade, frete=0):
"""Calcula o custo médio de cada item, incluindo o frete.
Parâmetros:
total: valor total dos produtos, em reais.
quantidade: número de itens; deve ser maior que zero.
frete: custo do frete, em reais. O padrão é 0.
Retorno:
O custo médio por item, em reais, incluindo o frete.
Condição de uso:
quantidade deve ser maior que zero.
Exemplo:
calcular_custo_medio(100, 4, frete=20)
Resultado esperado: 30.0
"""
return (total + frete) / quantidadeExemplo
Em frete, a docstring informa a unidade e o padrão. Em quantidade, registra a condição necessária para o cálculo. No retorno, explica que o valor representa o custo médio de cada item e inclui o frete — informação mais útil do que dizer apenas “retorna um número”.
Dica
A chamada escrita dentro da docstring serve para mostrar o uso esperado. Por estar dentro da string de documentação, ela não chama a função automaticamente.
Associe cada informação à parte adequada da docstring.
Toque em um item e depois no par correspondente.
Considere que dias representa a quantidade de dias do período e que total_litros representa o consumo total em litros.
def calcular_consumo_diario(total_litros, dias=7):
return total_litros / diasEscreva uma condição de uso para dias e um exemplo de chamada com resultado esperado. Não altere a implementação.
Escreva pelo menos 40 caracteres (0/40).

Passo 3 de 7
Documente separadamente a alteração feita em uma lista recebida e o valor retornado pela função.
Uma função pode alterar um argumento e, ao mesmo tempo, não retornar um valor útil. Nesse caso, a docstring deve registrar as duas informações separadamente: o efeito sobre o argumento e o retorno None.
A própria lista recebida ganha um novo elemento. A função não cria nem retorna outra lista.
def adicionar_mensagem(historico, mensagem):
"""Adiciona uma mensagem ao histórico.
Parâmetros:
historico: lista que receberá a nova mensagem.
mensagem: texto que será acrescentado.
Efeitos:
Altera a própria lista recebida em historico,
acrescentando mensagem ao final.
Retorno:
None.
"""
historico.append(mensagem)
mensagens = ["Olá", "Tudo bem?"]
resultado = adicionar_mensagem(mensagens, "Até logo!")
print(mensagens)
print(resultado)
Após a chamada, a lista original contém mais um elemento; separadamente, o resultado da chamada é None.
Exemplo
Impreciso: “Retorna a lista com a mensagem adicionada.”
Preciso: “Altera a própria lista recebida, acrescentando a mensagem ao final. Retorna None.”
A segunda descrição corresponde ao comportamento implementado: a mudança é um efeito sobre historico, não uma coleção entregue por return.
Dica
Depois de ler a docstring, o usuário consegue saber se deve observar a lista original ou guardar o resultado da chamada? Para esta função, ele deve observar a lista original.
Considere uma função que executa textos.append(texto) e não possui return com valor. Escreva as partes Efeitos e Retorno da docstring.
Escreva pelo menos 40 caracteres (0/40).

Passo 4 de 7
Aprenda a indicar os tipos esperados dos parâmetros e do retorno sem alterar os valores padrão nem a implementação da função.
Uma anotação registra o tipo esperado logo na assinatura da função:
nome: tipo.-> tipo antes dos dois-pontos que iniciam o corpo.ativo: bool = True.As anotações descrevem os tipos esperados. A docstring continua responsável por explicar o significado dos dados, as condições de uso e os efeitos da função.
Observe a posição de cada elemento na assinatura anotada.

A anotação acompanha o parâmetro; o valor padrão permanece depois dela. A anotação do retorno fica entre o fechamento dos parênteses e os dois-pontos.
Use int, float, str e bool para registrar expectativas simples. A anotação não substitui a docstring: saber que percentual é um float, por exemplo, não explica que ele representa uma porcentagem.
As implementações continuam iguais; somente as assinaturas receberam anotações.
def calcular_desconto(preco: float, percentual: float = 10.0) -> float:
"""Calcula o preço após aplicar um percentual de desconto."""
return preco - preco * percentual / 100
def criar_saudacao(nome: str) -> str:
"""Cria uma saudação para a pessoa informada."""
return f"Olá, {nome}!"
def pode_entrar(idade: int, acompanhado: bool = False) -> bool:
"""Informa se a pessoa pode entrar conforme idade e acompanhamento."""
return idade >= 18 or acompanhadoDica
Em acompanhado: bool = False, bool é a anotação e False continua sendo o valor padrão. Adicionar a anotação não exige mudar o corpo da função.
Quando uma função não retorna um valor com return, anote o retorno como -> None. Isso também vale quando a função produz um efeito, como alterar a própria lista recebida.
Neste exemplo, o parâmetro da coleção permanece sem anotação. A docstring informa que ele é uma lista e registra o efeito relevante.
def adicionar_aviso(avisos, texto: str) -> None:
"""Acrescenta um texto à lista de avisos.
Parâmetros:
avisos: lista que será alterada pela função.
texto: aviso que será acrescentado.
Retorno:
None.
Efeito:
Altera a própria lista recebida em avisos.
"""
avisos.append(texto)Sem modificar o corpo, complete a anotação:
def aplicar_desconto(preco: float, percentual: int = 10) -> ____:
return preco - preco * percentual / 100
Complete apenas a anotação de nome:
def formatar_status(nome: ____, ativo: bool = True) -> str:
return f"{nome}: {ativo}"
Complete o retorno sem anotar o parâmetro da coleção:
def registrar_mensagem(mensagens, texto: str) -> ____:
mensagens.append(texto)

Passo 5 de 7
Compare os tipos descritos na assinatura com os valores realmente usados durante a execução.
As anotações informam quais tipos são esperados, mas o Python não converte nem rejeita automaticamente um argumento durante a chamada. Se o corpo apenas devolve o argumento, o mesmo valor sai da função.
Apesar das anotações com int, a chamada recebe e devolve um texto.
def devolver(valor: int) -> int:
"""Devolve o valor recebido."""
return valor
resultado = devolver("olá")
print(resultado)
print(type(resultado))
# Saída:
# olá
# <class 'str'>
A assinatura descreve int, mas o valor textual permanece texto porque nenhuma conversão foi implementada.
Uma operação do corpo pode não funcionar com certo valor. Isso não significa que a anotação verificou o tipo: foi a própria operação que encontrou um valor inadequado.
A docstring informa que quantidade deve ser positiva, mas não implementa essa verificação.
def media_por_item(total: float, quantidade: int) -> float:
"""Calcula a média por item.
quantidade deve ser positiva.
"""
return total / quantidade
print(media_por_item(30.0, 3)) # 10.0
# media_por_item(30.0, 0) falha durante a divisãoAtenção
Nem a anotação nem a precondição escrita na docstring executam uma validação. Para converter ou verificar valores, seria necessário escrever código com esse comportamento.
Na chamada media_por_item(30.0, 0), a execução falha porque a anotação int rejeita automaticamente o zero.
Considere:
def identidade(dado: int) -> int: return dado
O que ocorre em identidade("Python")? Preveja o resultado e justifique por que não há conversão nem rejeição automática.
Escreva pelo menos 40 caracteres (0/40).

Passo 6 de 7
Use help para ler a assinatura e a docstring de uma função e compare essas informações com o resultado de uma chamada manual.
help apresenta informações sobre uma função sem chamá-la. Passe o nome da função, sem parênteses: help(aplicar_desconto). Se você escrever help(aplicar_desconto(...)), a chamada será executada primeiro e help receberá o resultado, não a função.
Execute esta definição no Python do seu computador. Depois, consulte a função com a última linha.
def aplicar_desconto(preco: float, desconto: float = 10.0) -> float:
"""Calcula o preço após um desconto percentual.
Parâmetros:
preco: preço original, maior ou igual a zero.
desconto: percentual de desconto, entre 0 e 100.
Retorno:
Preço final após aplicar o desconto.
Exemplo:
aplicar_desconto(200.0) retorna 180.0.
"""
return preco - desconto
help(aplicar_desconto)Na saída, localize a assinatura com nomes, anotações e valor padrão. Logo abaixo aparece a docstring, com finalidade, parâmetros, retorno, condições e exemplo. A apresentação exata pode variar conforme o ambiente.

help reúne a assinatura e a documentação em uma consulta, mas não confirma se elas correspondem ao comportamento real.
O cabeçalho pode mudar, mas estas são as informações principais que você deve reconhecer.
aplicar_desconto(preco: float, desconto: float = 10.0) -> float
Calcula o preço após um desconto percentual.
Parâmetros:
preco: preço original, maior ou igual a zero.
desconto: percentual de desconto, entre 0 e 100.
Retorno:
Preço final após aplicar o desconto.
Exemplo:
aplicar_desconto(200.0) retorna 180.0.Agora faça uma chamada manual e compare o resultado observado com o exemplo e o significado de desconto descritos na docstring.
Execute após definir a função.
resultado = aplicar_desconto(200.0)
print(resultado)Qual divergência existe entre a docstring e o resultado impresso? Explique também o que o corpo da função faz com desconto.
Escreva pelo menos 40 caracteres (0/40).
Após consultar uma função com help, qual conclusão é correta?

Passo 7 de 7
Documente duas funções, consulte help e confira se assinatura, docstring e comportamento comunicam a mesma coisa.
Copie o código abaixo para um arquivo no seu computador. Complete apenas as assinaturas e as docstrings.
Na primeira função, anote os dois parâmetros e o retorno. Documente a condição de que quantidade deve ser positiva.
Na segunda, mantenha itens sem anotação, anote texto com str e use -> None. Deixe explícito que a própria lista recebida é alterada e que a função retorna None.
Substitua cada comentário pela documentação ou anotação solicitada, sem alterar as instruções do corpo.
def calcular_valor_por_item(total, quantidade=1):
# Adicione aqui uma docstring completa.
return total / quantidade
def acrescentar_texto(itens, texto):
# Adicione aqui uma docstring completa.
itens.append(texto)
help(calcular_valor_por_item)
help(acrescentar_texto)
print(calcular_valor_por_item(45.0, 3))
print(calcular_valor_por_item(20.0))
nomes = ["Ana"]
resultado = acrescentar_texto(nomes, "Bia")
print(nomes)
print(resultado)Execute o arquivo e examine a saída de help. A apresentação pode variar entre ambientes, mas deve mostrar as assinaturas anotadas e as docstrings.
Depois, confira as chamadas: os cálculos devem produzir 15.0 e 20.0; a lista deve se tornar ['Ana', 'Bia']; e resultado deve ser None.
Revise se os nomes, valores padrão e tipos da assinatura coincidem com a docstring. Verifique também se a precondição, o retorno e o efeito sobre a lista correspondem ao comportamento observado.
Use o esquema como um ciclo de conferência: leia a assinatura, compare com a docstring e observe o resultado das chamadas.

Uma documentação coerente alinha o que a assinatura indica, o que a docstring explica e o que a função realmente faz.
Dica
A anotação quantidade: int e a precondição escrita na docstring comunicam expectativas. Elas não impedem automaticamente uma chamada inadequada. Somente instruções implementadas no corpo poderiam realizar essa verificação.
Registre: 1) as duas assinaturas e docstrings que você escreveu; 2) uma informação que confirmou na saída de cada help; 3) os resultados das chamadas; e 4) uma frase explicando por que as anotações e a precondição documentada não fazem validação automática.
Escreva pelo menos 250 caracteres (0/250).
Resumo
Antes de considerar uma função bem documentada, compare o que ela declara, explica e faz.
Parabéns! Você concluiu: Documentar funções com docstrings e tipos simples
100 XP
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