Trilha de aprendizado · Nível 4 · Tutorial 5

Documentar funções com docstrings e tipos simples

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.

  • Nível: Iniciante
  • Duração: 15 min
  • 7 passos
Documentar funções com docstrings e tipos simples

O que você vai percorrer

  1. 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
  2. Descrever como usar a função Organize uma docstring com resumo, parâmetros, retorno, condição de uso e exemplo breve. 2 min
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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

O que você vai aprender

  • Escrever uma docstring que descreva finalidade, parâmetros, retorno e condições de uso.
  • Registrar efeitos relevantes, como a alteração de uma coleção recebida.
  • Anotar parâmetros e retornos com tipos básicos, sem tratar as anotações como validação automática.
  • Consultar a documentação de uma função com help e conferir sua coerência com o comportamento implementado.

Antes de começar

  • Usar argumentos nomeados e valores padrão
  • Controlar o escopo e o estado das funções

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.

A primeira instrução do corpo

O que caracteriza uma docstring?

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.

Docstring bem posicionada

A string aparece imediatamente depois da assinatura e tem a mesma indentação das demais instruções do corpo.

python
def dobrar(numero):
    """Retorna o dobro do número recebido."""
    return numero * 2

Anatomia da posição

Diagrama de uma função em blocos: assinatura no topo, docstring como primeiro bloco indentado e implementação logo abaixo.

A docstring ocupa a primeira posição dentro do corpo indentado da função.

Parecido não é igual

Posição e forma importam

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.

Compare os três casos

Somente caso_correto contém uma docstring reconhecida como documentação da função.

python
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 resultado

Identifique a docstring

Qual função contém uma docstring?

Escolha o único trecho em que Python reconhece a string como docstring da função.

Passo 2 de 7

Descrever como usar a função

Organize uma docstring com resumo, parâmetros, retorno, condição de uso e exemplo breve.

Organize as informações

Da finalidade ao exemplo

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:

  • Parâmetros: o significado de cada entrada, incluindo unidades e valores padrão relevantes.
  • Retorno: o que o resultado representa, e não apenas que ele é um número ou texto.
  • Condição de uso: o que deve ser verdadeiro para a chamada fazer sentido.
  • Exemplo: uma chamada breve e seu resultado esperado.

Esses rótulos em português formam uma organização simples; você não precisa adotar um padrão externo.

Partes de uma docstring

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.

Diagrama vertical de uma docstring com os blocos Resumo, Parâmetros, Retorno, Condição de uso e Exemplo.

O resumo vem primeiro; os demais blocos esclarecem como chamar a função e interpretar o resultado.

Veja uma docstring completa

Custo médio por item

A documentação explica as unidades, o valor padrão, a condição esperada e o significado do resultado.

python
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) / quantidade

Exemplo

Por que cada detalhe importa

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

O exemplo não é executado

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

Partes da docstring

Associe cada informação à parte adequada da docstring.

Toque em um item e depois no par correspondente.

Redija condição e exemplo

Analise a implementação

Considere que dias representa a quantidade de dias do período e que total_litros representa o consumo total em litros.

python
def calcular_consumo_diario(total_litros, dias=7):
    return total_litros / dias

Complete duas partes da documentação

Escreva 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

Registrar efeitos além do retorno

Documente separadamente a alteração feita em uma lista recebida e o valor retornado pela função.

Efeito e retorno são informações diferentes

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.

Documentação completa do comportamento

A própria lista recebida ganha um novo elemento. A função não cria nem retorna outra lista.

python
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)

Antes, depois e retorno

Diagrama mostrando a mesma lista antes e depois de receber um terceiro elemento, enquanto uma saída separada representa o retorno None.

Após a chamada, a lista original contém mais um elemento; separadamente, o resultado da chamada é None.

Use uma descrição precisa

Exemplo

Evite prometer uma nova lista

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

Pergunta de revisão

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.

Documente os dois aspectos

Escreva o trecho da docstring

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

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.

Anatomia de uma assinatura anotada

Tipos esperados na assinatura

Uma anotação registra o tipo esperado logo na assinatura da função:

  • No parâmetro, use nome: tipo.
  • No retorno, use -> tipo antes dos dois-pontos que iniciam o corpo.
  • Se houver valor padrão, a anotação vem antes dele: 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.

Partes da assinatura

Observe a posição de cada elemento na assinatura anotada.

Diagrama da assinatura def calcular(preco: float, quantidade: int = 1) -> float, destacando nome, tipos, valor padrão e retorno.

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.

Tipos básicos em funções

Exemplos de entrada e saída

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.

Assinaturas anotadas

As implementações continuam iguais; somente as assinaturas receberam anotações.

python
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 acompanhado

Dica

Preserve o valor padrão

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 o retorno é None

Efeito e retorno são informações diferentes

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.

Alteração de uma lista recebida

python
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)

Complete as assinaturas

Retorno numérico

Sem modificar o corpo, complete a anotação:

def aplicar_desconto(preco: float, percentual: int = 10) -> ____:

return preco - preco * percentual / 100

Parâmetro de texto

Complete apenas a anotação de nome:

def formatar_status(nome: ____, ativo: bool = True) -> str:

return f"{nome}: {ativo}"

Função com efeito

Complete o retorno sem anotar o parâmetro da coleção:

def registrar_mensagem(mensagens, texto: str) -> ____:

mensagens.append(texto)

Passo 5 de 7

Entender o que as anotações não fazem

Compare os tipos descritos na assinatura com os valores realmente usados durante a execução.

Anotação não transforma valores

Expectativa não é conversã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.

Um texto atravessa a função

Apesar das anotações com int, a chamada recebe e devolve um texto.

python
def devolver(valor: int) -> int:
    """Devolve o valor recebido."""
    return valor

resultado = devolver("olá")
print(resultado)
print(type(resultado))

# Saída:
# olá
# <class 'str'>

Tipo esperado e valor observado

Diagrama em duas partes: uma assinatura apresenta a expectativa de número inteiro, enquanto um valor textual atravessa a função sem mudar.

A assinatura descreve int, mas o valor textual permanece texto porque nenhuma conversão foi implementada.

Quem produz o comportamento é o corpo

Erros podem vir da operação

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 condição documentada não é aplicada sozinha

A docstring informa que quantidade deve ser positiva, mas não implementa essa verificação.

python
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ão

Atenção

Documentar não é verificar

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.

Identifique a causa

Anotação ou operação?

Na chamada media_por_item(30.0, 0), a execução falha porque a anotação int rejeita automaticamente o zero.

Preveja antes de executar

Explique o resultado

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

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.

Passe a função para help

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.

Função para consultar

Execute esta definição no Python do seu computador. Depois, consulte a função com a última linha.

python
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)

Leia as partes da saída

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.

Anatomia da consulta

Diagrama de uma saída de help dividida em assinatura, anotações, valor padrão e docstring.

help reúne a assinatura e a documentação em uma consulta, mas não confirma se elas correspondem ao comportamento real.

Formato aproximado da saída

O cabeçalho pode mudar, mas estas são as informações principais que você deve reconhecer.

text
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.

Confira o comportamento

Agora faça uma chamada manual e compare o resultado observado com o exemplo e o significado de desconto descritos na docstring.

Chamada de conferência

Execute após definir a função.

python
resultado = aplicar_desconto(200.0)
print(resultado)

Localize a divergência

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).

O limite de help

O que help garante?

Após consultar uma função com help, qual conclusão é correta?

Passo 7 de 7

Aplicar e revisar a documentação

Documente duas funções, consulte help e confira se assinatura, docstring e comportamento comunicam a mesma coisa.

Prática integrada

Documente sem mudar a lógica

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.

Código inicial

Substitua cada comentário pela documentação ou anotação solicitada, sem alterar as instruções do corpo.

python
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)

Conferir três fontes de informação

Assinatura, docstring e comportamento

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.

Esquema de revisão

Use o esquema como um ciclo de conferência: leia a assinatura, compare com a docstring e observe o resultado das chamadas.

Diagrama com três painéis conectados: assinatura da função, documentação interna e resultados no console, todos unidos por setas e marcas de conferência.

Uma documentação coerente alinha o que a assinatura indica, o que a docstring explica e o que a função realmente faz.

Dica

Documentar não é validar

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 sua revisão

Relatório da prática

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).

Conclusão

Resumo

Checklist final

Antes de considerar uma função bem documentada, compare o que ela declara, explica e faz.

  • A docstring resume a finalidade e explica parâmetros, retorno e condições de uso.
  • Valores padrão e anotações da assinatura são coerentes com a documentação.
  • Efeitos sobre argumentos mutáveis são descritos separadamente do retorno.
  • Exemplos breves mostram chamadas e resultados esperados.
  • help apresenta assinatura e docstring, mas não comprova que elas sejam verdadeiras.
  • Anotações e precondições documentam expectativas; verificações só existem quando são implementadas no código.

Tutorial concluído

Parabéns! Você concluiu: Documentar funções com docstrings e tipos simples

Você concluiu “Documentar funções com docstrings e tipos simples”. Agora consegue descrever entradas, saídas, condições e efeitos, além de revisar a coerência da documentação com help e chamadas manuais.

100 XP

Baixe o Aplicativo agora para ter acesso a + de 5000 cursos gratuitos, exercícios, certificado e muito conteúdo sem pagar nada!

  • Cursos online 100% gratuitos do início ao fim

    Milhares de cursos online em vídeo, ebooks e áudiobooks.

  • Mais de 60 mil exercícios gratuitos

    Para testar seus conhecimentos no decorrer dos cursos online

  • Certificado Digital gratuito válido em todo o Brasil

    Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail

Aplicativo Cursa na tela de ebook, na tela de curso em vídeo e na tela de exercícios do curso, mais o certificado de conclusão de curso