Funções Python: guia completo para pessoas iniciantes e avançadas

O Python se destacou no mundo da tecnologia por unir simplicidade e versatilidade. Seja em ciência de dados, desenvolvimento web, automação ou projetos complexos, a linguagem se mostra confiável e adaptável. 

Entre seus recursos mais úteis estão as funções, que tornam o código mais organizado e evitam a repetição de tarefas.  

Em vez de reescrever a mesma lógica várias vezes, basta chamar a função e ela executa o que foi definido, deixando o programa mais limpo e reduzindo as chances de erro. 

Para aproveitar todo o potencial do Python, é importante entender como as funções funcionam e como elas podem facilitar a criação de programas eficientes e reutilizáveis.  

Neste artigo, você vai descobrir isso na prática, com explicações e exemplos aplicáveis ao seu dia a dia de programação. 

O que são funções em Python? 

Funções são blocos de código que executam uma tarefa específica. Elas permitem que você organize o programa em pequenas partes, cada uma responsável por uma função bem definida, evitando repetição e tornando o código mais eficiente e estruturado. 

Antes de começar a criar suas próprias funções, vale destacar alguns aspectos que tornam esse recurso tão útil: 

• Reutilização: uma função pode ser usada várias vezes no mesmo programa, sem precisar reescrever a lógica. 
• Entrada e saída de dados: funções podem receber informações (parâmetros) e devolver resultados (retorno), tornando o código mais flexível. 
• Organização do código: separar tarefas em funções ajuda a manter o programa mais limpo e fácil de entender. 

Por que usar funções em Python? 

Funções oferecem vantagens que vão além da organização do código. Elas tornam o desenvolvimento mais flexível e adaptável a mudanças, permitindo que você ajuste ou expanda funcionalidades sem precisar reescrever grandes trechos do programa. 

Além disso, funções ajudam a simplificar a resolução de problemas complexos, pois tarefas complicadas podem ser divididas em etapas menores, que podem ser implementadas e testadas separadamente. Elas também promovem consistência no código, garantindo que tarefas recorrentes sigam a mesma lógica e reduzindo discrepâncias. 

Para que servem? 

Funções transformam ideias em ações concretas dentro do código, criando estruturas que podem ser aproveitadas em diferentes contextos. Elas permitem automatizar processos repetitivos, encapsulando tarefas que exigem múltiplos passos e evitando retrabalho.  

Também ajudam a integrar funcionalidades, combinando várias etapas em um único comando e simplificando a execução de processos mais sofisticados. Além disso, funções apoiam o aprendizado e a experimentação, pois ao isolar uma funcionalidade em um bloco separado, você consegue testar novas abordagens sem comprometer o restante do código. 

Tipos de função em Python 

Em Python, existem diferentes formas de criar e utilizar funções, cada uma adequada para situações específicas. Conhecer esses tipos é importante para aproveitar ao máximo o que a linguagem oferece e escrever códigos mais organizados e versáteis. 

De forma geral, podemos dividir as funções em três categorias principais: 

• Funções definidas pelo usuário: são funções que você cria para resolver problemas específicos do seu programa. 
• Funções integradas (_built-in_): já vem prontas no Python, como `print()`, `len()`, e `type()`, facilitando tarefas comuns do dia a dia. 
• Funções anônimas ou _lambda_: funções pequenas, criadas em uma única linha, geralmente usadas e situações rápidas e simples. 

Cada um desses tipos tem suas particularidades e aplicações práticas, que veremos com mais detalhes mais a frente nesse artigo. 

Como definir uma função em Python 

Em Python, criar uma função é simples, mas para que ela funcione corretamente, é importante entender a sintaxe a as regras básicas que devemos seguir. 

Em termos gerais, a estrutura de uma função segue este formato: 

``` 
def nome_da_função(parametros): 
    <comandos>  
    return 
```

No exemplo acima temos as seguintes regras sendo aplicadas: 

• Palavra-chave _def_: todo bloco de função deve começar com `def`, indicando que você está criando uma função. 
• Nome da função: identifica exclusivamente a função. O nome deve seguir as mesmas regras de identificadores em Python (não pode começar com número, não pode conter caracteres especiais, entre outros). 
• Parâmetros (opcionais): os dados fornecidos à função, chamados de parâmetros, devem ser colocados entre parênteses. Caso a função não precise de entradas, os parênteses ficam vazios. 
• Dois pontos ( : ): marcam o final do cabeçalho da função, indicando que o bloco de código da função iniciou. 
• Corpo da função: uma ou mais instruções Python válidas que compõem o bloco de execução. 
• _return_ (opcional): permite que a função devolva um resultado ao chamador. Se não houver retorno explícito, a função retorna `None` por padrão.   

Agora um exemplo prático: 

``` 
def calcular_media(notas): 
    media = sum(notas) / len(notas) 
    return media 
```

No exemplo: 

• `def calcular_media(notas)`: cria uma função chamada `calcular_media` que recebe um parâmetro chamado `notas`. Esse parâmetro espera uma lista de números, que serão usados no cálculo da média. 
• Dentro da função, usamos `sum(notas)` para somar todos os valores da lista. A função `sum()` é uma função embutida do Python que retorna a soma de todos os elementos de uma lista ou outro iterável. 
• Em seguida, `len(notas)` é usado para contar quantos elementos existem na lista. A função `len()` retorna o número de itens presente em qualquer objeto que seja iterável, como listas, tuplas ou strings. 
• Então, dividimos a soma (`sum(notas)`) pelo número de elementos (`len(notas`) para calcular a média aritimética. O resultado dessa operação é então armazenado na variável `media`. 
• E por fim, o comando `return` envia o resultado da operação para quem chamou a função. 

Dessa forma, sempre que você passar uma lista de números para `calcular_media`, a função irá somar todos os valores, dividir pelo total de elementos e retornar o resultado, permitindo que você reutilize essa função em várias partes do seu programa sempre que precisar do mesmo cálculo. 

Parâmetros e argumentos 

Parâmetros e argumentos são importantes para tornar funções mais flexíveis e reutilizáveis. Eles permitem que uma função receba informações externas e execute operações diferentes dependendo dos valores fornecidos. 

Parâmetros são variáveis definidas na função, que representam os dados que a função espera receber. Por exemplo: 

``` 
def saudacao(nome): 
    print(f”Olá, {nome}! É um prazer te conhecer!”) 
```

Aqui, `nome` é o parâmetro da função. Já argumentos são os valores reais passados para a função quando a chamamos.  

``` 
saudacao(“Maria”) 
```

O valor `”Maria”` é o argumento passado para o parâmetro `nome`, e a função então imprime: 

``` 
Olá, Maria! É um prazer te conhecer! 
```

Vários parâmetros 

Funções podem receber mais de um parâmetro, permitindo processar diferentes tipos de informação ao mesmo tempo. Por exemplo: 

``` 
def apresentar_pessoa(nome, idade): 
    print(f“Nome: {nome}, Idade: {idade}”) 
```

Chamando essa função: 

``` 
apresentar_pessoa(“Carlos”, 30) 
```

E a saída: 

``` 
Nome: Carlos, Idade: 30 
```

Valores padrão em funções 

Em muitas situações, é conveniente que uma função tenha valores padrão para seus parâmetros. Isso significa que, caso nenhum argumento seja informado na chamada, a função usará o valor definido por padrão. 

Esse recurso torna o código mais flexível e evita erros quando um argumento não é fornecido. 

``` 
def saudacao(nome=”Visitante”): 
    print(f“Olá, {nome}! Como você está?”) 
```

• Ao chamar `saudacao(“Ana”)`, o parâmetro `nome` receberá o valor `”Ana”`. 
• Ao chamar apenas `saudacao()`, a função usará o valor padrão `”Visitante”`. 

Você também pode definir mais de um valor padrão: 

``` 
def apresentar_pessoa(nome=”Desconhecido”, idade=0): 
    print(f”Nome: {nome}, Idade: {idade}”) 
```

Assim, ao chamar: 

• `apresentar_pessoa(“Carlos”, 30)`, o programa imprime `”Nome: Carlos, Idade: 30”`. 
• `apresentar_pessoa(“João”)`o programa imprime `”Nome: João, Idade: 0”`. 
• `apresentar_pessoa()`o programa imprime `”Nome: Desconhecido, Idade: 0”`. 

Argumentos nomeados 

Ao chamar uma função, você pode passar os valores dos parâmetros de duas maneiras: seguindo a ordem definida ou informando o nome do parâmetro explicitamente. Quando usamos o nome do parâmetro, temos o que chamamos de argumentos nomeados (_keyword arguments_). 

Esse recurso aumenta a clareza do código, pois fica evidente qual valor corresponde a qual parâmetro. 

``` 
def apresentar_pessoa(nome, idade): 
    print(f”Nome: {nome}, Idade: {idade}”) 
# Chamando a função pela ordem dos parâmetros 
apresentar_pessoa(“Ana”, 25) 
# Chamando com argumentos nomeados 
apresentar_pessoa(idade=40, nome=“Henrique”) 
```

A saída será: 

``` 
Nome: Ana, Idade: 25 
Nome: Henrique, Idade: 40 
```

Observe que, com argumentos nomeados, a ordem não importa, já que o Python associa cada valor ao parâmetro correto. 

Funções integradas em Python 

O Python já vem com uma série de funções prontas para uso, chamadas de funções integradas (_build-in funtions_). Elas estão disponíveis em qualquer programa, sem que você precise importar bibliotecas externas, e resolvem tarefas do dia a dia de forma eficiente. 

Essas funções cobrem desde operações matemáticas básicas até manipulação de tipos de dados e interações com o usuário. Aprender a utilizá-las é um passo importante para escrever programas mais enxutos e produtivos. 

Alguns exemplos dessas funções: 

• `print()` - Exibe informações na tela. 

``` 
print(“Olá, mundo!”) 
```

• `len()` - Retorna o tamanho de uma sequência (lista, string, tupla, etc). 

``` 
frutas = [“maçã”, “banana”, “uva”] 
print(len(frutas)) # Saída: 3 
```

• `type()` - Informa o tipo de um objeto. 

``` 
# Tipo inteiro 
print(type(42))        # Saída: <class ‘int’> 
# Tipo string 
print(type(“Python”))      # Saída: <class ‘str’> 
```

• `sum()` - Soma os elementos de uma lista ou outra coleção numérica. 

``` 
notas = [8, 7.5, 9, 10] 
print(sum(notas)) # Saída: 34.5 
```

* `input()` - Permite capturar informações digitadas pelo usuário. 

``` 
nome = input(“Digite seu nome: ”) 
print(f”Olá, {nome}!”) 
```

Esses são apenas alguns exemplos, mas o Python possui dezenas de funções integradas prontas para uso. Você pode consultar a lista completa na documentação de funções embutidas do Python.

Funções lambda 

Funções lambda são funções anônimas, ou seja, não possuem um nome definido. Elas são usadas para criar pequenas funções de forma mais compacta, geralmente em situações em que você precisa realizar uma operação mais simples, sem necessidade de definir uma função completa com `def`. 

A sintaxe é bem direta: 

``` 
lambda argumentos: expressão 
```

Por exemplo, se quisermos criar uma função que dobra um número, poderíamos escrever: 

``` 
dobrar = lambda x: x * 2 
print(dobrar(5)) # Saída: 10 
```

Aqui, `lambda x: x * 2` cria uma função que recebe um parâmetro `x` e retorna o resultado da multiplicação por 2. 

Quando usar funções lambda? 

As funções lambda são úteis por sua simplicidade e por permitirem definir comportamentos rápidos. Elas são muito usadas em conjunto com outras funções que recebem funções como argumentos, como `map()`, `filter()` e `sorted()`. 

São especialmente úteis para: 

• Aplicar transformações em listas, tuplas ou outros iteráveis. 
• Filtrar dados de forma direta, com `filter()`. 
• Ordenar coleções com base em uma chave específica usando `sorted()`. 
• Evitar criar funções nomeadas que serão usadas apenas uma vez. 

Por exemplo, se quisermos ordenar uma lista de tuplas pelo segundo elemento, podemos fazer isso com uma função lambda: 

``` 
pares = [(1, 3), (2, 1), (4, 2)] 
ordenado = sorted(pares, key=lambda x: x[1]) 
print(ordenado)  # Saída: [(2, 1), (4, 2), (1, 3)] 
```

Mas é importante lembrar: se o comportamento for complexo ou precisar ser reutilizado várias vezes, prefira usar uma função comum com `def`. Assim, o código fica mais legível e fácil de manter. 

Recursão em funções 

A recursão é uma técnica em que a função chama a si mesma para resolver um problema. Esse conceito pode parecer estranho no início, mas é muito útil para situações em que um problema pode ser dividido em partes menores de forma repetitiva, como cálculos matemáticos, percorrer estruturas de dados ou resolver problemas em etapas. 

Em outras palavras, a recursão é uma forma de fazer com que uma função repita um processo até alcançar uma condição de parada. Essa condição é essencial para evitar que a função se chame infinitamente. 

Um exemplo clássico é o cálculo de fatorial de um número: 

``` 
def fatorial(n): 
    if n == 1: 
        return 1 
    else: 
        return n * fatorial(n - 1) 
 print(fatorial(5))     # Saída: 120 
```

Nesse código, a função `fatorial()` chama a si mesma com o valor de `n - 1` até que `n` seja igual a 1. Quando isso acontece, o processo “volta” resolvendo cada multiplicação pendente, resultando no fatorial completo. 

Então, ao chamar `fatorial(5)` o Python executa internamente: 

``` 
5 * 4 * 3 * 2 * 1 = 120 
```

No entanto, é um recurso que deve ser usado com cuidado, funções recursivas mal planejadas podem gerar loops infinitos ou consumir muita memória, causando um erro de _recursion limit_. 

Boas práticas ao criar funções em Python 

Criar funções é uma parte importante da programação, mas escrever funções de forma organizada ajuda a tornar o código mais legível, reutilizável e fácil de manter. Seguir algumas orientações garante que suas funções sejam claras e funcionais, facilitando o entendimento e a manutenção, mesmo quando outras pessoas (ou você no futuro) precisarem trabalhar com o código. 

• Escolha nomes descritivos: o nome da função deve indicar claramente o que ela faz. Prefira `calcular_media()` a `func1()`, por exemplo, tornando o código mais fácil de ler e compreender. 
• Mantenha o foco em uma única responsabilidade: uma função deve realizar apenas uma tarefa bem definida. Isso torna o comportamento da função mais previsível e reduz o risco de erros. 
• Use parâmetros e retornos de forma consciente: evite depender de variáveis globais e prefira passar dados como parâmetros. Retorne apenas o que é necessário. 
• Evite funções muito longas: se uma função começar a ficar extensa, considere dividi-la em funções menores, cada uma responsável por uma parte específica da tarefa.  
• Trate exceções quando necessário: em operações que podem gerar erros, como cálculos matemáticos ou leitura de arquivos, use blocos `try` e `except` para lidar com exceções de forma controlada. 
• Inclua docstrings: use _docstrings_ para explicar o propósito da função, seus parâmetros e o que ela retorna. Isso facilita a documentação e a colaboração entre desenvolvedores. 

Seguindo essas práticas, suas funções se tornam mais claras e seguras, permitindo que programas mais complexos sejam construídos e mantidos de forma eficiente.  

O que são docstrings? 

As _docstrings_ são cadeias de texto usadas para documentar funções, classes e módulos em Python. Elas servem para explicar o que determinado trecho faz, quais parâmetros recebe e o que retornar. Essa documentação é escrita logo após a definição da função, dentro de três aspas duplas (`””” “””`). 

Por exemplo: 

``` 
def saudacao(nome): 
    """ 
    Exibe uma mensagem de saudação personalizada. 
    Parâmetros: 
    nome (str): Nome da pessoa a ser saudada. 
    """ 
    print(f"Olá, {nome}!") 
```

Nesse exemplo, a _docstring_ descreve o propósito da função `saudacao` e explica o parâmetro utilizado. 

As _docstrings_ não interferem na execução do código, mas são muito úteis para quem vai ler ou dar manutenção em um projeto. Elas podem ser acessadas durante a execução do programa usando a função `help()` ou o atributo `.__doc__`, o que torna a documentação parte integrante do próprio código. 

Por exemplo: 

``` 
help(saudacao) 
# ou 
print(saudacao.__doc__) 
```

Isso exibirá no terminal o conteúdo da __docstring__, facilitando a compreensão da função sem precisar abrir o código-fonte. 

Como aprender mais sobre funções em Python 

Dominar o uso de funções é um passo fundamental para quem quer evoluir na programação com Python. Elas estão presentes em praticamente todos os projetos, desde scripts até sistemas complexos, e compreender bem como criá-las e aplicá-las eleva a qualidade e a eficiência do código no dia a dia de quem desenvolve 

Se você quer aprofundar seus conhecimentos e aprender a usar funções, uma excelente opção é seguir a nossa Carreira em Desenvolvimento Back-End Python.

Essa trilha foi criada para guia o aprendizado de forma estruturada, começando pelos fundamentos da linguagem e avançando até a construção de aplicações web, APIs e microsserviços. Ao longo do percurso, você vai: 

• Aprender a programar com Python a partir de desafios. 
• Entender a fundo como funções, condicionais e laços estruturam a base de qualquer aplicação. 
• Desenvolver o raciocínio computacional, aprendendo a decompor problemas e aplicar boas práticas desde o início. 

Se o seu objetivo é aprender na prática, ganhar confiança e entender como aplicar funções em projetos, essa é a oportunidade perfeita para iniciar seu caminho. 

FAQ | Perguntas frequentes sobre funções em Python 

1. O que são funções em Python? 

Funções são blocos de código que executam uma tarefa específica. Elas ajudam a organizar seu programa em partes menores, evitam a repetição de código e tornam o desenvolvimento mais eficiente. Funções podem ser reutilizadas, receber dados (parâmetros) e retornar resultados. 

2. Por que usar funções? 

Elas tornam o código mais organizado e fácil de entender, além de oferecerem flexibilidade para ajustar ou expandir funcionalidades. Funções também simplificam resolução de problemas complexos, dividindo-os em etapas menores e testáveis. 

3. Quais são os tipos de função em Python? 

Existem três categorias principais: 

• Funções definidas pelo usuário: Funções que você cria para resolver problemas específicos do seu programa. 
• Funções integradas (_built-in_): Funções que já vem prontas com o Python, como `print()`, `len()` e `type()`. 
• Funções anônimas ou _lambda_: Pequenas funções criadas em uma única linha, ideais para tarefas simples e rápidas. 

4. Qual a diferença entre parâmetro e argumento? 

Parâmetros são as variáveis listadas na definição da função que representam os dados esperados. Por exemplo, em `def saudacao(nome):`, `nome` é o parâmetro. Argumentos são os valores reais que você passa para a função quando a chama. Por exemplo, em `saudacao(“Maria”)`, `”Maria”` é o argumento. 

5. O que são argumentos nomeados? 

Argumentos nomeados são passados para a função usando o nome do parâmetro. Isso permite que você ignore a ordem dos parâmetros na chamada da função. Por exemplo,`apresentar_pessoa(idade=40, nome="Henrique")` funciona mesmo que o parâmetro `nome` venha antes de `idade` na definição da função. 

6. O que são funções lambda? 

Funções lambda são pequenas funções anônimas (sem nome) criadas em uma única linha, ideais para operações simples. A sintaxe é `lambda argumentos: expressão`. Elas são usadas para evitar a criação de uma função completa com `def` para uma tarefa pontual. 

7. O que é recursão em funções? 

Recursão é a técnica onde uma função chama a si mesma para resolver um problema. É útil para problemas que podem ser divididos em partes menores, como o cálculo de um fatorial. A recursão deve ter uma condição de parada para evitar que a função se chame infinitamente. 

8. O que são _docstrings_ e por que são importantes? 

_Docstrings_ são cadeias de texto usada para documentar funções, classes e módulos. Elas descrevem o propósito, os parâmetros e o que a função retorna. São escritas logo após a definição da função e ajudam a tornar o código mais legível e fácil de manter.