Como Utilizar Argumentos Opcionais em Python

[

Usando Argumentos Opcionais em Python ao Definir Funções

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 recebem 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 de parâmetro padrão
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

Você pode pensar em uma função 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 informações de que o mini programa precisará enquanto é executado. Quando a função completa todas as suas ações, ela pode enviar alguns dados de volta ao programa principal que a chamou.

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

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

Em Python, por convenção, você deve nomear uma função usando letras minúsculas, com palavras separadas por sublinhados, 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 tornar seu código mais legível.

Definindo Funções Sem Parâmetros de Entrada

Comece criando uma lista de compras:

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

Aqui você cria um dicionário chamado shopping_list, que possui produtos de supermercado como chaves e as quantidades desejadas como valores.

Agora você pode criar uma função para imprimir a lista de compras. Essa função não terá nenhum parâmetro de entrada. Aqui está como você define a função:

def imprimir_lista_compras():
    for produto, quantidade in shopping_list.items():
        print(f"{produto}: {quantidade}")

Nessa função, você percorre o dicionário shopping_list usando um loop for e imprime cada produto e sua quantidade. O método items() retorna uma lista de tuplas, cada uma contendo uma chave e um valor do dicionário.

Depois de definir a função imprimir_lista_compras(), você pode chamá-la para imprimir sua lista:

imprimir_lista_compras()

Usando Argumentos Opcionais em Python com Valores Padrão

Em alguns casos, você pode querer que uma função tenha um argumento opcional, o qual tenha um valor padrão definido caso nenhum valor seja passado quando a função é chamada. Isso permite que você defina um comportamento padrão para a função, mas também dá a opção de alterar esse comportamento se necessário.

Para especificar um valor padrão para um argumento, você precisa incluí-lo na definição da função e atribuir um valor a ele. Aqui está um exemplo:

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

Nessa função, o parâmetro nome é opcional e tem um valor padrão de “amigo”. Se você chamar a função sem especificar um valor para o parâmetro nome, o valor padrão será usado:

saudacao()  # Saída: Olá, amigo!

Se você quiser, pode passar um valor específico para substituir o valor padrão:

saudacao("João")  # Saída: Olá, João!

Dessa forma, você pode fornecer uma saudação personalizada para a função, substituindo o valor padrão.

Valores Padrão Com atribuição aos Parâmetros de Entrada

Outra forma de definir valores padrão para os argumentos é atribuir os valores diretamente aos parâmetros de entrada ao definir a função. Aqui está um exemplo:

def adicionar_fruits(frutas=[], nova_fruta):
    frutas.append(nova_fruta)
    return frutas

Nesse exemplo, a função adicionar_fruits() recebe dois parâmetros: frutas e nova_fruta. O valor padrão para frutas é uma lista vazia. Se você chamar a função sem passar o primeiro parâmetro, a lista vazia será usada:

adicionar_fruits("maçã")  # Saída: ['maçã']

No entanto, se você chamar a função várias vezes sem especificar valores diferentes para frutas, os valores atribuídos aos parâmetros na primeira chamada da função serão usados em todas as chamadas subsequentes. Isso acontece porque o valor padrão é avaliado apenas uma vez, quando a função é definida.

Para evitar esse comportamento indesejado, é melhor usar um valor imutável como valor padrão, como None, e verificar se o parâmetro foi especificado antes de executar qualquer ação. Aqui está um exemplo:

def adicionar_fruits_nome(frutas=None, nova_fruta):
    if frutas is None:
        frutas = []
    frutas.append(nova_fruta)
    return frutas

Dessa forma, você garante que a lista frutas seja recriada sempre que a função for chamada sem especificar um valor para ela.

Valores Padrão Compartilhados entre Chamadas de Funções

Se você definir um valor mutável como padrão para um argumento, tenha em mente que as alterações feitas no objeto dentro da função serão refletidas em chamadas subsequentes da função. Aqui está um exemplo:

def adicionar_valor_lista(valor, lista=[]):
    lista.append(valor)
    return lista

Nesse exemplo, a função adicionar_valor_lista() tem dois parâmetros: valor e lista. O valor padrão para lista é uma lista vazia. Se você chamar a função sem especificar um valor para lista, a lista vazia será usada:

adicionar_valor_lista(1)  # Saída: [1]

No entanto, se você chamar a função várias vezes sem especificar valores diferentes para lista, os valores atribuídos aos parâmetros na primeira chamada da função serão usados em todas as chamadas subsequentes:

adicionar_valor_lista(2)  # Saída: [1, 2]

adicionar_valor_lista(3)  # Saída: [1, 2, 3]

Isso ocorre porque a lista é um objeto mutável e a mesma lista é compartilhada entre todas as chamadas subsequentes da função. Se você deseja que cada chamada da função crie uma lista nova, é melhor usar um valor imutável como valor padrão, seguido de verificações e atribuições apropriadas dentro da função.

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

Ao definir valores padrão para argumentos em Python, é importante ter cuidado com o tipo de dados que você usa como padrão. Alguns tipos de dados podem apresentar comportamentos inesperados quando usados como valores padrão. Aqui estão alguns exemplos:

Listas Vazias

def adicionar_valor_lista(valor, lista=[]):
    lista.append(valor)
    return lista

Nesse exemplo, quando você chama a função várias vezes sem especificar um valor para lista, a mesma lista vazia é usada em todas as chamadas subsequentes. Isso ocorre porque a lista é mutável e é compartilhada entre todas as chamadas da função.

Para evitar esse comportamento indesejado, é melhor usar um valor imutável como padrão e atribuir a lista vazia dentro da função:

def adicionar_valor_lista(valor, lista=None):
    if lista is None:
        lista = []
    lista.append(valor)
    return lista

Objetos Mutáveis

def adicionar_valor_dicionario(chave, valor, dicionario={}):
    dicionario[chave] = valor
    return dicionario

Nesse exemplo, quando você chama a função várias vezes sem especificar um valor para dicionario, o mesmo dicionário vazio é usado em todas as chamadas subsequentes. Isso ocorre porque o dicionário é um objeto mutável e é compartilhado entre todas as chamadas da função.

Para evitar esse comportamento indesejado, você pode atribuir None ao valor padrão e criar um novo dicionário dentro da função:

def adicionar_valor_dicionario(chave, valor, dicionario=None):
    if dicionario is None:
        dicionario = {}
    dicionario[chave] = valor
    return dicionario

Ao fazer isso, você garante que um novo dicionário seja criado sempre que a função for chamada sem especificar um valor para dicionario.

Mensagens de Erro Relacionadas a Argumentos de Entrada

Ao definir funções com argumentos opcionais, você pode encontrar mensagens de erro relacionadas à forma como você chama a função. Aqui estão algumas mensagens de erro comuns e como resolvê-las:

TypeError: nome_da_funcao() takes x positional arguments but y were given

Esse erro ocorre quando você chama a função com um número incorreto de argumentos posicionais. Verifique a definição da função e certifique-se de passar o número correto de argumentos na chamada da função.

TypeError: nome_da_funcao() missing required positional arguments: ‘nome_do_argumento’

Esse erro ocorre quando você chama a função sem fornecer um argumento que seja obrigatório. Verifique a definição da função e certifique-se de fornecer todos os argumentos obrigatórios na chamada da função.

TypeError: nome_da_funcao() got an unexpected keyword argument ‘nome_do_argumento’

Esse erro ocorre quando você chama a função com um argumento nomeado que a função não reconhece. Verifique a definição da função e certifique-se de que os nomes dos argumentos estejam corretos na chamada da função.

Conclusion

Neste tutorial, você aprendeu como definir funções em Python com argumentos opcionais e valores padrão, bem como as melhores práticas ao lidar com argumentos opcionais. Agora você tem as ferramentas necessárias para criar funções mais flexíveis e reutilizáveis. Utilize essa habilidade para melhorar seus programas e torná-los mais poderosos e eficientes.

Clique aqui para obter um Python Cheat Sheet e aprender o básico de Python 3, como trabalhar com tipos de dados, dicionários, listas e funções Python.