Discussion :

[emmanuel_dumas]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
i=0
while i<10:
    ma_fonction()
    i = i +1

Depuis j'ai un peu changé pour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
for i in range(10):
   ma_fonction()

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

Cordialement
Emmanuel

[alexdevl]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Guigui_]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[tyrtamos]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[tyrtamos]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[emmanuel_dumas]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
def MaFunction():
    print "Je suis là"

Pour l'instant deux solutions retiennent mon attention :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
for i in range(10):
   MaFonction()

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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