Génial! Recommandez huit décorateurs Python sympas !

Préface

L'un des avantages du langage de programmation Python est qu'il regroupe toutes les fonctionnalités dans un petit package très utile.

De nombreuses fonctionnalités peuvent modifier complètement les fonctionnalités du code Python, rendant le langage encore plus flexible. Si elles sont utilisées correctement, certaines de ces fonctionnalités peuvent réduire efficacement le temps requis pour écrire un programme.

Les décorateurs de Python sont un excellent exemple de la réalisation de ces objectifs.

Décorateurs

Un décorateur est une fonction qui peut être utilisée pour modifier le comportement d'un objet fonction Python. Ils peuvent être appliqués à des classes et à des fonctions et peuvent faire beaucoup de choses vraiment intéressantes !

Les décorateurs peuvent être utilisés pour raccourcir votre code, l'accélérer et changer complètement le comportement de votre code en Python.

Inutile de dire que cela est certainement utile ! Aujourd'hui, je veux montrer quelques décorateurs qui, à mon avis, valent le détour.

Il y a beaucoup de décorateurs, mais j'en ai choisi certains qui, à mon avis, ont les fonctionnalités les plus cool.

1. @lru_cache

Le premier décorateur de cette liste vient du module functools.

Ce module est inclus dans la bibliothèque standard et est très simple à utiliser. Il contient également des fonctionnalités plus intéressantes que ce décorateur, mais ce décorateur est définitivement mon préféré.

Ce décorateur peut être utilisé pour accélérer l'exécution continue d'une fonction à l'aide de la mise en cache. Bien sûr, cela doit être utilisé avec quelques mises en garde concernant la mise en cache, mais dans les cas d'utilisation généraux, la plupart du temps, ce décorateur vaut la peine d'être utilisé.

C'est génial de pouvoir accélérer votre code avec un simple décorateur.

Un bon exemple de fonction pouvant bénéficier d'un tel décorateur est une fonction récursive, telle qu'une fonction qui calcule des factorielles :

def factorial(n):
 return n * factorial(n-1) if n else 1

La récursion peut être très difficile en termes de temps de calcul, mais l'ajout de ce décorateur permet de montrer Pour accélérer le fonctionnement continu de cette fonction.

@lru_cache
def factorial(n):
 return n * factorial(n-1) if n else 1

Maintenant, chaque fois que nous exécutons cette fonction, les premiers calculs factoriels seront enregistrés dans le cache.

Donc, la prochaine fois que nous appellerons cette fonction, il nous suffira de calculer la factorielle après la factorielle que nous avons utilisée auparavant.

Bien sûr, tous les calculs factoriels ne seront pas enregistrés, mais il est facile de comprendre pourquoi ce décorateur est une bonne application pour accélérer un code naturellement lent.

2. @jit

JIT est l'abréviation de Juste à Temps. Habituellement, chaque fois que nous exécutons du code en Python, la première chose qui se produit est la compilation.

Cette compilation entraîne une certaine surcharge car les types se voient allouer de la mémoire et sont stockés sous forme d'alias non alloués mais nommés. Avec la compilation juste à temps, nous compilons uniquement au moment de l'exécution.

À bien des égards, nous pouvons considérer cela comme quelque chose de similaire au calcul parallèle, où l'interpréteur Python gère deux choses en même temps pour gagner du temps.

Le compilateur Numba JIT est célèbre pour avoir apporté ce concept à Python. Semblable à @lru_cache, ce décorateur peut être appelé très facilement et améliore immédiatement les performances de votre code. Le package Numba fournit des décorateurs jit qui facilitent l'exécution de logiciels plus intensifs sans avoir à passer en C.

Le cas suivant utilise le décorateur @jit pour accélérer les calculs de la méthode Monte Carlo.

from numba import jit
import random
@jit(nopython=True)
def monte_carlo_pi(nsamples):
 acc = 0
 for i in range(nsamples):
 x = random.random()
 y = random.random()
 if (x ** 2 + y ** 2) < 1.0:
 acc += 1
 return 4.0 * acc / nsamples

3. @do_twice

Le décorateur do_twice fait exactement ce que son nom suggère. Ce décorateur peut être utilisé pour exécuter une fonction deux fois avec un seul appel. Cela a certainement quelques utilisations, je trouve cela particulièrement utile pour le débogage.

Il peut être utilisé pour mesurer les performances de deux itérations différentes. En prenant Functools comme exemple, nous pouvons exécuter une fonction deux fois pour vérifier les améliorations. Cette fonction est fournie par le module décorateur en Python, qui se trouve dans la bibliothèque standard.

from decorators import do_twice
@do_twice
def timerfunc():
%timeit factorial(15)

4. @count_calls

Le décorateur count_calls peut être utilisé pour fournir des informations sur le nombre de fois qu'une fonction est utilisée dans le logiciel.

Comme do_twice, cela peut certainement être utile lors du débogage.

Lorsqu'il est ajouté à une fonction donnée, nous recevrons une sortie nous indiquant combien de fois la fonction a été exécutée à chaque fois qu'elle est exécutée. Ce décorateur est également dans le module décorateur de la bibliothèque standard.

from decorators import count_calls
@count_calls
def function_example():
print("Hello World!")
function_example()
function_example()
function_example()

5. @dataclass

Pour gagner du temps en écrivant des cours, l'un des meilleurs décorateurs que j'ai utilisé est le décorateur @dataclass.

Ce décorateur peut être utilisé pour écrire rapidement des méthodes standards communes dans les classes que l'on trouvera généralement dans les classes que nous écrivons.

Ce décorateur est issu du module dataclass. Ce module est également dans la bibliothèque standard, donc aucun PIP n'est requis pour essayer cet exemple !

from dataclasses import dataclass
@dataclass
class Food:
name: str
unit_price: float
stock: int = 0
 def stock_value(self) -> float:
 return(self.stock * self.unit_price)

Ce code créera automatiquement une fonction d'initialisation init() avec les paramètres de position nécessaires pour remplir les données de la classe.

Ils seront également automatiquement fournis à soi-même, donc pas besoin d'écrire une longue fonction pour mettre certains paramètres de données dans la classe.

6. @singleton

Afin de comprendre le but du décorateur singleton, nous devons d'abord comprendre ce qu'est un singleton. Dans un sens, les singletons sont une version des types de variables globales.

这意味着类型被定义为只存在一次。尽管这些在 C++ 等语言中很常见，但在 Python 中却很少见到。使用单例，我们可以创建一个只使用一次的类并改变类，而不是通过初始化来构造新的类型。

通常，单例装饰器是由用户自己编写的，实际上并不是导入的。

这是因为单例仍然是对我们单例装饰器中提供的模板的引用。我们可以命名一个单例函数并编写一个包装器，以便在我们的类上使用这个装饰器：

def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class cls:
def func(self):

另一种方法是使用元类!

7. @use_unit

在科学计算中经常派上用场的一种装饰器是 @use_unit 装饰器。

此装饰器可用于更改返回结果的表示单位。这对于那些不想在数据中添加度量单位但仍希望人们知道这些单位是什么的人很有用。

这个装饰器也不是在任何模块中真正可用，但它是非常常见的，对科学应用程序非常有用。

def use_unit(unit):
"""Have a function return a Quantity with given unit"""
use_unit.ureg = pint.UnitRegistry()
def decorator_use_unit(func):
@functools.wraps(func)
def wrapper_use_unit(*args, **kwargs):
value = func(*args, *_kwargs)
return value _ use_unit.ureg(unit)
return wrapper_use_unit
return decorator_use_unit
@use_unit("meters per second")
def average_speed(distance, duration):
return distance / duration

8. @singledispatch

Functools 凭借非常有用的@singledispatch 装饰器再次在此列表中脱颖而出。

单调度是一种编程技术，在许多编程语言中都很常见，因为它是一种非常棒的编程方式。虽然我更喜欢多调度，但我认为单调度可以在很多方面扮演相同的角色。

这个装饰器使得在 Python 中使用多类型数据变得更加容易, 尤其当我们希望通过同一方法传递多种类型数据时，情况更是如此。

@singledispatch
def fun(arg, verbose=False):
if verbose:
print("Let me just say,", end=" ")
print(arg)
@fun.register
def _(arg: int, verbose=False):
if verbose:
print("Strength in numbers, eh?", end=" ")
print(arg)
@fun.register
def _(arg: list, verbose=False):
if verbose:
print("Enumerate this:")
for i, elem in enumerate(arg):
print(i, elem)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!