Python: dynamically create function at runtime

Question

How to dynamically create a function in Python?

I saw a few answers here but I couldn't find one which would describe the most general case.

Consider:

def a(x):
 return x + 1

How to create such function on-the-fly? Do I have to compile('...', 'name', 'exec') it? But what then? Creating a dummy function and replacing its code object for then one from the compile step?

Or should I use types.FunctionType? How?

I would like to customize everything: number of argument, their content, code in function body, the result, ...

• Martijn Pieters: possible duplicate of True dynamic and anonymous functions possible in Python?
• Ecir Hana: I don't think it a duplicate: dynf = FunctionType(compile('def f(x): return x + 3', 'dyn.py', 'exec'), globals()) and print dynf(1) breaks with TypeError: '<module>() takes no arguments (1 given)'
• Martijn Pieters: Just because the answer there might be wrong doesn't mean this isn't a duplicate question.
• Martijn Pieters: The linked question has an updated answer demonstrating how to create a function with arguments.
• Xingzhou Liu: are you sure you can't achieve what you want using functional programming as it exists in python (lambdas, closures, compositions...)? the code objects are fiddly, and they're not well documented (or really at all). Plus they're considered internals, subject to change with or without notice.

Answer 1

Use exec:

>>> exec("""def a(x):
... return x+1""")
>>> a(2)
3

• user16776498: if anyone gets NameError consider using `locals().get('a')
• joel: given the option of safer alternatives, I think this answer should come with an appropriate warning

Answer 2

Did you see this, its an example which tells you how to use types.FunctionType

Example:

import types
def create_function(name, args):
 def y(): pass
 y_code = types.CodeType(args,
 y.func_code.co_nlocals,
 y.func_code.co_stacksize,
 y.func_code.co_flags,
 y.func_code.co_code,
 y.func_code.co_consts,
 y.func_code.co_names,
 y.func_code.co_varnames,
 y.func_code.co_filename,
 name,
 y.func_code.co_firstlineno,
 y.func_code.co_lnotab)
 return types.FunctionType(y_code, y.func_globals, name)
myfunc = create_function('myfunc', 3)
print repr(myfunc)
print myfunc.func_name
print myfunc.func_code.co_argcount
myfunc(1,2,3,4)
# TypeError: myfunc() takes exactly 3 arguments (4 given)

• Ecir Hana: Yes, I saw it and it seems to be exactly what I'm after. But I don't know how to create/modify function body and return values..?
• Julien Greard: I just tryed it, when you change the call at the end with the correct nb of args, it segfault...
• Module_art: Did you ever try to execute this code? Because this code can't run.
• Melendowski: yeah func_Code attribute doesn't exist in python 3.
• Toothpick Anemone: The original post said, "Did you see this?". However, the original webpage is dead now. There is no http://snipplr.com/view/17819/.

Answer 3

If you need to dynamically create a function from a certain template try this piece:

def create_a_function(*args, **kwargs):
 def function_template(*args, **kwargs):
 pass
 return function_template
my_new_function = create_a_function()

Within function create_a_function() you can control, which template to chose. The inner function function_template serves as template. The return value of the creator function is a function. After assignment you use my_new_function as a regular function.

Typically, this pattern is used for function decorators, but might by handy here, too.

• Nils: Thank you! Exactly what I was looking for. My use case was to create a function based on one of my dynamic generated class attribute. But it should not depend on 'self'. Therefore it is a static func create_a_function with the parameter as an argument. Thereby the attribute can be used in the inner function as a normal variable and the function is detached :-)
• Fu Hanxi: it has some limit, can't be serialized by pickle

Answer 4

You can use lambda for this.

a = lambda x: x + 1
>>> a(2)
3

• Chris Tophski: This is almost the one I'm using now. In my case I need to dynamically build a function as a string or to precompile a configured string expression, so I used a = eval("lambda x: x + 1") instead, but the result is the same. In my case I also provide math functions to expressions, so I also added from math import * in the python scripts that evaluate and execute the lambda.
• endolith: Note that you can use this to create a list or dict of functions that can be run like generic['d'](3)

Answer 5

What about this approach?

In this example I'm parametrizing first order functions on one variable (x -> ax+b) in one class:

class Fun: 
 def __init__(self, a,b):
 self.a, self.b = a,b
 def f(self, x):
 return (x*self.a + self.b)
 u = Fun(2,3).f

Here u will be the function x->2x+3.

• cowbert: there's always functools.partial applied to lambdas as well: u = partial(lambda a, b, x: x*a + b, 2, 3)

Answer 6

You can do at this manner:

new_func='def next_element(x):\n return x+1'
the_code=compile(new_func,'test','exec')
exec(the_code)
next_element(1)

It's similar to the previous exec solution.

Answer 7

simpler than Berci's answer

def get_fn(a, b): # factory function
 def fn(): # result function
 print(a, b)
 return fn
fn = get_fn(1, 2)
fn()

this is useful to turn variables into constants ("template variables for dynamic functions")

Answer 8

In my case I need a function returning the function to save it into a variable:

def create_function(function_name, function_arguments, function_code):
 function_string = f"def {function_name}({function_arguments}): {function_code}"
 exec(function_string)
 return_value = eval(function_name)
 return return_value
name = 'say_hello'
arguments = 'name'
code = 'print(f"Hello, {name}!")'
myfunc = create_function(name, arguments, code)
print(myfunc, type(myfunc))
myfunc('John Doe')

Answer 9

for the sake of completeness, the way how dynamically created function works can be simply parametrized

def dynamically_create_greeting(greet_style):
 def inner(name):
 print(f'{greet_style} {name}')
 return inner
say_hello = dynamically_create_greeting(greet_style='hello')
say_hello('John')
say_hi = dynamically_create_greeting(greet_style='hi')
say_hi('John')

this produces output >

hello John

hi John

• mimic: Hi, can you explain, how it works? It looks like the greet_style parameter is passed to the function before it's called, what is the explanation? Thanks!
• stam: Note these are separate functions and parameters. First is dynamically_create_greeting() function, and you pass the 'greet_style' in there as a parameter. That will just dynamically create (without executing it) inner function what will behave based on that parameter, and returns it. In the example above we will refer to the returned functions using 'say_hello' and 'say_hi'. Then, you actually call (execute) say_hello() itself, what accepts it's own parameter - 'name'.
• mimic: Yeah, I understand the functions are created dynamically. What I don't understand is how and where the "greet_style" parameter is stored. Because when we call say_hello and say_hi, we pass only the name but not the greet_style.
• stam: It's not stored in a sense of a an object having member you can interact with or change. You create a function and it behaves in some way, it does 'something'. So you create it (dynamically in this case) with how to do 'something' built-in. It's 'stored' in the same way as print function behavior to display smt on a console is 'stored' somewhere so print does exactly that and not something else ( if that's where are you heading, your function behavior ("greet_style) is 'stored' somewhere in your active python session's memory, look for 'inspect' module for this low level operations)