Introduction to the method of dynamically defining functions in Python

This article brings you an introduction to the method of dynamically defining functions in Python. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Under the MIT License

In Python, there is no syntactic sugar that simplifies function definition at runtime. However, this does not mean that it is impossible or difficult to achieve.

from types import FunctionType

foo_code = compile('def foo(): return "bar"', "", "exec")
foo_func = FunctionType(foo_code.co_consts[0], globals(), "foo")

print(foo_func())

Output:

bar

Analysis

Looking at the code line by line, you will find how fragile the language/interpreter barrier is.

>>> from types import FunctionType

Python documentation usually does not list features that are not intended for manually created classes (which is perfectly reasonable). There are three ways to solve this problem: help(), inspect (built-in methods cannot be inspected), and the final solution, which is to inspect the CPython source code. (Recommended: python tutorial)

In this example, both help() and inspect can get the job done, but looking at the actual source code will reveal more about the data type detail.

>>> from inspect import signature
>>> signature(FunctionType)

1. code

is internally a PyCodeobject and is open to the outside world as types.CodeType. Non-built-in methods have a __code__ attribute, which stores the corresponding code object. Types.CodeType objects can be created at runtime using the built-in compile() method.

2. globals

If a function references a variable that is not defined locally, but is passed in as a parameter, provided by a default parameter value, or provided through a closure context, it will Search in the globals dictionary.

The built-in globals() method returns a reference to the current module's global symbol table and can therefore be used to provide a dictionary that is always consistent with the state of the current table. It is also possible to pass in any other dictionary (FunctionType((lambda: bar).__code__, {"bar" : "baz"}, "foo")() == "baz").

3. name (optional)

Control the __name__ attribute of the returned function. Only really useful for lambdas (which usually don't have names due to anonymity), and rename functions.

4. argdefs (optional)

Provides a way to supply default argument values ​​by passing in a tuple containing objects of any type (def foo(bar="baz" )). (FunctionType((lambda bar: bar).__code__, {}, "foo", (10,))() == 10).

5. closure (optional)

(If it needs to be executed in a Python VM other than CPython (PyPy, Jython, ...), it probably shouldn't be touched as it seriously Depends on implementation details).

A tuple of cell objects. Creating a cell object is not entirely straightforward, as it requires calls to CPython's internal components, but there is a library that makes it easier: exalt (shameless advertising). (Annotation: This library was developed by the author.)

>>> foo_code = compile('def foo(): return "bar"', "", "exec")

compile() is a built-in method, so it is also well documented.

exec mode is used because defining a function requires multiple statements.

>>> foo_func = FunctionType(foo_code.co_consts[0], globals(), "foo")

Aggregate the entire contents and assign the dynamically created function to a variable.

The function compiled into by the previous sentence of code becomes the first constant of the generated code object, so just pointing to foo_code is not sufficient. This is a direct consequence of exec mode, since the generated code object can contain multiple constants.

>>> print(foo_func())

Dynamically generated functions can be called like other functions.

Finally

In addition to doing experiments, there are very few scenarios where dynamically created functions are needed.
Toying around Python's internals is a great way to learn more about the language.
Effortlessly cross interpreter/language boundaries if desired.

The above is the detailed content of Introduction to the method of dynamically defining functions in Python. For more information, please follow other related articles on the PHP Chinese website!