Question: I have hundreds of functions test1, test2, ... Function testX may or may not have kwargs: def test1(x, z=1, **kwargs): pass def test2(x, y=1): pass def test3(x, y=1, z=1): pass ...  and I have a function call_center: tests = [test1, test2, test3] def call_center(**kwargs): for test in tests: test(**kwargs)  call_center will be called with various input parameters: call_center(x=1,y=1) call_center(x=1,z=1)  I don't want to filter kwargs by inspect.signature of the called function, because these function will be called millions of times, filtering at runtime costs a lot. How can I define a decorator extend_kwargs that adds kwargs to functions that do not have kwargs? I can use signature to find if kwargs exists. def extender(func): sig = signature(func) params = list(sig.parameters.values()) if any( param.name for param in sig.parameters.values() if param.kind == param.VAR_KEYWORD ): return func # add kwargs to func here ... return func  and i tried add Parameter to signature like this  kwargs = Parameter("__auto_kwargs", Parameter.VAR_KEYWORD) params.append(kwargs) new_sig = sig.replace(parameters=params) func.__signature__ = new_sig  It seems signature is just signature, does not affect the execution. and i tried to modify __code__ of func.  old_code = func.__code__ code = old_code.replace( co_varnames=old_code.co_varnames + ("__auto_kwargs",), co_nlocals=old_code.co_nlocals + 1, ) func.__code__ = code  Still not work Refer to the accepted answer, the following code works. The judgment is simplified and add the modification of co_flags. def extender(func): if not func.__code__.co_flags & inspect.CO_VARKEYWORDS: code = func.__code__ func.__code__ = code.replace( co_flags=code.co_flags | inspect.CO_VARKEYWORDS, co_varnames=code.co_varnames + ("kwargs",), co_nlocals=code.co_nlocals + 1, ) return func  If you don't want to modify the original function directly, see the accepted answer

Answer: To add variable keyword parameters (kwargs) to a function that does not have it you can re-create the function with types.FunctionType but with the code object replaced with one that has the inspect.CO_VARKEYWORDS flag enabled in the co_flags attribute, the kwargs name added to the co_varnames attribute, and the number of local variables incremented by 1 in the co_nlocals attribute. So a decorator that adds kwargs to functions that do not have it can look like: import inspect from types import FunctionType def ensure_kwargs(func): if func.__code__.co_flags & inspect.CO_VARKEYWORDS: return func # already supports kwargs return FunctionType( code=func.__code__.replace( co_flags=func.__code__.co_flags | inspect.CO_VARKEYWORDS, co_varnames=func.__code__.co_varnames + ('kwargs',), co_nlocals=func.__code__.co_nlocals + 1 ), globals=func.__globals__, name=func.__name__, argdefs=func.__defaults__, closure=func.__closure__ )  so that: def test1(x, z=1, **kwargs): print(f'{x=}, {z=}, {kwargs=}') def test2(x, y=1): print(f'{x=}, {y=}') def test3(x, y=1, z=1): print(f'{x=}, {y=}, {z=}') def call_center(**kwargs): for test in tests: test(**kwargs) tests = list(map(ensure_kwargs, [test1, test2, test3])) call_center(x=1, y=2) call_center(x=3, z=4)  outputs: x=1, z=1, kwargs={'y': 2} x=1, y=2 x=1, y=2, z=1 x=3, z=4, kwargs={} x=3, y=1 x=3, y=1, z=4  Demo: https://ideone.com/0aeT2m