Python 3 quick start tutorial errors and exceptions Hot Topics

Posted by bigger on Thu, 07 May 2020 10:12:10 +0200 Java - 6403

Python - 2524
There are at least two types of errors in Python: syntax errors and exceptions.
Javascript - 1868
syntax error Database - 1639
Syntax errors are also called parsing errors: Linux - 1537
Back-end - 1512
>>> while True print('Hello world')
Spring - 1429
File "<stdin>", line 1
Algorithm - 1406
while True print('Hello world')

^
Front-end - 1257
SyntaxError: invalid syntax
Android - 1140
C++ - 1108
MySQL - 1045
The parser indicates the error line and displays ^ before the location where the error was detected.
Programming - 1042
abnormal network - 904
Even if a statement or expression is syntactically correct, it can cause errors when executed. Errors detected during data structure - 866
runtime are called exceptions Attribute - 865
C - 742
What I don't know in the learning process can add to me

xml - 735
python Learning buckle qun，784758214

//There are good practical courses, development tools and e-books in the group
less - 697
//Share with you the current talent needs of python enterprises and how to learn python from scra github - 694

>>> 10 * (1/0)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ZeroDivisionError: division by zero

>>> 4 + spam*3

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

NameError: name 'spam' is not defined

>>> '2' + 2

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: Can't convert 'int' object to str implicitly

The last line of the error message indicates what error occurred. There are also different types of exceptions, which are
displayed as part of the error message: the exceptions in the example are ZeroDivisionError, NameError and TypeError.
When printing error information, the type of exception is displayed as the built-in name of the exception. This is true for all
built-in exceptions, but user-defined exceptions are not necessarily (although this is a useful Convention). Standard
exception names are built-in identifiers (non reserved keywords).

The latter part of the line is a detailed description of the exception type, which means that its content depends on the
exception type.

The first half of the error message lists where the exception occurred in the form of a stack. The source lines are usually
listed in the stack, however, the source code from standard input is not displayed.

Built in exceptions list built-in exceptions and what they mean.

exception handling
Example: the user is required to enter a valid integer, but is allowed to interrupt the program (using Control-C or any
method supported by the system). Note: user generated interrupts cause KeyboardInterrupt exceptions.

>>> while True:

... try:

... x = int(input("Please enter a number: "))

... break

... except ValueError:

... print("Oops! That was no valid number. Try again...")

The try statement works as follows.

First, execute the content between try and except

If no exception occurs, ignore the except statement.
If an exception occurs during the execution of a try clause, the rest of the clause is ignored. If the exception matches
the exception type specified after *, the corresponding exception clause is executed. Then continue to execute the
code after the try statement.
If an exception occurs and there is no matching branch in the exception clause, it is passed to the previous try
statement. If the corresponding processing statement cannot be found, it will become an unhandled exception,
terminate the program operation, and display a prompt message.

A try statement may contain more than one except clause, which specifies that different exceptions are handled. Take at
most one branch. The exception handler will only handle the exceptions in the corresponding try clause. In the same try
statement, the exceptions in other clauses will not be handled. The exception clause can list the names of multiple
exceptions in a tuple, for example:

... except (RuntimeError, TypeError, NameError):

... pass

Exception matching: if the class in the except ion clause is the same class or its base class (otherwise, if it is a subclass, it
is not allowed). For example, the following code prints B, C, D in this order:

class B(Exception):

pass

class C(B):

pass

class D(C):

pass

for cls in [B, C, D]:

try:

raise cls()

except D:

print("D")

except C:

print("C")

except B:

print("B")

If except B is earlier, B, B, B will be printed.

Finally, the exception clause can omit the exception name as a wildcard. Please use this function carefully, because it is
easy to cover up real programming errors! It can also be used to print error messages and then re throw the exception
(which also allows the caller to handle the exception):

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

try … An except statement can have an else clause, which can only appear after all except clauses. When the try
statement does not throw an exception, you need to execute some code. You can use this clause. For example:

for arg in sys.argv[1:]:

try:

f = open(arg, 'r')

except OSError:

print('cannot open', arg)

else:

print(arg, 'has', len(f.readlines()), 'lines')

f.close()

Using else clause is better than appending code in try clause, because it can avoid try Exception unexpectedly intercepts
except ions thrown by code that does not belong to them.

When an exception occurs, there may be related values that exist as parameters of the exception. Whether this parameter
exists and what type it is depends on the type of exception.

After the exception name (tuple), you can also specify a variable for the exception clause. This variable is bound to the
exception instance and is stored in the instance.args parameter. For convenience, the exception instance defines str(), so
that you can directly access the print parameters without having to reference. Args. You can also initialize an exception
before throwing it and add properties to it as needed.

What I don't know in the learning process

python learning buckle qun, 784758214

There are good practical courses, development tools and e-books in the group

Share with you the current talent needs of python enterprises and how to learn python from scratch
>>> try:

... raise Exception('spam', 'eggs')

... except Exception as inst:

... print(type(inst)) # the exception instance

... print(inst.args) # arguments stored in .args

... print(inst) # __str__ allows args to be printed directly,

... # but may be overridden in exception subclasses

... x, y = inst.args # unpack args

... print('x =', x)

... print('y =', y)

...

<class 'Exception'>

('spam', 'eggs')

('spam', 'eggs')

x = spam

y = eggs

For unhandled exceptions, if they have parameters, they are printed as the last part of the exception information ("details").

Exception handlers not only handle exceptions that happen immediately in the try clause, but also handle the exceptions
that occur inside the functions that are called in the try clause. For example:

>>> try:

... raise Exception('spam', 'eggs')

... except Exception as inst:

... print(type(inst)) # the exception instance

... print(inst.args) # arguments stored in .args

... print(inst) # __str__ allows args to be printed directly,

... # but may be overridden in exception subclasses

... x, y = inst.args # unpack args

... print('x =', x)

... print('y =', y)

...

<class 'Exception'>

('spam', 'eggs')

('spam', 'eggs')

x = spam

y = eggs

Throw exception
The raise statement can force the specified exception to be thrown. For example:

>>> raise NameError('HiThere')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

NameError: HiThere

The Exception to be thrown is identified by the unique parameter of raise. It must be an Exception instance or Exception
class (a class inherited from Exception). If an Exception class is passed, it is implicitly instantiated by calling its
parameterless constructor:

raise ValueError # shorthand for 'raise ValueError()'

If you want to know whether an exception is thrown, but you don't want to handle it, the raise statement can simply rethrow
the exception:

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

NameError: HiThere

User defined exception

Inherited exceptions directly or indirectly can be customized.

The exception class can define anything that can be defined in any other class, but usually in order to keep it simple, only
a few attribute information is added to it for exception handling handle extraction. If several different errors need to be
thrown in the newly created module, it is usually done to define the exception base class for the module, and then derive
the corresponding exception subclass according to different error types:

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

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

Similar to standard exceptions, most exceptions are named after "Error.".

Many standard modules define their own exceptions to report errors that may occur in the functions they define. For more
information about Classes, see Classes.

Define cleanup behavior

The try statement has optional clauses that define the cleanup operations that must be performed in any case. For
example:

>>> try:

... raise KeyboardInterrupt

... finally:

... print('Goodbye, world!')

...

Goodbye, world!

KeyboardInterrupt

Traceback (most recent call last):

File "<stdin>", line 2, in <module>

Whether or not an exception occurs, the finally clause is executed before the program leaves try. When an uncaught
exception occurs in a statement (or it occurs in an exception or else clause), it is thrown again after the finally clause is
executed. A try statement exit through a break, continue, or return statement also executes a finally clause.

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

File "<stdin>", line 3, in divide

TypeError: unsupported operand type(s) for /: 'str' and 'str'

finally clauses are often used to release external resources (such as files or network connections).

Predefined cleanup behavior

Some objects define standard cleanup behavior, which will work when they are no longer needed, regardless of whether
the object operation is successful or not. The following example attempts to open a file and output the contents to the
screen.

What I don't know in the learning process can add to me

python learning buckle qun, 784758214

There are good practical courses, development tools and e-books in the group

Share with you the current talent needs of python enterprises and how to learn python from scratch

for line in open("myfile.txt"):

print(line, end="")

The problem with this code is that the open file is not closed immediately after code execution. There's nothing in a simple
script, but large applications can go wrong. With statement enables objects such as files to be cleaned up timely and
accurately.

with open("myfile.txt") as f:

for line in f:

print(line, end="")

After the statement is executed, the file f is always closed, even if there is an error processing the file line. Whether other
objects provide predefined cleanup behaviors should refer to relevant documents.

Topics: Programming Python REST Attribute

Topics: Programming Python REST Attribute