Funções em Python: tipos de argumentos

Posts Relacionados:

Métodos úteis de strings em Python

Operadores de atribuição em Python

Você sabe alinhar textos com Python?

01.10.24

Parâmetros ou argumentos são informações que podemos fornecer para uma função. Conheça seus tipos principais, casos de uso e aprenda como utilizá-los.

Receba nossa newsletter

Funções em Python

Quando definimos e chamamos funções em Python, podemos usar parâmetros ou argumentos para passar informações. Geralmente, os dois termos são usados como sinônimos. Mas, formalmente, parâmetro é a variável listada entre parênteses na definição da função. Argumento é um valor enviado para a função quando ela é chamada. Ambos são dados sobre quais funções executam alguma ação e retornam o resultado. Não é obrigatório usar argumentos na definição de funções em Python. Usamos argumento na definição de uma função quando precisamos executar a mesma tarefa várias vezes com dados diferentes.

Tipos de argumentos

Em Python, temos os seguintes tipos de argumentos que podem ser usados em uma função:

Argumentos posicionais
Argumentos padrão
Argumentos de palavra-chave (argumentos nomeados)
Argumentos posicionais arbitrários (*args)
Argumentos de palavra-chave arbitrários (**kwargs)

Argumentos posicionais

Os argumentos posicionais são o tipo mais básico. Eles são passados para uma função em uma ordem específica e sua posição determina a qual parâmetro eles são atribuídos.

				
					def imprime_produto_preco(produto, preco):
    print(f"O preço para {produto} é R$ {preco}" )

imprime_produto_preco('cadeira', '20,00')
# resultado: O preço para cadeira é R$ 20,00

No exemplo acima, a ordem dos argumentos fornecidos é essencial para que a informação impressa seja correta.

Argumentos padrão

Argumentos padrão possibilitam especificar um valor padrão para um parâmetro. Se nenhum argumento for fornecido quando a função for chamada, o valor padrão será usado.

				
					def calcula_desconto(preco, desconto=10):
    preco_final = preco - preco * (desconto/100)
    print(f"O preco com desconto é R$ {preco_final}" )

# chama função usando valor padrão como argumento
calcula_desconto(100)
# resultado: O preco com desconto é R$ 90.0

# chama função usando um novo valor como argumento
calcula_desconto(100, 5)
# resultado: O preco com desconto é R$ 95.0

Neste exemplo, primeiro a função é chamada sem especificar um novo valor para o argumento desconto. Neste caso, o valor padrão (10) é usado. Na segunda vez em que a função foi chamada, o argumento foi modificado para usar um novo valor (5).

Argumentos necessários (Required Arguments)

Os argumentos necessários são aqueles que devem ser fornecidos ao chamar a função. Eles são definidos sem um valor padrão.

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

soma(100, 200)
# resultado: 300

soma(100)
# TypeError: soma() missing 1 required positional argument: 'b'

Neste exemplo, a mesma função é chamada duas vezes. Na primeira, os valores de a e b foram passados corretamente. Na segunda, apenas um argumento foi fornecido, por isso houve uma exceção.

Argumentos de palavra-chave (Keyword Arguments)

Os argumentos de palavra-chave são passados para uma função usando o nome do parâmetro. Isso permite que você especifique argumentos em qualquer ordem. Veja abaixo um exemplo ilustrativo.

				
					def cadastro_cliente(nome, email, telefone):
    print(f"Dados para {nome}: email - {email}, telefone: {telefone}")

# chama função usando usando os nomes dos parâmetros - a ordem dos parâmetros chamados pelo nome não importa
cadastro_cliente(email='maria@email.com', nome='Maria', telefone='021-1233333')
# resultado: Dados para Maria: email - maria@email.com, telefone: 021-1233333

# chama função usando usando os nomes com outra ordem
cadastro_cliente(telefone='021-1233333', email='maria@email.com', nome='Maria')
# resultado: Dados para Maria: email - maria@email.com, telefone: 021-1233333

Neste exemplo, chamamos a função duas vezes. Cada chamada usou uma ordem de argumentos diferentes. Mas, como eles foram identificados pelos nomes que foram definidos, não houve nenhum problema.

Argumentos posicionais arbitrários (*args)

A sintaxe *args permite que uma função aceite qualquer número de argumentos posicionais. Esses argumentos são empacotados em uma tupla dentro da função. Esse tipo de argumento é extremamente útil para conferir flexibilidade aos códigos.

				
					def soma_numeros(*numeros):
    return sum(numeros)

print(soma_numeros(100, 90, 150, 200))  
# Resultado: 540

Argumentos de palavra-chave arbitrários ( **kwargs )

A sintaxe **kwargs permite que uma função aceite qualquer número de argumentos de palavra-chave. Ou seja, argumentos identificados por seus nomes. Esses argumentos são empacotados em um dicionário dentro da função. Veja um exemplo:

				
					def print_info(**clientes):
    for key, value in clientes.items():
        print(f"{key}: {value}")

print_info(nome="Maria", telefone="0211234567", cidade="Rio de Janeiro")
# resultado:
# nome: Maria
# telefone: 0211234567
# cidade: Rio de Janeiro

Neste exemplo, empacotamos três informações sobre um cliente. No exemplo abaixo, a mesma função é usada para imprimir cinco informações:

				
					print_info(nome="Maria", telefone="0211234567", cidade="Rio de Janeiro", email='maria@email.com', profissao='gerente')
# resultado:
# nome: Maria
# telefone: 0211234567
# cidade: Rio de Janeiro
# email: maria@email.com
# profissao: gerente

Combinado múltiplos tipos de argumentos

Ao definir funções, podemos combinar diferentes tipos de argumentos. No entanto, há uma ordem específica a seguir:

Argumentos necessários
Argumentos padrão
Argumentos posicionais arbitrários (*args)
Argumentos de palavra-chave arbitrários (**kwargs)

Veja abaixo um caso ilustrativo onde alguns desses argumentos foram usados em conjunto:

				
					def clientes(nome, desconto=10, **dados):
    print(f"O valor do desconto para {nome} é de {desconto}%. A entrega deve ser feita em {dados}")

#dados = 'cidade': 'Londrina', 'rua': 'Rua do centro', '123', 'bloco A', 'apartamento 101')
clientes('Ana', desconto=10, cidade='Londrina', rua='Rua do centro', número='123', bloco='bloco A', apartamento='apartamento 101')
# resultado: O valor do desconto para Ana é de 10%. A entrega deve ser feita em {'cidade': 'Londrina', 'rua': 'Rua do centro', 'número': '123', 'bloco': 'bloco A', 'apartamento': 'apartamento 101'}

Ao dominar os diferentes tipos de argumentos que o Python possui, você pode criar funções mais flexíveis e eficientes.