The ultimate guide to senior engineering interviews. Strategies developed by FAANG engineers on Python concurrency, multithreading, monitors, and event loops. Prep faster for top company questions.

Concurrency in Python is one of the most complex and advanced topics brought up during senior engineering interviews. Knowledge of concurrency and multithreading can put interviewees at a considerable advantage. This course lays the foundations of advanced concurrency and multithreading and explains concepts such as Monitors, Event Loops and Deferred Callbacks in depth. It also builds simple and complete solutions to popular concurrency problems that can be asked about in interviews like the Reader-Writer Problem and the Dining Philosopher Problem. While prior knowledge of concurrency is not required to follow through with this course, familiarity with the very basic Python would be helpful.

Python Concurrency for Senior Engineering Interviews

<div class="card">
   # Generator   
   <div class="ans">
<p>Functions containing a <code class="clazz">yield</code> statement are compiled as generators. Using a yield expression in a function’s body causes that function to be a generator. These functions return an object which supports the iteration protocol methods. The generator object created, automatically receives a <code class="mthd">__next()__</code> method. Going back to the example from the previous section we 
can invoke <code class="mthd">__next__</code> directly on the generator object instead of using <code class="mthd">next()</code>:</p>

<b>

```python
def keep_learning_asynchronous():
    yield "Educative"


if __name__ == "__main__":
    gen = keep_learning_asynchronous()

    str = gen.__next__()
    print(str)

```
</b>

<p>You can execute the above code in the code widget below:</p>
</div>
</div>


def keep_learning_asynchronous():
    yield "Educative"


if __name__ == "__main__":
    gen = keep_learning_asynchronous()

    str = gen.__next__()
    print(str)


<div class="ans">
<p>Also note, the snippet <code class="mthd">iter(gen) is gen</code> returns True. Thereby, confirming that a generator function returns a generator object which is an iterator.</p>
</div>

def keep_learning_asynchronous():
    yield "Educative"


if __name__ == "__main__":
    gen = keep_learning_asynchronous()

    print(iter(gen) is gen)


<div class="ans">
## Recap
<p>Remember the following about generators:</p>

<ul>
<li><p>Generator functions allow us to procrastinate computing expensive values. We only compute the next value when required. This <span class="hi-yl">makes generators memory and compute efficient.</span> They refrain from saving long sequences in memory or doing all expensive computations upfront.</p></li>

<li><p>Generators when suspended retain the code location, which is the last yield statement executed, and their entire local scope. This allows them to resume execution from where they left off.</p>
</li>

<li><p>Generator objects are nothing more than iterators.</p></li>

<li><p>Remember to make a distinction between a <b>generator function</b> and the associated <b>generator object</b> which are often used interchangeably. A generator function when invoked returns a generator object and <code class="mthd">next()</code> is invoked on the generator object to run the code within the generator function.</p></li>
</ul>


## Example
<p>We are familiar with how functions work, which may also be called methods or subroutines. Generators are methods too but they can be paused and resumed later. The rationale for writing a generator function is somewhat the same for lazy instantiation. We don't want to waste time and resources if we won't need a value. To make the concept concrete, consider a function that returns natural numbers (1, 2, 3 ....) and let's assume that finding the next natural number is a very expensive operation. Also,  we don't know how many natural numbers we'll ask for from our method <code class="mthd">natural_nums()</code> but we do know that in the worst case it would not be more than 100. One approach is that the method <code class="mthd">natural_nums()</code> computes all the first 100 natural numbers that <b>may</b> be required and return them as needed. However, with this approach, we incur the cost of calculating all the first 100 hundred natural numbers and maybe we use only the first 5 in a particular run.</p>
<p>The alternative approach is to use a generator function. The trick is two part:</p>

<ul>
<li><p>Instead of <code class="clazz">return</code> use <code class="clazz">yield</code> to return a value from a generator function.</p></li>
<li><p>We pass the return value of a generator function to the <code class="mthd">next()</code> method to get the actual value yielded or returned from the generator method.</p></li>
</ul>

<p>Let's dive into an example:</p>
### Generator function example
<b>

```python
def natural_nums():
    i = 0
    while True:
        i += 1
        yield i

```
</b>

<p>And the usage would be as follows:</p>

### Generator function example
<b>

```python
    iter = natural_nums()

    next(iter)
    next(iter)
```
</b>

<p>The above example can be run in the code widget below:</p>

</div>

<div>
   # Generator   
   <div>
<p>Functions containing a <code>yield</code> statement are compiled as generators. Using a yield expression in a function’s body causes that function to be a generator. These functions return an object which supports the iteration protocol methods. The generator object created, automatically receives a <code>__next()__</code> method. Going back to the example from the previous section we 
can invoke <code>__next__</code> directly on the generator object instead of using <code>next()</code>:</p>

<b>

```python
def keep_learning_asynchronous():
    yield "Educative"


if __name__ == "__main__":
    gen = keep_learning_asynchronous()

    str = gen.__next__()
    print(str)

```
</b>

<p>You can execute the above code in the code widget below:</p>
</div>
</div>


<div>
<p>Also note, the snippet <code>iter(gen) is gen</code> returns True. Thereby, confirming that a generator function returns a generator object which is an iterator.</p>
</div>

<div>
## Recap
<p>Remember the following about generators:</p>

<ul>
<li><p>Generator functions allow us to procrastinate computing expensive values. We only compute the next value when required. This <span>makes generators memory and compute efficient.</span> They refrain from saving long sequences in memory or doing all expensive computations upfront.</p></li>

<li><p>Generators when suspended retain the code location, which is the last yield statement executed, and their entire local scope. This allows them to resume execution from where they left off.</p>
</li>

<li><p>Generator objects are nothing more than iterators.</p></li>

<li><p>Remember to make a distinction between a <b>generator function</b> and the associated <b>generator object</b> which are often used interchangeably. A generator function when invoked returns a generator object and <code>next()</code> is invoked on the generator object to run the code within the generator function.</p></li>
</ul>


## Example
<p>We are familiar with how functions work, which may also be called methods or subroutines. Generators are methods too but they can be paused and resumed later. The rationale for writing a generator function is somewhat the same for lazy instantiation. We don't want to waste time and resources if we won't need a value. To make the concept concrete, consider a function that returns natural numbers (1, 2, 3 ....) and let's assume that finding the next natural number is a very expensive operation. Also,  we don't know how many natural numbers we'll ask for from our method <code>natural_nums()</code> but we do know that in the worst case it would not be more than 100. One approach is that the method <code>natural_nums()</code> computes all the first 100 natural numbers that <b>may</b> be required and return them as needed. However, with this approach, we incur the cost of calculating all the first 100 hundred natural numbers and maybe we use only the first 5 in a particular run.</p>
<p>The alternative approach is to use a generator function. The trick is two part:</p>

<ul>
<li><p>Instead of <code>return</code> use <code>yield</code> to return a value from a generator function.</p></li>
<li><p>We pass the return value of a generator function to the <code>next()</code> method to get the actual value yielded or returned from the generator method.</p></li>
</ul>

<p>Let's dive into an example:</p>
### Generator function example
<b>

```python
def natural_nums():
    i = 0
    while True:
        i += 1
        yield i

```
</b>

<p>And the usage would be as follows:</p>

### Generator function example
<b>

```python
    iter = natural_nums()

    next(iter)
    next(iter)
```
</b>

<p>The above example can be run in the code widget below:</p>

</div>

This lesson discusses the concept of a generator in Python.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Generator

Generator

Recap