Python exception handling
python provides two very important functions to handle exceptions and errors python program that appears in the operation. You can use this feature to debug python programs.
- Exception handling: Python tutorial site specific description.
- Assert (Assertions): Python tutorial site specific description.
python standard exceptions
| The exception name | description |
|---|---|
| BaseException | The base class for all exceptions |
| SystemExit | Interpreter request to exit |
| KeyboardInterrupt | User Interrupt Executing (usually enter ^ C) |
| Exception | General error base class |
| StopIteration | Iterator no more values |
| GeneratorExit | Generator (generator) to notify the abnormal exit |
| StandardError | All of the built-in standard base class for exceptions |
| ArithmeticError | All numerical error base class |
| FloatingPointError | Floating-point calculation error |
| OverflowError | Numerical operations exceeded the maximum limit |
| ZeroDivisionError | In addition to (or modulus) zero (all data types) |
| AssertionError | Assertion failure |
| AttributeError | This object has no property |
| EOFError | No built-in input and arriving EOF marker |
| EnvironmentError | Operating system error base class |
| IOError | Input / output operations to fail |
| OSError | Operating system error |
| WindowsError | System call failed |
| ImportError | Import Module / object failed |
| LookupError | Invalid class data base queries |
| IndexError | Without this sequence index (index) |
| KeyError | Without this key mapping |
| MemoryError | Memory overflow error (for Python interpreter is not fatal) |
| NameError | Undeclared / initialize the object (not property) |
| UnboundLocalError | Access uninitialized local variable |
| ReferenceError | Weak reference objects (Weak reference) have been trying to access the garbage collection of |
| RuntimeError | General runtime error |
| NotImplementedError | The method has not been implemented |
| SyntaxError | Python syntax error |
| IndentationError | Indent error |
| TabError | Tab and space mix |
| SystemError | Usually interpreter system error |
| TypeError | Invalid operation type |
| ValueError | Invalid arguments passed in |
| UnicodeError | Unicode related errors |
| UnicodeDecodeError | Unicode decoding of error |
| UnicodeEncodeError | Unicode code error |
| UnicodeTranslateError | Unicode conversion error |
| Warning | Warning base class |
| DeprecationWarning | Warnings about deprecated features |
| FutureWarning | Warnings about the future structure of the semantics have changed |
| OverflowWarning | The old warning about automatically promoted to a long integer (long) of |
| PendingDeprecationWarning | It will be a warning about waste characteristics |
| RuntimeWarning | Suspicious runtime behavior (runtime behavior) warning |
| SyntaxWarning | Syntax warnings suspicious |
| UserWarning | Warns the user code generation |
What is abnormal?
That exception is an event that will occur during the execution of the program, affecting the normal program execution.
Under normal circumstances, when Python programs do not properly handle an exception occurs.
Exception is Python object representing an error.
An exception occurs when the Python script we need to capture handle it, otherwise the program will be terminated.
Exception Handling
You can catch the exception using try / except statement.
try / except statement is used to detect errors in the try block, so that except statement to catch the exception and process the information.
If you do not want an exception occurs when the end of your program, just try to catch it in the inside.
The following is a simple try . except . else syntax:
try works, when starting a try statement is, python will be marked in the context of the current program, so that when an abnormality occurs can be back here, try clause is executed first, what happens next depends on execution whether there is an exception.
- If an exception occurs when you try to perform when the statement after, python jump back to try and perform the first matching except clause is the exception, exception processing is completed, the control flow on through the entire try statement (unless an exception is processed time and trigger a new exceptions).
- If an abnormality occurs in the try statement after the years, but no matching except clause, an exception will be submitted to the top of the try, or to the top of the program (which will end the program, and print a default error message).
- If an exception occurs when you try clause is not executed, python else statement will be executed after the statement (if then else), then the flow of control through the entire try statement.
Examples
Here is a simple example, it opens a file, the contents of the file content is written, and is not an exception occurs:
The above program output:
Examples
Here is a simple example, it opens a file, the contents written in the file contents, but the file does not have write permission, an exception occurred:
Before executing the code in order to facilitate the testing, we can first remove write access to the file testfile command is as follows:
Then execute the code above:
Except without using any type of exception with
You can use without any exception type except, the following examples:
Above manner try-except statement to catch all exceptions that occur. But this is not a good way, through this program we can not identify the specific exception information. Because it captures all the exceptions.
And with the use of multiple types of exceptions except
You can also use the same except statements to handle multiple exceptions, as follows:
try-finally statement
try-finally statement, whether an exception occurs will perform the final code.
Examples
If you open a file does not have write permission, output is as follows:
The same example can also be written as follows:
When thrown an exception in the try block, the finally block of code immediately.
finally block all statements after the execution, the exception is triggered again and execution except block code.
Contents of the parameter is different from the exception.
Abnormal parameters
An exception can take parameters, as abnormality information output parameters.
You can catch the exception through parameter statements except as follows:
Outlier variables typically included in the received exception statement. Variables in the form of tuples may receive one or more values.
Tuple typically contains the error string, wrong number, wrong location.
Examples
The following are examples of a single exception:
Results of the above procedures are as follows:
Trigger abnormal
We can use the statement to raise themselves trigger an exception
raise syntax is as follows:
Exception statement is the type of exception (for example, NameError) parameter is an abnormal parameter value. This parameter is optional, if not provided, the exception argument is "None".
The last argument is optional (rarely used in practice), if there is a trace exception object.
Examples
An exception can be a string, a class or object. Python's exception provided by the kernel, most are instances of the class, which is a parameter of an instance of a class.
Very simple definition of an exception, as follows:
Note: To be able to catch the exception, "except" statement must be useful to throw the same exception class object or string.
For example, we capture more than an exception, "except" statement is as follows:
Examples
Implementation of the above code, the output is:
User-defined exceptions
By creating a new exception class, the program may name their own exceptions. Typical exceptions should be inherited from the Exception class, either directly or indirectly.
Following is associated with RuntimeError instance instance create a class, the base class is RuntimeError, for outputting additional information when an exception is triggered.
In the try block, the user performs a block statement except custom exception, variable e is used to create instances Networkerror class.
After you define the above categories, you can trigger the exception, as follows:
Python Exit Commands-Know More
There are four major ways to access the commands to exit status of a program in Python. These methods are quit(), exit(), sys.exit() and os._exit(). Unlike other programming languages, Python’s exit status is interpreted universally. However, some platforms have their own conventions regarding which code will be considered exciting and which will not. For example, exit(0) will signal successful termination, while exit(1) will have a system-specific meaning. Some systems may consider it a failure, indicating that the program must be stopped. Here we will see about Python Exit Commands
Python Exit Commands
Exit() function
The exit code of a program is any number between 0 and 255. A non-zero exit code means that the program has an issue. A non-zero exit code is not a normal exit. This code is useful for other programs that need to know the status of a program. For instance, you need to stop a program if you may need to return a certain value. Exit codes are useful because they tell the status of a program.
The exit() function in Python can be used in several manners. For instance, it can be used to print a data frame. Another use for the function is to modify the bin size of a histogram. It can also be used to execute a shell command without waiting. For instance,you can use sys.exit(), if you want to exit a program from a loop.
The exit() function is a built-in method in Python that lets you exit a program whenever you wish. You do not need to add an argument to it. By using this function inside a loop, you can safely exit the program from within it. There are other methods of exiting a program, but the quit() method is the easiest and makes it one of the most popular languages for programmers.
The exit() function in Python raises a SystemException, which is a type of error that forces the interpreter to stop the execution of a program. The sys module has many other functions that can be used to exit a program before it reaches its end. This exit function is one of the best ways to end a Python program, and it can be found in almost every Python code.
Please enable JavaScript
Quit() function
Quit() function in Python allows you to end a program without using the library. The function only works when the main thread is running and raises a SystemExit exception when the program is stopped. It should be placed inside the interpreter and should never be called directly from a program. The quit() function is called -exit() when used inside a site module.
Using the quit() function is a better way to exit Python programs. The function raises a SystemExit exception. It also has some limitations and should not be used in production code. You should also avoid using exit() in your code if you don’t need the exception, as it relies on the site module to work. The exit() function raises an exception if the program doesn’t load a site module.
If you encounter the quit function in a program, it will stop the execution of that program. The quit() function can be used within loops as well. The program will exit with a warning message if it reaches a condition that is unspecified in the program’s code. If you have written a program and have a problem, you can always use the Quit() function in Python.
Quit() function in Python is the most common type of exit method. It ends a Python program immediately. It is best not to use this function in production code because it can cause the program to terminate abruptly. Moreover, the quit function should not be used in production code. However, it’s good to know that you can use the exit() function in Python without using the Python library.
Non-Zero Exit Status
For most platforms, a non-zero exit status indicates that a program did not complete successfully. It can be any number from 0 to 255. Non-zero exit status is an abnormal exit, indicating that the program was unable to complete successfully. Python exit commands return the non-zero status as modulo 256. The error code is the perfect example of this: -f. An error code is given for each Python exit command. The value of f is the result of the command’s evaluation. A code less than zero indicates an error. A value greater than zero indicates successful execution, so you can use a higher number to deduce whether your code ran successfully. However, if a script raises an error before line 5, it is called a subprocess.CalledProcessError.
A non-zero exit status in Python may also signal a permissions problem. The command invoked may be missing a keyword or its PATH might be invalid. If you’re unsure of the problem, you can use an interactive shell to find the problem and decipher the error code. If you’re not sure of what is wrong, it might be worth trying an interactive shell to determine the cause.
$? is a useful way to determine the exit status of a Python script. If the script is useful, it will likely be wrapped in another script or one-line bash script. It may also be used with automated monitoring or automation tools. This way, you can ensure the script will exit successfully. Once you have written the script, you can then use it with monitoring and automation tools. If you can’t determine the exit status of the script, you can always check the code for that particular error.
Conclusion
The Exit() function in Python raises an exception called the SystemExit. This will terminate the program when the value reaches six. The function should only be applied in the interpreter. If you’re using the system module, you’ll need to import it to use it correctly. Using the system Exit() function will cause the main program to terminate, not the interpreter. However, some programs will still be executed if the exit code is nonzero. This is why you need to be careful when using the exit() function.
Python Exit Codes
Sys.exit() allows you to set an exit code for a process and the exit code attribute on the multiprocessing.Process class will enable you to access the exit code. In this article, you will learn how to get and set exit codes for processes in Python.
Why Process Exit Codes?
An active instance of computer software is known as a process. In a Process, a fresh instance of the Python interpreter, every Python program is run. One thread, known as the MainThread, is used by this process, which goes by the moniker MainProcess, to carry out the program’s instructions. The underlying operating system creates and controls both processes and threads.
In order to run code concurrently, we sometimes may need to establish new child processes in our application. Python offers the ability to manage multiple processes simultaneously using class multiprocessing.Process. In addition, in multiprocessing, we might need to let other processes know whether a task carried out by a child process succeeded or failed. As a result, exit codes are used to do this.
Python Exit Codes: How to Use Them
When a process is finished, it can communicate with other processes via an exit code or exit status to let them know if it was completed successfully or not.
When a child process or callee completes the execution of a particular procedure or delegated task, it passes a tiny number to the parent process or caller, which is known as the caller’s exit status. An exit code typically has an integer value to indicate if the procedure was successful or unsuccessful, but it can also have a string message attached.
Let’s look more closely at the setting of exit codes in processes and the checking of exit codes in procedures by other processes.
Setting an Exit Code
A process can intentionally or automatically establish the exit code. For instance, the exit code will be set to zero if the process ends normally. The exit code would be set to one if the process ended due to an error or other exception. Additionally, it can set its exit code if a process actively exits.
Calling sys.exit() and supplying the exit code as a parameter will do this. As a matter of fact, the sys.exit() function causes the current process to raise a SystemExit exception, which causes the process to end. For example, the optional argument arg may be another kind of object or an integer indicating the exit status defaulting to zero.
This function assumes that the SystemExit exception is not handled and must be invoked from the process’ main thread. A successful exit is indicated by an argument value of 0. For instance:
There is no need to provide the following because it takes on the argument’s default value.
Почему sys.exit (4294967295) устанавливает для% ERRORLEVEL% значение -1?
Я наткнулся на это, когда возился с пакетным скриптом, который вызывает скрипт Python.
В скрипте Python я вызвал sys.exit(-1) , который устанавливает для %ERRORLEVEL% значение 4294967295. Прочитав, что Windows использует 32-битные целые числа без знака, я изменил его на sys.exit(4294967295) , но теперь <
Почему происходит обратное? sys.exit(-1) имеет смысл, потому что его (2 ^ 32) -1 и сохраняется с переносом, но почему использование максимального значения 32-битного целого числа без знака преобразуется в -1? Это что-то в C внизу?
1 ответ
Отрицательные целочисленные значения могут быть представлены с использованием системы счисления. Таким образом, одно и то же базовое четырехбайтовое значение 0xFFFFFFFF может представлять 32-битное значение без знака 4294967295 или 32-битное значение со знаком дополнение до двух значение -1. Это просто вопрос того, как байты интерпретируются в контексте, который включает в себя использование подписанных и неподписанных инструкций, таких как, например, в x86 ISA, JG (переход, если больше — подписанный) по сравнению с <
Когда CMD ожидает завершения процесса, он получает статус выхода через GetExitCodeProcess и сохраняет его как 32-битное целое число со знаком cmd!LastRetCode . ( имя_модуля! имя_символа — это то, как отладчик, такой как windbg или cdb, ссылается на глобальное имя символа в загруженном модуле.) CMD интерпретирует статус выхода как целое число со знаком, даже если на уровне API Windows возвращает DWORD , который является определением типа C для unsigned long .
Обычно статус выхода процесса в Windows представляет собой 16-битное значение без знака в диапазоне 0-65535. Часто это пройдено-неуспешно, т.е. либо EXIT_SUCCESS (0) или EXIT_FAILURE (1). Однако, если программа Windows завершается ненормально, например, из-за необработанного исключения, кодом состояния обычно будет значение NTSTATUS , которое представляет собой 32-разрядное целое число со знаком, которое представляет предупреждения и сбои как отрицательные значения. Например, нарушение прав доступа: STATUS_ACCESS_VIOLATION (0xC0000005 или -1073741819).
Пакетный сценарий может потребовать специальной обработки, когда программа завершается ненормально. Последний статус выхода можно проверить с помощью выражения errorlevel <number> , которое истинно, если последний статус выхода равен указанному номеру или превышает его. Например:
Сам CMD имеет специальную обработку для печати «^ C» для STATUS_CONTROL_C_EXIT (0xC000013A или -1073741510), статуса выхода, который указывает на необработанное событие управления консолью, которое включает необработанные Ctrl + C (отмена) и Ctrl + Break. Например:
В дополнение к проверке errorlevel CMD имеет встроенную переменную среды %ERRORLEVEL% . Переменные встроенной среды фактически не хранятся в блоке среды процесса. Они представлены как значения по умолчанию. В отладчике вы можете заметить, что CMD вызывает cmd!GetEnvVar для получения значения переменной среды. Эта функция сначала пробует WinAPI GetEnvironmentVariableW , который либо возвращает реальную переменную среды процесса (например, PATH ), либо одну из встроенных переменных ОС (например, __APPDIR__ , __CD__ ). Если GetEnvironmentVariableW не может найти «ERRORLEVEL», GetEnvVar по умолчанию использует встроенное значение, которое представляет собой значение LastRetCode , преобразованное в строку с помощью StringCchPrintfW , со строкой формата << X11>> (т.е. десятичное целое число со знаком). Например:
CMD также устанавливает последний статус выхода как %=ExitCode% (обычно скрытый, потому что имя начинается с » A»):
Что касается sys.exit(4294967295) в Python, обратите внимание, что sys.exit(status) — и raise SystemExit(status) под ним — обрабатывает статус выхода как целое число Python со знаком, которое преобразуется в C long int в диапазон от -2147483648 до 2147483647. Использование значения вне этого диапазона приводит к сбою преобразования и устанавливает статус выхода на -1. См. _Py_HandleSystemExit в исходном коде. опубликовано на GitHub. Бывает, что 4294967295 (0xFFFFFFFF) — это два дополнительных представления -1, но вы получите тот же результат для любого другого неподдерживаемого значения. Например:
Нормальный статус выхода — 0 в случае успеха и 1 в случае неудачи, в том числе при выводе сообщения об ошибке в stderr: