Good way to count number of functions of a python file, given path

Question

I do not want to import my module. I have to count the number of functions given the .py file path. What is the best way to do so?

One thing I thought about was to count the number of "def" in my code, but it does not seem like the best way to go about this. Is there any better way to count the number of functions?

Answer 1

To count the top level definition, use ast module like this:

import ast

with open(filename) as f:
    tree = ast.parse(f.read())
    sum(isinstance(exp, ast.FunctionDef) for exp in tree.body)

Answer 2

You can use ast.NodeVisitor:

import inspect
import importlib
import ast

class CountFunc(ast.NodeVisitor):
    func_count = 0
    def visit_FunctionDef(self, node):
        self.func_count += 1


mod = "/path/to/some.py"

p = ast.parse(open(mod).read())

f = CountFunc()
f.visit(p)

print(f.func_count)

If you wanted to include lambdas you would need to add a visit_Lambda:

 def visit_Lambda(self, node):
    self.func_count += 1

That will find all defs including methods of any classes, we could add more restrictions to disallow that:

class CountFunc(ast.NodeVisitor):
    func_count = 0

    def visit_ClassDef(self, node):
        return 

    def visit_FunctionDef(self, node):
        self.func_count += 1


    def visit_Lambda(self, node):
        self.func_count += 1

You can tailor the code however you like, all the nodes and their attributes are described in the greentreesnakes docs

Answer 3

Padraic beats me to it, but here is my code, which works with Python 2 and Python 3.

from __future__ import print_function
import ast

class FunctionCounter(ast.NodeVisitor):
    def __init__(self, filename):
        self.function_count = 0
        with open(filename) as f:
            module = ast.parse(f.read())
            self.visit(module)

    def visit_FunctionDef(self, node):
        print('function: {}'.format(node.name))
        self.function_count += 1

    # Uncomment this to disable counting methods, properties within a
    # class
    # def visit_ClassDef(self, node):
    #     pass

if __name__ == '__main__':
    counter = FunctionCounter('simple.py')
    print('Number of functions: {}'.format(counter.function_count))

Discussion

• This code not only count the function at the module level, it also count functions (method and properties) nested within class definitions.
• To disable counting functions in the class definitions, uncomment the 2 lines for visit_ClassDef

Answer 4

You can use

len(dir(module))

Hope it helps

Answer 5

you can use the pyclbr module to get results of the module, the only catch is that you need to use the name of the module as you would import it instead of the file path, this benefits from also recognizing from X import Y for python source based modules (not builtin ones like math)

from pyclbr import readmodule_ex, Function
#readmodule_ex is function 1

def test(): #2
    pass
def other_func(): #3
    pass

class Thing:
    def method(self):
        pass


result = readmodule_ex("test") #this would be it's own file if it is test.py

funcs = sum(isinstance(v,Function) for v in result.values())

print(funcs)

Answer 6

My answer is an edit to the answer of @ Naveen Kumar because I can not edit his answer at the moment. You can use

import module

len(dir(module))

i.e:

import math
print(len(dir(math)))

output:

 63