Avoir de multiples '*args, **kwargs' est-il possible dans une fonction ?

On connaît le schéma classique pour passer des arguments:

Code:

---

1 2	def f(*args, **kwargs): <du code>

---

Mais je voudrais utiliser une méthode comme ci-dessous, le nombre "n" de tuples variant de 0 à un nombre maximal fixé dans mon application:

Code:

---

1 2	def f((*args_1, **kwargs_1), (*args_2, **kwargs_2), ... , (*args_n, **kwargs_n), **kwargs) <du code>

---

Pour produire ce type d'appel :

foo((20, 30, a='xx', b='yy'), (50, 60, 20, a='ww'), globalparam='zz')

A priori c'est impossible, mais est-ce (raisonnablement) contournable ? Merci.

Bonjour,

Ton code semble tout à fait faisable, car tu regroupes les différents args/kwargs dans des tuples, ce qui permet de les identifier

Code:

---

1 2 3 4

def foo(*a,**k): % chaque tuple dans *a <=> (*a(n),**k(n)) all_a= [aa[0] for aa in a] % tous les args all_k= [aa[1] for aa in a]% tous les kwargs

---

Malheureusement ça ne semble pas fonctionner. Copier le dernier exemple que je donne avec "foo", par exemple.

Bonsoir,

Avec l’assignation dans le tuple difficile...
Sinon pourquoi ne pas utiliser des dico ?

Code:

---

1 2 3

def foo(*a, **k): pass foo((20, 30, {'a':'xx'}, {'b':'yy'}), (50, 60, 20, {'c':'ww'}), globalparam='zz')

---

@+

Je précise le contexte. En fait j'écris un programme avec une interface dans lequel l'utilisateur manipule et créer des objets, disons "Bar" pour l'exemple. Pour une question d'ergonomie, j'aimerais beaucoup que l'initialisation puisse se faire comme je l'indique, dans mon cas réel il y aura beaucoup de paramètres, or cette forme est très expressive et me semble la meilleure.

Code:

---

1 2 3 4 5 6 7 8 9 10

class Bar:   def __init__(self, *args, **kwargs) <code> self.__foo(args, kargs) <code>   def __foo(self, *args, **kwargs) <code>

---

invite de commande :
my_bar = Bar((20, 30, a='xx', b='yy'), (50, 60, 20, a='ww'), globalparam='zz')

J'aimerais que l'utilisateur n'ai pas à créer des objets intermédiaires (des dictionnaires par exemple).

@PauseKawa

Le meilleur compromis possible semble celui que vous proposez : utiliser des dictionnaires anonymes incorporés dans les n tuples.

Merci.

Bonjour,

Je ne sais pas si le problème posé par le 1er message existe toujours, mais voilà une solution possible (Python 2.7):

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

def f1(*args, **kwargs): print "appel de f1" for arg in args: print arg for key in kwargs: print key, "=>", kwargs[key], {key:kwargs[key]}   def f2(x, y, z, c=0): print "appel de f2" print x print y print z print c   def f((args1, kwargs1), (args2, kwargs2)): f1(*args1, **kwargs1) f2(*args2, **kwargs2)   args1 = (1,2,3) kwargs1 = {'a':4, 'b':5}   args2 = (6,7,8) kwargs2 = {'c':9}   f((args1, kwargs1), (args2, kwargs2))

---

Ce qui affiche:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

appel de f1 1 2 3 a => 4 {'a': 4} b => 5 {'b': 5} appel de f2 6 7 8 9

---

Petite particularité concernant le passage des arguments nommés par dictionnaire:
- on les passe avec les noms de variables comme des chaines de caractères
- si dans la fonction appelée ces variables ne sont pas définies (exemple: f1 avec le **kwargs), les clés du dictionnaire restent des chaines
- si par contre les variables sont définies (ici f2 => c=0), les variables passées (c) sont de vraies variables (on peut faire print c => affiche sa valeur)

Salut,
Juste pour suggérer une amélioration du code de Tyrtamos:
A la place de:

Code:

---

1 2 3 4 5 6 7

args1 = (1,2,3) kwargs1 = {'a':4, 'b':5}   args2 = (6,7,8) kwargs2 = {'c':9}   f((args1, kwargs1), (args2, kwargs2))

---

On pourrait écrire:

Code:

---

1 2	_ = lambda *a, **k: (a, k) f(_(1,2,3, a=4, b=5), _(6, 7, 8, c=9))

---

Ce qui est plus proche de la syntaxe recherchée.

- W
PS: Mais je suis assez perplexe quant à l'intention car transporter des tuple de la forme (list, dict) est une chose. Proposer l'interpréteur Python comme IHM à des utilisateurs sans leur apprendre les rudiments du langage en est une autre.