performence boucle for

Version imprimable

Bonjour,

j'essaye d'optimiser le filtre suivant:
Code:

1 2 3 4 5 6 7 8 def update(self,event,ctrl=False): for elm in self[::-1]: if elm.active and hasattr(elm,'update'): if elm.update.__class__.__name__ == 'method': ctrl = elm.update(event,ctrl) elif elm.update.__class__.__name__ == 'function': ctrl = elm.update(elm,event,ctrl) return ctrl
l'objet est une liste de 2000 éléments mais peu ont l'attribut active==True.
la liste doit être parcourue en sens inverse, l'ordre doit être conservé.

une idée ?

14/10/2025, 11h46
fred1599

Hello,

Pas trop le temps de l'analyse, mais mon réflexe serait de virer la copie self[::-1] par la méthode reversed().
À tester pour voir si c'est mieux déjà
14/10/2025, 13h16
josmiley

pas de gain significatif avec reversed, j'ai essayé plein de trucs, try/except, préfiltrage, sorted ... aucun gain, car il faut de toute façon parcourir au moins une fois la liste.
14/10/2025, 14h06
fred1599

Je veux bien les temps mesurés, ça n'a pas de sens que reversed ne soit pas meilleur... ou alors c'est qu'il y a si peu d'éléments que cette différence est négligeable.

D'ailleurs 2000, c'est peu !

Code:

1
2
3
4
5
6
7
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
 
reversed(self)
15000/5000    1.967    0.000   18.732    0.004 elm.py:255(update)
 
self[::-1]
15000/5000    2.186    0.000   19.117    0.004 elm.py:255(update)

Si la boucle parcourt inutilement des milliers d'éléments inactifs, c'est un potentiel goulot d'étranglement...

Code:

1
2
3
4
5
6
7
8
9
10
11
 
def update(self, event, ctrl=False):
    active_elms = [elm for elm in self if elm.active and hasattr(elm, 'update')]
 
 
    for elm in reversed(active_elms):
        if elm.update.__class__.__name__ == 'method':
            ctrl = elm.update(event, ctrl)
        elif elm.update.__class__.__name__ == 'function':
            ctrl = elm.update(elm, event, ctrl)
    return ctrl

Je suppose que tu as déjà testé, mais sait-on jamais

oui déjà essayé, c'est très léger

Code:

1
2
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
15000/5000    1.850    0.000   18.503    0.004 elm.py:264(update)

14/10/2025, 15h00
fred1599

Il faudrait arrêter de recalculer la liste des éléments actifs à chaque fois et la maintenir à jour en permanence.

Je crois qu'on appelle cela une solution "avec état" (stateful), mais même dans ce cas le gain sera sans doute pas énorme.
14/10/2025, 15h11
papajoker

bonjour

pourquoi vouloir optimiser une boucle classique si ton algo est mauvais ou ta function "update" est longue ?

Imagine que ta fonction update() prenne 99% du temps, aucun intéret de vouloir changer ta boucle...
Mais, faut-il absolument calculer "ctrl" a chaque itération bonne ? pour au final ne retourner que le dernier

"update" est une méthode/fonction récursive , il me semble ou tu utilises le même nom mais pour 2 fonctions bien différentes ???
14/10/2025, 15h22
josmiley

En effet, mais il faudrait surcharger tout un tas de méthodes pour maintenir une "vue" de la liste. Beaucoup de travail pour de rares cas où la liste sera "longue".

Merci d'avoir répondu ;)

update est récursif effectivement, ctrl est passé d'appel en appel avec possible modification, le dernier état est retenu. Possible qu'il y ait un autres goulot dans mon code ...