Argumentos de função em

Sobre Argumentos de função

Para o básico sobre argumentos de função, veja o conceito de função.

Nomes de parâmetros

Nomes de parâmetros, assim como nomes de variáveis, precisam começar com uma letra ou um sublinhado e podem conter letras, sublinhados ou números. Nomes de parâmetros não devem conter espaços nem pontuação.

Argumentos posicionais

Argumentos posicionais são valores passados para uma função na mesma ordem dos parâmetros que se ligam a eles. Argumentos posicionais podem, opcionalmente, ser passados usando o nome do parâmetro:

def concat(greeting, name):
    return f"{greeting}{name}"

# Passing data to the function by position.
print(concat("Hello, ", "Lilly"))
#->  Hello, Lilly

# Passing data to the function using the parameter name.
print(concat(name="Glenn", greeting="Hello, "))
#-> Hello, Glenn

A primeira chamada a concat passa os argumentos por posição. A segunda chamada a concat passa os argumentos por nome, o que permite alterar suas posições.

Repare que argumentos posicionais não podem vir depois de argumentos passados por nome (também chamados de argumentos nomeados. Não devem ser confundidos com parâmetros var-positionais ou **kwargs**).)

Este conjunto de argumentos:

print(concat(greeting="Hello, ", "Gregor"))

Resulta neste erro:

SyntaxError: positional argument follows keyword argument

Exigir argumentos apenas posicionais nas chamadas de função pode ser feito com o uso do operador / na lista de parâmetros:

# Parameters showing a position-only operator. 
def concat(greeting, name, /):
    return f"{greeting}{name}"

print(concat("Hello, ", "Ginnie"))
#-> Hello, Ginnie

# Call to the function using keyword arguments.
print(concat(name="Franklin", greeting="Hello, "))
Traceback (most recent call last):
    print(concat(name="Franklin", greeting="Hello, "))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting, name'

Argumentos nomeados

Argumentos nomeados usam o nome do parâmetro ao chamar uma função. Eles também podem, opcionalmente, ser referidos por posição:

def concat(greeting, name):
    return f"{greeting}{name}"

# Function call using parameter names as argument keywords.
print(concat(name="Eliza", greeting="Hello, "))
#-> Hello, Eliza

# Function call with positional data as arguments.
print(concat("Hello, ", "Tim"))
#-> Hello, Tim

Exigir argumentos apenas nomeados nas chamadas de função pode ser feito com o uso do operador * na lista de parâmetros:

# Function definition requiring keyword-only arguments.
def concat(*, greeting, name):
    return f"{greeting}{name}"

# Keyword arguments can be in an arbitrary order.
print(concat(name="Kimmie", greeting="Hello, "))
#-> Hello, Kimmie

# Calling the function with positional data raises an error.
print(concat("Hello, ", "Coleen"))
Traceback (most recent call last):
    print(concat("Hello, ", "Coleen"))
TypeError: concat() takes 0 positional arguments but 2 were given

Valores padrão de argumentos

Valores padrão para um ou mais argumentos podem ser fornecidos na lista de parâmetros. Isso permite chamar a função com menos argumentos, se necessário. Os valores padrão podem ser substituídos chamando a função com um novo valor de argumento, sobrepondo o padrão:

# Function with default argument values.
def concat(greeting, name="you", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

print(concat("Hello"))
#-> Hello, you!

# Overriding the default values
print(concat("Hello", name="Polly", punctuation="."))
#-> Hello, Polly.

Argumentos posicionais ou nomeados

Os argumentos podem ser posicionais ou nomeados se nem o operador / nem o * forem usados nas definições dos parâmetros. Como alternativa, os argumentos posicionais ou nomeados podem ser colocados entre os parâmetros apenas posicionais, à esquerda, e os parâmetros apenas nomeados, à direita:

# Position-only argument followed by position-or-keyword, followed by keyword-only.
def concat(greeting, /, name, *, ending):
    return f"{greeting}{name}{ending}"

print(concat("Hello, ", "Mark", ending="!"))
#-> Hello, Mark!

print(concat("Hello, ", name="Rachel", ending="!"))
#-> Hello, Rachel!

print(concat(greeting="Hello, ", name="JoJo", ending="!"))
Traceback (most recent call last):
    print(concat(greeting="Hello, ", name="JoJo", ending="!"))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting'

*args

Exemplos de código costumam usar uma definição de função mais ou menos assim:

def my_function(*args, **kwargs):
    # code snipped

*args é um nome de duas partes que representa uma tuple com um número indefinido de argumentos posicionais separados, também conhecida como variadic argument. args é o nome dado à tuple de argumentos, mas poderia ser qualquer outro nome válido em Python, como my_args, arguments, etc. O * é o operador que transforma o grupo de argumentos separados em uma tuple.

Como uma tuple pode ser iterada, args pode ser passado para qualquer outra função que aceite um iterável. Embora *args seja comumente justaposto a **kwargs, ele não precisa ser:

def add(*args):
    # args is passed to the sum function, which iterates over it.
    return sum(args)

print(add(1, 2, 3))
#-> 6

Se *args vier depois de um ou mais argumentos posicionais, *args será o que sobrar após os argumentos posicionais:

def add(first, *args):
    # first will be 1, leaving the values 2 and 3 in *args
    return first + sum(args)

print(add(1, 2, 3))
#-> 6

Se um ou mais argumentos padrão forem definidos depois de *args, eles ficam separados dos valores de *args:

def add(first, *args, last=0):
    return first + sum(args) + last
 
print(add(1, 2, 3))
#-> 6

print(add(1, 2, 3, last=4))
#-> 10

# This uses the unpacking operator * to separate the list elements into positional arguments.
# It does not have the same behavior as the * (packing) in *args.
print(add(*[1, 2, 3]))
#-> 6

Repare que, quando um argumento já está dentro de um iterable (como uma tuple ou uma list), ele precisa ser desempacotado antes de ser passado para uma função que recebe um número arbitrário de argumentos separados. Isso é feito usando *, que é o operador de desempacotamento.

O *, nesse contexto, desempacota o contêiner em seus elementos separados, que então são transformados por *args em uma tuple. Quando há apenas argumentos posicionais, a ação de desempacotamento precisa resultar no mesmo número de argumentos que há de parâmetros formais definidos.

Sem desempacotar a lista passada para add, o programa daria erro:

def add(first, *args, last=0):
    return first + sum(args) + last

print(add([1, 2, 3]))
Traceback (most recent call last):
    print(add([1, 2, 3]))
    return first + sum(args) + last
TypeError: can only concatenate list (not "int") to list

**kwargs

**kwargs é um nome de duas partes que representa um número indefinido de argumentos separados do tipo par chave-valor. kwargs é o nome do grupo de argumentos e poderia ser qualquer outro nome, como my_args, arguments, etc. O ** transforma o grupo de argumentos nomeados em um dictionary de pares {argument name: argument value}.

Como um dicionário pode ser iterado, kwargs pode ser passado para qualquer outra função que aceite um iterável. Embora **kwargs seja comumente justaposto a *args, ele não precisa ser:

def add(**kwargs):
    return sum(kwargs.values())

print(add(one=1, two=2, three=3))
#-> 6

Repare que o método dict.values() é chamado para iterar pelos values do dicionário kwargs. Ao iterar sobre um dicionário, o padrão é iterar pelas keys, então dict.values() precisa ser especificado explicitamente:

def concat(**kwargs):
    # Join concatenates the tuples from `kwargs.items()`
    return " ".join((str(item) for item in kwargs.items()))

print(concat(one=1, two=2, three=3))
#-> ('one', 1) ('two', 2) ('three', 3)