Operations in Python

Question

My question is fairly basic yet might need a challenging solution.

Essentially, I have an arbitrary function which we will call some_function.

def some_function(n):
    for i in range(n):
           i+i
    r = 1
    r = r+1

And I want to count the number of operations took place in an arbitrary call to this function is executed (e.g. some_function(5). there are 7 operations that took place).

How would one count the number of operations that took place within a function call? I cannot modify some_function.

Answer 1

I think you're really after what others already told you - the big O notation.

But if you really want to know the actual number of instructions executed you can use this on linux:

perf stat -e instructions:u python yourscript.py

Which will output:

Performance counter stats for 'python yourscript.py':

    22,260,577 instructions:u           

   0.014450363 seconds time elapsed

Note though that it includes all the instructions for executing python itself. So you'd have to find your own reference.

Answer 2

Using byteplay:

Example:

#!/usr/bin/env python


from byteplay import Code


def some_function(n):
    for i in range(n):
        i + i
    r = 1
    r = r + 1


def no_of_bytecode_instructions(f):
    code = Code.from_code(f.func_code)
    return len(code.code)


print(no_of_bytecode_instructions(some_function))

Output:

$ python -i foo.py
28
>>> 

NB:

• This still gives you no idea how complex f is here.
• "Number of Instructions" != "Algorithm Complexity" (not by itself)
• See: Big O

Algorithm complexity is a measure of the no. of instructions executed relative to the size of your input data set(s).

Some naive examples of "complexity" and Big O:

def func1(just_a_list):
    """O(n)"""

    for i in just_a_list:
        ...

def func2(list_of_lists):
    """O(n^2)"""

    for i in list_of_lsits:
        for j in i:
            ...

def func3(a_dict, a_key):
    """O(1)"""

    return a_dict[a_key]