avec déclaration
Ainsi, dans cet article, nous discuterons de la façon dont nous pouvons utiliser le 'avec' déclaration.
Nous pouvons comprendre cela avec un exemple très simple.
Chaque fois que nous codons quelque chose à lire ou à écrire un fichier, la première chose que nous devons faire est d'ouvrir le fichier, puis nous effectuons les opérations de lecture ou d'écriture à ce sujet et, enfin, nous fermons le fichier afin que toutes les ressources ne sera pas occupé. Cela signifie donc que nous devons libérer la ressource après avoir terminé notre travail.
Nous pouvons également comprendre celle-ci du gestionnaire de contexte. Un gestionnaire de contexte est un objet qui prend soin des ressources pour enregistrer, restaurer, verrouiller ou déverrouiller les ressources, ouvrir et fermer les fichiers, etc. Le gestionnaire de contexte est actif lorsque nous ouvrons un fichier pour la lecture ou l'écriture. Si nous ne fermons pas le fichier après la lecture ou l'écriture, la ressource est toujours allouée à ce fichier particulier, et pour cette raison, la ressource sera occupée si un processus particulier veut utiliser cette ressource.
C'est pourquoi nous appelons la méthode close () après avoir lu ou écrit le fichier.
f = ouvert ("démo.SMS")
données = f.lire()
F.fermer()
Donc, dans le code ci-dessus, il est simple, et il n'y a pas de gestionnaire d'exception que nous avons utilisé. Donc, si une erreur se produit, le programme s'arrêtera inconditionnellement. Et le deuxième cas est que parfois nous oublions aussi d'ajouter le fichier de fermeture comme nous l'avons fait.
Donc, pour surmonter certains des problèmes, nous pouvons utiliser la méthode suivante pour écrire le code ci-dessus.
essayer:
f = ouvert ('démo.txt ',' r ')
Imprimer (F.lire())
sauf exception comme e:
imprimer ("erreur s'est produite", e)
enfin:
F.fermer()
Dans le code ci-dessus, vous pouvez voir que nous avons utilisé l'essai, sauf et enfin bloquer. Donc, de cette façon, nous pouvons également contrôler la gestion des exceptions. Et nous fermons enfin le fichier dans le bloc enfin. Nous avons également utilisé le bloc sauf, qui gérera les exceptions. Donc, si nous utilisons le scénario ci-dessus, notre code ne s'arrêtera pas inconditionnellement. Et notre fichier se fermera sûrement même si nous obtenons une erreur lors de la lecture du fichier.
Mais nous pouvons également affiner le code ci-dessus à travers une autre méthode que nous avons appelé l'instruction «avec». La déclaration «avec» gérera automatiquement la fermeture du fichier, et nous n'avons pas à nous soucier de la fermeture du fichier après la lecture ou l'écriture.
Le gestionnaire de contexte crée une méthode ENTER () et quitte () au moment de l'exécution et l'appelle lorsqu'ils doivent détruire le fichier. Tout en faisant du code simple ou avec un essai, à l'exception de Block, nous appelons la méthode sortie () via la méthode close (). Mais la déclaration «avec» s'occupe automatiquement de la méthode d'exit (). C'est donc la beauté de la déclaration «avec».
Nous pouvons réécrire le code ci-dessus avec l'instruction «avec» comme ci-dessous:
avec ouvert ("démo.txt ") comme f:
données = f.lire()
Le code ci-dessus est très simple, et nous n'avons pas à y penser à chaque fois que nous fermons le fichier, ce qui est effectué par l'instruction «avec» automatiquement.
Cela ressemble à de la magie, mais en fait, ce n'est pas de la magie. La déclaration «avec» informe deux objets que nous avons appelés __enter__ () et __Exit__ (). L'énoncé qui suit les instructions «avec» est appelé __enter__ () et renvoie un objet attribué à la variable, et après tout le processus de bloc, il appelle le __Exit__ ().
Exemple 1: ex1.py
# ex1.py
Démo de classe:
def __enter __ (soi):
print ("Calling to __enter__ Method")
retourner "true"
def __Exit __ (self, exc_type, exc_val, exc_tb):
print ("Calling to __Exit__ Method")
def Call_demo ():
retour de démo ()
avec CALL_DEMO () comme f:
Print ("Demo:", F)
Sortir:
➜ ~ ~ CD Desktop
➜ Desktop Python3 Ex1.py
Appel à la méthode __enter__
démo: vrai
Appel à la méthode __exit__
➜ Bureau
Explication:
- Lorsque nous exécutons le code ci-dessus Ex1.py, puis il s'appelle d'abord la méthode __enter__.
- Ensuite, il renvoie quelque chose du code (vrai) attribué à la variable F.
- Ensuite, le bloc du code a été exécuté. Dans ce bloc, nous imprimons la valeur du F, ce qui est vrai.
- Enfin, lorsque le processus du bloc est terminé, il est appelé la méthode __exit__.
La meilleure chose à propos de la déclaration «avec» est qu'elle gère automatiquement l'exception aussi. Comme vous pouvez le voir dans l'exemple de code ci-dessus Ex1.py, la méthode __Exit__ prend trois paramètres: exc_TYPE, exc_val, exc_tb. Ces paramètres aident à gérer les exceptions.
Syntaxe: __Exit __ (self, exc_type, exc_value, exc_tb)
Exc_Type: Il raconte le nom de la classe où une exception se produit.
exc_value: Il indique le type de l'exception comme Divide by Zero Error, etc.
Exc_traceback: Le traceback est un détail complet sur l'exception, tout comme un rapport pour résoudre l'erreur qui s'est produite dans le programme.
Maintenant, nous allons modifier le code ci-dessus pour voir comment il gérera automatiquement les exceptions.
Exemple_2: Zérodivisionerror.py
#ZerodivisionError.py
Démo de classe:
def __init __ (self, x, y):
print ("Entrer __init__")
soi.x = x
soi.y = y
def __enter __ (soi):
imprimer ("Rechercher le __enter__")
se retourner
def __Exit __ (self, exc_type, exc_val, exc_tb):
print ("\ trouver le __exit__")
print ("\ ntype:", exc_type)
print ("\ nvalue:", exc_val)
print ("\ ntraceback:", exc_tb)
def exceptiondemo (self):
# Exception ZerodivisionError
Imprimer (soi.X / Self.y)
# avec la déclaration ne soulève pas une exception
avec démo (4, 2) comme f:
F.exceptiondemo ()
Print ("\ n \ n ========================================= \ n \ n ")
# avec déclaration augmentera une ZerodivisionError
avec démo (1, 0) comme f:
F.exceptiondemo ()
Sortir:
➜ Desktop Python3 ZerodivisonError.py
Entrez __init__
Trouvez le __enter__
2.0
\ Trouver le __exit__
Type: aucun
Valeur: aucun
Traceback: aucun
=====================================================
Entrez __init__
Trouvez le __enter__
\ Trouver le __exit__
taper:
Valeur: Division par zéro
Traceback:
Traceback (dernier appel dernier):
Fichier "ZerodivisonError.py ", ligne 32, en
F.exceptiondemo ()
Fichier "ZerodivisonError.py ", ligne 21, dans exceptiondemo
Imprimer (soi.X / Self.y)
ZerodivisionError: Division par zéro
➜ Bureau
Explication:
Dans le code ci-dessus, Ligne numéro 25, Nous exécutons le code avec l'instruction «avec». En cela, nous passons la valeur de x As 4 et Y comme 2. Dans la section de sortie, nous pouvons voir qu'il appelle d'abord le __init__Method et initialise x et y. Puis il appelle la méthode __enter__ et a attribué cet objet à la variable f.Ensuite, il appelle la méthode exceptiondemo en utilisant la variable F puis imprime la valeur de division, qui est 2. Après cela, il appelle la méthode __Exit__ puis imprime les trois valeurs des paramètres importants dont aucune parce que nous n'avons aucune erreur jusqu'à présent.
À la ligne numéro 31, nous appelons la même méthode avec la valeur de x que 1 et y comme 0 parce que nous voulons lever l'exception et voir comment l'instruction `` avec '' le gère sans essai et à l'exception du blocage. On peut voir que dans la section de sortie, les valeurs à trois paramètres sont différentes.
Le premier paramètre (exc_type) Types d'impression du nom de classe, ce qui a provoqué une erreur.
Le deuxième paramètre (exc_val) imprime le type d'erreur.
Le troisième paramètre (exc_tb) imprimer les détails de traceback.
Conclusion:
Donc, nous avons vu comment l'instruction «avec» fonctionne réellement intelligemment pour gérer automatiquement la gestion des exceptions. La déclaration «avec» aide également à fermer correctement le gestionnaire de contexte, qui peut quitter l'ouverture pendant la programmation.
Ce code d'article est disponible sur le lien GitHub:
https: // github.com / shekharpandey89 / avec statement