# Generators in python

## 1. What are Generators?

Generators are functions that can be used to create iterators. They allow you to generate a sequence of values on-the-fly, without the need to store the entire sequence in memory. When you create a generator, you define a sequence of values using a function, and then you can iterate through that sequence using a for loop or other iterator functions.

Generators are different from traditional functions in that they use the yield statement instead of the return statement to return values. When a generator function is called, it returns a generator object, which can be used to generate the sequence of values. Each time the next() method is called on the generator object, the generator function resumes execution and continues from where it left off, generating the next value in the sequence.

Here is an example of a simple generator function that generates the first n numbers of the Fibonacci sequence:

```
def fibonacci(n):
a, b = 0, 1
for i in range(n):
yield a
a, b = b, a + b
```

In this example, we define a function called fibonacci that takes an integer n as an argument. Inside the function, we create two variables a and b, and set their initial values to 0 and 1. We then use a for loop to generate the first n numbers of the Fibonacci sequence, using the yield statement to return each value.

Here is an example of how to use this generator function to generate the first 10 numbers of the Fibonacci sequence:

```
for num in fibonacci(10):
print(num)
```

When this code is executed, it will output the following sequence of numbers:

```
0
1
1
2
3
5
8
13
21
34
```

As you can see, the generator function generates the sequence of values on-the-fly, without the need to store the entire sequence in memory. This makes it much more memory-efficient and faster than traditional functions.

## 2. The Advantages of Generators

Generators offer several advantages over traditional functions:

**Memory Efficiency:**Generators allow you to generate a sequence of values on-the-fly, without the need to store the entire sequence in memory. This makes them much more memory-efficient, especially when working with large sequences.**Speed:**Generators are faster than traditional functions because they generate values on-the-fly, instead of first generating and storing the entire sequence in memory.**Easier to Use:**Generators are easier to use than traditional functions because they use the yield statement instead of the return statement to return values. This makes it easier to generate and iterate over a sequence of values.**Infinite Sequences:**Generators allow you to generate infinite sequences of values, such as the sequence of all prime numbers or the sequence of all Fibonacci numbers.

## 3. Practical Applications of Generators

Generators are used in many different areas of Python programming. Here are some practical examples:

### 3.1. Reading Large Files

When you need to read a large file that is too big to fit into memory, you can use a generator function to read and process the file one line at a time.

```
def read_large_file(file):
with open(file) as f:
for line in f:
yield line
```

In this example, we define a function called read_large_file that takes the name of a large file as an argument. Inside the function, we open the file using a with statement, and then use a for loop to read the file one line at a time, using the yield statement to return each line.

Here is an example of how to use this generator function to read a large file:

```
for line in read_large_file('large_file.txt'):
process(line)
```

When this code is executed, it will read the large_file.txt file one line at a time, and call the process function on each line.

### 3.2. Filtering Data

When you need to filter a sequence of values, you can use a generator function to create a new sequence that only contains the values that meet your criteria.

```
def filter_data(data, condition):
for item in data:
if condition(item):
yield item
```

In this example, we define a function called filter_data that takes a sequence of data and a condition function as arguments. Inside the function, we use a for loop to iterate through the data, and then use the condition function to determine whether to include each item in the new sequence.

Here is an example of how to use this generator function to filter a sequence of numbers:

```
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_data = filter_data(data, lambda x: x % 2 == 0)
for num in filtered_data:
print(num)
```

When this code is executed, it will create a new sequence that only contains the even numbers from the original sequence, and then iterate over the new sequence using a for loop.

### 3.3. Generating Infinite Sequences

When you need to generate an infinite sequence of values, such as the sequence of all prime numbers or the sequence of all Fibonacci numbers, you can use a generator function to generate the values on-the-fly.

```
def primes():
num = 2
primes = []
while True:
for prime in primes:
if num % prime == 0:
break
else:
primes.append(num)
yield num
num += 1
```

In this example, we define a function called primes that generates the sequence of all prime numbers. Inside the function, we use a while loop to generate an infinite sequence of numbers, and then use a for loop to check whether each number is divisible by any of the prime numbers we have generated so far. If the number is not divisible by any of the prime numbers, we add it to the list of prime numbers and yield it as the next value in the sequence.

Here is an example of how to use this generator function to generate the first 10 prime numbers:

```
prime_generator = primes()
for i in range(10):
print(next(prime_generator))
```

When this code is executed, it will generate the first 10 prime numbers, using the primes generator function.

## 4. Conclusion

Generators are an important concept in Python programming. They allow you to generate a sequence of values on-the-fly, without the need to store the entire sequence in memory. This makes them much more memory-efficient and faster than traditional functions, especially when working with large sequences.

Generators are easy to use and offer several advantages over traditional functions, including their memory efficiency, speed, and ability to generate infinite sequences of values. They are used in many different areas of Python programming, such as reading large files, filtering data, and generating infinite sequences.

In this blog, we have explored the concept of generators in Python, how they work, and their practical applications. I hope this blog has been helpful in introducing you to the world of generators in Python.