Cómo resolver errores de tipo Python
Python es un lenguaje orientado a objetos, por lo que las excepciones lanzadas por el programa también son clases. Hay varias excepciones comunes de Python, solo necesita echarles un vistazo para tener una idea visual de ellas y, cuando programe, estoy seguro de que las encontrará más de una vez (a menos que no usar Python nunca más).
Descripción de la excepción
NameError al intentar acceder a una variable no afirmada
ZeroDivisionError división por 0
Error de sintaxis SyntaxError
IndexError El índice excede el rango de secuencia
KeyError Solicitando una clave de diccionario que no existe
IOError Errores de entrada y salida (por ejemplo, el archivo que se intenta leer no existe)
AttributeError Intentando acceder a un atributo de objeto desconocido
ValueError El tipo de parámetro pasado a la función es incorrecto, por ejemplo, pasando una forma de cadena a la función int()
2. Detectar la excepción
p>La declaración completa de Python para detectar una excepción se parece un poco a esto:
Copie el código de la siguiente manera:
intente:
try_suite
excepto Excepción1, Excepción2,... Parámetros:
excepción_suite
...... #otro bloque de excepción
else:
no_exceptions_detected_suite
finalmente:
always_execute_suite
Um... ¿Es complicado? ? Por supuesto, cuando queremos detectar excepciones, no tenemos que escribir exactamente en este formato. Podemos eliminar la declaración else o la declaración finalmente o incluso eliminar la declaración de excepción y conservar la declaración finalmente. ¿Mareo? Pues a continuación te explicaremos cada uno.
2.1. intentar...excepto...
Como sabes, try_suite es el código que necesitamos para detectar excepciones. La declaración except es la clave. Intentamos detectar la excepción en el segmento de código try_suite y luego se la entregamos a except para su procesamiento.
La declaración try... .except más simple es la siguiente:
Copia el código de la siguiente manera:
try:
try_suite
p>except:
Bloque de excepción
La cláusula de excepción anterior no va seguida de ninguna excepción ni parámetro de excepción, por lo que cualquier excepción detectada por try será entregada. Vaya a la cláusula except Manejo del bloque de excepciones. ¿Qué sucede si queremos manejar una excepción específica, por ejemplo, solo queremos manejar la excepción de división por cero y, si ocurre alguna otra excepción, dejar que se lance sin manejarla? ¡En este momento, debemos pasar un parámetro de excepción a la cláusula excepto! ExceptionN es la categoría de excepción que queremos asignar a la cláusula de excepción (consulte la tabla de categorías de excepción), lo que significa que si se detecta dicha excepción, se entregará a la cláusula de excepción.
Por ejemplo:
Copia el código de la siguiente manera:
prueba:
try_suite
excepto excepción:
Bloque de excepción
Ejemplo:
Copia el código de la siguiente manera:
>& & gt;> prueba:
.... res = 2 /0
... excepto ZeroDivisionError:
... print "Error: ¡El divisor no debe ser cero!"
...
Error: ¡El divisor no debe ser cero!
¡Mira, realmente detectamos la excepción ZeroDivisionError! Entonces, ¿qué pasa si quiero detectar y manejar múltiples excepciones? Hay dos formas de hacer esto: una es pasar múltiples parámetros de clase de excepción a la cláusula de excepción y la otra es escribir múltiples cláusulas de excepción, cada una de las cuales pasa el parámetro de clase de excepción que desea manejar. ¡Los dos usos pueden incluso combinarse! Te daré un ejemplo a continuación.
Copia el código de la siguiente manera:
intenta:
floatnum = float(raw_input("Ingresa un flotante:"))
intnum = int(floatnum)
imprimir 100/intnum
excepto ZeroDivisionError:
print "Error: debe ingresar un número flotante que sea grande o igual luego 1! "
excepto ValueError:
print "Error: ¡debes ingresar un número flotante!"
[root@Cherish tmp]# prueba de Python. py
Ingrese un número de punto flotante: fjia
Error: ¡Debe ingresar un número de punto flotante!
[root@Cherish tmp]# python test.py
Ingrese un número de punto flotante: 0.9999
Error: debe ingresar un valor mayor que o igual a 1 ¡Números de coma flotante!
[root@Cherish tmp]# python test.py
Ingrese un float:25.091
4
Para el ejemplo anterior , todos Está claro a primera vista, así que no lo explicaré más. Siempre que comprenda que nuestras excepciones pueden manejar una excepción, múltiples excepciones o incluso todas las excepciones, estará listo.
Te habrás dado cuenta de que no hemos explicado cuál es el argumento después de la cláusula except. No te preocupes, déjame explicarte. Este argumento es en realidad una instancia de la clase de excepción (no me diga que no sabe qué es una instancia) y contiene información de diagnóstico para el código de excepción. Es decir, si detecta una excepción, puede obtener más información sobre la excepción utilizando esta instancia de la clase de excepción.
Por ejemplo:
Copia el código de la siguiente manera:
>>> prueba:
... 1/0
.. , excepto ZeroDivisionError, motivo:
... pasar
...
>>> tipo(motivo)
>>> motivo de impresión
División entera o módulo cero
>>> motivo
ZeroDivisionError( 'división de entero o módulo por cero',)
>>> motivo .__class__
>>> motivo. __class__ .__doc__
'El segundo argumento de una operación de división o modulación es cero. '
>>> Reason.__class__.name___
'ZeroDivisionError'
En el ejemplo anterior, detectamos la excepción de división por cero, pero ¿qué no? Yo tampoco lo hago. Como puede verse en el tipo, REASON es una instancia de la clase de excepción ZeroDivisionError.
2.2.intenta...excepto...la declaración else
Ahora hablemos de la declaración else. Póngalo dentro de una declaración try y hace casi lo mismo: cuando no se detecta ninguna excepción, ejecuta la declaración else. Por ejemplo, puede que le resulte más fácil de entender:
Copiar código:
>>> importar syslog
>>> probar:
... f = open("/root/test.py")
... excepto IOError,e:
... syslog.syslog(syslog LOG_ERR,"%s"%e)
... else:
... syslog.syslog(syslog.LOG_INFO, "no se detectó ninguna excepción\n")
...
>>> f.close()
2.3 La cláusula final
La cláusula finalmente es un párrafo ya sea una excepción se detecta o no. El código se ejecutará. Podemos abandonar las cláusulas except y else y usar una cláusula try...finally, o combinarla con una cláusula como except.
Por ejemplo, en el ejemplo 2.2, si ocurre otra excepción que no se puede detectar y el programa se cierra de manera anormal, el archivo f no se cerrará correctamente.
Este no es el resultado que queremos ver, pero si ponemos la declaración f.close en la declaración finalmente, el archivo se cerrará normalmente independientemente de si ocurre una excepción. ¿No sería maravilloso?
Copie el código de la siguiente manera:
>>> import syslog
>>& gt; intente:
.... f = open("/root; /test.py")
... excepto IOError,e:
... syslog.syslog(syslog.LOG_ERR,"%s"%e)
... else :
... syslog.syslog(syslog.LOG_INFO, "no se detectó ninguna excepción\n")
... finalmente:
>>> f .close()
Verás, nuestro ejemplo anterior en realidad usa las cuatro cláusulas try, excepto, else y finalmente. :-), ¿no es interesante? Ahora, básicamente has aprendido cómo detectar excepciones regulares y manejarlas en Python.
3. Dos métodos especiales y convenientes para manejar excepciones
3.1 Afirmaciones
¿Qué es una aserción? Veamos primero su sintaxis:
Copie el código de la siguiente manera:
Expresión de afirmación [, motivo]
Entre ellos, afirmar es la palabra clave de afirmación. Al ejecutar esta declaración, primero se determina la expresión de la expresión. Si la expresión es verdadera, no se realiza ninguna operación; si la expresión es falsa, se lanza una excepción. no entiendes? ¡No importa! ¡Lo más práctico!
Copie el código de la siguiente manera:
>>> afirmar len('love') == len('me gusta')
>> afirmar 1= = 1
>> afirmar 1==2, "¡1 no es igual a 2!"
Rastreo (última llamada más reciente):
Archivo "< stdin >", línea 1, en
AssertionError: ¡1 no es igual a 2!
Podemos ver que si la expresión después de afirmar es verdadera, no se realizará ninguna operación; si no es verdadera, se generará una excepción AssertionErro y la cadena que pasemos se usará como excepción. class Existe información específica de la instancia.
De hecho, las excepciones de aserción también se pueden detectar mediante bloques de código de prueba:
Copie el código de la siguiente manera:
>>> try:
... afirmar 1 = = 2 , "¡1 no es igual a 2!"
... excepto AssertionError,razón:
... print "%s:%s"%(razón. __clase__. __nombre__,razón)
...
AssertionError:1 no es igual a 2!
>>> tipo(razón)
3.2.Gestión de contexto (con declaración)
Si usa try, except, finalmente codifique solo para asegurarse de que *** disfrute de los recursos (como archivos, datos) se asignan y liberan de forma única al final de la tarea, ¡entonces estás de suerte! ¡Esto con declaración te libera de intentar, excepto y finalmente! La sintaxis es la siguiente:
Copiar el código El código es el siguiente:
with context_expr [as var]:
with_suite
¿Aún no estás seguro? Esto es normal, ¡da un ejemplo!
Copia el código de la siguiente manera:
>>> con open('/root/test.py') como f:
... para la línea in f:
... imprimir línea
¿Qué hacen las líneas de código anteriores?
(1) Abra el archivo /root/test.py
(2) Asigne el objeto de archivo a f
(3) Genere todas las líneas del file
(4) Independientemente de si hay excepciones en el código, Python cerrará el archivo por nosotros y no necesitamos preocuparnos por estos detalles.
Ahora, al usar la declaración with para usar estos recursos que disfruta ****, no tenemos que preocuparnos de que no se publiquen por alguna razón, ¿tiene sentido? Pero no todos los objetos pueden usar la declaración with. Solo se pueden usar los objetos que admiten el protocolo de gestión de contexto. Entonces, ¿qué objetos admiten este protocolo? 4. Lanzar excepciones (raise)
Si queremos lanzar excepciones activamente en el programa que escribimos, la declaración rise puede ayudarnos a lograr este objetivo. La sintaxis básica es la siguiente:
Copie el código de la siguiente manera:
raise [SomeException [, args [,traceback]]
El primer parámetro SomeException debe ser una clase de excepción o una instancia de la clase de excepción
El segundo parámetro es el parámetro pasado al parámetro SomeException y debe ser una tupla. Este parámetro se utiliza para pasar información útil sobre la excepción.
El tercer parámetro es el rastreo, que rara vez se usa y se usa principalmente para proporcionar objetos de registro posteriores (rastreo).
A continuación se muestran varios ejemplos.
Copia el código de la siguiente manera:
>>> generar NameError
Rastreo (última llamada más reciente):
Archivo "< stdin >", línea 1, en <.module>
NameError
>>> plantear NameError() #Ejemplo de clase de excepción
Rastreo (última llamada recientemente ):
Archivo "
NameError
>>> levanta NameError,("Hay un nombre error", "in test.py")
Rastreo (última llamada más reciente):
Archivo "
> > > plantear NameError("Hay un error de nombre", "en test.py") #Tenga en cuenta la diferencia con el ejemplo anterior. )#Tenga en cuenta la diferencia con el ejemplo anterior
Rastreo (llamada más reciente):
Archivo "
NameError: ('Hay un error de nombre', 'en test.py')
>>> elevar NameError,NameError("Hay un error de nombre", "en test.py") # Nota Diferencias con el ejemplo anterior
Rastreo (llamada más reciente):
Archivo "
NameError: ( 'Hay un error de nombre', 'en test.py')
En realidad. Generalmente usamos esto para pasar el primer argumento, para indicar el tipo de excepción y, como máximo, una tupla para proporcionar información explicativa. Como el tercer ejemplo anterior.
5. Excepciones y módulo sys
Otra forma de obtener información de excepción es a través de la función exc_info() en el módulo sys.
Esta función devuelve un triple: (clase de excepción, instancia de clase de excepción, siguiente objeto de registro)
Copia el código de la siguiente manera:
>>> intenta:
... 1/0
... excepto:
... import sys
... tuple = sys.exc_info()
...
>>> imprimir tupla
(
>>> para i en tupla:
... imprimir i
...
División entera o módulo cero #Instancia de clase de excepción