[Python] Temps d'exécution lorsqu'une fonction est saisie dans une valeur de dictionnaire

Python sans la syntaxe switch (select) peut utiliser un dictionnaire à la place, Une note sur son temps d'exécution.

Conclusion

• ** Insérez la fonction elle-même : ** {key: func} ** - Court instant ** --Seule la fonction sélectionnée par la touche est exécutée
• ** Entrez la valeur de retour de la fonction **: ** {key: func ()} **
• Cela prend plus de temps --Toutes les fonctions sont exécutées une fois et la valeur de retour est entrée.

Si les arguments de la fonction sont différents

--Préparer (* args, ** kwargs) comme argument de la fonction à l'avance et absorber la différence.

• L'argument donné lui-même est également transformé en dictionnaire
  • e.g. dict_kwargs = { 1: { 'arg1': arg1 }, 2: { 'arg2': arg2 } }

La méthode est envisageable.

Exemple

Prenons le cas où les deux fonctions suivantes sont exécutées séparément. (Je veux connaître le temps d'exécution, donc je l'écris pour qu'il soit lent.)

def myfunc1():
    nx, ny = 50, 40
    arr = np.empty( ( nx, ny ) )
    for iy in range( ny ):
        for ix in range( nx ):
            arr[ix,iy] = ix * ix + iy * iy
    return arr


def myfunc2():
    nx, ny = 50, 40
    arr = np.empty( ( nx, ny ) )
    for iy in range( ny ):
        for ix in range( nx ):
            arr[ix,iy] = 1
    return arr

Après cela, nous avons mesuré le temps requis pour les trois méthodes d'exécution suivantes (en utilisant %% timeit de JupyterLab, ci-dessous est myfunc1 uniquement).

#Exécuter la fonction directement
myfunc1()

# { key: func }Exécuter à partir du dictionnaire de types
key = 1
dict_func = { 1: myfunc1, 2: myfunc2 }
dict_func[ key ]()

# { key: func() }Exécuter à partir du dictionnaire de types
dict_return = { 1: myfunc1(), 2: myfunc2() }
dict_return[ key ]

Le résultat était le suivant. Vous pouvez voir que le type {key: func ()} prend un temps proche du moment où les deux fonctions sont exécutées.

#Exécution directe
1: 488 µs ± 26.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2: 286 µs ± 925  ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# { key: func }Moule
1: 461 µs ± 332  ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2: 298 µs ± 22.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# { key: func() }Moule
1: 763 µs ± 3.96 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2: 771 µs ± 31.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)