Como usar argumentos opcionais no Python?

[

Usando Argumentos Opcionais em Python ao Definir Funções

Por Stephen Gruppetta

Introdução

Definir suas próprias funções é uma habilidade essencial para escrever código limpo e eficaz. Neste tutorial, você explorará as técnicas disponíveis para definir funções em Python que aceitam argumentos opcionais. Quando você dominar os argumentos opcionais em Python, poderá definir funções mais poderosas e flexíveis.

Neste tutorial, você aprenderá:

• Qual é a diferença entre parâmetros e argumentos.
• Como definir funções com argumentos opcionais e valores padrão para parâmetros.
• Como definir funções usando args e kwargs.
• Como lidar com mensagens de erro relacionadas a argumentos opcionais.

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

Uma função pode ser entendida como um mini programa que é executado dentro de outro programa ou dentro de outra função. O programa principal chama o mini programa e envia as informações necessárias enquanto ele é executado. 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 objetivo principal de uma função é permitir que você reutilize o código dentro dela sempre que precisar, utilizando entradas diferentes, se necessário.

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

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 quando chamá-la. Como as funções representam ações, é uma boa prática começar os nomes das funções com um verbo para tornar 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,
}

Neste caso, a função não possui parâmetros de entrada. Define-se uma lista de compras inicial e a imprime. Podemos fazer isso criando uma função print_shopping_list():

def print_shopping_list():
    for item, quantity in shopping_list.items():
        print(f"{item}: {quantity}")

print_shopping_list()

Ao chamar a função print_shopping_list(), a lista de compras será impressa. O resultado será:

Pão: 1
Leite: 2
Chocolate: 1
Manteiga: 1
Café: 1

Definindo Funções Com Argumentos Obrigatórios

Agora, vamos supor que você queira adicionar um novo item à lista de compras antes de imprimi-la. Nesse caso, precisaremos modificar nossa função para aceitar um argumento que representa o item a ser adicionado. Vamos chamar esse argumento de new_item.

def print_shopping_list(new_item):
    shopping_list[new_item] = 1
    for item, quantity in shopping_list.items():
        print(f"{item}: {quantity}")

print_shopping_list("Ovos")

Ao chamar a função atualizada print_shopping_list("Ovos"), a lista de compras será atualizada para incluir os ovos e será impressa novamente:

Pão: 1
Leite: 2
Chocolate: 1
Manteiga: 1
Café: 1
Ovos: 1

Usando Argumentos Opcionais em Python com Valores Padrão

Os argumentos opcionais permitem que você defina um valor padrão para um parâmetro, de modo que esse parâmetro seja considerado opcional ao chamar a função. Se nenhum valor for passado para o parâmetro, o valor padrão será utilizado.

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

Vamos supor que você queira adicionar a opção de definir uma quantidade diferente para cada item na lista de compras. Podemos definir um valor padrão de 1 para o parâmetro quantity ao criar a função print_shopping_list().

def print_shopping_list(new_item, quantity=1):
    shopping_list[new_item] = quantity
    for item, quantity in shopping_list.items():
        print(f"{item}: {quantity}")

print_shopping_list("Papel Higiênico", 3)

Ao chamar a função print_shopping_list("Papel Higiênico", 3), a lista de compras será atualizada com o novo item e a quantidade especificada, e será impressa novamente:

Pão: 1
Leite: 2
Chocolate: 1
Manteiga: 1
Café: 1
Ovos: 1
Papel Higiênico: 3

Se você chamar a função apenas com o argumento obrigatório, o valor padrão será utilizado:

print_shopping_list("Creme Dental")

Pão: 1
Leite: 2
Chocolate: 1
Manteiga: 1
Café: 1
Ovos: 1
Papel Higiênico: 3
Creme Dental: 1

Valores Padrão Comuns para Argumentos Opcionais

Às vezes, há valores padrão comuns que fazem sentido para um determinado parâmetro. Por exemplo, se você estiver escrevendo uma função para calcular a média de uma lista de números, o valor padrão para a lista poderia ser uma lista vazia.

Podemos definir um valor padrão comum para o parâmetro quantity:

def print_shopping_list(new_item, quantity=None):
    if quantity is None:
        quantity = 1
    shopping_list[new_item] = quantity
    for item, quantity in shopping_list.items():
        print(f"{item}: {quantity}")

Ao chamar a função print_shopping_list("Pasta de Dente"), a lista de compras será atualizada com o novo item e a quantidade padrão, e será impressa novamente:

Pão: 1
Leite: 2
Chocolate: 1
Manteiga: 1
Café: 1
Ovos: 1
Papel Higiênico: 3
Creme Dental: 1
Pasta de Dente: 1

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

Ao definir valores padrão para parâmetros, é importante ter cuidado com os tipos de dados que você está utilizando. Alguns tipos de dados, como listas ou dicionários, são mutáveis. Isso significa que, se você definir um valor padrão desses tipos e modificar esse valor dentro da função, o valor padrão será atualizado e compartilhado entre todas as chamadas da função.

Por exemplo, vamos definir um valor padrão como uma lista:

def modify_list(item, items=[]):
    items.append(item)
    print(items)

modify_list("Apple")
modify_list("Banana")

Ao chamar a função modify_list("Apple"), a lista será atualizada para incluir a maçã e será impressa:

['Apple']

Ao chamar a função modify_list("Banana"), a lista será atualizada novamente para incluir a banana e será impressa:

['Apple', 'Banana']

Isso ocorre porque a lista items foi definida apenas uma vez, quando a função foi definida. Como a lista é mutável, ela é compartilhada entre todas as chamadas da função. Portanto, todas as chamadas subsequentes da função irão modificar a mesma lista.

Para evitar esse comportamento indesejado, é recomendado usar um valor não mutável como valor padrão:

def modify_list(item, items=None):
    if items is None:
        items = []
    items.append(item)
    print(items)

Agora, ao chamar a função modify_list("Apple"), a lista será atualizada para incluir apenas a maçã e será impressa:

['Apple']

E quando chamarmos a função modify_list("Banana"), a lista será atualizada apenas com a banana e será impressa:

['Banana']

Mensagens de Erro Relacionadas a Argumentos de Entrada

Ao usar argumentos opcionais em funções, é importante lidar com mensagens de erro caso os argumentos não sejam fornecidos corretamente ao chamar a função.

Por exemplo, se a função print_shopping_list() for chamada sem fornecer um novo item, ocorrerá um erro:

print_shopping_list()

TypeError: print_shopping_list() missing 1 required positional argument: 'new_item'

Para evitar esse tipo de erro, você pode definir um valor padrão para o parâmetro new_item:

def print_shopping_list(new_item=None, quantity=None):
    if new_item is None:
        print("New item is required.")
        return

    if quantity is None:
        quantity = 1

    shopping_list[new_item] = quantity
    for item, quantity in shopping_list.items():
        print(f"{item}: {quantity}")

Agora, se a função print_shopping_list() for chamada sem fornecer um novo item, a mensagem de erro será exibida:

print_shopping_list()

New item is required.

Conclusão

Neste tutorial, você aprendeu a usar argumentos opcionais em Python ao definir funções. Isso permite que você crie funções mais flexíveis, com valores padrão para parâmetros e a possibilidade de aceitar qualquer número de argumentos ou argumentos-chave.

As técnicas apresentadas neste tutorial ajudarão você a escrever código mais legível e a reutilizar seu código com mais eficiência. Agora você tem o conhecimento necessário para criar funções mais poderosas em Python.

Continue praticando e experimentando diferentes casos de uso para argumentos opcionais em suas próprias funções. Isso o ajudará a aprofundar sua compreensão e aprimorar suas habilidades de programação em Python.

Voltar para o topo