What is the correct way to call a function within a function in Python?

General Discussions
1

I have a function, and I want to create another function that calls the first one. In languages like MATLAB, this is possible as long as the functions are in the same directory.

Here’s a basic example:

def square(x):
return x * x

Now, in my new function, I want to use the square function. I tried the following:

def something(y, z):
import square
something = square(y) + square(z)
return something

But it gives me this error: builtins.TypeError: 'module' object is not callable.

What should I do to fix this and correctly call a function within a function in Python?

2

In Python, when you use import square, you’re importing the module (if it’s in a separate file), not the function. To call the square function, you need to import it correctly.

Here’s the fix:

  1. Save your square function in a file named square.py.

  2. Import the square function from the square module in the second file:

    # square.py
def square(x):
return x * x
# your second function
from square import square
def something(y, z):
result = square(y) + square(z)
return result

In this solution, the square function is directly imported, and you can call it as you would any other function.

3

If both functions are in the same file, you don’t need to import anything. Simply define both functions in the same scope:

def square(x):
return x * x
def something(y, z):
result = square(y) + square(z)
return result

This solution ensures that the square function is in the same scope as the something function, making it directly accessible.

4

If you are dynamically loading functions and want to call them by their name (for example, if square is defined dynamically), you can use globals() or locals():

def square(x):
return x * x
def something(y, z):
result = globals()['square'](y) + globals()['square'](z)
return result

This solution uses the globals() function to dynamically call the square function. It can be useful if you’re working with dynamic function names or when importing functions dynamically.