Latest web development tutorials

python3 errores y excepciones

Como un principiante de Python, sólo el aprendizaje de la programación Python menudo ver algún mensaje de error, que no mencionamos en frente de este capítulo nos dedicaremos.

Python tiene dos errores fácilmente reconocibles: los errores y excepciones de sintaxis.

Error de sintaxis

Python errores de sintaxis o llamada analítica mal, los principiantes a menudo se encuentran, como ejemplos

>>> while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

En este ejemplo, la función print () se comprueban los errores antes de que le falta dos puntos (:).

Analizador señaló el error de su partido, y en el lugar equivocado para encontrar el primer marcador de una pequeña flecha.

anormal

Incluso programa Python gramática es correcta, es el momento de correr, puede haber errores. Tiempo de ejecución errores detectados se llaman excepciones.

La mayoría no será un manejador de excepciones en forma de mensajes de error de pantalla aquí:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

Parecen anormales en diferentes tipos, estos tipos se imprimen como parte de la información: Ejemplos de tipos ZeroDivisionError, NameError y TypeError.

La parte frontal del mensaje de error muestra el contexto de una excepción ocurre, la pila de llamadas y se muestra en forma de información específica.

El manejo de excepciones

En el siguiente ejemplo, permite a los usuarios introducir un número entero válido, pero permite al usuario interrumpir el programa (utilizando los métodos del sistema operativo proporcionadas Control-C o). interrupciones al usuario causarán una excepción KeyboardInterrupt.

>>> while True:
        try:
            x = int(input("Please enter a number: "))
            break
        except ValueError:
            print("Oops!  That was no valid number.  Try again   ")
   

tratar las obras de los estados de la siguiente manera;

  • En primer lugar, la cláusula try (entre las palabras clave y palabras clave, excepto declaraciones try)
  • Si no se produce ninguna excepción, la cláusula de excepción se ignora, es tratar la cláusula extremos ejecutados.
  • Si se produce una excepción en el procedimiento de la cláusula try, a continuación, tratar cláusula, se ignorará el resto. Si el nombre y el tipo de excepción, salvo después del partido, entonces la correspondiente cláusula de excepción se ejecuta. Código tratar declaración después de la última ejecución.
  • Si una excepción no coincide con ninguna excepción, esta excepción se pasará a la prueba superior.

Una sentencia try puede contener más de una cláusula de excepción, para hacer frente a diferentes excepciones específicas. A lo sumo una rama será ejecutado.

Controlador sólo para el correspondiente procesamiento de excepciones try, en lugar de al gestor de excepciones try.

Una cláusula except puede manejar múltiples excepciones que serán colocados en un paréntesis como una tupla, por ejemplo:

    except (RuntimeError, TypeError, NameError):
        pass

La última cláusula except puede pasar por alto el nombre de la excepción, será tratado como un comodín. Puede utilizar este método para imprimir un mensaje de error, y luego se vuelven a desmontar.

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

tratar excepto afirmación tiene una cláusula else opcional, si se utiliza esta cláusula, debe ser colocado después de todo, excepto cláusulas. Esta cláusula no tendrá ningún problema ocurre en la cláusula try ejecuta. Por ejemplo:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

Utilice la cláusula más que todas las declaraciones contenidas en la cláusula try que es mejor evitar algunos inesperados, pero excepto que no capta la excepción.

El manejo de excepciones no sólo hacer frente a esas excepciones se producen tratar directamente la cláusula, sino también para llamar la cláusula controlador (incluso las llamadas a funciones indirectas), donde lanzada. Por ejemplo:

>>> def this_fails():
        x = 1/0
   
>>> try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)
   
Handling run-time error: int division or modulo by zero

Lanzar una excepción

Python utiliza instrucción throw para levantar una excepción especificada. Por ejemplo:

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: HiThere

elevar sólo un parámetro especifica la excepción a ser lanzado. Debe ser una instancia de una clase inusual o anormal (es decir subclase de Exception).

Si desea saber si se produce una excepción, no quiere tratar con él, a continuación, una declaración simple puede aumentar de nuevo lanzada.

>>> try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

excepciones definidas por el usuario

Usted puede tener sus propias excepciones creando una nueva clase de excepción. Las excepciones deben heredar de la clase de excepción, ya sea directamente herencia, la sucesión o indirectamente, por ejemplo:

>>> class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
   
>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)
   
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

En este ejemplo, la clase de excepción __ __init predeterminado () se sobrescribe.

Al crear un módulo puede lanzar una variedad de anormal Una práctica común es crear una clase de excepción base para este paquete, y luego en base a esta clase de base para crear diferentes subclases para diferentes condiciones de error:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

La mayoría de los nombres son la excepción a la "error" al final, al igual que una nomenclatura estándar como anormal.


el comportamiento de limpieza definido

try tiene otra cláusula opcional, que define el comportamiento de limpieza en ningún caso va a realizar. Por ejemplo:

>>> try:
        raise KeyboardInterrupt
	finally:
        print('Goodbye, world!')
   
Goodbye, world!
KeyboardInterrupt

Independientemente de los ejemplos anteriores intentan cláusula, no se produce ninguna excepción, finalmente se ejecuta cláusula.

Si una excepción en el bloque try (o excepto y cláusula else) fue expulsado, pero no tienen ninguna, excepto que se detuvo, entonces esto va a elevarse de nuevo después de que se ejecute la cláusula finally.

Aquí está un ejemplo más complejo (que figura en la misma instrucción en un intento excepción y, finalmente, la cláusula):

>>> def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
   
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

el comportamiento de limpieza predefinida

Algunos objetos definen el comportamiento de limpieza estándar, independientemente de si el sistema es utilizado con éxito una vez no lo necesita, a continuación, limpiar este comportamiento estándar se ejecuta.

Este ejemplo muestra este lado intenta abrir un archivo y luego imprimir el contenido de la pantalla:

for line in open("myfile.txt"):
    print(line, end="")

El problema anterior con este código es que cuando haya terminado, el archivo permanece abierto, no cerrado.

Las palabras clave con objetos declaración se pueden garantizar tales como archivos se termine de usar la correcta ejecución de sus métodos de limpieza:

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

Después de que se terminó el código anterior, incluso si los problemas en el proceso, el archivo f está siempre cerrada.