Pular para o conteúdo
CodeMDD.io | Coding Tutorials

Como usar parâmetros opcionais no Python?

[

Usando Parâmetros Opcionais em Python ao Definir Funções

Criando Funções em Python para Reutilizar Código

Você pode pensar em uma função como um mini-programa que roda dentro de outro programa ou dentro de outra função. O programa principal chama o mini-programa e envia informações que o mini-programa precisará enquanto roda. Quando a função completa todas as suas ações, ela pode enviar alguns dados de volta para o programa principal que a chamou.

O principal objetivo de uma função é permitir que você reutilize o código dentro dela sempre que precisar, usando diferentes entradas, se necessário.

Quando você usa funções, está expandindo seu vocabulário Python. Isso permite que você expresse a solução para o seu problema de uma maneira mais clara e sucinta.

Em Python, por convenção, você deve nomear uma função usando letras minúsculas com palavras separadas por um sublinhado, como fazer_algo(). Essas convenções são descritas no PEP 8, que é o guia de estilo do Python. Você precisará adicionar parênteses após o nome da função ao chamá-la. Como as funções representam ações, é uma boa prática começar os nomes das funções com um verbo para deixar seu código mais legível.

Definindo Funções Sem Parâmetros de Entrada

Neste tutorial, usaremos o exemplo de um programa básico que cria e mantém uma lista de compras e a imprime quando você estiver pronto para ir ao supermercado.

Comece criando uma lista de compras:

shopping_list = {
    "Pão": 1,
    "Leite": 2,
    "Chocolate": 1,
    "Manteiga": 1,
    "Café": 1,
}

Definindo Funções Com Argumentos de Entrada Obrigatórios

Agora que temos a nossa lista de compras, vamos criar uma função para adicionar itens a ela. Essa função receberá como argumentos obrigatórios o nome do item e a quantidade desejada. Aqui está o código:

def adicionar_item(lista_compras, nome_item, quantidade):
    lista_compras[nome_item] = quantidade

Agora, podemos chamar essa função para adicionar itens à nossa lista de compras da seguinte forma:

adicionar_item(shopping_list, "Ovos", 6)
adicionar_item(shopping_list, "Banana", 3)

Após chamar essas duas vezes a função adicionar_item(), nossa lista de compras será atualizada para incluir os itens “Ovos” com quantidade 6 e “Banana” com quantidade 3.

Usando Parâmetros Opcionais em Python com Valores Padrão

Até agora, vimos como definir funções com parâmetros obrigatórios, onde é necessário passar valores específicos ao chamar a função. No entanto, também é possível definir parâmetros opcionais em uma função, que têm valores padrão pré-definidos. Isso significa que, se nenhum valor for passado para o parâmetro opcional, ele assumirá o valor padrão.

Para definir um parâmetro opcional, basta atribuir um valor padrão ao parâmetro durante a definição da função. Por exemplo:

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

Neste exemplo, a função saudacao() tem um parâmetro opcional chamado nome, com um valor padrão de “amigo”. Isso significa que, se chamarmos a função sem passar um valor para o parâmetro nome, ele imprimirá “Olá, amigo!“.

Podemos chamar a função saudacao() de diferentes maneiras:

saudacao()  # Imprime: Olá, amigo!
saudacao("João")  # Imprime: Olá, João!

Valores Padrão Atribuídos aos Parâmetros de Entrada

As funções em Python permitem que você atribua valores padrão a quantos parâmetros desejar. Veja um exemplo de função com vários parâmetros opcionais:

def criar_usuario(nome, ativo=True, admin=False):
    print(f"Criando usuário: {nome}")
    print(f"Ativo: {ativo}")
    print(f"Admin: {admin}")

Neste exemplo, a função criar_usuario() recebe três parâmetros: nome, ativo e admin. O parâmetro nome é obrigatório, enquanto os outros dois são opcionais, com valores padrão True e False, respectivamente.

Podemos chamar a função criar_usuario() passando diferentes combinações de valores para os parâmetros:

criar_usuario("Maria")  # Imprime: Criando usuário: Maria, Ativo: True, Admin: False
criar_usuario("João", True)  # Imprime: Criando usuário: João, Ativo: True, Admin: False
criar_usuario("Pedro", False, True)  # Imprime: Criando usuário: Pedro, Ativo: False, Admin: True

Valores Padrão Comuns para Argumentos Opcionais

Existem alguns valores padrão comuns que você pode atribuir a argumentos opcionais em suas funções. Esses valores são amplamente utilizados e ajudam a melhorar a legibilidade e facilidade de uso do seu código. Aqui estão alguns exemplos:

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


def calcular_media(numeros=[]):
    if len(numeros) == 0:
        return 0
    return sum(numeros) / len(numeros)


def imprimir_nome(nome=None):
    if nome is None:
        nome = "Desconhecido"
    print(f"Nome: {nome}")

Nesses exemplos, as funções têm parâmetros opcionais com valores padrão que são amplamente utilizados:

  • A função saudacao() tem um parâmetro opcional nome com um valor padrão de “amigo”.
  • A função calcular_media() tem um parâmetro opcional numeros com um valor padrão de uma lista vazia. Isso permite que a função seja chamada sem passar quaisquer argumentos e evita um erro de divisão por zero.
  • A função imprimir_nome() tem um parâmetro opcional nome com um valor padrão None. Neste caso, se nenhum valor for passado para o parâmetro nome, ele será alterado para a string “Desconhecido”.

Tipos de Dados que Não Devem Ser Usados como Argumentos Padrão

Ao definir argumentos opcionais em suas funções, é importante ter cuidado ao escolher os valores padrão. Alguns tipos de dados específicos não devem ser usados como argumentos padrão, pois podem levar a comportamentos inesperados. Um exemplo comum é usar uma lista vazia como argumento padrão:

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


print(adicionar_item("A"))  # Imprime: ['A']
print(adicionar_item("B"))  # Imprime: ['A', 'B']

Neste exemplo, a função adicionar_item() recebe um argumento item e um argumento opcional lista, que tem uma lista vazia como valor padrão. No entanto, observe que, quando chamamos a função duas vezes, é impressa uma lista acumulativa contendo todos os itens adicionados até o momento. Isso ocorre porque a lista padrão é criada apenas uma vez na memória e continua sendo referenciada nas chamadas subsequentes à função.

Para evitar esse comportamento indesejado, é recomendável usar None como valor padrão e, dentro da função, verificar se o valor é None e, em caso afirmativo, criar uma nova lista vazia:

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


print(adicionar_item("A"))  # Imprime: ['A']
print(adicionar_item("B"))  # Imprime: ['B']

Agora, a função adicionar_item() funciona corretamente, pois cria uma nova lista vazia sempre que o valor padrão for None.

Mensagens de Erro Relacionadas a Argumentos de Entrada

Ao utilizar argumentos opcionais em suas funções, pode ser útil fornecer informações claras sobre como eles devem ser usados ​​para evitar erros de programação. Uma maneira de fazer isso é lançar exceções personalizadas quando um valor inválido for passado para um argumento.

Por exemplo, suponha que você esteja escrevendo uma função que calcule a área de um retângulo e que os lados do retângulo sejam argumentos opcionais com um valor padrão de 1. Se um valor negativo for passado para um desses argumentos, você pode lançar uma exceção ValueError com uma mensagem de erro adequada:

def calcular_area_retangulo(largura=1, altura=1):
    if largura <= 0 or altura <= 0:
        raise ValueError("As dimensões do retângulo devem ser maiores que zero.")
    return largura * altura


print(calcular_area_retangulo())  # Imprime: 1
print(calcular_area_retangulo(5, 10))  # Imprime: 50
print(calcular_area_retangulo(-1, 5))  # Levanta uma exceção ValueError

Neste exemplo, a função calcular_area_retangulo() verifica se a largura e a altura do retângulo são maiores que zero. Se um valor inválido for passado para algum dos argumentos, uma exceção ValueError será lançada com a mensagem “As dimensões do retângulo devem ser maiores que zero”. Isso ajuda a fornecer informações claras sobre o motivo da exceção e como corrigi-la.

Usando *args e **kwargs

Até agora, discutimos como usar parâmetros opcionais com valores padrão em nossas funções. No entanto, em alguns casos, você pode não saber quantos argumentos opcionais serão passados para sua função, ou você pode querer passar argumentos opcionais com nomes específicos.

Para lidar com esses casos, Python permite que você use os parâmetros especiais *args e **kwargs em suas definições de função.

Funções que Aceitam Qualquer Número de Argumentos

Vamos começar com o parâmetro especial *args. Ao definir um parâmetro com um asterisco antes do nome, você está dizendo ao Python para coletar todos os argumentos adicionais e colocá-los em uma tupla. Vejamos um exemplo:

def somar_numeros(*args):
    soma = 0
    for numero in args:
        soma += numero
    return soma


print(somar_numeros(1, 2, 3, 4))  # Imprime: 10
print(somar_numeros(10, 20, 30))  # Imprime: 60
print(somar_numeros(5, 10))  # Imprime: 15

Neste exemplo, a função somar_numeros() recebe qualquer número de argumentos e os soma todos. Os argumentos passados para a função são coletados em uma tupla chamada args, que pode ser percorrida usando um loop for.

Funções que Aceitam Qualquer Número de Argumentos com Nomes Específicos

Agora, vamos ver o parâmetro especial **kwargs. Ao definir um parâmetro com dois asteriscos antes do nome, você está dizendo ao Python para coletar todos os argumentos adicionais e colocá-los em um dicionário, onde as chaves são os nomes dos argumentos e os valores são seus valores correspondentes. Vejamos um exemplo:

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


imprimir_info(nome="Maria", idade=30, cidade="São Paulo")
# Imprime:
# nome: Maria
# idade: 30
# cidade: São Paulo

Neste exemplo, a função imprimir_info() recebe argumentos com nomes específicos e imprime suas informações. Os argumentos passados para a função são coletados em um dicionário chamado kwargs, que pode ser percorrido usando um loop for.

Conclusão

Neste tutorial, você aprendeu como definir funções em Python que aceitam argumentos opcionais. Você viu como definir parâmetros opcionais com valores padrão, como lidar com diferentes tipos de dados e como fornecer mensagens de erro claras relacionadas a argumentos de entrada. Além disso, você explorou o uso dos parâmetros especiais *args e **kwargs, que permitem lidar com qualquer número de argumentos ou argumentos com nomes específicos.

Dominar os argumentos opcionais em Python permite que você crie funções mais poderosas e flexíveis, que podem ser reutilizadas em várias situações. Use esse conhecimento para melhorar a legibilidade e a concisão do seu código, tornando-o mais fácil de ler e entender.

Lembre-se de que a prática é fundamental para se familiarizar com esses conceitos. Experimente desenvolver suas próprias funções com argumentos opcionais e explore diferentes casos de uso para aprofundar seu entendimento.