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.
Veja também:
Concatenações com join() para strings em Python
O que é operador ternário em Python?
F-strings em Strings Multilinhas
Decodificação de strings em Python com decode()
Métodos para Manipular Strings em Python
Módulo Getpass para Prompts de Senhas
Aprenda a comparar textos com Python com Difflib
Módulo textwrap para formatação de textos
Manipulação de arquivos com Python
os.environ: gerenciamento de variáveis de ambiente com Python
Encontrou algum erro ou quer fazer uma sugestão? Por favor, entre em contato usando nosso formulário de contatos.
