Comparaison de vitesse Python regex vs startswith vs str [: word_length]

Comparaison de vitesse Python regex vs startswith vs str [: num]

introduction

Il existe plusieurs façons de déterminer une correspondance de préfixe pour une chaîne qui est Ptyhon. Parmi eux, les trois comparaisons de vitesse typiques suivantes sont effectuées.

• Expressions régulières
• startswith
• str[:word_length] == word

Méthode de mesure

environnement

Implémenter dans l'environnement d'exécution suivant

programme

Vérifiez le fonctionnement en fonction du programme suivant. Les rôles de chaque variable et de chaque fonction sont les suivants. Modifiez la variable en fonction des caractéristiques que vous souhaitez mesurer.

import re
import time


def time_logging(func):
    def deco(*args, **kwargs):
        stime = time.time()
        res = func(*args, **kwargs)
        etime = time.time()
        print(f'Finish {func.__name__}. Takes {round(etime - stime, 3)}s.', flush=True)
        return res

    return deco


@time_logging
def compare_regex(compare_words):
    pattern = re.compile(f'^{target_word}')
    for word in compare_words:
        if pattern.match(word):
            pass


@time_logging
def compare_startswith(compare_words):
    for word in compare_words:
        if word.startswith(target_word):
            pass


@time_logging
def compare_str(compare_words):
    length = len(target_word)
    for word in compare_words:
        if word[:length] == target_word:
            pass


target_word = f'foo'
match_word = f'{target_word}'
not_match_word = f'bar'
compare_word_num = 100_000_000
match_rate = 50
compare_func = compare_regex


def main():
    compare_words = []
    for index in range(compare_word_num):
        if index % 100 <= match_rate:
            compare_words.append(f'{match_word}_{index}')
        else:
            compare_words.append(f'{not_match_word}_{index}')

    compare_func(compare_words)


if __name__ == '__main__':
    main()

Paramètres

Parce que la tendance de la vitesse d'exécution peut changer en fonction de la longueur de la chaîne de caractères à comparer Mesurez la vitesse d'exécution de compare_regex, compare_startswith et compare_str lorsque target_word est changé en 5, 10, 50, 100 et 500 caractères, respectivement.

La mesure

Unité (secondes)

Considération

En termes de vitesse, il devrait être implémenté avec commence par oustr [: word_length]pour n'importe quel nombre de caractères. Le plus recommandé est «commence par», qui est le moins affecté par la chaîne de caractères à comparer. Je l'aime aussi le plus en termes de lisibilité.