How to get list of parameters name from a function in Python?

The task of getting a list of parameter names from a function in Python involves extracting the function's arguments using different techniques. These methods allow retrieving parameter names efficiently, whether from bytecode, introspection or source code analysis. For example, if a function fun(a, b, c=10) is defined, the extracted parameter names will be ['a', 'b', 'c'].

Using __code__.co_varnames

This method retrieves function parameter names directly from the function's bytecode using __code__.co_varnames. It is the fastest approach as it does not require any module imports. However, it only works for positional arguments and does not support keyword-only parameters.

def fun(a, b, c=10):
    pass

res = fun.__code__.co_varnames[:fun.__code__.co_argcount]
print(res)

('a', 'b', 'c')

Explanation:

• __code__ attribute stores metadata, including co_varnames, which lists all variables.
• The slice [:fun.__code__.co_argcount] extracts only the parameters, excluding locals and returns them as a tuple.

Using inspect.signature()

This method, provided by the inspect module, is the most reliable and modern approach for extracting parameter names. It supports positional, keyword-only and default arguments, making it suitable for detailed function analysis.

import inspect

def fun(a, b, c=10):
    pass

res = list(inspect.signature(fun).parameters.keys())
print(res) 

['a', 'b', 'c']

Explanation: inspect.signature(fun).parameters returns an ordered mapping of parameter names and extracting .keys() converts them into a list.

Using inspect.getfullargspec()

inspect.getfullargspec() retrieves a function's parameter names along with details like default values and annotations. It provides a comprehensive view of the function’s arguments but is deprecated in favor of inspect.signature().

import inspect

def fun(a, b, c=10):
    pass

res = inspect.getfullargspec(fun).args
print(res)

['a', 'b', 'c']

Explanation: inspect.getfullargspec(fun) retrieves detailed information about the function’s arguments and accessing .args extracts only the parameter names as a list.

Using ast (Abstract Syntax Tree)

ast module allows analyzing a function’s source code to extract parameter names. This method is useful for static code analysis, especially when working with dynamically loaded scripts, but is not efficient for direct function inspection.

import ast

source = """
def my_function(a, b, c=10):
    pass
"""

tree = ast.parse(source)
func_node = tree.body[0]  # assuming the first function in the script

res = [arg.arg for arg in func_node.args.args]
print(res)

['a', 'b', 'c']

Explanation: ast.parse(source) generates an abstract syntax tree (AST) from the function's source code. tree.body[0] retrieves the first function node and [arg.arg for arg in func_node.args.args] extracts parameter names from the function definition as a list.

riturajsaha

Follow

Improve

Article Tags :

• Technical Scripter
• Python
• Technical Scripter 2020
• Python-Functions
• Python function-programs

+1 More

Practice Tags :

• python
• python-functions