O que ** (estrela/asterisco duplo) e * (estrela/asterisco) fazem para os parâmetros?
https://stackoverflow.com/questions/36901
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Nas definições de método a seguir, o que o * e ** fazer por param2?
def foo(param1, *param2):
def bar(param1, **param2):
Solução
O *args e **kwargs é uma expressão comum para permitir um número arbitrário de argumentos para funções conforme descrito na seção mais sobre como definir funções na documentação do Python.
O *args lhe dará todos os parâmetros de função como uma tupla:
In [1]: def foo(*args):
...: for a in args:
...: print a
...:
...:
In [2]: foo(1)
1
In [4]: foo(1,2,3)
1
2
3
O **kwargs vou te dar tudoargumentos de palavra-chave exceto aqueles que correspondem a um parâmetro formal como um dicionário.
In [5]: def bar(**kwargs):
...: for a in kwargs:
...: print a, kwargs[a]
...:
...:
In [6]: bar(name='one', age=27)
age 27
name one
Ambas as expressões podem ser misturadas com argumentos normais para permitir um conjunto de argumentos fixos e alguns variáveis:
def foo(kind, *args, **kwargs):
pass
Outro uso do *l idioma é descompactar listas de argumentos ao chamar uma função.
In [9]: def foo(bar, lee):
...: print bar, lee
...:
...:
In [10]: l = [1,2]
In [11]: foo(*l)
1 2
Em Python 3 é possível usar *l no lado esquerdo de uma tarefa (Descompactação Iterável Estendida), embora forneça uma lista em vez de uma tupla neste contexto:
first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]
Além disso, o Python 3 adiciona nova semântica (consulte PEP 3102):
def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
pass
Tal função aceita apenas 3 argumentos posicionais, e tudo depois * só podem ser passados como argumentos de palavra-chave.
Outras dicas
Também é importante notar que você pode usar * e ** ao chamar funções também.Este é um atalho que permite passar vários argumentos para uma função diretamente usando uma lista/tupla ou um dicionário.Por exemplo, se você tiver a seguinte função:
def foo(x,y,z):
print("x=" + str(x))
print("y=" + str(y))
print("z=" + str(z))
Você pode fazer coisas como:
>>> mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3
>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3
>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3
Observação:As chaves em mydict devem ser nomeados exatamente como os parâmetros da função foo.Caso contrário, ele lançará um TypeError:
>>> mydict = {'x':1,'y':2,'z':3,'badnews':9}
>>> foo(**mydict)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'badnews'
O único * significa que pode haver qualquer número de argumentos posicionais extras. foo() pode ser invocado como foo(1,2,3,4,5).No corpo de foo() param2 há uma sequência contendo 2-5.
O duplo ** significa que pode haver qualquer número de parâmetros nomeados extras. bar() pode ser invocado como bar(1, a=2, b=3).No corpo de bar() param2 há um dicionário contendo {'a':2, 'b':3 }
Com o seguinte código:
def foo(param1, *param2):
print(param1)
print(param2)
def bar(param1, **param2):
print(param1)
print(param2)
foo(1,2,3,4,5)
bar(1,a=2,b=3)
a saída é
1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}
O que
**(estrela dupla) e*(estrela) faça para parâmetros
Eles permitem funções a serem definidas para aceitar e para usuários para passar qualquer número de argumentos, posicionais (*) e palavra-chave (**).
Definindo Funções
*args permite qualquer número de argumentos posicionais opcionais (parâmetros), que serão atribuídos a uma tupla chamada args.
**kwargs permite qualquer número de argumentos de palavras-chave opcionais (parâmetros), que estarão em um ditado chamado kwargs.
Você pode (e deve) escolher qualquer nome apropriado, mas se a intenção for que os argumentos sejam de semântica não específica, args e kwargs são nomes padrão.
Expansão, passando qualquer número de argumentos
Você também pode usar *args e **kwargs para passar parâmetros de listas (ou qualquer iterável) e dictos (ou qualquer mapeamento), respectivamente.
A função que recebe os parâmetros não precisa saber que eles estão sendo expandidos.
Por exemplo, o xrange do Python 2 não espera explicitamente *args, mas como são necessários 3 números inteiros como argumentos:
>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x) # expand here
xrange(0, 2, 2)
Como outro exemplo, podemos usar a expansão dict em str.format:
>>> foo = 'FOO'
>>> bar = 'BAR'
>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
'this is foo, FOO and bar, BAR'
Novidade em Python 3:Definindo funções com argumentos apenas de palavras-chave
Você pode ter argumentos apenas de palavras-chave depois de *args - por exemplo, aqui, kwarg2 deve ser fornecido como um argumento de palavra-chave - não posicionalmente:
def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs):
return arg, kwarg, args, kwarg2, kwargs
Uso:
>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})
Também, * pode ser usado sozinho para indicar que seguem apenas argumentos de palavras-chave, sem permitir argumentos posicionais ilimitados.
def foo(arg, kwarg=None, *, kwarg2=None, **kwargs):
return arg, kwarg, kwarg2, kwargs
Aqui, kwarg2 novamente deve ser um argumento de palavra-chave explicitamente nomeado:
>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})
E não podemos mais aceitar argumentos posicionais ilimitados porque não temos *args*:
>>> foo(1,2,3,4,5, kwarg2='kwarg2', foo='foo', bar='bar')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() takes from 1 to 2 positional arguments
but 5 positional arguments (and 1 keyword-only argument) were given
Novamente, de forma mais simples, aqui exigimos kwarg a ser dado pelo nome, não posicionalmente:
def bar(*, kwarg=None):
return kwarg
Neste exemplo, vemos que se tentarmos passar kwarg posicionalmente, obtemos um erro:
>>> bar('kwarg')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: bar() takes 0 positional arguments but 1 was given
Devemos passar explicitamente o kwarg parâmetro como um argumento de palavra-chave.
>>> bar(kwarg='kwarg')
'kwarg'
Demonstrações compatíveis com Python 2
*args (normalmente dito "star-args") e **kwargs (estrelas podem estar implícitas ao dizer "kwargs", mas ser explícito com "kwargs de estrela dupla") são expressões idiomáticas comuns do Python para usar o * e ** notação.Esses nomes de variáveis específicos não são obrigatórios (por exemplovocê poderia usar *foos e **bars), mas um desvio das convenções provavelmente enfurecerá seus colegas programadores Python.
Normalmente usamos isso quando não sabemos o que nossa função receberá ou quantos argumentos podemos passar, e às vezes até mesmo quando nomear cada variável separadamente ficaria muito confuso e redundante (mas este é um caso em que geralmente explícito é melhor que implícito).
Exemplo 1
A função a seguir descreve como eles podem ser usados e demonstra o comportamento.Observe o nomeado b argumento será consumido pelo segundo argumento posicional antes:
def foo(a, b=10, *args, **kwargs):
'''
this function takes required argument a, not required keyword argument b
and any number of unknown positional arguments and keyword arguments after
'''
print('a is a required argument, and its value is {0}'.format(a))
print('b not required, its default value is 10, actual value: {0}'.format(b))
# we can inspect the unknown arguments we were passed:
# - args:
print('args is of type {0} and length {1}'.format(type(args), len(args)))
for arg in args:
print('unknown arg: {0}'.format(arg))
# - kwargs:
print('kwargs is of type {0} and length {1}'.format(type(kwargs),
len(kwargs)))
for kw, arg in kwargs.items():
print('unknown kwarg - kw: {0}, arg: {1}'.format(kw, arg))
# But we don't have to know anything about them
# to pass them to other functions.
print('Args or kwargs can be passed without knowing what they are.')
# max can take two or more positional args: max(a, b, c...)
print('e.g. max(a, b, *args) \n{0}'.format(
max(a, b, *args)))
kweg = 'dict({0})'.format( # named args same as unknown kwargs
', '.join('{k}={v}'.format(k=k, v=v)
for k, v in sorted(kwargs.items())))
print('e.g. dict(**kwargs) (same as {kweg}) returns: \n{0}'.format(
dict(**kwargs), kweg=kweg))
Podemos verificar a ajuda online para a assinatura da função, com help(foo), o que nos diz
foo(a, b=10, *args, **kwargs)
Vamos chamar esta função com foo(1, 2, 3, 4, e=5, f=6, g=7)
que imprime:
a is a required argument, and its value is 1
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 2
unknown arg: 3
unknown arg: 4
kwargs is of type <type 'dict'> and length 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: g, arg: 7
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
4
e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns:
{'e': 5, 'g': 7, 'f': 6}
Exemplo 2
Também podemos chamá-lo usando outra função, na qual apenas fornecemos a:
def bar(a):
b, c, d, e, f = 2, 3, 4, 5, 6
# dumping every local variable into foo as a keyword argument
# by expanding the locals dict:
foo(**locals())
bar(100) impressões:
a is a required argument, and its value is 100
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 0
kwargs is of type <type 'dict'> and length 4
unknown kwarg - kw: c, arg: 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: d, arg: 4
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
100
e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns:
{'c': 3, 'e': 5, 'd': 4, 'f': 6}
Exemplo 3:uso prático em decoradores
OK, talvez ainda não estejamos vendo o utilitário.Então imagine que você tem diversas funções com código redundante antes e/ou depois do código diferenciador.As funções nomeadas a seguir são apenas pseudocódigo para fins ilustrativos.
def foo(a, b, c, d=0, e=100):
# imagine this is much more code than a simple function call
preprocess()
differentiating_process_foo(a,b,c,d,e)
# imagine this is much more code than a simple function call
postprocess()
def bar(a, b, c=None, d=0, e=100, f=None):
preprocess()
differentiating_process_bar(a,b,c,d,e,f)
postprocess()
def baz(a, b, c, d, e, f):
... and so on
Poderíamos ser capazes de lidar com isso de forma diferente, mas certamente podemos extrair a redundância com um decorador e, portanto, nosso exemplo abaixo demonstra como *args e **kwargs pode ser muito útil:
def decorator(function):
'''function to wrap other functions with a pre- and postprocess'''
@functools.wraps(function) # applies module, name, and docstring to wrapper
def wrapper(*args, **kwargs):
# again, imagine this is complicated, but we only write it once!
preprocess()
function(*args, **kwargs)
postprocess()
return wrapper
E agora cada função empacotada pode ser escrita de forma muito mais sucinta, já que fatoramos a redundância:
@decorator
def foo(a, b, c, d=0, e=100):
differentiating_process_foo(a,b,c,d,e)
@decorator
def bar(a, b, c=None, d=0, e=100, f=None):
differentiating_process_bar(a,b,c,d,e,f)
@decorator
def baz(a, b, c=None, d=0, e=100, f=None, g=None):
differentiating_process_baz(a,b,c,d,e,f, g)
@decorator
def quux(a, b, c=None, d=0, e=100, f=None, g=None, h=None):
differentiating_process_quux(a,b,c,d,e,f,g,h)
E fatorando nosso código, que *args e **kwargs nos permite fazer isso, reduzimos linhas de código, melhoramos a legibilidade e a manutenção e temos locais canônicos únicos para a lógica em nosso programa.Se precisarmos alterar qualquer parte desta estrutura, temos um local para fazer cada alteração.
Vamos primeiro entender o que são argumentos posicionais e argumentos de palavras-chave.Abaixo está um exemplo de definição de função com Argumentos posicionais.
def test(a,b,c):
print(a)
print(b)
print(c)
test(1,2,3)
#output:
1
2
3
Portanto, esta é uma definição de função com argumentos posicionais.Você também pode chamá-lo com palavras-chave/argumentos nomeados:
def test(a,b,c):
print(a)
print(b)
print(c)
test(a=1,b=2,c=3)
#output:
1
2
3
Agora vamos estudar um exemplo de definição de função com argumentos de palavra-chave:
def test(a=0,b=0,c=0):
print(a)
print(b)
print(c)
print('-------------------------')
test(a=1,b=2,c=3)
#output :
1
2
3
-------------------------
Você também pode chamar esta função com argumentos posicionais:
def test(a=0,b=0,c=0):
print(a)
print(b)
print(c)
print('-------------------------')
test(1,2,3)
# output :
1
2
3
---------------------------------
Portanto, agora conhecemos definições de funções com argumentos posicionais e também de palavras-chave.
Agora vamos estudar o operador '*' e o operador '**'.
Observe que esses operadores podem ser usados em 2 áreas:
a) chamada de função
b) definição de função
O uso do operador '*' e do operador '**' em chamada de função.
Vamos direto a um exemplo e depois discuti-lo.
def sum(a,b): #receive args from function calls as sum(1,2) or sum(a=1,b=2)
print(a+b)
my_tuple = (1,2)
my_list = [1,2]
my_dict = {'a':1,'b':2}
# Let us unpack data structure of list or tuple or dict into arguments with help of '*' operator
sum(*my_tuple) # becomes same as sum(1,2) after unpacking my_tuple with '*'
sum(*my_list) # becomes same as sum(1,2) after unpacking my_list with '*'
sum(**my_dict) # becomes same as sum(a=1,b=2) after unpacking by '**'
# output is 3 in all three calls to sum function.
Então lembre
quando o operador '*' ou '**' é usado em um chamada de função -
O operador '*' descompacta a estrutura de dados, como uma lista ou tupla, em argumentos necessários para a definição da função.
O operador '**' descompacta um dicionário em argumentos necessários para a definição da função.
Agora vamos estudar o uso do operador '*' em definição de função.Exemplo:
def sum(*args): #pack the received positional args into data structure of tuple. after applying '*' - def sum((1,2,3,4))
sum = 0
for a in args:
sum+=a
print(sum)
sum(1,2,3,4) #positional args sent to function sum
#output:
10
Em função definição o operador '*' empacota os argumentos recebidos em uma tupla.
Agora vamos ver um exemplo de '**' usado na definição de função:
def sum(**args): #pack keyword args into datastructure of dict after applying '**' - def sum({a:1,b:2,c:3,d:4})
sum=0
for k,v in args.items():
sum+=v
print(sum)
sum(a=1,b=2,c=3,d=4) #positional args sent to function sum
Em função definição O operador '**' empacota os argumentos recebidos em um dicionário.
Então lembre:
Em um chamada de função o '*' descompacta estrutura de dados de tupla ou lista em argumentos posicionais ou de palavras-chave a serem recebidos pela definição da função.
Em um chamada de função o '**' descompacta estrutura de dados do dicionário em argumentos posicionais ou de palavras-chave a serem recebidos pela definição da função.
Em um definição de função o '*' pacotes argumentos posicionais em uma tupla.
Em um definição de função o '**' pacotes argumentos de palavras-chave em um dicionário.
* e ** tem uso especial na lista de argumentos da função. *implica que o argumento é uma lista e ** implica que o argumento é um dicionário.Isso permite que as funções tomem número arbitrário de argumentos
Embora os usos dos operadores star/splat tenham sido expandido em Python 3, gosto da tabela a seguir no que se refere ao uso desses operadores com funções.O(s) operador(es) splat podem ser usados tanto dentro da função construção e na função chamar:
In function construction In function call
=======================================================================
| def f(*args): | def f(a, b):
*args | for arg in args: | return a + b
| print(arg) | args = (1, 2)
| f(1, 2) | f(*args)
----------|--------------------------------|---------------------------
| def f(a, b): | def f(a, b):
**kwargs | return a + b | return a + b
| def g(**kwargs): | kwargs = dict(a=1, b=2)
| return f(**kwargs) | f(**kwargs)
| g(a=1, b=2) |
-----------------------------------------------------------------------
Isso serve apenas para resumir o pensamento de Lorin Hochstein responder mas acho que é útil.
Para você que aprende com exemplos!
- O propósito de
*é dar-lhe a capacidade de definir uma função que pode receber um número arbitrário de argumentos fornecidos como uma lista (por exemplof(*myList)). - O propósito de
**é dar-lhe a capacidade de alimentar os argumentos de uma função fornecendo um dicionário (por exemplof(**{'x' : 1, 'y' : 2})).
Vamos mostrar isso definindo uma função que recebe duas variáveis normais x, y, e pode aceitar mais argumentos como myArgs, e pode aceitar ainda mais argumentos como myKW.Mais tarde, mostraremos como alimentar y usando myArgDict.
def f(x, y, *myArgs, **myKW):
print("# x = {}".format(x))
print("# y = {}".format(y))
print("# myArgs = {}".format(myArgs))
print("# myKW = {}".format(myKW))
print("# ----------------------------------------------------------------------")
# Define a list for demonstration purposes
myList = ["Left", "Right", "Up", "Down"]
# Define a dictionary for demonstration purposes
myDict = {"Wubba": "lubba", "Dub": "dub"}
# Define a dictionary to feed y
myArgDict = {'y': "Why?", 'y0': "Why not?", "q": "Here is a cue!"}
# The 1st elem of myList feeds y
f("myEx", *myList, **myDict)
# x = myEx
# y = Left
# myArgs = ('Right', 'Up', 'Down')
# myKW = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------
# y is matched and fed first
# The rest of myArgDict becomes additional arguments feeding myKW
f("myEx", **myArgDict)
# x = myEx
# y = Why?
# myArgs = ()
# myKW = {'y0': 'Why not?', 'q': 'Here is a cue!'}
# ----------------------------------------------------------------------
# The rest of myArgDict becomes additional arguments feeding myArgs
f("myEx", *myArgDict)
# x = myEx
# y = y
# myArgs = ('y0', 'q')
# myKW = {}
# ----------------------------------------------------------------------
# Feed extra arguments manually and append even more from my list
f("myEx", 4, 42, 420, *myList, *myDict, **myDict)
# x = myEx
# y = 4
# myArgs = (42, 420, 'Left', 'Right', 'Up', 'Down', 'Wubba', 'Dub')
# myKW = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------
# Without the stars, the entire provided list and dict become x, and y:
f(myList, myDict)
# x = ['Left', 'Right', 'Up', 'Down']
# y = {'Wubba': 'lubba', 'Dub': 'dub'}
# myArgs = ()
# myKW = {}
# ----------------------------------------------------------------------
Ressalvas
**é reservado exclusivamente para dicionários.- A atribuição de argumentos não opcionais acontece primeiro.
- Você não pode usar um argumento não opcional duas vezes.
- Se aplicável,
**deve vir depois*, sempre.
Da documentação do Python:
Se houver mais argumentos posicionais do que slots de parâmetros formais, uma exceção TypeError será gerada, a menos que um parâmetro formal usando a sintaxe "*identifier" esteja presente;neste caso, esse parâmetro formal recebe uma tupla contendo os argumentos posicionais em excesso (ou uma tupla vazia se não houver argumentos posicionais em excesso).
Se algum argumento de palavra-chave não corresponder a um nome de parâmetro formal, uma exceção TypeError será gerada, a menos que um parâmetro formal usando a sintaxe "**identifier" esteja presente;neste caso, esse parâmetro formal recebe um dicionário contendo os argumentos de palavras-chave em excesso (usando as palavras-chave como chaves e os valores dos argumentos como valores correspondentes), ou um (novo) dicionário vazio se não houver argumentos de palavras-chave em excesso.
No Python 3.5, você também pode usar esta sintaxe em list, dict, tuple, e set displays (às vezes também chamados de literais).Ver PEP 488:Generalizações adicionais de descompactação.
>>> (0, *range(1, 4), 5, *range(6, 8))
(0, 1, 2, 3, 5, 6, 7)
>>> [0, *range(1, 4), 5, *range(6, 8)]
[0, 1, 2, 3, 5, 6, 7]
>>> {0, *range(1, 4), 5, *range(6, 8)}
{0, 1, 2, 3, 5, 6, 7}
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> e = {'six': 6, 'seven': 7}
>>> {'zero': 0, **d, 'five': 5, **e}
{'five': 5, 'seven': 7, 'two': 2, 'one': 1, 'three': 3, 'six': 6, 'zero': 0}
Também permite que vários iteráveis sejam descompactados em uma única chamada de função.
>>> range(*[1, 10], *[2])
range(1, 10, 2)
(Obrigado a mgilson pelo link PEP.)
Quero dar um exemplo que outros não mencionaram
* também pode descompactar um gerador
Um exemplo do documento Python3
x = [1, 2, 3]
y = [4, 5, 6]
unzip_x, unzip_y = zip(*zip(x, y))
unzip_x será [1, 2, 3], unzip_y será [4, 5, 6]
O zip() recebe vários argumentos irtable e retorna um gerador.
zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))
Além das chamadas de função, *args e **kwargs são úteis em hierarquias de classes e também evitam a necessidade de escrever __init__ método em Python.Uso semelhante pode ser visto em estruturas como o código Django.
Por exemplo,
def __init__(self, *args, **kwargs):
for attribute_name, value in zip(self._expected_attributes, args):
setattr(self, attribute_name, value)
if kwargs.has_key(attribute_name):
kwargs.pop(attribute_name)
for attribute_name in kwargs.viewkeys():
setattr(self, attribute_name, kwargs[attribute_name])
Uma subclasse pode então ser
class RetailItem(Item):
_expected_attributes = Item._expected_attributes + ['name', 'price', 'category', 'country_of_origin']
class FoodItem(RetailItem):
_expected_attributes = RetailItem._expected_attributes + ['expiry_date']
A subclasse então será instanciada como
food_item = FoodItem(name = 'Jam',
price = 12.0,
category = 'Foods',
country_of_origin = 'US',
expiry_date = datetime.datetime.now())
Além disso, uma subclasse com um novo atributo que faça sentido apenas para aquela instância da subclasse pode chamar a classe Base __init__ para descarregar a configuração de atributos.Isso é feito através de *args e **kwargs.kwargs usado principalmente para que o código seja legível usando argumentos nomeados.Por exemplo,
class ElectronicAccessories(RetailItem):
_expected_attributes = RetailItem._expected_attributes + ['specifications']
# Depend on args and kwargs to populate the data as needed.
def __init__(self, specifications = None, *args, **kwargs):
self.specifications = specifications # Rest of attributes will make sense to parent class.
super(ElectronicAccessories, self).__init__(*args, **kwargs)
que pode ser instanciado como
usb_key = ElectronicAccessories(name = 'Sandisk',
price = '$6.00',
category = 'Electronics',
country_of_origin = 'CN',
specifications = '4GB USB 2.0/USB 3.0')
O código completo é aqui
* significa receber argumentos variáveis como lista
** significa receber argumentos variáveis como dicionário
Usado como o seguinte:
1) solteiro *
def foo(*args):
for arg in args:
print(arg)
foo("two", 3)
Saída:
two
3
2) Agora **
def bar(**kwargs):
for key in kwargs:
print(key, kwargs[key])
bar(dic1="two", dic2=3)
Saída:
dic1 two
dic2 3
Um bom exemplo de uso de ambos em uma função é:
>>> def foo(*arg,**kwargs):
... print arg
... print kwargs
>>>
>>> a = (1, 2, 3)
>>> b = {'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(*a,**b)
(1, 2, 3)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,**b)
((1, 2, 3),)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,b)
((1, 2, 3), {'aa': 11, 'bb': 22})
{}
>>>
>>>
>>> foo(a,*b)
((1, 2, 3), 'aa', 'bb')
{}
Este exemplo ajudaria você a lembrar *args, **kwargs e até mesmo super e herança em Python de uma só vez.
class base(object):
def __init__(self, base_param):
self.base_param = base_param
class child1(base): # inherited from base class
def __init__(self, child_param, *args) # *args for non-keyword args
self.child_param = child_param
super(child1, self).__init__(*args) # call __init__ of the base class and initialize it with a NON-KEYWORD arg
class child2(base):
def __init__(self, child_param, **kwargs):
self.child_param = child_param
super(child2, self).__init__(**kwargs) # call __init__ of the base class and initialize it with a KEYWORD arg
c1 = child1(1,0)
c2 = child2(1,base_param=0)
print c1.base_param # 0
print c1.child_param # 1
print c2.base_param # 0
print c2.child_param # 1
DR
Ele empacota os argumentos passados para a função em list e dict respectivamente dentro do corpo da função.Quando você define uma assinatura de função como esta:
def func(*args, **kwds):
# do stuff
ele pode ser chamado com qualquer número de argumentos e argumentos de palavras-chave.Os argumentos que não são palavras-chave são compactados em uma lista chamada args dentro do corpo da função e os argumentos da palavra-chave são compactados em um ditado chamado kwds dentro do corpo da função.
func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])
agora dentro do corpo da função, quando a função é chamada, existem duas variáveis locais, args que é uma lista com valor ["this", "is a list of", "non-keyword", "arguments"] e kwds que é um dict tendo valor {"keyword" : "ligma", "options" : [1,2,3]}
Isso também funciona ao contrário, ou seja,do lado do chamador.por exemplo, se você tiver uma função definida como:
def f(a, b, c, d=1, e=10):
# do stuff
você pode chamá-lo descompactando iteráveis ou mapeamentos que você possui no escopo de chamada:
iterable = [1, 20, 500]
mapping = {"d" : 100, "e": 3}
f(*iterable, **mapping)
# That call is equivalent to
f(1, 20, 500, d=100, e=3)
*args e **kwargs:permitem que você passe um número variável de argumentos para uma função.
*args:é usado para enviar uma lista de argumentos de comprimento variável sem palavras-chave para a função:
def args(normal_arg, *argv):
print("normal argument:", normal_arg)
for arg in argv:
print("Argument in list of arguments from *argv:", arg)
args('animals', 'fish', 'duck', 'bird')
Vai produzir:
normal argument: animals
Argument in list of arguments from *argv: fish
Argument in list of arguments from *argv: duck
Argument in list of arguments from *argv: bird
**kwargs*
**kwargs permite que você passe argumentos de comprimento variável com palavras-chave para uma função.Você deveria usar **kwargs se você quiser lidar com argumentos nomeados em uma função.
def who(**kwargs):
if kwargs is not None:
for key, value in kwargs.items():
print("Your %s is %s." % (key, value))
who(name="Nikola", last_name="Tesla", birthday="7.10.1856", birthplace="Croatia")
Vai produzir:
Your name is Nikola.
Your last_name is Tesla.
Your birthday is 7.10.1856.
Your birthplace is Croatia.
def foo(param1, *param2):é um método que pode aceitar um número arbitrário de valores para*param2,def bar(param1, **param2):é um método que pode aceitar um número arbitrário de valores com chaves para*param2param1é um parâmetro simples.
Por exemplo, a sintaxe para implementar varargs em Java da seguinte maneira:
accessModifier methodName(datatype… arg) {
// method body
}
