Funções em Python: como usar def, return e parâmetros

✅ Artigo atualizado em Setembro 2026 (Python 3.13) Nova resposta rápida, seções sobre def, print vs return, escopo, docstrings e type hints, erros comuns com traceback e 8 exercícios resolvidos. Todos os códigos foram executados novamente e os exemplos com f-string que não imprimiam os valores foram corrigidos.

1
2
3
4
5
6
7
8

def soma(a, b):
    return a + b          # devolve o valor

def mostra_soma(a, b):
    print(a + b)          # só exibe na tela

total = soma(2, 3)        # total == 5
nada = mostra_soma(2, 3)  # exibe 5, mas nada == None

Salve salve Pythonista!

Uma função nada mais é que um trecho de código que possui uma responsabilidade específica e que damos um nome a ele. Funções evitam repetição (DRY - Don’t Repeat Yourself) e organizam o código!

Nesse post você vai aprender:

• Como criar funções com a palavra reservada def,
• A diferença entre print e return,
• Como definir parâmetros, valores padrão, *args e **kwargs,
• Como funciona o escopo de variáveis (local e global),
• Como documentar funções com docstrings e type hints,
• E ainda: erros comuns com traceback e exercícios resolvidos!

Então vem com a gente!

Vá Direto ao Assunto…

• O que é def em Python
• Introdução
• Parâmetros
• Valores Padrão (ou Valores Default)
• Chamada de Função Posicional versus Chamada de Função Nomeada
• Parâmetro *args
• Parâmetro **kwargs
• Funções com retorno de dados
• Diferença entre print e return
• Palavra reservada pass
• Função de uma linha
• Escopo de variáveis: local e global
• Docstrings e type hints em funções
• Casos Práticos
• DRY Principle
• Erros comuns
• Exercícios resolvidos

O que é def em Python

def (de define) é a palavra reservada do Python que cria uma função. Ao executar um def, o Python cria um objeto do tipo função e o associa ao nome que você escolheu. A estrutura completa é:

1
2
3
4
5
6
7
8

def saudacao(nome):
    """Retorna uma saudação personalizada."""
    return f"Olá, {nome}!"


mensagem = saudacao("Ana")
print(mensagem)
print(type(saudacao))

Saída:

1
2

Olá, Ana!
<class 'function'>

Cada parte tem um papel:

• def: avisa ao Python que uma função vai ser definida;
• saudacao: o nome da função (use snake_case e um verbo ou substantivo que diga o que ela faz);
• (nome): a lista de parâmetros, os dados de entrada (pode ficar vazia: ());
• :: os dois pontos abrem o bloco da função;
• corpo indentado: o código que roda a cada chamada (a primeira linha pode ser uma docstring, a string de documentação);
• return: devolve o resultado para quem chamou e encerra a função.

Um detalhe que cai em prova: definir não é executar. O código dentro do def só roda quando a função é chamada, como em saudacao("Ana"). A explicação oficial está no tutorial do Python, na seção Definindo funções.

Introdução

Funções são blocos de código que executam funcionalidades específicas.

Normalmente são utilizados para evitar que determinada parte do seu código sejá escrito varias vezes.

Em Python sua sintaxe é definida usando def e atribuindo um nome a ela, veja um exemplo:

1
2

def funcao():
    print("Bloco de código")

Observando essa função, podemos extrair algumas informações, iniciando com a palavra reservada para funções def o nome atribuido à função funcao e os parênteses () utilizado para definição dos dados de entrada da função, também chamados de parâmetros.

Em seguida usa-se dois pontos : e abaixo o bloco de código a ser executado, que neste caso é apenas imprimir de uma string.

Para “chamar” uma função, utilizamos o nome que foi definido, dessa forma:

1
2
3
4
5

def funcao():
    print("Bloco de código")


funcao()

Resultado do código acima:

1

Bloco de código

Parâmetros

Além de executar código, funções também podem receber e retornar dados.

Podemos enviar dados para uma função através de seus parâmetros.

Observe o exemplo:

1
2
3
4
5
6
7

def imprime_nome(nome):
    print(f"Nome: {nome}")


imprime_nome("Erickson")
imprime_nome("Renan")
imprime_nome("Daniel")

Resultado do código acima:

1
2
3

Nome: Erickson
Nome: Renan
Nome: Daniel

Não entendeu essa notação do print(f"Nome: {nome}")? Isso se chama F-strings e é uma maneira de formatar código Python e Strings! Quer saber mais sobre esse assunto, então acesse nosso Post completo sobre F-Strings!

Quando a função é chamada, passamos uma string como dado de entrada - através do parâmetro nome - que é concatenada e impressa dentro da função.

Caso nenhum valor seja infomado ao chamar a função, um erro será gerado. Por exemplo, o seguinte código:

1
2
3
4
5

def imprime_nome(nome):
    print(f"Nome: {nome}")


imprime_nome()

Ocasionará o seguinte erro:

1

TypeError: imprime_nome() missing 1 required positional argument: 'nome'

Podemos resolver esse erro utilizando os “Valores Padrão” e é exatamente isso que veremos agora!

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Valores Padrão (ou Valores Default)

A utilização dos valores padrão serve para dar um valor quando quem chamou a função não passar nenhum valor para os parâmetros definidos.

Fazemos isso dessa forma:

1
2
3
4
5
6

def flor(flor='Rosa', cor='Vermelha'):
    print(f"A cor da {flor} é {cor}")


flor()
flor("Orquídea", "Azul")

Veja o resultado:

1
2

A cor da Rosa é Vermelha
A cor da Orquídea é Azul

Ou seja, o erro anterior não ocorreu novamente!

Duas regras sobre valores padrão:

• Parâmetros com valor padrão devem vir depois dos obrigatórios. def f(a=1, b): gera SyntaxError: parameter without a default follows parameter with a default (no Python 3.10 a mensagem é non-default argument follows default argument).
• Não use objetos mutáveis, como [] ou {}, como valor padrão: eles são criados uma única vez e compartilhados entre as chamadas. Veja o exemplo em Erros comuns.

Chamada de Função Posicional versus Chamada de Função Nomeada

Quando chamamos uma função, podemos utilizar a localização dos parâmetros para fazer o casamento entre o que foi chamado e o que foi definido na função.

Para entender melhor, veja o exemplo a seguir:

1
2
3
4
5

def monta_computador(cpu='', armazenamento=0, memoria=0):
    print(f'A configuração é: \n\t- CPU: {cpu}\n\t- Armazenamento: {armazenamento}Tb\n\t- Memória: {memoria}Gb')


monta_computador('Intel Core i9', 4, 64)

A saída será:

1
2
3
4

A configuração é:
    - CPU: Intel Core i9
    - Armazenamento: 4Tb
    - Memória: 64Gb

O programador que escreveu a chamada da função monta_computador está respeitando a posição dos parâmetros, ou seja:

• O valor "Intel Core i9" é referente ao primeiro parâmetro (cpu)
• O valor 4 é referente ao segundo parâmetro (armazenamento)
• O valor 64 se refere ao terceiro parâmetro (memoria)

Essa é uma chamada de função posicional, ou seja: que respeita a ordem dos parâmetros.

Outra forma de fazer essa chamada de função é utilizar os nomes dos parâmetros!

Dessa forma, não é necessário respeitar a ordem de definição dos parâmetros!

Veja o mesmo exemplo, mas agora utilizando os nomes dos parâmetros:

1

monta_computador(memoria=64, armazenamento=4, cpu='Intel Core i9')

A saída será a mesma, pois como utilizamos os nomes, o Python saberá qual valor referencia qual parâmetro!

Criei o Ebookr.ai, uma plataforma que usa IA para gerar ebooks profissionais sobre qualquer tema - com capa gerada por IA, infográficos automáticos e exportação em PDF. Confere!

Parâmetro *args

Caso você queira desenvolver uma função que recebe um número variável de parâmetros, você pode utilizar o parâmetro *args!

Dessa forma, a função receberá os argumentos em forma de Tupla e você poderá processá-los com um loop for por exemplo!

Veja o código abaixo para entender melhor:

1
2
3
4
5
6
7
8
9
10

def maior_30(*args):
    print(args)
    print(type(args))

    for num in args:
        if num > 30:
            print(num)


maior_30(10, 20, 30, 40, 50, 60)

A função acima irá receber todos os valores passados para função no parâmetro *args e irá iterar sobre eles com um loop for.

Veja a saída:

1
2
3
4
5

(10, 20, 30, 40, 50, 60)
<class 'tuple'>
40
50
60

Observação: O nome *args é uma convenção, ou seja uma boa prática entre programadores Python! Contudo, nada te impede de alterar esse nome para *numeros por exemplo. Dessa forma, a definição da função seria: def maior_30(*numeros):

Parâmetro **kwargs

Agora, se quiser desenvolver uma função com número variado de parâmetros nomeados, utilize **kwargs.

Dessa forma, todos os dados passados à função serão guardados nessa variável **kwargs, em formato de um dicionário.

Oberve como podemos obter a chave a valor deles percorrendo os itens deste dicionário:

1
2
3
4
5
6
7
8

def dados_pessoa(**kwargs):
    print(type(kwargs))

    for chave, valor in kwargs.items():
        print(f"{chave}: {valor}")


dados_pessoa(nome='João', idade=35, carreira='Desenvolvedor Fullstack')

Na saída podemos observar o tipo de dado que a função recebeu e a estrutura construida para percorrer o dicionário:

1
2
3
4

<class 'dict'>
nome: João
idade: 35
carreira: Desenvolvedor Fullstack

Observação: O nome **kwargs é uma convenção, ou seja uma boa prática entre programadores Python! Contudo, nada te impede de alterar esse nome para **pessoa por exemplo.

Para aprofundar (desempacotamento com * e ** na chamada, ordem obrigatória dos parâmetros e casos reais), veja nosso guia completo de *args e **kwargs no Python.

Resumo dos tipos de parâmetro vistos até aqui:

Funções com retorno de dados

As funções também podem retornar valores através da palavra reservada return.

Veja o exemplo:

1
2
3
4
5
6
7
8

def soma_dois_numeros(valor1, valor2):
    soma = valor1 + valor2
    return soma


valor_soma = soma_dois_numeros(32, 15)
print(valor_soma)
print(soma_dois_numeros(50, 10))

Saída com o retorno da soma dos valores introduzidos na função:

1
2

47
60

Funções com retorno múltiplos

Funções também podem retornar múltiplos dados. Veja o exemplo:

1
2
3
4
5
6
7
8
9
10

def soma_dois_numeros_e_calcula_media(valor1, valor2):
    soma = valor1 + valor2
    media = (valor1 + valor2)/2

    return soma, media


valor_soma = soma_dois_numeros_e_calcula_media(32, 15)
print(valor_soma)
print(soma_dois_numeros_e_calcula_media(50, 10))

A saída será:

1
2

(47, 23.5)
(60, 30.0)

Repare que os dois valores voltam juntos numa tupla. Para separá-los em duas variáveis, use desempacotamento: soma, media = soma_dois_numeros_e_calcula_media(32, 15).

Diferença entre print e return

Essa é a dúvida mais comum de quem está começando (e aparece muito em provas): print mostra, return devolve.

• print() escreve um valor na tela. O valor não volta para o código que chamou a função.
• return entrega o valor para quem chamou, que pode guardá-lo numa variável, usá-lo numa conta ou passá-lo para outra função. Ele também encerra a função na hora.

Veja as duas versões lado a lado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def area_com_print(base, altura):
    print(base * altura)


def area_com_return(base, altura):
    return base * altura


a = area_com_print(3, 4)
b = area_com_return(3, 4)
print("a =", a)
print("b =", b)
print(b * 2)
print(a * 2)

Saída:

1
2
3
4
5

12
a = None
b = 12
24
TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'

O 12 da primeira linha foi exibido pelo print de dentro de area_com_print, mas a variável a recebeu None, porque a função não tem return. Já b recebeu 12 e pôde ser usado na conta b * 2. A última linha falha porque não dá para multiplicar None por um número.

E como o return encerra a função, nada que vem depois dele é executado:

1
2
3
4
5
6
7
8
9

def verifica_idade(idade):
    if idade >= 18:
        return "Maior de idade"
    return "Menor de idade"
    print("Esta linha nunca roda")


print(verifica_idade(20))
print(verifica_idade(15))

Saída:

1
2

Maior de idade
Menor de idade

Esse padrão de vários return dentro de if é muito usado junto com as estruturas condicionais do Python.

Regra prática: funções que calculam devem usar return; deixe o print para a parte do programa que conversa com o usuário. Se quiser revisar como ler e exibir dados, veja o post sobre input e print no Python.

Palavra reservada pass

Caso você deseje definir uma função sem corpo nenhum, ou seja, sem código, saiba que isso irá disparar o erro IndentationError, pois funções não podem estar vazias.

Porém se por algum motivo precisar use a palavra reservada pass, da seguinte forma:

1
2

def funcao():
    pass

Função de uma linha

Python possibilita a criação de funções com apenas uma linha de código. Veja os exemplo a seguir:

1
2
3
4
5
6
7
8
9

# Definição das funções
def soma(valor1, valor2): return valor1 + valor2
def divisao(valor1, valor2): return valor1 / valor2
def multiplicacao(valor1, valor2): return valor1 * valor2

# Chamada das funções
print(soma(1, 5))
print(divisao(8, 2))
print(multiplicacao(8, 2))

O resultado do código acima será:

1
2
3

6
4.0
16

Para funções curtas que você vai usar uma única vez (por exemplo, como critério de ordenação), o Python também tem as funções anônimas. Veja o post sobre funções lambda no Python.

Escopo de variáveis: local e global

Escopo é a região do código onde uma variável existe. Em funções, há dois casos principais:

• Local: variável criada dentro da função (incluindo os parâmetros). Ela nasce quando a função é chamada e some quando a função termina.
• Global: variável criada fora de qualquer função, no corpo do arquivo. Ela pode ser lida dentro das funções.

1
2
3
4
5
6
7
8
9
10

taxa = 0.1  # variável global


def calcula_imposto(valor):
    imposto = valor * taxa  # imposto é local; taxa é lida do escopo global
    return imposto


print(calcula_imposto(200))
print(imposto)

Saída:

1
2

20.0
NameError: name 'imposto' is not defined

A função leu taxa sem problemas, mas imposto não existe fora dela. O jeito certo de “tirar” um valor de dentro da função é com return.

Para alterar uma variável global dentro da função, é preciso declarar global:

1
2
3
4
5
6
7
8
9
10
11

contador = 0


def incrementa():
    global contador
    contador += 1


incrementa()
incrementa()
print(contador)

Saída:

1

2

Funciona, mas deixa o código difícil de acompanhar, porque qualquer função pode mudar o valor. Prefira receber o valor por parâmetro e devolver o novo com return:

1
2
3
4
5
6
7
8

def incrementa(valor):
    return valor + 1


contador = 0
contador = incrementa(contador)
contador = incrementa(contador)
print(contador)

Saída:

1

2

Sem o global, a tentativa de alterar a variável gera um UnboundLocalError, que está explicado em Erros comuns.

Docstrings e type hints em funções

Duas práticas deixam suas funções mais fáceis de usar e de manter:

• Docstring: uma string entre aspas triplas logo na primeira linha do corpo, explicando o que a função faz. Ela aparece em help(funcao), no atributo funcao.__doc__ e no autocompletar dos editores. A convenção está na PEP 257.
• Type hints (dicas de tipo): anotações que indicam o tipo esperado de cada parâmetro (nome: tipo) e do retorno (-> tipo), definidas na PEP 484.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def calcular_media(notas: list[float], casas: int = 1) -> float:
    """Calcula a média aritmética de uma lista de notas.

    Args:
        notas: lista com as notas do aluno.
        casas: número de casas decimais do resultado.

    Returns:
        A média arredondada.
    """
    return round(sum(notas) / len(notas), casas)


print(calcular_media([7.5, 8.0, 9.0]))
print(calcular_media.__doc__.splitlines()[0])

Saída:

1
2

8.2
Calcula a média aritmética de uma lista de notas.

Atenção: o Python não verifica os type hints ao executar. def dobro(x: int) -> int: return x * 2 aceita dobro("ab") e devolve 'abab' sem erro. Quem usa as dicas são o editor e ferramentas como o mypy, que apontam o problema antes de rodar o código. A sintaxe list[float] funciona a partir do Python 3.9.

Funções bem escritas, com parâmetros claros e escopo controlado, são metade do caminho pra escrever Python profissional. Se você quer chegar lá com uma trilha guiada, do básico ao Django, conheça a Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Casos Práticos

1. Validação de Dados

1
2
3
4
5
6
7
8

def validar_email(email):
    return '@' in email and '.' in email

def validar_cpf(cpf):
    return len(cpf) == 11 and cpf.isdigit()

print(validar_email("[email protected]"))  # True
print(validar_cpf("12345678901"))  # True

2. Cálculos Reutilizáveis

1
2
3
4
5
6
7
8
9
10

def calcular_imc(peso, altura):
    imc = peso / (altura ** 2)
    return round(imc, 2)

def calcular_desconto(preco, percentual):
    desconto = preco * (percentual / 100)
    return preco - desconto

print(calcular_imc(70, 1.75))  # 22.86
print(calcular_desconto(100, 10))  # 90.0

3. Formatadores

1
2
3
4
5
6
7
8

def formatar_cpf(cpf):
    return f"{cpf[:3]}.{cpf[3:6]}.{cpf[6:9]}-{cpf[9:]}"

def formatar_telefone(tel):
    return f"({tel[:2]}) {tel[2:7]}-{tel[7:]}"

print(formatar_cpf("12345678901"))  # 123.456.789-01
print(formatar_telefone("11987654321"))  # (11) 98765-4321

DRY Principle

DRY = Don’t Repeat Yourself (Não se repita)

1
2
3
4
5
6
7
8
9
10
11
12
13

# ❌ Sem função (repetição!)
preco1 = 100
preco1_com_desconto = preco1 * 0.9

preco2 = 200
preco2_com_desconto = preco2 * 0.9

# ✅ Com função (DRY!)
def aplicar_desconto(preco, percentual=10):
    return preco * (1 - percentual/100)

preco1_com_desconto = aplicar_desconto(100)
preco2_com_desconto = aplicar_desconto(200)

Erros comuns

1. Esquecer o return (a função devolve None)

1
2
3
4
5
6
7

def calcula_total(preco, quantidade):
    total = preco * quantidade


valor = calcula_total(10, 3)
print(valor)
print(valor + 5)

1
2

None
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

A conta foi feita, mas o resultado ficou preso na variável local total. Toda função sem return devolve None. Correção: troque a última linha do corpo por return preco * quantidade.

2. Chamar a função antes de defini-la

1
2
3
4
5

print(saudacao("Ana"))


def saudacao(nome):
    return f"Olá, {nome}!"

1

NameError: name 'saudacao' is not defined

O Python executa o arquivo de cima para baixo, e o nome saudacao só passa a existir quando a linha do def roda. Correção: coloque as definições das funções antes das chamadas (normalmente no topo do arquivo).

3. Passar o número errado de argumentos

1
2
3
4
5

def calcular_total(preco, quantidade):
    return preco * quantidade


calcular_total(10)

1

TypeError: calcular_total() missing 1 required positional argument: 'quantidade'

Com argumentos a mais, o erro muda: calcular_total(10, 3, 2) gera TypeError: calcular_total() takes 2 positional arguments but 3 were given. Correção: passe exatamente um argumento para cada parâmetro obrigatório, ou dê um valor padrão ao parâmetro opcional (def calcular_total(preco, quantidade=1):).

4. Usar uma lista como valor padrão

1
2
3
4
5
6
7

def adiciona_item(item, lista=[]):
    lista.append(item)
    return lista


print(adiciona_item("maçã"))
print(adiciona_item("banana"))

1
2

['maçã']
['maçã', 'banana']

Não há traceback, e é isso que torna o erro perigoso: a segunda chamada “lembrou” o item da primeira. O valor padrão é criado uma única vez, quando o def roda, e a mesma lista é reaproveitada em todas as chamadas. Correção: use None como padrão e crie a lista dentro da função.

1
2
3
4
5
6
7
8
9

def adiciona_item(item, lista=None):
    if lista is None:
        lista = []
    lista.append(item)
    return lista


print(adiciona_item("maçã"))
print(adiciona_item("banana"))

1
2

['maçã']
['banana']

5. Alterar uma variável global sem declarar global (UnboundLocalError)

1
2
3
4
5
6
7
8

contador = 0


def incrementa():
    contador += 1


incrementa()

1

UnboundLocalError: cannot access local variable 'contador' where it is not associated with a value

No Python 3.10 e anteriores, a mensagem é UnboundLocalError: local variable 'contador' referenced before assignment. Como existe uma atribuição (+=) dentro da função, o Python trata contador como variável local, e ela ainda não tem valor quando a soma é feita. Correção: receba o valor por parâmetro e devolva com return (ou, em último caso, declare global contador), como mostrado em Escopo de variáveis: local e global.

Exercícios resolvidos

Tente resolver cada exercício antes de abrir a solução. Todos os códigos foram executados no Python 3.13. Se quiser praticar funções em projetos guiados, do básico ao avançado, conheça o nosso curso de Python completo.

Exercício 1. Crie uma função quadrado(n) que retorna o quadrado de um número e mostre o resultado para 7.

1
2
3
4
5

def quadrado(n):
    return n ** 2


print(quadrado(7))

Exercício 2. Escreva uma função eh_par(numero) que retorna True se o número for par e False caso contrário. Teste com 10 e 7.

1
2
3
4
5

def eh_par(numero):
    return numero % 2 == 0


print(eh_par(10), eh_par(7))

Exercício 3 (questão de prova). Ao criar uma função para calcular o valor total de uma compra, um estudante definiu def calcular_total(preco, quantidade):. Qual corpo permite usar o resultado em outra conta, como calcular_total(10.0, 3) * 0.9?

a) print(preco * quantidade)
b) return preco * quantidade
c) return preco + quantidade
d) preco * quantidade

1
2
3
4
5

def calcular_total(preco, quantidade):
    return preco * quantidade


print(calcular_total(10.0, 3) * 0.9)

Exercício 4. Crie uma função potencia(base, expoente=2) e mostre o resultado de potencia(3), potencia(2, 3) e potencia(expoente=0, base=5).

1
2
3
4
5

def potencia(base, expoente=2):
    return base ** expoente


print(potencia(3), potencia(2, 3), potencia(expoente=0, base=5))

Exercício 5 (questão de prova). Qual é a saída do código abaixo?

1
2
3
4
5
6
7
8
9

x = 5


def altera():
    x = 10
    return x


print(altera(), x)

a) 10 10
b) 10 5
c) 5 5
d) UnboundLocalError

Exercício 6. Escreva uma função min_max(numeros) que retorna o menor e o maior valor de uma lista, e guarde os dois em variáveis separadas.

1
2
3
4
5
6

def min_max(numeros):
    return min(numeros), max(numeros)


menor, maior = min_max([4, 9, 1, 7])
print(menor, maior)

Exercício 7. Crie uma função media(*numeros) que aceita qualquer quantidade de números e retorna a média. Teste com media(7, 8, 9) e media(10, 5).

1
2
3
4
5
6

def media(*numeros):
    return sum(numeros) / len(numeros)


print(media(7, 8, 9))
print(media(10, 5))

Exercício 8. Escreva uma função classificar_nota(nota) que retorna "Aprovado" para nota maior ou igual a 7, "Recuperação" para nota maior ou igual a 5 e "Reprovado" nos demais casos. Teste com 8.5, 6 e 3.

1
2
3
4
5
6
7
8
9
10

def classificar_nota(nota):
    if nota >= 7:
        return "Aprovado"
    elif nota >= 5:
        return "Recuperação"
    return "Reprovado"


for nota in [8.5, 6, 3]:
    print(nota, classificar_nota(nota))

1
2
3

8.5 Aprovado
6 Recuperação
3 Reprovado

Conclusão

Neste guia de Funções, você aprendeu:

✅ def - Criar funções
✅ Parâmetros - Argumentos posicionais e nomeados
✅ return - Retornar valores
✅ DRY - Não repetir código
✅ Casos práticos - Validação, cálculo, formatadores

Principais lições:

• Funções evitam repetição
• Use nomes descritivos
• Funções devem ter uma responsabilidade
• return encerra a função
• Parâmetros padrão são opcionais

Próximos passos:

• Aprenda *args/**kwargs
• Explore Decorators
• Pratique funções puras
• Estude type hints (Python 3.5+)

Nesse post vimos como podemos criar Funções em Python, que nada mais é que “pedaço de código nomeado”.

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Erickson Lopes em 08/02/2022

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes:

• 
•