Programming FAQ — Python 3.15.2 documentation
Navigation index modules | next | previous | Python » 3.15.2 documentation » Python Frequently Asked Questions » Programming FAQ | Theme | Programming FAQ ¶ General questions ¶ Is there a source code-level debugger with breakpoints and single-stepping? ¶ Yes. Several debuggers for Python are described below, and the built-in function breakpoint() allows you to drop into any of them. The pdb module is a simple but adequate console-mode debugger for Python.
It is part of the standard Python library, and is documented in the Library Reference Manual . You can also write your own debugger by using the code for pdb as an example. The IDLE interactive development environment, which is part of the standard Python distribution (normally available as idlelib ), includes a graphical debugger. PythonWin is a Python IDE that includes a GUI debugger based on pdb. The PythonWin debugger colors breakpoints and has quite a few cool features such as debugging non-PythonWin programs.
PythonWin is available as part of pywin32 project and as a part of the ActivePython distribution. Eric is an IDE built on PyQt and the Scintilla editing component. trepan3k is a gdb-like debugger. Visual Studio Code is an IDE with debugging tools that integrates with version-control software. There are a number of commercial Python IDEs that include graphical debuggers. They include: Wing IDE PyCharm Are there tools to help find bugs or perform static analysis? ¶ Yes.
Ruff , Pylint and Pyflakes do basic checking that will help you catch bugs sooner. Static type checkers such as mypy , ty , Pyrefly , and pytype can check type hints in Python source code. How can I create a stand-alone binary from a Python script? ¶ You don't need the ability to compile Python to C code if all you want is a stand-alone program that users can download and run without having to install the Python distribution first.
There are a number of tools that determine the set of modules required by a program and bind these modules together with a Python binary to produce a single executable. One is to use the freeze tool, which is included in the Python source tree as Tools/freeze . It converts Python byte code to C arrays; with a C compiler you can embed all your modules into a new program, which is then linked with the standard Python modules.
It works by scanning your source recursively for import statements (in both forms) and looking for the modules in the standard Python path as well as in the source directory (for built-in modules). It then turns the bytecode for modules written in Python into C code (array initializers that can be turned into code objects using the marshal module) and creates a custom-made config file that only contains those built-in modules which are actually used in the program.
It then compiles the generated C code and links it with the rest of the Python interpreter to form a self-contained binary which acts exactly like your script. The following packages can help with the creation of console and GUI executables: Nuitka (Cross-platform) PyInstaller (Cross-platform) PyOxidizer (Cross-platform) cx_Freeze (Cross-platform) py2app (macOS only) py2exe (Windows only) Are there coding standards or a style guide for Python programs? ¶ Yes.
The coding style required for standard library modules is documented as PEP 8 . Core language ¶ Why am I getting an UnboundLocalError when the variable has a value? ¶ It can be a surprise to get the UnboundLocalError in previously working code when it is modified by adding an assignment statement somewhere in the body of a function. This code: >>> x = 10 >>> def bar (): ... print ( x ) ... >>> bar () 10 works, but this code: >>> x = 10 >>> def foo (): ... print ( x ) ... x += 1 results in an UnboundLocalError : >>> foo () Traceback (most recent call last): ...
UnboundLocalError : cannot access local variable 'x' where it is not associated with a value This is because when you make an assignment to a variable in a scope, that variable becomes local to that scope and shadows any similarly named variable in the outer scope. Since the last statement in foo assigns a new value to x , the compiler recognizes it as a local variable. Consequently when the earlier print(x) attempts to print the uninitialized local variable and an error results.
In the example above you can access the outer scope variable by declaring it global: >>> x = 10 >>> def foobar (): ... global x ... print ( x ) ... x += 1 ... >>> foobar () 10 This explicit declaration is required in order to remind you that (unlike the superficially analogous situation with class and instance variables) you are actually modifying the value of the variable in the outer scope: >>> print ( x ) 11 You can do a similar thing in a nested scope using the nonlocal keyword: >>> def foo (): ... x = 10 ... def bar (): ... nonlocal x ... print ( x ) ... x += 1 ... bar () ... print ( x ) ... >>> foo () 10 11 What are the rules for local and global variables in Python? ¶ In Python, variables that are only referenced inside a function are implicitly global.
If a variable is assigned a value anywhere within the function's body, it's assumed to be a local unless explicitly declared as global. Though a bit surprising at first, a moment's consideration explains this. On one hand, requiring global for assigned variables provides a bar against unintended side-effects. On the other hand, if global was required for all global references, you'd be using global all the time. You'd have to declare as global every reference to a built-in function or to a component of an imported module.
This clutter would defeat the usefulness of the global declaration for identifying side-effects. Why do lambdas defined in a loop with different values all return the same result? ¶ Assume you use a for loop to define a few different lambdas (or even plain functions), for example: >>> squares = [] >>> for x in range ( 5 ): ... squares . append ( lambda : x ** 2 ) This gives you a list that contains 5 lambdas that calculate x**2 .
You might expect that, when called, they would return, respectively, 0 , 1 , 4 , 9 , and 16 . However, when you actually try you will see that they all return 16 : >>> squares [ 2 ]() 16 >>> squares [ 4 ]() 16 This happens because x is not local to the lambdas, but is defined in the outer scope, and it is accessed when the lambda is called --- not when it is defined. At the end of the loop, the value of x is 4 , so all the functions now return 4**2 , that is 16 .
You can also verify this by changing the value of x and see how the results of the lambdas change: >>> x = 8 >>> squares [ 2 ]() 64 In order to avoid this, you need to save the values in variables local to the lambdas, so that they don't rely on the value of the global x : >>> squares = [] >>> for x in range ( 5 ): ... squares . append ( lambda n = x : n ** 2 ) Here, n=x creates a new variable n local to the lambda and computed when the lambda is defined so that it has the same value that x had at that point in the loop.
This means that the value of n will be 0 in the first lambda, 1 in the second, 2 in the third, and so on. Therefore each lambda will now return the correct result: >>> squares [ 2 ]() 4 >>> squares [ 4 ]() 16 Note that this behaviour is not peculiar to lambdas, but applies to regular functions too. How do I share global variables across modules? ¶ The canonical way to share information across modules within a single program is to create a special module (often called config or cfg).
Just import the config module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere. For example: config.py: x = 0 # Default value of the 'x' configuration setting mod.py: import config config . x = 1 main.py: import config import mod print ( config . x ) Note that using a module is also the basis for implementing th
The rest of this page is on the live site.