pointeur sur une string ?

Bonjour,
Je trouve dans une appli python le code suivant :

Code:

---

1 2 3 4 5

def pPrint(*str): tmp_str="" for s in str: tmp_str = tmp_str+s print tmp_str

---

Quel est le sens du * dans l'argument de pPrint ? Est ce la même chose qu'en C ?
Merci

Salut,
Ce n'est pas un pointeur, c'est une forme générique pour dire que la fonction accepte une liste quelconque d'arguments.
Exemple, soit

Code:

---

1 2	def f(a, b, c): 'une fonction qui admet 3 arguments'

---

Imaginons une fonction g qui soit passe plat vers f, style:

Code:

---

1 2	def g(*args, **kwds): return f(*args, **kwds)

---

g ne connait pas la signature de f.
- W

Bonjour,
Et pour ce qui est du "**" C est pour dire que la fonction prend egalement en parametre un nombre indetermine de parametres de la forme

Code:

---

nom_param = valeur

---

Donc, pour une fonction g de la forme:

Code:

---

1 2	def g(*args, **kwds): print (args, kwds)

---

tu peux avoir les appels:

Code:

---

1 2 3

g() g(1,2,3) g("hello world", value=1024)

---

Petite question:
Je connait *args qui signifie tous nombre et tous type d'arguments.
on pourrait traduire par: '*(joker: remplace tout)' + 'args(arguments)'
mais que signifie **kwds:
le ** ?
et surement: keywords ?
Excuser la petite incursion.

Ne serait il pas plus logique d'employer une syntaxe avec:
-un * pour le nombre d'arguments et
-un autre * pour tous types d'arguments.

Salut,

Un callable Python accepte des paramètres positionnels (une liste de...) et des paramètres nommés (i.e. des paires clés/valeurs).

On peut mixer les choses, i.e. le prototype d'un callable pourrait très bien être:

f(a, b, *rest, c=False, **others_kwds)

i.e. on veut que l'appelant donne au moins a, b, on verra pour *rest.

c=False permet de donner une valeur par défaut à c et de ne pas obliger l'appelant à... quand à others_kwds rien n'est imposé dans le prototype: ce n'est que plus tard (après l'appel) qu'on s'en inquiétera.

Le tutoriel livré avec la doc de Python raconte cela très bien et donne quelque cas pratique d'utilisation intéressantes de cela.

- W

Bonjour,

L'erreur n'étant pas toujours compréhensible d'un premier abord(1), et n'ayant pas vu l'information dans le lien, je préciserai que les paramètres 'voulus' doivent précédés les optionnels. Le c=False doit précéder le tuple *rest(2).
A noter l'Important warning: The default value is evaluated only once' de 4.7.1. Default Argument Values. L'exemple de L=[] me semble bien fait.

Bon code

(1)

Code:

---

1 2 3 4 5

>>> def test(*args, value): File "<stdin>", line 1 def test(*args, value): ^ SyntaxError: invalid syntax

---

(2)

Code:

---

1 2 3 4 5 6 7

>>> def f(a, b, *rest, c=False, **others_kwds): File "<stdin>", line 1 def f(a, b, *rest, c=False, **others_kwds): ^ SyntaxError: invalid syntax >>> def f(a, b, c=False, *rest, **others_kwds): ...

---

Très juste: c=False reste un paramètre "positionnel" et doit donc être placé avant le *rest. Je me fais toujours avoir parce que les règles de composition sont surprenantes:

Code:

---

1 2 3 4 5 6 7 8

def spam(a, b=False, c='a', **kwds): print 'a = %s, b = %s, c = %s, kwds= %s' % (a, b, c, kwds)   def jam(a, **kwds): print 'a = %s, kwds= %s' % (a, kwds) spam(a, **kwds)   jam(1, c='d', x='e')

---

affiche: a = 1, b = False, c = d, kwds= {'x': 'e'}
i.e. les paramètres nommés sont "positionnels" ou "instanciables" en fonction du dict passé par l'appelant.

Le 'ou' est parce que spam(1, True, 'd', b=False) râle:
TypeError: spam() got multiple values for keyword argument 'b'
Normal, il faut savoir ce qu'on veut...

- W

Merci de ces explications très argumentées.

Bonjour,

J'exhume cette discussion, même taggée "Résolu", parce qu'un point qui me semble important n'a pas été (ou partiellement) abordé : celui de l'appel de ces fonctions (celles avec du '*args' ou '**kwd').

Les seuls exemples que j'ai vus sont des exemples où le nombre d'arguments ou de couples (clé,valeur) est connu au moment du codage. Personnellement, j'utilise assez régulièrement ces fonctions et construis dynamiquement les arguments que je passe effectivement à la fonction.

Pour les '*args' : on peut contstruire une liste/un tuple et appeler une fonction en réutilisant ce formalisme '*args'. Exemple (inutile mais didactique) d'un script qui concatène les arguments (autres que le nom du script) et affiche le résultat :

Code:

---

1 2 3 4 5 6 7 8 9

import sys   def concatener(*args): # args est de type tuple return ' puis '.join(args)   vrais_arguments = sys.argv[1:] print concatener(*vrais_arguments)

---

donne

Code:

---

1 2 3

plx@sony:~$ python2.6 concatener.py un deux trois quatre un puis deux puis trois puis quatre

---

Cette fois-ci pour **kwd (très utile, par exemple, pour des données organisées en "colonnes", dont on ne connait ni le nombre, ni les "noms"). Dans l'exemple ci-dessous, je récupère les noms de colonnes depuis la ligne de commande et leur associe leur "rang" (de 0 à ...)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

import sys   def artificiel(**kwd): for k,v in kwd.items(): print "cle %s valeur %d" % (k,v)   dico = dict() for a,arg in enumerate(sys.argv[1:]): dico[arg] = a   artificiel(**dico)

---

donne :

Code:

---

1 2 3 4 5 6

plx@sony:~$ python2.6 dico.py nom prenom age adresse cle nom valeur 0 cle age valeur 2 cle adresse valeur 3 cle prenom valeur 1

---

Là, pour le coup, les clés doivent obligatoirement être des chaines de caractères.