Implémentez votre propre commande magique jupyter% timeit, pratique pour la mesure de vitesse, en Python

Choses à faire

Implémentez quelque chose comme% timeit dans jupyter. Je veux utiliser la valeur de retour de ceci comme variable.

ipynb

%timeit -n 10 -r 100 test()

Il existe des options autres que -n et -r, mais cette fois, nous n'implémenterons pas d'autre que ces deux.

Que faites-vous avec % timeit -n 10 -r 100 test () en premier lieu?

1. Répétez le test () 100 fois et renvoyez la valeur avec la vitesse d'exécution la plus rapide.
2. Répétez 1 10 fois et prenez la moyenne.

En d'autres termes, cela donne ** la moyenne la plus rapide de 10 pièces **.

Timeit dans la bibliothèque standard est-il inutile?

1. Répétez le test () 100 fois et renvoyez la valeur avec la vitesse d'exécution la plus rapide.

↑ N'y a-t-il pas une méthode pour faire cela? Pour le moment, je vais essayer de le mettre en œuvre moi-même ainsi que d'étudier.

https://docs.python.org/ja/3/library/timeit.html

Structure du répertoire

.
├── utils
│   ├── speed_test.py
│   └── __init__.py
└── main.py

code

module

speed_test.py

import time


class Measurer(object):
    def mean_time(self, num=10):
        """
Un décorateur qui renvoie la moyenne des résultats de l'exécution num fois.
        """
        def outer_wrapper(func):
            def wrapper(*args, **kwargs):
                fast_time_list = [func(*args, **kwargs) for _ in range(num)]
                mean = sum(fast_time_list) / len(fast_time_list)
                return mean
            return wrapper
        return outer_wrapper

    def fast_time(self, repeat=10):
        """
La valeur minimale (la vitesse d'exécution la plus rapide) parmi les exécutions répétées)Un décorateur qui revient.
        """
        def outer_wrapper(func):
            def wrapper(*args, **kwargs):
                result_list = [func(*args, **kwargs) for _ in range(repeat)]
                # print(result_list)
                min_time = min(result_list)
                # print(result_list)
                # print(min_time)
                return min_time
            return wrapper
        return outer_wrapper

    def onece_time(self, func):
        """
Un décorateur qui renvoie la vitesse d'exécution de la fonction passée en argument.
        """
        def wrapper(*args, **kwargs):
            # print('test start')
            start_time = time.time()
            func(*args, **kwargs)
            finish_time = time.time()
            elapsed_time = finish_time - start_time
            # print('elapsed_time => {:.10f}sec'.format(elapsed_time))
            # print('test finish')
            return elapsed_time
        return wrapper

    def execute(self, func, *args, num, repeat):
        """
        1.Calcule la valeur la plus rapide parmi les exécutions répétées.
        2.Répétez 1 num fois et renvoyez la moyenne des valeurs num les plus rapides.
        """
        @self.mean_time(num=num)
        @self.fast_time(repeat=repeat)
        @self.onece_time
        def _execute(fn, *args):
            return fn(*args)
        return _execute(func, *args)

Dossier d'exécution

main.py

from utils import speed_test


#Définir une fonction pour la mesure
def test(max_count):
    count = 0
    for _ in range(max_count):
        count += 1


def main():
    max_count = 100
    num = 10
    repeat = 100

    measurer = speed_test.Measurer()
    #Après le deuxième argument, vous pouvez passer plusieurs arguments de longueur variable
    result = measurer.execute(test, max_count, num=num, repeat=repeat)
    print('result -> {:.12f}'.format(result))


if __name__ == '__main__':
    main()

Motif à visualiser

Puisque la valeur de retour peut être prise, il est facile de visualiser et de comparer.

py：main.py

import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import display

from utils import speed_test


def test1(str_list):
    """
Convertir numériquement tous les éléments de la liste de chaînes de caractères ①
    """
    int_list = [int(i) for i in str_list]


def test2(str_list):
    """
Convertir numériquement tous les éléments de la liste de chaînes de caractères ②
    """
    int_list = list(map(int, str_list))


def main():
    num = 10
    repeat = 100

    #Générer une liste de chaînes
    str_list = [str(i) for i in range(10000)]
    # ['0', '1', '2', ... '9997', '9998', '9999']

    measurer = speed_test.Measurer()
    #Après le deuxième argument, vous pouvez passer plusieurs arguments de longueur variable
    result1 = measurer.execute(test1, str_list, num=num, repeat=repeat)
    result2 = measurer.execute(test2, str_list, num=num, repeat=repeat)
    # print('result -> {:.12f}'.format(result))

    df = pd.DataFrame({
        'for': [result1],
        'map': [result2]
    })

    display(df)

    x = ['for', 'map']
    y = [result1, result2]
    plt.bar(x, y)
    plt.show


if __name__ == '__main__':
    main()

for	        map
0.001499	0.00109