Comment implémenter l'importation paresseuse-importation paresseuse de Python

Si votre programme Python comporte un grand nombre d'importations et démarre très lentement, vous devriez essayer l'importation paresseuse. Cet article présente une méthode pour réaliser une importation paresseuse. Bien que PEP0690[1] ait proposé de permettre au compilateur Python (-L) ou à la bibliothèque standard d'ajouter cette fonctionnalité, la version actuelle de Python ne l'a pas encore implémentée.

Comme nous le savons tous, les applications Python effectueront des opérations d'importation avant d'effectuer les opérations réelles de l'utilisateur. Différents modules peuvent provenir de différents emplacements, l'exécution de certains modules peut prendre beaucoup de temps et certains modules peuvent ne pas être appelés par. l'utilisateur du tout. Par conséquent, l'importation de nombreux modules est une perte de temps.

Nous avons donc besoin d'une importation paresseuse. Lors de l'application d'une importation paresseuse, l'exécution de import foo ajoutera uniquement le nom foo à l'espace de nom complet global (globals()) comme référence paresseuse. Le compilateur rencontre un accès. La véritable opération d'importation sera effectuée. uniquement dans le code de foo. De même, from foo import bar ajoutera bar à l'espace de noms, et lorsqu'il rencontrera du code qui appelle bar, il importera foo.

Écrire du code pour l'implémenter

Alors, comment écrire du code pour l'implémenter ? En fait, il n'est pas nécessaire d'écrire du code pour l'implémenter. Il existe déjà des projets qui implémentent la fonction d'importation paresseuse, c'est-à-dire TensorFlow. Son code ne dépend d'aucune bibliothèque tierce. lorsque vous avez besoin d'une importation paresseuse, vous pouvez directement mettre la classe LazyLoader[2]. Copiez-la simplement dans votre propre projet.

Le code source est le suivant :

# Code copied from https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/util/lazy_loader.py
"""A LazyLoader class."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import importlib
import types


class LazyLoader(types.ModuleType):
"""Lazily import a module, mainly to avoid pulling in large dependencies.

`contrib`, and `ffmpeg` are examples of modules that are large and not always
needed, and this allows them to only be loaded when they are used.
"""

# The lint error here is incorrect.
def __init__(self, local_name, parent_module_globals, name):# pylint: disable=super-on-old-class
self._local_name = local_name
self._parent_module_globals = parent_module_globals

super(LazyLoader, self).__init__(name)

def _load(self):
# Import the target module and insert it into the parent's namespace
module = importlib.import_module(self.__name__)
self._parent_module_globals[self._local_name] = module

# Update this object's dict so that if someone keeps a reference to the
# LazyLoader, lookups are efficient (__getattr__ is only called on lookups
# that fail).
self.__dict__.update(module.__dict__)

return module

def __getattr__(self, item):
module = self._load()
return getattr(module, item)

def __dir__(self):
module = self._load()
return dir(module)

Description du code :

La classe LazyLoader hérite de types.ModuleType La fonction d'initialisation garantit que le module paresseux sera correctement ajouté à la variable globale comme un vrai module. car le module est réellement utilisé, c'est-à-dire que lorsque __getattr__ ou __dir__ est exécuté, le module réel est réellement importé, la variable globale est mise à jour pour pointer vers le module réel et tout son statut (__dict__) est mis à jour vers l'état du module réel afin de référencer le chargement retardé et de charger le module. Il n'est pas nécessaire de passer par le processus de chargement à chaque visite.

Utilisation du code :

Normalement, nous importons le module comme ceci :

import tensorflow.contrib as contrib

La version d'importation différée correspondante est la suivante :

contrib = LazyLoader('contrib', globals(), 'tensorflow.contrib')

PEP0690 L'approche recommandée

La proposition de PEP0690 est de le compiler dans le compilateur ( Code C), implémentation de la couche, les performances seront donc meilleures. Il existe deux façons de l'utiliser.

One way

Une méthode consiste à ajouter le paramètre -L lors de l'exécution du script Python. Par exemple, il existe deux fichiers spam.py avec le contenu suivant :

import time
time.sleep(10)
print("spam loaded")

egg.py avec le contenu suivant. :

import spam
print("imports done")

Import normal Dans ce cas, "spam chargé" sera imprimé en premier après 10 secondes, puis "importations terminées" sera imprimé lors de l'exécution de python -L Eggs.py, le module spam ne sera jamais importé. , et le module anti-spam appliqué ne sera pas utilisé du tout. Si le contenu de egg.py est le suivant :

import spam
print("imports done")
spam

Lorsque python -L Eggs.py est exécuté, "importations effectuées" sera imprimé en premier et "spam chargé" sera imprimé 10 secondes plus tard).

Deuxième

Une autre façon consiste à appeler la méthode importlib de la bibliothèque standard :

import importlib 
importlib.set_lazy_imports(True)

Si certains modules ne peuvent pas être chargés paresseux et doivent être exclus, vous pouvez le faire

import importlib 
importlib.set_lazy_imports(True,excluding=["one.mod", "another"])

Vous pouvez également le faire :

from importlib import eager_imports

with eager_imports():
import foo
import bar

Derniers mots

Après des tests effectués par des professionnels sur un véritable programme de ligne de commande Python, l'application d'une importation paresseuse peut augmenter le temps de démarrage de 70 % et réduire l'utilisation de la mémoire de 40 %, ce qui est très impressionnant.

Références

[1]PEP0690 : https://github.com/python/peps/blob/main/pep-0690.rst

[2]LazyLoader : https://github.com/tensorflow/tensorflow / blob/master/tensorflow/python/util/lazy_loader.py

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!