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)

- [Protocols](protocols.md)

- [Generators](generators.md)

Python can establish informal interfaces using protocols In order to improve code structure, reusability, and type checking. Protocols allow for progressive adoption and are more flexible than standard interfaces in other programming languages like JAVA, which are tight contracts that specify the methods and attributes a class must implement.

This is a module in python which provides

1. Provides classes, functions, and type aliases.

2. Allows adding type annotations to our code.

3. Enhances code readability.

4. Helps in catching errors early.

Type hints allow you to specify the expected data types of variables, function parameters, and return values. This can improve code readability and help with debugging.

Here is a simple function that adds two numbers:

def add(a,b):

return a + b

add(10,20)

While this works fine, adding type hints makes the code more understandable and serves as documentation:

def add(a:int, b:int)->int:

return a + b

print(add(1,10))

In this version, `a` and `b` are expected to be integers, and the function is expected to return an integer. This makes the function's purpose and usage clearer.

The function given below takes an iterable (it can be any off list, tuple, dict, set, frozeset, String... etc) and print it's content in a single line along with it's type.

from typing import Iterable

def print_all(l: Iterable)->None:

print(type(l),end=' ')

for i in l:

print(i,end=' ')

print()

l = [1,2,3,4,5] # type: List[int]

s = {1,2,3,4,5} # type: Set[int]

t = (1,2,3,4,5) # type: Tuple[int]

for iter_obj in [l,s,t]:

print_all(iter_obj)

Output:

and now lets try calling the function `print_all` using a non-iterable object `int` as argument.

a = 10

print_all(a) # This will raise an error

Output:

This error occurs because `a` is an `integer`, and the `integer` class does not have any methods or attributes that make it work like an iterable. In other words, the integer class does not conform to the `Iterable` protocol.

**Benefits of Type Hints**

Using type hints helps in several ways:

1. **Error Detection**: Tools like mypy can catch type-related problems during development, decreasing runtime errors.

2. **Code Readability**: Type hints serve as documentation, making it easy to comprehend what data types are anticipated and returned.

3. **Improved Maintenance**: With unambiguous type expectations, maintaining and updating code becomes easier, especially in huge codebases.

Now that we have understood about type hints and typing module let's dive deep into protocols.

In Python, protocols define interfaces similar to Java interfaces. They let you specify methods and attributes that an object must implement without requiring inheritance from a base class. Protocols are part of the `typing` module and provide a way to enforce certain structures in your classes, enhancing type safety and code clarity.

A protocol specifies one or more method signatures that a class must implement to be considered as conforming to the protocol.

This concept is often referred to as "structural subtyping" or "duck typing," meaning that if an object implements the required methods and attributes, it can be treated as an instance of the protocol.

Let's write our own protocol:

from typing import Protocol

class Printable(Protocol):

def print(self) -> None:

"""Print the object"""

pass

class Book:

def __init__(self, title: str):

self.title = title

def print(self) -> None:

print(f"Book Title: {self.title}")

def print_object(obj: Printable) -> None:

obj.print()

book = Book("Python Programming")

print_object(book)

Output:

In this example:

1. **Printable Protocol:** Defines an interface with a single method print.

2. **Book Class:** Implements the Printable protocol by providing a print method.

3. **print_object Function:** Accepts any object that conforms to the Printable protocol and calls its print method.

we got our output because the class `Book` confirms to the protocols `printable`.

similarly When you pass an object to `print_object` that does not conform to the Printable protocol, an error will occur. This is because the object does not implement the required `print` method.

Let's see an example:

class Team:

def huddle(self) -> None:

print("Team Huddle")

c = Team()

print_object(c) # This will raise an error

Output:

In this case:

- The `Team` class has a `huddle` method but does not have a `print` method.

- When `print_object` tries to call the `print` method on a `Team` instance, it raises an `AttributeError`.

**Ensuring Protocol Conformance**

To avoid such errors, you need to ensure that any object passed to `print_object` implements the `Printable` protocol. Here's how you can modify the `Team` class to conform to the protocol:

class Team:

def __init__(self, name: str):

self.name = name

def huddle(self) -> None:

print("Team Huddle")

def print(self) -> None:

print(f"Team Name: {self.name}")

c = Team("Dream Team")

print_object(c)

Output:

The `Team` class now implements the `print` method, conforming to the `Printable` protocol. and hence, no longer raises an error.

Protocols can also be used in combination with inheritance to create more complex interfaces.

we can do that by following these steps:

**Step 1 - Base protocol**: Define a base protocol that specifies a common set of methods and attributes.

**Step 2 - Derived Protocols**: Create derives protocols that extends the base protocol with addition requirements

**Step 3 - Polymorphism**: Objects can then conform to multiple protocols, allowing for Polymorphic behavior.

Let's see an example on this as well:

from typing import Protocol

class Printable(Protocol):

def print(self) -> None:

"""Print the object"""

pass

class Serializable(Protocol):

def serialize(self) -> str:

pass

class PrintableAndSerializable(Printable, Serializable):

pass

class Book_serialize:

def __init__(self, title: str):

self.title = title

def print(self) -> None:

print(f"Book Title: {self.title}")

def serialize(self) -> None:

print(f"serialize: {self.title}")

def test(obj: PrintableAndSerializable):

obj.print()

obj.serialize()

book = Book_serialize("lean-in")

test(book)

Output:

serialize: lean-in

In this example:

**Printable Protocol:** Specifies a `print` method.

**Serializable Protocol:** Specifies a `serialize` method.

**PrintableAndSerializable Protocol:** Combines both `Printable` and `Serializable`.

**Book Class**: Implements both `print` and `serialize` methods, conforming to `PrintableAndSerializable`.

**test Function:** Accepts any object that implements the `PrintableAndSerializable` protocol.

If you try to pass an object that does not conform to the `PrintableAndSerializable` protocol to the test function, it will raise an `error`. Let's see an example:

class Team:

def huddle(self) -> None:

print("Team Huddle")

c = Team()

test(c) # This will raise an error

output:

In this case:

The `Team` class has a `huddle` method but does not implement `print` or `serialize` methods.

When test tries to call `print` and `serialize` on a `Team` instance, it raises an `AttributeError`.

**In Conclusion:**

- [FastAPI](fast-api.md)

- [Stacks in Python](stacks.md)

- [Sliding Window Technique](sliding-window.md)

- [Trie](trie.md)