Introdução

Assim como todas as linguagens de programação, o Python permite que você defina funções. Depois de definir uma função, você pode chamá-la sempre que precisar no script e também importar uma função de um módulo específico dentro de outro módulo. As funções tornam seu código modular e reutilizável.

No Python, você pode definir funções para receber diferentes tipos de argumentos. E este guia irá ensiná-lo tudo sobre argumentos de função em Python. Vamos começar.

Uma rápida revisão de funções em Python

Para definir uma função em Python, você pode usar a palavra-chave "def" seguida pelo nome da função e parênteses. Se você quiser que a função receba argumentos, então os nomes dos argumentos devem ser especificados como parâmetros entre parênteses. Após definir uma função, você pode chamá-la com valores para os parâmetros, chamados de argumentos.

Por exemplo, considere a definição da função "add()": "num1" e "num2" são os parâmetros e os valores usados para esses parâmetros na chamada da função são os argumentos.

Argumentos posicionais

Considere a seguinte função "meet()". Ela recebe três strings e imprime as informações da pessoa.

def meet(name,job_title,city):
    return f"Meet {name}, a {job_title} from {city}."

Você pode chamar a função com argumentos, como mostrado abaixo:

meet1 = meet('James','Writer','Nashville')
print(meet1)

Saída >> Meet James, a Writer from Nashville.

Ao chamar a função dessa maneira, os argumentos são passados como argumentos posicionais. Argumentos posicionais são mapeados para os parâmetros da função na mesma ordem em que aparecem na chamada da função.

Portanto, o primeiro, segundo e terceiro argumentos na chamada da função são usados como valores de nome, cargo e cidade, respectivamente.

Aqui está um exemplo:

meet2 = meet('Artist','John','Austin')
print(meet2)

Saída >> Meet Artist, a John from Austin.

Nesse caso, a saída "Meet Artist, a John from Austin." não faz sentido. É aqui que os argumentos de palavra-chave podem ajudar.

Argumentos de palavra-chave

Ao usar argumentos de palavra-chave na chamada da função, você deve especificar o nome do parâmetro e o valor que ele recebe.

Você pode especificar os argumentos de palavra-chave em qualquer ordem, desde que os nomes dos parâmetros estejam corretos. Vamos chamar a mesma função "meet()", mas desta vez com argumentos de palavra-chave.

meet3 = meet(city='Madison',name='Ashley',job_title='Developer')
print(meet3)

Saída >> Meet Ashley, a Developer from Madison.

E se você quiser usar uma combinação de argumentos posicionais e de palavra-chave? Isso tornará seu código menos legível e não é recomendado. Mas se você estiver usando argumentos posicionais e de palavra-chave na chamada da função, os argumentos posicionais devem sempre preceder os argumentos de palavra-chave. Caso contrário, você encontrará erros.

Chamando funções com um número variável de argumentos

Até agora, sabíamos o número de argumentos antecipadamente e definimos a função de acordo. No entanto, nem sempre pode ser o caso. E se você gostaria que sua função aceitasse um número variável de argumentos cada vez que ela é chamada?

Ao trabalhar com bases de código Python, você provavelmente se deparou com definições de função da seguinte forma:

def some_func(*args, **kwargs):
	# do something on args and kwargs

Usando *args e **kwargs na definição da função, você pode fazer a função aceitar um número variável de argumentos posicionais e de palavra-chave, respectivamente. Eles funcionam da seguinte maneira:

• args coleta um número variável de argumentos posicionais como uma tupla, que pode ser desempacotada usando o operador * de desempacotamento.
• kwargs coleta todos os argumentos de palavra-chave na chamada da função como um dicionário. Esses argumentos de palavra-chave podem ser desempacotados usando o operador **.

Nota: Usar *args e **kwargs não é um requisito estrito. Você pode usar qualquer nome de sua escolha.

Vamos tomar exemplos para entender isso melhor.

Número Variável de Argumentos Posicionais

A função reverse_strings aceita um número variável de strings e retorna uma lista de strings invertidas.

def reverse_strings(*strings):
    reversed_strs = []
    for string in strings:
        reversed_strs.append(string[::-1])
    return reversed_strs

Agora você pode chamar a função com um ou mais argumentos conforme necessário. Aqui estão alguns exemplos:

rev_strs1 = reverse_strings('Python')
print(rev_strs1)

Saída >> ['nohtyP']

rev_strs2 = reverse_strings('Coding','Is','Fun')
print(rev_strs2)

Saída >> ['gnidoC', 'sI', 'nuF']

Número Variável de Argumentos de Palavras-chave

A seguinte função running_sum() aceita um número variável de argumentos de palavras-chave:

def running_sum(**nums):
    sum = 0
    for key,val in nums.items():
        sum+=val
    return sum

Como nums é um dicionário Python, você pode chamar o método items() no objeto dict para obter uma lista de tuplas. Cada tupla é um par chave-valor.

Aqui estão alguns exemplos:

sum1 = running_sum(a=1,b=5,c=10)
print(sum1)

Saída >> 16

sum2 = running_sum(num1=7,num2=20)
print(sum2)

Saída >> 27

Nota: Quando se usa *args e **kwargs, os argumentos posicionais e de palavras-chave não são obrigatórios. Portanto, essa é uma maneira de tornar seus argumentos de função opcionais.

Usando Valores Padrão para Argumentos

Ao definir funções em Python, você pode fornecer valores padrão para um ou mais parâmetros. Se você fornecer um valor padrão para um parâmetro específico, não será necessário usar o argumento na chamada da função.

• Se o argumento correspondente ao parâmetro for fornecido na chamada da função, esse valor será usado.
• Caso contrário, o valor padrão será usado.

No exemplo a seguir, a função greet() tem um parâmetro, name, definido com um valor padrão de "there".

def greet(name='there'):
    print(f"Hello {name}!")

Então, quando você chama greet() com uma string específica como argumento, o valor dessa string é usado.

greet('Jane')

Saída >> Hello Jane!

Quando você não passa a string "name", o argumento padrão "there" é usado.

greet()

Saída >> Hello there!

Argumentos Padrão Mutáveis

Ao usar argumentos padrão, você deve ter cuidado para não definir o valor padrão como um objeto mutável. Mas por quê? Vamos pegar um exemplo para entender.

A seguinte função append_to_list() recebe um elemento e uma lista como argumentos. Ela adiciona o elemento ao final da lista e retorna a lista resultante.

# def_args.py
def append_to_list(elt,py_list=[]):
    py_list.append(elt)
    return py_list

Você esperaria o seguinte comportamento:

• Quando a função é chamada com ambos o elemento e a lista, ela retorna a lista contendo o elemento adicionado ao final da lista original.
• Quando você chama a função com apenas o elemento como argumento, ela retorna uma lista contendo apenas esse elemento.

Mas vamos ver o que acontece.

Abra o seu terminal, execute o comando python -i para iniciar um REPL do Python. Eu defini a função append_to_list() no arquivo def_args.py.

>>> from def_args import append_to_list

Quando você chama a função com o número 4 e a lista [1,2,3] como argumentos, você obtém [1,2,3,4], o que é esperado.

>>> append_to_list(4,[1,2,3])
[1, 2, 3, 4]

Agora, vamos fazer uma série de chamadas de função com apenas o elemento a ser adicionado à lista:

>>> append_to_list(7)
[7]

>>> append_to_list(9)
[7, 9]

>>> append_to_list(10)
[7, 9, 10]

>>> append_to_list(12)
[7, 9, 10, 12]

Espere, isso não é o que esperávamos. Na primeira vez em que a função é chamada com 7 como argumento (sem a lista), obtemos [7]. No entanto, nas chamadas seguintes, vemos que os elementos são adicionados a esta lista.

Isso ocorre porque argumentos padrão são vinculados à definição da função apenas uma vez - no momento da definição da função. A lista é modificada pela primeira vez durante a chamada da função append_to_list(7). A lista não está mais vazia. E todas as chamadas subsequentes à função - sem a lista - modificarão a lista original.

Portanto, você deve evitar o uso de argumentos padrão mutáveis. Uma possível solução alternativa é definir o valor padrão como None e inicializar uma lista vazia sempre que a chamada da função não contiver a lista.

Conclusão

Aqui está um resumo do que você aprendeu neste tutorial. Você aprendeu como chamar funções Python com argumentos posicionais e de palavra-chave e como usar *args e **kwargs para passar um número variável de argumentos posicionais e de palavra-chave, respectivamente. Em seguida, você aprendeu como definir valores padrão para certos parâmetros e o caso curioso de argumentos padrão mutáveis. Espero que você tenha achado este tutorial útil. Continue programando!