Gestionnaire de contexte Python

Gestion des ressources

L'utilisation de ressources telles que les manipulations de fichiers ou l'accès à la base de données est assez répandue dans tous les langages de l'ordinateur. Cependant, il y a un nombre fini de ces ressources. Nous devons nous assurer que la restauration de ces ressources après utilisation serait l'obstacle clé. Lorsqu'ils ne sont pas donnés, une fuite de ressources se produira et elle ralentit ou même endommage l'ordinateur. La possibilité pour les utilisateurs de développer et de décomposer les ressources de réaffectation sera massivement précieuse. Les gestionnaires de contexte Python qui facilitent la gestion efficace des ressources pourraient être utilisés pour y parvenir.

Gestionnaire de contexte pour la gestion des ressources

Il deviendra difficile de fermer un fichier immédiatement lorsqu'un morceau de code lance une erreur ou a un mécanisme compliqué, y compris de nombreuses voies retournées. Try-except finalement est généralement utilisé dans certains langages de programmation pour garantir que. En effet, la ressource de fichier est terminée après l'avoir utilisée, bien qu'il y ait une erreur. Les gestionnaires de contexte, un module de Python, permettent simplement la gestion des ressources. Le terme «avec» sera utilisé. Cela créera un objet qui gère le contexte jusqu'à ce qu'il ait été analysé. Des classes ou des processus avec des modificateurs seraient utilisés pour créer des gestionnaires de contexte. Discutons de plus de gestionnaire de contexte.

Exemple n ° 1

Tout en utilisant des classes pour construire des gestionnaires de contexte, assurez-vous que la classe contient les fonctions comme Entrée () et Exit (). Les activités de nettoyage sont effectuées via la fonction exit (), qui ne renverra rien d'autre que la fonction Entrée () fournit la ressource qui nécessite un développement. Pour analyser le cadre de la génération de gestionnaires de contexte avec des classes, développez d'abord une classe de base nommée contextManager, comme vu ici:

classe contextManager ():
def __init __ (self1):
print ('la fonction init sera appelée')
def __enter __ (self2):
print ('Entrer la fonction sera appelé')
Retour Self2
def __Exit __ (self2, exc_TYPE, exc_value, exc_traceback):
imprimer ('la fonction de sortie sera appelée')
avec contextManager () en tant que gestionnaire:
imprimer («voici la déclaration avec»)

Au début du code, nous créons une classe appelée contextManager. Dans cette classe, nous définissons une fonction init (). Ensuite, nous utilisons la méthode print () pour afficher l'instruction «La fonction d'initiation sera appelée». Dans la ligne suivante, une autre fonction, enter (), sera définie. Cette fonction contient «self2» comme argument. Nous appellerons la méthode print () pour imprimer l'instruction «Entrez la fonction sera appelée». Ensuite, l'instruction de retour est appelée.

Définissons une nouvelle fonction nommée sortie (). Cette fonction a quatre arguments différents, qui contiennent la valeur de Self2, exc_TYPE, exc_value et exc_traceback. Pour cette fonction, l'instruction print () est également appliquée pour afficher la ligne «La fonction de sortie sera appelée». Enfin, nous créerons un gestionnaire d'objets de la classe ContextManager. Nous employons une déclaration print () qui montre le message «Voici la déclaration avec la déclaration».

Une instance ContextManager est générée dans cet exemple. L'attribut après le terme «gestionnaire» reçoit cette allocation. Les fonctions suivantes sont effectuées séquentiellement lors de l'exécution du code susmentionné:

• init ()
• entrer()
• Un organisme de déclaration qui contient du code dans une section «avec».
• sortie(). Les arguments de cette fonction sont utilisés pour contrôler les erreurs.

Exemple n ° 2

Utilisons l'approche précédente pour construire une classe qui aide à gérer les ressources de fichiers. La classe FileManager facilite l'accès, l'écriture ou la lecture et la fin des fichiers.

classe FileManager ():
Def __init __ (self1, nom de fichier, mode):
self1.nom de fichier = nom de fichier
self1.mode = mode
self1.fichier = aucun
def __enter __ (self2):
self2.file = Open (self2.nom de fichier, self2.mode)
Retour Self2.déposer
def __Exit __ (self2, exc_TYPE, exc_value, exc_traceback):
self2.déposer.fermer()
avec FileManager ('Bonjour.txt ',' w ') comme f:
F.écrire ('test')

Imprimer (F.fermé)

Tout d'abord, nous créons une classe connue sous le nom de «FileManager». Maintenant, nous définissons différentes fonctions liées à cette classe. Tout d'abord, nous définissons la fonction d'init (). Dans cette fonction, nous passons trois arguments divers. Le premier paramètre est «self1», le deuxième paramètre affiche le nom du fichier «nom de fichier», et le dernier paramètre affiche le «mode» du fichier. Nous créons un objet appelé un nom de fichier et définissons sa valeur égale au nom d'origine du fichier requis.

Ensuite, nous créons un autre objet appelé «Mode», et ici nous spécifions le format du fichier défini. Nous déclarons le dernier objet nommé «fichier», et maintenant la valeur de cet objet sera définie comme «aucune». Initialisons une autre fonction Entrée (). Nous fournissons la valeur de «Self2» comme argument pour cette fonction. Ici, nous appelons la méthode Open () pour ouvrir le fichier spécifié. Cette fonction contient deux paramètres qui incluent le nom du fichier que nous voulons ouvrir et le mode d'ouverture du fichier. Le paramètre de mode affiche dans quel but nous voulons ouvrir le fichier. Le mode du fichier sera «écrire» ou «lire».

Ensuite, nous utilisons l'instruction de retour. Dans l'étape suivante, nous voulons quitter ce fichier. Nous appliquons donc la méthode de sortie (). Nous passerons quatre arguments à cette fonction. Ensuite, nous utilisons la méthode FileManager (). Nous chargeons un fichier en utilisant cette fonction. Dans cette fonction, nous spécifions le texte que nous voulons écrire dans le fichier. Et aussi, nous spécifions le mode du fichier «W». Maintenant, nous appliquons la méthode écrite (). Pour résilier le code, nous utilisons la méthode print (). Dans cette fonction, nous utilisons une instruction close pour fermer simplement le fichier.

En utilisant le gestionnaire de contexte, nous gérerons les fichiers. Lorsque le bloc «avec» est mis en œuvre, les étapes appropriées se produisent les unes après les autres:

• Chaque fois que la fonction init () est appelée, une instance FileManager est construite, ayant bonjour.txt comme titre du fichier et «w» comme format du fi • le bonjour.Le fichier txt est accessible au format d'écriture par la fonction Entrée (), qui renvoie également une classe de fichiers à l'attribut f.
• Le fichier contient le contenu «Tester."
• Lorsque la section avec la section est terminée, la fonction sortie () gère la fermeture du fichier. Parce que le FileManager a effectivement géré efficacement la résiliation du fichier, qui aurait normalement été tenu de gérer explicitement, lors de l'impression (F.fermé) est exécuté, le résultat sera vrai.

Conclusion

Dans cet article, nous avons parlé du gestionnaire de contexte Python. Nous pouvons affecter et utiliser les ressources aux moments précis que nous choisissons en raison des gestionnaires de contexte. L'expression «avec» est l'illustration la plus fréquemment utilisée d'un gestionnaire de contexte. Chaque fois que nous voulons associer deux événements connexes et implémenter un morceau de code entre eux, nous utilisons des gestionnaires de contexte. Nous exécutons un exemple dans lequel nous démontrons la création d'un gestionnaire de contexte. Nous manipulons les fichiers en utilisant un gestionnaire de contexte et avec des commandes.