3 min de leitura ·

Explorando Funções em Python: Um Guia Completo

As funções são uma das ferramentas mais poderosas em Python, permitindo organizar e reutilizar código de maneira eficiente. Neste post, vamos mergulhar profundamente no mundo das funções, desde os conceitos básicos até técnicas mais avançadas.

O que são Funções?

Funções são blocos de código reutilizáveis que realizam uma tarefa específica. Elas ajudam a tornar o código mais modular e legível.

Definindo Funções

Para definir uma função, usamos a palavra-chave def, seguida pelo nome da função e parênteses. Dentro dos parênteses, podemos definir parâmetros. O bloco de código da função é indentado.

def nome_da_funcao(parametro1, parametro2):
    # Corpo da função
    resultado = parametro1 + parametro2
    return resultado

Exemplos Básicos

Função sem Parâmetros

def saudacao():
    print("Olá, mundo!")

saudacao()

Função com Parâmetros

def soma(a, b):
    return a + b

resultado = soma(3, 5)
print(resultado)  # Saída: 8

Função com Valor Padrão para Parâmetros

def saudacao(nome="mundo"):
    print(f"Olá, {nome}!")

saudacao("Alice")
saudacao()  # Usará o valor padrão "mundo"

Funções `lambda`

Funções lambda são pequenas funções anônimas, definidas usando a palavra-chave lambda. Elas podem ter múltiplos argumentos, mas apenas uma expressão.

soma = lambda x, y: x + y
print(soma(2, 3))  # Saída: 5

Escopo de Variáveis

Variáveis definidas dentro de uma função têm escopo local e não são acessíveis fora dela.

def minha_funcao():
    x = 10  # x é uma variável local
    print(x)

minha_funcao()
# print(x)  # Isso resultará em um erro, pois x não está definido fora da função

Parâmetros e Argumentos

Parâmetros Obrigatórios

def subtracao(a, b):
    return a - b

resultado = subtracao(10, 5)  # Saída: 5

Parâmetros Opcionais (com Valor Padrão)

def saudacao(nome="Visitante"):
    print(f"Olá, {nome}!")

saudacao("Carlos")  # Saída: Olá, Carlos!
saudacao()  # Saída: Olá, Visitante!

Argumentos Arbitrários (`*args` e `**kwargs`)

*args permite passar um número variável de argumentos posicionais.
**kwargs permite passar um número variável de argumentos nomeados.

def soma(*args):
    return sum(args)

print(soma(1, 2, 3, 4))  # Saída: 10

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

exibir_informacoes(nome="Alice", idade=30) 
# Saída:
# nome: Alice
# idade: 30

Funções Recursivas

Funções recursivas são aquelas que chamam a si mesmas. É importante ter uma condição de parada para evitar recursão infinita.

def fatorial(n):
    if n == 0:
        return 1
    else:
        return n * fatorial(n-1)

print(fatorial(5))  # Saída: 120

Documentação de Funções

É uma boa prática documentar suas funções para descrever o que elas fazem, seus parâmetros e o valor retornado. Para isso, usamos docstrings.

def soma(a, b):
    """
    Retorna a soma de dois números.

    Parâmetros:
    a (int, float): O primeiro número.
    b (int, float): O segundo número.

    Retorna:
    int, float: A soma de a e b.
    """
    return a + b

print(soma.__doc__)

Conclusão

Funções são uma parte fundamental do Python, permitindo a modularização e reutilização de código. Entender como defini-las, utilizá-las e documentá-las corretamente é crucial para escrever programas eficientes e legíveis.

Espero que este guia tenha esclarecido suas dúvidas sobre funções em Python. Pratique criando e utilizando suas próprias funções para solidificar seu entendimento. Boa codificação!

kht

4 meses atrás

Complementando:

Sobre o escopo de variáveis, existe uma "brecha": acessar uma variável que foi declarada fora da função (desde que não haja uma atribuição a ela) é permitido. Exemplo:

def f():
    print('dentro da função', x)

x = 10
f()
print('fora da função', x)

A saída deste código é:

dentro da função 10
fora da função 10

Ou seja, o x dentro da função refere-se à variável que foi criada fora dela. Isso é possível porque dentro da função não é feita nenhuma atribuição à variável x.

Agora se eu mudar para:

def f():
    x = 2
    print('dentro da função', x)

x = 10
f()
print('fora da função', x)

Agora a saída é:

dentro da função 2
fora da função 10

No caso, a atribuição x = 2 feita dentro da função poderia ser interpretada como a criação de uma variável local, ou uma alteração da variável x criada fora da função. Mas de acordo com as regras da linguagem, optaram pela primeira opção (ou seja, o x dentro da função não é o mesmo que está fora dela).

Se eu quisesse que a variável x externa fosse alterada dentro da função, teria que usar a declaração global:

def f():
    global x # quero usar a variável x que está definida fora da função
    x = 2
    print('dentro da função', x)

x = 10
f()
print('fora da função', x)

Agora a saída será:

dentro da função 2
fora da função 2

Sobre o parâmetro com valor default, tem uma pegadinha. Se usar tipos mutáveis, como listas ou dicionários, podem ocorrer situações inesperadas. Por exemplo:

# função recebe uma lista, e se não for passada, usa uma lista vazia
def f(lista=[]):
    lista.append(1)
    print(lista)

# chama a função 3 vezes
f()
f()
f()

O resultado será:

[1]
[1, 1]
[1, 1, 1]

Isso porque o valor default só é criado uma vez, quando a função é definida. Ou seja, cada vez que a função é chamada, ela acaba adicionando um elemento na mesma lista. Por isso que a cada chamada ela aumenta. A solução, neste caso, seria mudar para:

def f(lista=None):
    if lista is None:
        lista = []
    lista.append(1)
    print(lista)

Assim, a cada chamada sem parâmetros, uma nova lista é criada.

Por fim, sobre o *args e **kwargs, vale lembrar que também é possível usar ambos:

def f(*args, **kwargs):
    print('args:', args)
    print('kwargs:', kwargs)

print('somente posicionais:')
f(1, 2)

print('somente nomeados:')
f(a=3, b=4)

print('misturado:')
f(1, 2, a=3, b=4)

Assim, se eu chamar a função somente com argumentos posicionais, apenas args será preenchido e kwargs ficará vazio. E se chamar somente com argumentos nomeados, ocorre o contrário. E se chamar com ambos, tanto args quanto kwargs estarão preenchidos. A saída do código acima é:

somente posicionais:
args: (1, 2)
kwargs: {}
somente nomeados:
args: ()
kwargs: {'a': 3, 'b': 4}
misturado:
args: (1, 2)
kwargs: {'a': 3, 'b': 4}

Lembrando que os argumentos nomeados devem vir no final, ou seja, se fizer algo como f(a=1, b=2, 3, 4) ou ainda f(1, b=2, 3), dará erro.

Delabela

4 meses atrás

Eu estava estudando sobre funções esses dias e esse guia caiu como uma luva!

Obrigado por compartilhar seu conhecimento, vai ser muito util!

nicolas11

Autor

4 meses atrás

Fico muito feliz em contribuir com seus estudos.
fique de olho virão novos conteudos.
Ass:Nicolas

Explorando Funções em Python: Um Guia Completo