Meilleur façon de répéter N fois un appel

Bonjour


Selon vous, quelle est la meilleur manière de répéter N fois un appel de fonction.

Mes premières tentatives étaient directement inspirées de ce qui se fait en C :

Code:

---

1 2 3 4 5

i=0 while i<10: ma_fonction() i = i +1

---

Depuis j'ai un peu changé pour

Code:

---

1 2 3

for i in range(10): ma_fonction()

---

Est-ce qu'il existe une manière encore plus propre ?

Cordialement
Emmanuel

Bonjour,
Il est possible d'utiliser des list-comprehension pour avoir la boucle en une ligne.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

def ma_fonction(x): print x return "ok"   # Lancement direct [ma_fonction(i) for i in range(10)]   # ou pour avoir un retour dans une liste : infoRetour=[ma_fonction(i) for i in range(10)] print infoRetour

---

Si c'est pour éxécuter toujours la même fonction, i étant une variable muette (donc inutile), tu peux aussi passer par itertools.repeat (c'est pas dit que ce soit plus rapide)

Code:

---

1 2 3

import itertools() for i in itertools.repeat(ma_fonction, 10): i()

---

Bonjour,

Pour mémoire, il y a aussi les expressions génératrices.

La syntaxe est la même que les compréhensions de listes, à part que l'on utilise les parenthèses au lieu des crochets. Mais cela fabrique un itérateur au lieu d'une liste. Exemple:

Code:

---

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

cube = (i*i*i for i in xrange(0,10)) for x in cube: print x   0 1 8 27 64 125 216 343 512 729

---

Par rapport à la compréhension de liste, l'avantage est qu'on peut utiliser chaque élément de la liste sans avoir à la fabriquer (donc, consommation plus faible de mémoire). Pour la rapidité, je ne sais pas.

Tyrtamos

On peut aussi fabriquer un itérateur à partir d'une classe:

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 26 27 28 29 30

class Cube(object):   def __init__(self, deb, fin): self.cpt = deb # initialisation du compteur self.fin = fin   def __iter__(self): return self   def next(self): if self.cpt>=self.fin: raise StopIteration k = self.cpt self.cpt += 1 # incrementation du compteur return k*k*k   for i in Cube(0,10): print i   0 1 8 27 64 125 216 343 512 729

---

L'avantage étant le même que précédemment: on peut exploiter chacun des éléments de la séquence sans avoir à créer la liste complète en mémoire. C'est comme xrange(), à part qu'ici, on peut renvoyer des éléments plus complexes (ici, le cube du compteur).

On pourrait aussi passer une fonction comme paramètre. Par exemple:

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

def cube(x): return x*x*x   class xplage(object):   def __init__(self, fn, deb, fin, pas=1): self.fn = fn self.cpt = deb # initialisation du compteur self.fin = fin self.pas = pas   def __iter__(self): return self   def next(self): if self.cpt>=self.fin: raise StopIteration k = self.cpt self.cpt += self.pas # incrementation du compteur return self.fn(k)   for i in xplage(cube,0,10): print i

---

Tyrtamos

Tout d'abord merci pour toutes ces réponses.

Je rappel que je cherche seulement une manière élégante de répéter N appels à une fonction.

On va dire que la fonction à appeler est celle-ci :

Code:

---

1 2 3

def MaFunction(): print "Je suis là"

---

Pour l'instant deux solutions retiennent mon attention :

Code:

---

1 2 3

for i in range(10): MaFonction()

---

et

Code:

---

1 2	[MaFonction() for i in range(10)]

---

Ces deux solutions sont courtes, et en générale plus c'est court mieux c'est.
Cependant dans les deux cas, j'ai besoin d'une variable i qui ne sert à rien, mise à part compter les itérations.

Pour moi, la première méthode a l'avantage d'être plus compréhensible surtout par ceux qui maitrise mal le python. La deuxième méthode à l'avantage d'être très court, et de permettre de récupérer la valeur de chaque appel.

Existe-t-il un aspect du python que je ne connais pas encore qui permette d'appeler N fois une fonction sans créer de variable que quelqu'un avait qualifiée de muette

Cordialement
Emmanuel

Il y a aussi:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

def mafonction(i): print "coucou"   map(mafonction, xrange(0,5))   coucou coucou coucou coucou coucou

---

La fonction map exécute la fonction "mafonction" avec pour argument chacun des éléments de la séquence qui suit.

Mais je ne sais pas si map continuera d'exister dans les versions suivantes de Python (j'utilise encore la 2.5).

Tyrtamos

Edit: mais si map n'existait plus, il est facile à refabriquer:

Code:

---

1 2	xmap = lambda fn, seq: [fn(x) for x in seq]

---

Comme tout le monde s'y met à coeur joie...

Je propose ceci, qui est une variante de la solution de Guigui:

Code:

---

1 2 3 4 5 6 7

for f in [ma_fonction]*10: f()   ou bien:   for f in (ma_fonction,)*10: f()

---

Et en voici une autre, plutôt inhabituelle mais très courte:

Code:

---

1 2	eval('mafonction(),'*10)

---

Si nécessaire, on pourrait transmettre les bibliothèques de variables globales et locales si mafonction() en utilise.

Citation:

---

Est-ce qu'il existe une manière encore plus propre ?

---

Qu'est ce que ça veut dire «plus propre» ?

Citation:

---

je cherche seulement une manière élégante de répéter N appels à une fonction

---

Qu'est ce que ça veut dire «manière élégante» ?

Ce doit être quand «c'est court». Parce que

Citation:

---

en général plus c'est court mieux c'est.

---

Mais qu'est ce que ça veut dire «mieux c'est» ?

---------------------

Citation:

---

Cependant dans les deux cas, j'ai besoin d'une variable i qui ne sert à rien, mise à part compter les itérations.

---

Ça me fait imaginer la scène suivante: un pêcheur du néolithique (avant l'invention de l'écriture, ce qui exclut une représentation mentale de nombres encore jamais écrits) qui rouspète sur une grève: «Ah lala, que je pêche avec un harpon ou avec un filet, j'ai besoin d'une main qui ne sert à rien, mis à part compter les poissons que je dois obtenir pour mes 3 enfants et ma femme».

C'est un peu tiré par les cheveux, mais c'est pour dire que compter c'est toujours établir une correspondance entre une succession de choses et un ensemble stable d'éléments pris comme référence de comptage, que ce soit les doigts de la main, des petits cailloux assemblés en tas de diverses manières, des noeuds sur des cordelettes, des signes écrits arbitraires ou la représentation mentale de ces signes.
Et que cette représentation va se traduire dans un programme informatique par l'utilisation d'un ensemble ou d'une variable, comment faire autrement ?

Dans tous les exemples ci-dessus, qu'on le perçoive immédiatement ou non, il y a toujours un ensemble ou une variable qui servent à surveiller le déroulement de l'itération, non ?
Par exemple

Code:

---

1 2	for f in (ma_fonction,)*10: f()

---

si on fait print (ma_fonction,)*10
on voit qu'il s'agit d'un tuple de 10 objets-fonction. Je suis pas sûr que ce soit mieux que d'itérer i dans range(10).
Je ne connait pas bien eval() mais je subodore que

Code:

---

eval('mafonction(),'*10)

---

nous fait un truc du même genre.
Dans

Code:

---

[MaFonction() for i in range(10)]

---

aussi il y a un ensemble: range(1) est [0,1,2,3,4,5,6,7,8,9]

---
Par contre, dans

Code:

---

for i in itertools.repeat(ma_fonction, 10):

---

et

Code:

---

cube = (i*i*i for i in xrange(0,10))

---

ça me semble déjà mieux: il n'y a pas d'ensemble construit en préalable. Il y a un indice i qui prend des valeurs successivement calculées (cf définition de repeat(), l'équivalent contient xrange() ).
Mais ces valeurs appartiennent bien à l'ensemble conceptuel des nombres de 1 à 10. D'une manière ou d'une autre si on veut compter, il y a bien des doigts ou une variable qui intervient quelque part, muette ou pas.

«ça me semble déjà mieux» , ça veut dire quoi ?
Ça veut dire que ça tient moins de place en mémoire.

Un autre critère pour savoir ce qui serait "mieux" serait la vitesse d'exécution de chaque solution proposée.

Bref,
astuce algorithmique, je veux bien, mais élégance d'un code, fondée sur son apparence, je ne vois pas trop ce que ça veut dire.

NB: tout ceci, dit sans acrimonie. Je me pose en fait souvent ce même genre de question un peu stérile


EDIT
au fait, voici une solution dans laquelle il n'y a pas de variable muette et pas de nombre 10. Mais c'est illusoire

Code:

---

1 2 3 4 5 6

def f(x): print 'Je suis la' return x[:-1]   x = 'abcdefghij' while x: x = f(x)

---

A part l'utilisation mémoire et la vitesse d'exécution, il y a un autre élément qui peut avoir son importance, mais il est plus subjectif: l'élégance du code. Pour moi, elle est liée à la lisibilité du code, c'est à dire la facilité avec laquelle un lecteur va comprendre ce que fait un morceau de code. C'est particulièrement important en Python, car c'est un langage assez riche pour exprimer simplement beaucoup de choses. Ce n'est pas pour rien qu'on dit que le code Python ressemble à du pseudo-code.

Avec ce critère, je trouve ton dernier morceau de code, eyquem, très mauvais car très obscur (tu en conviendras certainement; j'ai bien compris que ce n'était pas une proposition sérieuse).

Le code avec la compréhension de liste (ou encore mieux: une generator expression, le cas échéant) est pour moi ce qu'il y a de mieux si on veut effectivement garder le résultat des appels. Mais si on n'exécute la fonction plusieurs fois que pour ses effets de bord, il n'est pas idéal car cet aspect n'est pas immédiatement apparent. Dans ce cas, la solution que je trouve la plus élégante est celle de Guigui avec repeat; sa lecture est proche de l'énoncé du problème en français. Son seul défaut est de faire appel à une fonction que tout le monde ne connais pas. Si le but est d'être compris le plus facilement par le plus grand nombre (tout en restant efficace), la solution avec la boucle for classique et le (x)range(10) est peut-être bien le meilleur choix.

Mais je dois admettre que Ruby permet de faire mieux que Python dans ce cas-ci:

Code:

---

10.times { ma_fonction }

---

D'un simplicité sidérante, n'est-ce pas ?

Allez je mets la mienne aussi !!

Le for étant une structure des plus courantes, je reste sur li='dée que dans ce cas là c'est la plus "lisible".

Concernant la demande du départ, 2 points que je retiens, utilisé xrange qui est plus économique en mémoire. Range construit une liste qui est itéré, alors que xrange est l'équivalent d'un yield sans construction de liste intermédiaire.

D'autre part, pour ne pas noté 'i' qui ne sert à rien, on peut utiliser '_' qui représente une variable qui justement indique qu'elle ne sert à rien.

Code:

---

1 2 3 4 5 6 7 8

#!/usr/bin/env python # -*- coding: utf-8 -*-   def func(): pass   for _ in xrange(10): func()

---

Concernant range et xrange :

Code:

---

1 2 3 4 5 6 7 8

#!/usr/bin/env python # -*- coding: utf-8 -*-   x = range(10) print x, type(x)   x = xrange(10) print x, type(x)

---

renvoi

Code:

---

1 2	[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <type 'list'> xrange(10) <type 'xrange'>

---