How do you call a sub function in Python?

Functions are one of the "first-class citizens" of Python, which means that functions are at the same level as other Python objects like integers, strings, modules, etc. They can be created and destroyed dynamically, passed to other functions, returned as values, etc.

Python supports the concept of a "nested function" or "inner function", which is simply a function defined inside another function. In the rest of the article, we will use the word "inner function" and "nested function" interchangeably.

There are various reasons as to why one would like to create a function inside another function. The inner function is able to access the variables within the enclosing scope. In this article, we will be exploring various aspects of inner functions in Python.

Defining an Inner Function

To define an inner function in Python, we simply create a function inside another function using the Python's def keyword. Here is an example:

Output

Hello from outer function
Hello from inner function

In the above example,

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

It is important to mention that the outer function has to be called in order for the inner function to execute. If the outer function is not called, the inner function will never execute. To demonstrate this, modify the above code to the following and run it:

The code will return nothing when executed!

Here is another example:

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

Output

50

The code returns the multiplication of the two numbers, that is, 10 and 5. The example shows that an inner function is able to access variables accessible in the outer function.

So far, you have seen that it is possible for us to access the variables of the outer function inside the inner function. What if we attempt to change the variables of the outer function from inside the inner function? Let us see what happens:

Output

2
9

The output shows that it is possible for us to display the value of a variable defined within the outer function from the inner function, but not change it. The statement

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

In the next section, we will be discussing the main reasons as to why we use inner functions in Python.

Why use Inner Functions?

Encapsulation

A function can be created as an inner function in order to protect it from everything that is happening outside of the function. In that case, the function will be hidden from the global scope. Here is an example:

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

Output

Traceback (most recent call last):
  File "C:/Users/admin/inner.py", line 7, in 
    inner_increment(5)
NameError: name 'inner_increment' is not defined

In the above code, we are trying to call the

50

Now, comment out the call to

50

50

Output

5 7

The script above shows that the inner function, that is,

50

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

50

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

Closures and Factory Functions

All the examples we have seen till now just contain ordinary functions that have been nested inside other functions. It is possible for us to write such functions in another way instead of nesting them inside other functions. We don't have a specific reason as to why we should nest them.

However, for the case of closures, one must use the nested functions.

We can bind/pass data to a function without necessarily passing the data to the function via parameters. This is done using a closure. It is a function object that is able to remember values in the enclosing scopes even when they are not available in the memory. This means that we have a closure when a nested function references a value that is in its enclosing scope.

The purpose of a closure is to make the inner function remember the state of its environment when it is called, even if it is not in the memory. A closure is caused by an inner function, but it's not the inner function. The closure works by closing the local variable on the stack, which stays around after the creation of the stack has finished executing.

The following are the conditions that are required to be met in order to create a closure in Python:

• There must be a nested function
• The inner function has to refer to a value that is defined in the enclosing scope
• The enclosing function has to return the nested function

Consider the following example:

def function1(name):
    def function2():
        print('Hello ' + name)
    return function2

func = function1('Nicholas')
func()

Output

Hello Nicholas

The above code demonstrates that with closures, we are able to generate and invoke a function from outside its scope via function passing. The scope of

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

def num1(x):
   def num2(y):
      return x * y
   return num2
res = num1(10)

print(res(5))

Inner functions help us in defining factory functions. A factory function is a function that creates another object. For example:

Output

256
81

In the script above, from the

2
9

2
9

2
9

2
9

2
9

2
9

Conclusion

An inner function is simply a function that is defined inside another function. The inner function is able to access the variables that have been defined within the scope of the outer function, but it cannot change them. There are a number of reasons as to why we may need to create an inner function. For instance, an inner function is protected from what happens outside it. Inner functions are also a good way of creating closures in Python.

How do you use sub function in Python?

Can Python call a function below it?

How do you call a subroutine in Python?

How function calls another function in Python?