con declaración

El Python With Declary es una característica muy avanzada que ayuda a implementar el protocolo de gestión del contexto. Cuando el programador comienza a codificar, básicamente están utilizando el try/excepto/finalmente para mantener los recursos. Pero hay otra forma de hacer esto automáticamente, llamada declaración 'con'.

Entonces, en este artículo, discutiremos cómo podemos usar el 'con' declaración.

Podemos entender esto con un ejemplo muy simple.

Cada vez que codificamos algo para leer o escribir un archivo, lo primero que tenemos que hacer es abrir el archivo, y luego realizamos las operaciones de lectura o escritura en eso y, por fin, cerramos el archivo para que todos los recursos no estará ocupado. Entonces significa que tenemos que lanzar el recurso después de completar nuestro trabajo.

Esto también podemos entender del gerente de contexto. Un gerente de contexto es un objeto que se encarga de los recursos para guardar, restaurar, bloquear o desbloquear recursos, abrir y cerrar archivos, etc. El administrador de contexto está activo cuando abrimos un archivo para leer o escribir. Si no cerramos el archivo después de leer o escribir, entonces el recurso aún se asigna a ese archivo en particular, y debido a esto, el recurso estará ocupado si un proceso en particular quiere usar ese recurso.

Es por eso que llamamos al método Close () después de leer o escribir el archivo.

f = abierto ("demo.TXT")
datos = F.leer()
F.cerca()

Entonces, en el código anterior, es sencillo, y no hay un manejador de excepción que usamos. Entonces, si ocurre algún error, el programa se detendrá incondicionalmente. Y el segundo caso es que a veces también nos olvidamos de agregar el archivo cerrado como lo hicimos.

Entonces, para superar algunos de los problemas, podemos usar el siguiente método para escribir el código anterior.

intentar:
F = abierto ('demo.txt ',' r ')
imprimir (F.leer())
Excepto la excepción como E:
Imprimir ("Ocurrió el error", E)
finalmente:
F.cerca()

En el código anterior, puede ver que usamos el intento, excepto y finalmente bloquear. Entonces, de esta manera, también podemos controlar el manejo de excepciones. Y cerramos el archivo por fin en el bloque finalmente. También utilizamos el bloque excepto, que manejará las excepciones. Entonces, si usamos el escenario anterior, nuestro código no se detendrá incondicionalmente. Y nuestro archivo seguramente se cerrará incluso si recibimos algún error durante la lectura del archivo.

Pero también podemos refinar el código anterior a través de otro método que llamamos la declaración 'con'. La instrucción 'con' manejará automáticamente el cierre del archivo, y no tenemos que preocuparnos por cerrar el archivo después de leer o escribir.

El administrador de contexto crea un método Enter () y salir () en el momento de ejecución y lo llama cuando tienen que destruir el archivo. Mientras realizamos un código simple o con un intento, excepto el bloque, llamamos al método Exit () a través del método Close (). Pero la declaración 'con' se encarga automáticamente del método EXIT (). Entonces esta es la belleza de la declaración 'con'.

Podemos reescribir el código anterior con la declaración 'con' como se muestra a continuación:

con abierto ("Demo.txt ") como f:
datos = F.leer()

El código anterior es muy simple, y no tenemos que pensar en ello cada vez que cerramos el archivo, lo cual es realizado por la instrucción 'con' automáticamente.

Esto parece magia, pero en realidad, esto no es mágico. La declaración 'con' inicia dos objetos que llamamos __enter__ () y __exit__ (). La declaración que sigue las declaraciones 'con' se llama __enter__ () y devuelve un objeto asignado como variable, y después de todo el proceso de bloque se realiza, llama al __exit__ ().

Ejemplo 1: ex1.py

#EX1.py
Demo de clase:
def __enter __ (self):
Imprimir ("Llamar al método __enter__")
Devolver "verdadero"
def __exit __ (self, exc_type, exc_val, exc_tb):
Imprimir ("Llamar al método __exit__")
Def Calling_Demo ()::
Demo de retorno ()
con callar_demo () como F:
imprimir ("demo:", f)

Producción:

➜ ~ CD Desktop
➜ Desktop Python3 EX1.py
Llamar al método __enter__
Demo: verdadero
Llamar al método __exit__
➜ Escritorio

Explicación:

1. Cuando ejecutamos el código anterior ex1.py, luego se llama primero el método __enter__.
2. Luego devuelve algo del código (verdadero) asignado a la variable F.
3. Luego, el bloque del código fue ejecutado. En ese bloque, estamos imprimiendo el valor de la F, que es verdad.
4. Por fin, cuando termina el proceso del bloque, se llama el método __exit__.

Lo mejor de la declaración 'con' es que también maneja automáticamente la excepción. Como puede ver en el ejemplo de código anterior ex1.PY, el método __exit__ toma tres parámetros: exc_type, exc_val, exc_tb. Estos parámetros ayudan a manejar las excepciones.

Sintaxis: __exit __ (self, exc_type, exc_value, exc_tb)

exc_type: Dice el nombre de la clase donde ocurre una excepción.
exc_value: Dice el tipo de excepción como divide por error cero, etc.
exc_traceback: El rastreo es un detalle completo sobre la excepción, al igual que un informe para resolver el error que ocurrió en el programa.

Ahora, cambiaremos el código anterior para ver cómo manejará automáticamente las excepciones.

Ejemplo_2: ZeroDivisionError.py

#ZeroDivisionError.py
Demo de clase:
def __init __ (self, x, y):
Imprimir ("Ingrese __init__")
ser.x = x
ser.y = y
def __enter __ (self):
Imprimir ("Encuentra el __enter__")
volver a ser
def __exit __ (self, exc_type, exc_val, exc_tb):
imprimir ("\ Buscar el __exit__")
imprimir ("\ ntype:", exc_type)
imprimir ("\ nValue:", exc_val)
imprimir ("\ ntraceback:", exc_tb)
Def ExceptionDemo (Self):
# Excepción de zerodivisionError
Imprimir (yo mismo.x / yo.y)
# con la declaración no aumentar la excepción
con demostración (4, 2) como F:
F.ExceptionDemo ()
Imprima ("\ n \ n ======================================== \ n \ n ")
# con la declaración planteará un ZeroDivisionError
con demostración (1, 0) como F:
F.ExceptionDemo ()

Producción:

➜ Desktop Python3 ZeroDivisonError.py
Ingrese __init__
Encuentra el __enter__
2.0
\ Encuentra el __exit__
Tipo: ninguno
Valor: ninguno
Traza: ninguno
========================================
Ingrese __init__
Encuentra el __enter__
\ Encuentra el __exit__
tipo:
Valor: División por cero
Rastrear:
Rastreo (llamadas recientes más última):
Archivo "ZeroDivisonError.py ", línea 32, en
F.ExceptionDemo ()
Archivo "ZeroDivisonError.py ", línea 21, en ExceptionDemo
Imprimir (yo mismo.x / yo.y)
ZeroDivisionError: División por cero
➜ Escritorio

Explicación:
En el código anterior, línea número 25, Ejecutamos el código con la declaración 'con'. En eso, pasamos el valor de x como 4 e y como 2. En la sección de salida, podemos ver que primero llama al __init__method e inicializa X e Y. Luego llama al método __enter__ y asignó ese objeto a la variable F.Luego llama al método ExceptionDemo usando la variable F y luego imprime el valor de división, que es 2. Después de eso, llama al método __exit__ y luego imprime los tres valores de parámetros importantes ninguno porque no tenemos ningún error hasta ahora.

En la línea número 31, llamamos el mismo método con el valor de x como 1 e y como 0 porque queremos aumentar la excepción y ver cómo la instrucción 'con' lo maneja sin el intento y excepto el bloqueo. Podemos ver que en la sección de salida, los valores de tres parámetros son diferentes.

El primer parámetro (exc_type) tipos imprimiendo el nombre de clase, que causó un error.

El segundo parámetro (exc_val) Imprime el tipo de error.

El tercer parámetro (exc_tb) Impresión de los detalles del rastreo.

Conclusión:
Entonces, hemos visto cómo la declaración 'con' realmente funciona de manera inteligente para manejar el manejo de excepción automáticamente. La instrucción 'con' también ayuda a cerrar el administrador de contexto correctamente, que puede dejar abierto durante la programación.

Este código de artículo está disponible en el enlace GitHub:
https: // github.com/shekharpandey89/with-statement