Can You Define a Function Within a Function Python

Let's wait at examples of the benefits of nested Python functions and how to use themto encapsul closures, and decorators.

Nested (or inner, nested) functions are functions that we ascertain within other functions to direct admission the variables and names defined in the enclosing office. Nested functions have many uses, primarily for creating closures and decorators.

In this guide, we will

• learn how to provide encapsulation and hibernate functions from external access

• write helper functions to make code easier to reuse

• implement closures to persist state betwixt calls

• let's create decorators to add behaviour to existing functions

Creating Nested Functions in Python

Let's kickoff with a lawmaking example containing a nested function:

def outer_func():     def inner_func():         print("Hello, World!")     inner_func() outer_func()

OUTPUT

Howdy, World!

In this code, nosotros define internally to display a string . To exercise this, we telephone call on the last line . inner_func()  outer_func() Hello, World! inner_func() outer_func()

The major utilise of internal functions is their easiness to admission variables and objects from an subscribed ("external") office. The enclosing function provides a namespace bachelor to the nested role:

def outer_func(who):     def inner_func():         print(f"How-do-you-do, {who}")     inner_func() outer_func("World!")

OUTPUT

Hullo, Earth!

Now we can pass a string as an argument to the part, and will refer to this statement through the name . This name is divers in the local telescopic. The names we defined in the local scope of the outer function are defined as. They are non-local from a point of view. external_func() inner_func() who outer_func() nonlocal inner_func()

Some other case of a more complex nested role:

def factorial(number):     if non isinstance(number, int):         raise TypeError("The number must be whole.")     if number < 0:         raise ValueError("The number must be non-negative.")     #Factorial calculation     def inner_factorial(number):         if number <= one:             render one         render number * inner_factorial(number - one)     return inner_factorial(number)  factorial(four)

OUTPUT

24

In the function, we first validate the input to brand sure the user is providing a not-negative integer. We and then define a recursive named inner function that computes the factorial. In the final pace, the corresponding adding is called and performed. factorial() inner_factorial() inner_factorial()

The primary advantage of using such a design is that past doing all the argument checks in the outer function, we tin can safely skip the error checking in the inner function and focus on the current computation.

The basics of using nested functions in Python

Encapsulation

A mutual utilise case for internal functions is when you need to protect or hide a function from everything that happens outside of it, that is, completely hide the function from the global telescopic. This behaviour is commonly referred to as encapsulation.

Let's start with an illustrative instance:

def increment(number):     def inner_increment():         return number + 1     render inner_increment()  print(increase(10))

OUTPUT

xi

# Let's telephone call the nested function inner_increment() >>> print(inner_increment())

OUTPUT

Name Error: proper name 'inner_increment' is not divers

In this case, we don't accept directly access to. Past trying to admission the nested office, nosotros get. The function hides the office completely, preventing access from the global scope. inner_increment() Name Error increment() inner_increment()

Creating internal helper functions

Sometimes we need a function that executes the same piece of code in several places in its torso. Let's take an example to create a part to access and use a CSV file containing data about Wireless hotspots. To find out the total number of admission points, as well as information about the company that provides them, nosotros created the following script:

import CSV from collections import Counter def process_hotspots(file):     def most_common_provider(file_obj):         hotspots = []         with file_obj as csv_file:             content = csv.DictReader(csv_file)             for row in content:                 hotspots.append(row["Provider"])         counter = Counter(hotspots)         print(              f "{counter.most_common (1) [0] [1]} provides"              f "{counter.most_common (1) [0] [0]}."         )     if isinstance(file, str): # Get the path to the file                 file_obj = open(file, "r")         most_common_provider(file_obj)     else:         # We take the file object         most_common_provider(file)

This takes an argument and checks if the file is a string path to a physical file or a file object. The function and so calls a helper inner function that takes a file object and performs the following operations: process_hotspots() file most_common_provider()

1. Reads the contents of a file into a generator that creates dictionaries using. CSV.DictReader

2. Lists Wi-Fi providers.

3. Counts the number of Wi-Fi hotspots for each provider using a facility. collections.Counter

4. Prints a message with the information received.

By running the role, nosotros get the following output:

>>> from hotspots import process_hotspots >>> file_obj = open ("./ NY_Wi-Fi_Hotspot_Locations.csv", "r") >>> process_hotspots (file_obj) At that place are three,319 Wi-Fi points in New York. 1,868 of these are provided by LinkNY - City bridge. >>> process_hotspots ("./ NY_Wi-Fi_Hotspot_Locations.csv") In that location are 3,319 Wi-Fi points in New York. 1,868 of these are provided by LinkNY - Urban center bridge.

Regardless of whether nosotros call with a cord file path or a file object, you will become the same consequence. process_hotspots()

Using internal and private helper functions

We unremarkably create helper internal functions, such as when we want to provide encapsulation or when nosotros are not going to call them anywhere other than the enclosing function. most_common_provider()

Although writing internal helper functions gives the desired issue, it is usually best to expose them as top-level functions. In this case, y'all can use the underscore prefix in the function name to indicate that information technology is private to the electric current module or class. To brand the code cleaner and readable we use extraction of internal functions into top-level private functions. This practice is consistent with the principle of single responsibility.

Saving State with Nested Functions: Closures in Python

Python functions in their rights are equal to any other objects, such every bit numbers, strings, lists, tuples, modules, etc. That is, they can be dynamically created or destroyed, stored in information structures, passed as arguments to other functions, used as returned values.

Source

If nosotros do non need to hide the internal functions from the outside world, then in that location is no detail reason for nesting.

In this section, we'll talk most another kind of nested function – closures. These are dynamically created functions returned by other functions. To access variables and names defined in the local namespace closures have full rights, no matter whether the enclosing function has finished executing or not.

There are three steps to defining a closure:

1. Create a nested function.

2. Refer to variables from the enclosing role.

3. Render a nested office.

Allow'due south look at some examples now.

Saving state in a closure

So, the closure forces the nested role, when called, to save the state of its surroundings. That is, the closure is not only the internal office itself but also the environment.

Consider the following example:

powers.py def generate_power(exponent):     def power(base):         render base ** exponent     return power

Hither we define a function that is a factory for creating closures. That is, this role creates and returns a new closure office each time information technology is called. The adjacent line defines a function that is an internal function and takes a single argument and returns the result of the expression. The terminal line returns as a function object without calling it. generate_power() power() base base ** exponent power

Where does the exponent value come from? This is where snapping comes into play. This case gets the exponent value from an external function. This is what Python does when nosotros telephone call : power() exponent ability() generate_power() generate_power()

1. Defines a new example that takes an argument. ability() base

2. Takes a "snapshot" of the environment. It includes the current value. power() exponent

3. Returns along with the state. power()

Thus, when we phone call the instance returned by the part, we tin encounter that the role remembers the value of the degree: power() generate_power() exponent

>>> raise_two = generate_power(2) >>> raise_three = generate_power(3) >>> raise_two(4)

OUTPUT

16

>>> raise_two(five)

OUTPUT

25

>>> raise_three(iv)

OUTPUT

64

Note that both closures recollect the corresponding exponent between calls. In these examples, remembers what , and remembers what . raise_two() exponent = 2 rise_three() exponent = 3

Let's consider another example:

def has_permission(page):     def permission(username):         if username.lower() == "admin":           return f "'{username}' has right to open up {page}."          else:              return f "'{username}' does not have right to open {page}."     render permission

check_admin_page_permision = has_permission("Admin Page") >>> print (check_admin_page_permision ("admin"))

OUTPUT

'admin' has access to the Admin Folio.

>>> print (check_admin_page_permision ("john"))

OUTPUT

'john' does not have access to the Admin Folio.

The nested function checks if the given user has the required admission rights to the page. Instead of checking if the user is equal, you can query the database . 'admin'

Closures ordinarily do not change the country they received at nativity, as shown in the examples above. Just you tin also create dynamic closures using mutable objects such as dictionaries, sets, or lists.

Suppose yous want to calculate the boilerplate for a dataset. The data comes in the grade of a stream of successive measurements of the analyzed parameter, and it is necessary that the function retains the previous measurements between calls. In this case, the mill code for creating closures might look similar this:

def mean():     sample = []     def inner_mean(number):         sample.append(number)         render sum(sample) / len(sample)     return inner_mean sample_mean = mean() >>> sample_mean(100) 100.0 >>> sample_mean(105) 102.5 >>> sample_mean(101) 102.0 >>> sample_mean(98) 101.0

A closure assigned maintains the fetch state between calls. Although we define a listing internally, it is likewise available in a closure. sample_mean sample mean()

Changing the state of a snapping

Closure variables are normally completely hidden from the outside globe. However, we can ascertain getter and setter functions for them:

def make_point(x, y):     def betoken():         print(f"Betoken({10}, {y})")     def get_x():         return 10     def get_y():         return y     def set_x(value):         nonlocal x         ten = value     def set_y(value):         nonlocal y         y = value     # Adding getters and setters     point.get_x = get_x     point.set_x = set_x     signal.get_y = get_y     betoken.set_y = set_y     render point point = make_point(1, ii) >>> point.get_x() i >>> betoken.get_y() 2 >>> point() Point(1, 2) >>> point.set_x(42) >>> point.set_y(7) >>> point() Point(42, 7)

Here returns a closure representing the object. Functions are attached to this object that we can employ to gain access to read and write variables and. make_point() indicate 10 y

Such a factory may even exist faster than an equivalent form, but the approach does non provide inheritance, descriptors, and other features of Python classes.

Irresolute Behavior with Nested Functions: Decorators

Python decorators are the adjacent popular and easier employ cases for internal functions, peculiarly for closures. Decorators are higher-order functions that take a callable object (function, method, course) as an argument and return some other callable object.

Source

Typically, decorators are used to dynamically add properties to an existing callee and transparently extend its behaviour without affecting or modifying the callee. A decorator part can be practical to whatever callable object. To practice this, the symbol and the proper name of the decorator are placed in the line preceding it

@decorator def decorated_func():     # Function body...

laissez passer

This syntax forces you to automatically accept it as an statement and process information technology in your body. This performance is an abbreviation for a statement like this: decorator() decorator_func()

decorated_func = decorator(decorated_func)

Here's an case of how you tin create a decorator function to change the behaviour of an existing office:

def add_messages(func):     def _add_messages():        impress ("This is my first decorator.")          func ()          print ("Bye!")      return _add_messages @add_messages def greet ():      impress ("Hello globe!")  greet()

OUTPUT

Hello Globe!

In this example, we use functions to decorate. As a event, the role gains new functionality. Now, when we call, instead of simply typing, it prints out two additional messages. @add_messages greet() greet() Hello World!

The simplest practice for debugging Python code is to insert calls to check the values ​​of variables. All the same, by adding and removing calls, we gamble forgetting about some of them. To preclude this state of affairs, we can write the following decorator: print() print()

def debug(func):     def _debug(*args, **kwargs):         issue = func(*args, **kwargs)         print(             f"{func.__name__}(args: {args}, kwargs: {kwargs}) -> {result}"         )         render result     return _debug @debug def add(a, b):     return a + b >>> add(5, 6) add(args: (five, half-dozen), kwargs: {}) -> eleven 11

In this example, the decorator function prints the name of the function to decorate, the current values ​​of each argument, and the return result. Such a decorator tin can be used for the basic debugging of functions. Once we go the desired outcome, it is enough to remove the call to the decorator, and the debugged function will piece of work as usual. debug () @debug

Allow'south give the concluding case and reimplement it as a decorator function: generate_power()

def generate_power(exponent):     def power(func):         def inner_power(*args):             base = func(*args)             return base ** exponent         return inner_power     return power @generate_power(2) def raise_two(northward):     render northward @generate_power(iii) def raise_three(due north):     return n >>> raise_two(seven) 49 >>> raise_three(5) 125

This version gives the same results as the original implementation. In this case, to store the exponent. generate_power() func() in a modified version we use both the closure every bit well as a decorator.

Hither the decorator must have an statement (exponent), and then we needed two levels of nesting. The first level is represented by a part that takes the function to decorate equally an statement. The second level is represented by a role that packs the exponent into, performs the final calculation, and returns the result. power() inner_power() args

Conclusion

So, in Python, nested functions have direct access to the variables and names that you define in the enclosing function. It provides a mechanism for encapsulating functions, creating helper solutions, and implementing closures and decorators.

The media shown in this article are not endemic by Analytics Vidhya and are used at the Author's discretion.

borcherslierected.blogspot.com

Source: https://www.analyticsvidhya.com/blog/2021/08/how-nested-functions-are-used-in-python/

Share this post