Dans les épisodes précédents, je m'étonnais de voir des concaténations de chaînes de caractères être plus rapide que des remplissages de listes. Depuis je cogite car il est indiqué un peu partout qu'il faut privillégier les listes. Et j'ai fini par trouver une réponse :-).

Considérons la même chaîne de caractères :

strings = ["tagada"]*1000000 + ["tsouintsouin"]*1000000

Et la même fonction foo2() :

def foo2():
    string_final = []
    for string in strings:
        if not "tsouin" in string:
            string_final.append(string)
    return "".join(string_final)

Donc cette fonction met environ 4,70 secondes à créer cette énorme chaîne de caractères. Ce que j'avais alors oublié de tester, ce sont les alias. En effet, les fonctions de type list.append sont réévaluées à chaque itération en python, ce qui fait perdre un temps fou, la preuve en chiffres :

def foo3():
    string_final = []
    app = string_final.append
    for string in strings:
        if not "tsouin" in string:
            app(string)
    return "".join(string_final)

Et là on tombe à 3,50 secondes ! Ainsi les listes peuvent être plus rapides que les concaténations de chaînes de caractères, encore faut-il pouvoir créer un alias...

Bon et puisque j'y suis, une autre petite astuce d'optimisation : on peut lire dans les astuces d'optimisation de Zope qu'il vaut mieux utiliser les méthodes du module string plutôt que des portions de listes. Bon dit comme ça on comprend pas trop de quoi je parle alors un petit exemple pour clarifier tout ça :

def foo4():
    string_final = ""
    for string in strings:
        if string[:5] == "tagad":
            string_final += string
    return string_final
    
def foo5():
    string_final = ""
    for string in strings:
        if string.startswith("tagad"):
            string_final += string
    return string_final

La méthode foo4() s'exécute en 7,2 secondes et foo5() en 12 secondes... tiens c'est le contraire qui est obtenu ici, me serais-je trompé ? Je revérifie et non j'ai bien ces temps là d'exécution, soit presque le double lorsque l'on utilise les méthodes du module string.

Première conclusion : vérifiez toujours les astuces d'optimisation qu'on vous propose (ceci est valable pour celles-ci aussi) car elle peuvent évoluer selon les versions de Python ou du contexte par exemple.

Seconde conclusion : les listes finalement c'est pas si mal pour traiter les chaînes de caractères :-).

Je vous rappelle qu'un billet récapitule l'ensemble des bonnes pratiques et optimisations en Python.

Commentaires

Ajouter un commentaire