In order to have complete understanding of this topic in python, one needs to be crystal clear with the concept of functions and the different types of them which are namely First Class Functions and Nested Functions.

These are the normal functions used by the programmer in routine as they can be assigned to variables, passed as arguments and returned from other functions.

These are the functions defined within other functions and involve thorough usage of **Closures**. It is also referred as **Inner Functions** by some books. There are times when it is required to prevent a function or the data it has access to from being accessed from other parts of the code, and this is where Nested Functions come into play. Basically, its usage allows the encapsulation of that particular data/function within another function. This enables it to be virtually hidden from the global scope.

In nested functions, if the outer function basically ends up returning the inner function, in this case the concept of closures comes into play.

A closure is a function object that remembers values in enclosing scopes even if they are not present in memory. There are certain neccesary condtions required to create a closure in python :

1. The inner function must be defined inside the outer function.

2. The inner function must refer to a value defined in the outer function.

3. The inner function must return a value.

* Closures make it possible to pass data to inner functions without first passing them to outer functions

* Closures can be used to create private variables and functions

* They also make it possible to invoke the inner function from outside of the encapsulating outer function.

* It improves code readability and maintainability

def make_multiplier_of(n):

def multiplier(x):

return x * n

return multiplier

times3 = make_multiplier_of(3)

times5 = make_multiplier_of(5)

print(times3(9))

print(times5(3))

The **multiplier function** is defined inside the **make_multiplier_of function**. It has access to the n variable from the outer scope, even after the make_multiplier_of function has returned. This is an example of a closure.

def decorator_function(original_function):

def wrapper_function(*args, **kwargs):

print(f"Wrapper executed before {original_function.__name__}")

return original_function(*args, **kwargs)

return wrapper_function

def display():

print("Display function executed")

display()

The code in the example defines a decorator function: ***decorator_function*** that takes a function as an argument and returns a new function **wrapper_function**. The **wrapper_function** function prints a message to the console before calling the original function which appends the name of the called function as specified in the code.

The **@decorator_function** syntax is used to apply the decorator_function decorator to the display function. This means that the display function is replaced with the result of calling **decorator_function(display)**.

When the **display()** function is called, the wrapper_function function is executed instead. The wrapper_function function prints a message to the console and then calls the original display function.

def create_closures():

closures = []

for i in range(5):

def closure(i=i): # Capture current value of i by default argument

return i

closures.append(closure)

return closures

my_closures = create_closures()

for closure in my_closures:

print(closure())

The code in the example defines a function **create_closures** that creates a list of closure functions. Each closure function returns the current value of the loop variable i.

The closure function is defined inside the **create_closures function**. It has access to the i variable from the **outer scope**, even after the create_closures function has returned. This is an example of a closure.

The **i**=*i* argument in the closure function is used to capture the current value of *i* by default argument. This is necessary because the ****i** variable in the outer scope is a loop variable, and its value changes in each iteration of the loop. By capturing the current value of *i* in the default argument, we ensure that each closure function returns the correct value of **i**. This is responsible for the generation of output 0,1,2,3,4.

For more examples related to closures, [click here](https://dev.to/bshadmehr/understanding-closures-in-python-a-comprehensive-tutorial-11ld).

Closures in Python provide a powerful mechanism for encapsulating state and behavior, enabling more flexible and modular code. Understanding and effectively using closures enables the creation of function factories, allows functions to have state, and facilitates functional programming techniques

The `eval` function in Python allows you to execute a string-based Python expression dynamically. This can be useful in various scenarios where you need to evaluate expressions that are not known until runtime.

```python

eval(expression, globals=None, locals=None)

* expression: String is parsed and evaluated as a Python expression

* globals [optional]: Dictionary to specify the available global methods and variables.

* locals [optional]: Another dictionary to specify the available local methods and variables.

Example 1:

result = eval('2 + 3 * 4')

print(result) # Output: 14

Example 2:

x = 10

expression = 'x * 2'

result = eval(expression, {'x': x})

print(result) # Output: 20

Example 3:

x = 10

def multiply(a, b):

return a * b

expression = 'multiply(x, 5) + 2'

result = eval(expression)

print("Result:",result) # Output: Result:52

Example 4:

expression = input("Enter a Python expression: ")

result = eval(expression)

print("Result:", result)

Example 5:

import numpy as np

a=np.random.randint(1,9)

b=np.random.randint(1,9)

operations=["*","-","+"]

op=np.random.choice(operations)

expression=str(a)+op+str(b)

correct_answer=eval(expression)

given_answer=int(input(str(a)+" "+op+" "+str(b)+" = "))

if given_answer==correct_answer:

print("Correct")

else:

print("Incorrect")

print("correct answer is :" ,correct_answer)

The eval function is a powerful tool in Python that allows for dynamic evaluation of expressions.

The filter function is a built-in Python function used for constructing an iterator from elements of an iterable for which a function returns true.

**Syntax**:

```python

filter(function, iterable)

**Parameters**:<br>

*function*: A function that tests if each element of an iterable returns True or False.<br>

*iterable*: An iterable like sets, lists, tuples, etc., whose elements are to be filtered.<br>

*Returns* : An iterator that is already filtered.

**Example 1: Filtering a List of Numbers**:

def is_even(n):

return n % 2 == 0

numbers = [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_numbers = filter(is_even, numbers)

print(list(even_numbers)) # Output: [2, 4, 6, 8, 10]

**Example 2: Filtering with a Lambda Function**:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

odd_numbers = filter(lambda x: x % 2 != 0, numbers)

print(list(odd_numbers)) # Output: [1, 3, 5, 7, 9]

**Example 3: Filtering Strings**:

words = ["apple", "banana", "cherry", "date", "elderberry", "fig", "grape" , "python"]

long_words = filter(lambda word: len(word) > 5, words)

print(list(long_words)) # Output: ['banana', 'cherry', 'elderberry', 'python']

**Example 4: Filtering Objects with Attributes**:

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

people = [

Person("Alice", 30),

Person("Bob", 15),

Person("Charlie", 25),

Person("David", 35)

]

adults = filter(lambda person: person.age >= 18, people)

adult_names = map(lambda person: person.name, adults)

print(list(adult_names)) # Output: ['Alice', 'Charlie', 'David']

**Example 5: Using None as the Function**:

numbers = [0, 1, 2, 3, 0, 4, 0, 5]

non_zero_numbers = filter(None, numbers)

print(list(non_zero_numbers)) # Output: [1, 2, 3, 4, 5]

**NOTE**: When None is passed as the function, filter removes all items that are false.

- The time complexity of filter() depends on two factors:

1. The time complexity of the filtering function (the one you provide as an argument).

2. The size of the iterable being filtered.

- If the filtering function has a constant time complexity (e.g., O(1)), the overall time complexity of filter() is linear (O(n)), where ‘n’ is the number of elements in the iterable.

- The space complexity of filter() is also influenced by the filtering function and the size of the iterable.

- Since filter() returns an iterator, it doesn’t create a new list in memory. Instead, it generates filtered elements on-the-fly as you iterate over it. Therefore, the space complexity is O(1).

Python’s filter() allows you to perform filtering operations on iterables. This kind of operation consists of applying a Boolean function to the items in an iterable and keeping only those values for which the function returns a true result. In general, you can use filter() to process existing iterables and produce new iterables containing the values that you currently need.Both versions of Python support filter(), but Python 3’s approach is more memory-efficient due to the use of iterators.

- ['itertools' module](itertools.md)

- [Type Hinting](type-hinting.md)

- [Match Case Statement](match_case_statement.md)

- [Closures](closures.md)

- [Filter](filter-function.md)

- [Reduce](reduce-function.md)

- [List Comprehension](list-comprehension.md)

- [Eval Function](eval_function.md)