What are the Python debugging methods? I will tell you how to use Python debugging commands in 3 minutes.

The probability that a programmer can write a program in one go and run it normally is very small, basically no more than 1%. There are always various bugs that need to be fixed. Some bugs are very simple. You can tell by looking at the error message. Some bugs are very complicated. We need to know which variables have correct values ​​and which variables have wrong values ​​when an error occurs. Therefore, we need a complete set of means to debug the program. to fix the bug. This method is called Debugging Command in programming.

The first method is simple, direct, crude and effective, which is to use print() to print out the variables that may have problems:

def foo(s):
    n = int(s)
    print('>>> n = %d' % n)    return 10 / ndef main():
    foo('0')
main()

After execution, look for the printed variable value in the output:

$ python err.py
>>> n = 0
Traceback (most recent call last):
  ...
ZeroDivisionError: integer division or modulo by zero

The biggest disadvantage of using print() is that you have to delete it in the future. Think about the fact that print() is everywhere in the program, and the running results will also contain a lot of junk information. So, we have a second method.

Assertion

Wherever print() is used to assist viewing, assertion can be used instead:

def foo(s):
    n = int(s)    assert n != 0, 'n is zero!'
    return 10 / ndef main():
    foo('0')

assert means that the expression n != 0 should be True, otherwise, according to the logic of program operation, the following code will definitely go wrong.

If the assertion fails, the assert statement itself will throw an AssertionError:

$ python err.py
Traceback (most recent call last):
  ...
AssertionError: n is zero!

If the program is full of asserts, it will be no better than print(). However, you can use the -O parameter to turn off assert when starting the Python interpreter:

$ python -O err.py
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

After turning it off, you can view all assert statements as passes.

logging

Replacing print() with logging is the third way. Compared with assert, logging will not throw an error and can be output to a file:

import logging
s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

logging.info() can output a piece of text. Run and find no information except ZeroDivisionError. what happened?

Don’t worry, add a line of configuration after import logging and try again:

import logging
logging.basicConfig(level=logging.INFO)

See the output:

$ python err.py
INFO:root:n = 0
Traceback (most recent call last):
  File "err.py", line 8, in <module>
    print(10 / n)
ZeroDivisionError: division by zero

This is the benefit of logging, it allows you to specify records The levels of information include debug, info, warning, error, etc. When we specify level=INFO, logging.debug will not work. In the same way, after specifying level=WARNING, debug and info will not work. In this way, you can safely output different levels of information without deleting it, and finally control which level of information is output.

Another benefit of logging is that through simple configuration, a statement can be output to different places at the same time, such as the console and files.

The above is the detailed content of What are the Python debugging methods? I will tell you how to use Python debugging commands in 3 minutes.. For more information, please follow other related articles on the PHP Chinese website!