erros python3 e excepções

Como um novato Python, apenas aprender a programação Python muitas vezes ver alguma mensagem de erro, que não mencionou na frente deste capítulo será dedicado.

Python tem dois facilmente reconhecíveis de erro: erros e exceções de sintaxe.

Erro de sintaxe

Python erros de sintaxe ou analítica chamada errada, os novatos muitas vezes encontram, como exemplos

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

Neste exemplo, a função print () é marcada por erros antes que ele está faltando dois pontos (:).

Analisador apontou o erro do seu partido, e no lugar errado para encontrar o primeiro marcador de uma pequena seta.

anormal

Mesmo gramática programa Python é correto, é hora de correr, pode haver erros. erros de execução detectados são chamados de exceções.

A maioria não vai ser um manipulador de exceção na forma de mensagens de erro exibição aqui:

>>> 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

Parecem anormais em diferentes tipos, estes tipos são impressos como parte das informações: Exemplos de tipos ZeroDivisionError, NameError e TypeError.

A parte da frente da mensagem de erro mostra o contexto de uma excepção ocorre, a pilha de chamadas e apresentado sob a forma de informações específicas.

Manipulação de exceção

O exemplo a seguir, permite que os usuários insiram um número inteiro válido, mas permite que o usuário interromper o programa (usando os métodos do sistema operacional fornecidas Control-C ou). interrupções de usuário fará com que uma exceção de KeyboardInterrupt.

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

tente instrução funciona da seguinte forma;

• Em primeiro lugar, a cláusula try (entre as palavras-chave e palavra-chave, exceto as instruções try)
• Se nenhuma exceção ocorrer, a cláusula except é ignorada, tente cláusula é extremidades executados.
• Se ocorrer uma exceção no procedimento da cláusula try, em seguida, tentar cláusula, o resto será ignorado. Se o nome eo tipo de exceção, exceto após o jogo, então a correspondente cláusula except é executado. Código tente declaração após a última execução.
• Se uma exceção não combinar com qualquer exceção, esta exceção será passado para o try superior.

A instrução try pode conter mais de uma cláusula except para lidar com diferentes exceções específicas. No máximo um ramo será executado.

Handler apenas para o processamento de exceção cláusula try correspondente, em vez de o outro manipulador de exceção tentativa.

Uma cláusula except pode lidar com várias exceções que serão colocados em um parêntese como uma tupla, por exemplo:

    except (RuntimeError, TypeError, NameError):
        pass

A última cláusula except pode ignorar o nome da exceção, ele será tratado como um curinga. Você pode usar este método para imprimir uma mensagem de erro e, em seguida, novamente lançada.

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

tente except possui uma cláusula else opcional, se você usar essa cláusula, deve ser colocada após todas as outras cláusulas. Esta cláusula não terá qualquer problema ocorre na cláusula try executa. Por exemplo:

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()

Use a cláusula mais do que todas as declarações na cláusula try que é melhor evitar algum imprevisto, mas, exceto que eles não capturar a exceção.

manipulação de exceção não só lidar com essas exceções ocorrem tentar diretamente cláusula, mas também para chamar cláusula de manipulador (inclusive chamadas de função indiretas), onde lançada. Por exemplo:

>>> 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

Lançar uma exceção

Python usa instrução throw para levantar uma exceção especificada. Por exemplo:

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

levantar apenas um parâmetro especifica a exceção seja lançada. Ele deve ser um exemplo incomum de uma classe ou anormal (isto é exceção subclasse).

Se você quer saber se ele lança uma exceção, não quer lidar com isso, então uma simples declaração pode aumentá-lo novamente acionada.

>>> 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

exceções definidas pelo usuário

Você pode ter suas próprias exceções, criando uma nova classe de exceção. Excepções devem herdar da classe de exceção, seja herança direta, sucessão ou indirectamente, por exemplo:

>>> 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!'

Neste exemplo, a classe Exception __init __ () padrão é substituído.

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

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

>>> 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'

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

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