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.

Generators in Python are a sophisticated feature that enables the creation of iterators without the need to construct a full list in memory. They allow you to generate values on-the-fly, which is particularly beneficial for working with large datasets or infinite sequences. We will explore generators in depth, covering their types, mathematical formulation, advantages, disadvantages, and implementation examples.

Function generators are created using the `yield` keyword within a function. When invoked, a function generator returns a generator iterator, allowing you to iterate over the values generated by the function.

Function generators can be represented mathematically using set-builder notation. The general form is:

Where:

- `expression` is the expression to generate values.

- `variable` is the variable used in the expression.

- `iterable` is the sequence of values to iterate over.

- `condition` is an optional condition that filters the values.

1. **Memory Efficiency**: Function generators produce values lazily, meaning they generate values only when needed, saving memory compared to constructing an entire sequence upfront.

2. **Lazy Evaluation**: Values are generated on-the-fly as they are consumed, leading to improved performance and reduced overhead, especially when dealing with large datasets.

3. **Infinite Sequences**: Function generators can represent infinite sequences, such as the Fibonacci sequence, allowing you to work with data streams of arbitrary length without consuming excessive memory.

1. **Single Iteration**: Once a function generator is exhausted, it cannot be reused. If you need to iterate over the sequence again, you'll have to create a new generator.

2. **Limited Random Access**: Function generators do not support random access like lists. They only allow sequential access, which might be a limitation depending on the use case.

def fibonacci():

a, b = 0, 1

while True:

yield a

a, b = b, a + b

fib_gen = fibonacci()

for _ in range(10):

print(next(fib_gen))

Generator expressions are similar to list comprehensions but return a generator object instead of a list. They offer a concise way to create generators without the need for a separate function.

Generator expressions can also be represented mathematically using set-builder notation. The general form is the same as for function generators.

1. **Memory Efficiency**: Generator expressions produce values lazily, similar to function generators, resulting in memory savings.

2. **Lazy Evaluation**: Values are generated on-the-fly as they are consumed, providing improved performance and reduced overhead.

1. **Single Iteration**: Like function generators, once a generator expression is exhausted, it cannot be reused.

2. **Limited Random Access**: Generator expressions, similar to function generators, do not support random access.

square_gen = (x**2 for x in range(10))

for num in square_gen:

print(num)

Generators offer a powerful mechanism for creating iterators efficiently in Python. By understanding the differences between function generators and generator expressions, along with their mathematical formulation, advantages, and disadvantages, you can leverage them effectively in various scenarios. Whether you're dealing with large datasets or need to work with infinite sequences, generators provide a memory-efficient solution with lazy evaluation capabilities, contributing to more elegant and scalable code.

- [OOPs](oops.md)

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

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

- [Generators](generators.md)

- [Match Case Statement](match-case.md)

- [Closures](closures.md)

- [Filter](filter-function.md)

- [Reduce](reduce-function.md)

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

- [Eval Function](eval_function.md)