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">
   # Chaining Coroutines   
   <div class="ans">
<p>One of the most prominent uses of coroutines is to chain them to process data pipelines. We can chain coroutines in a fashion similar to how we pipe Unix commands in a shell.</p>

<p>The idea is that the input passes through the first coroutine, which may perform some actions on the input and then passes on the modified data to the second coroutine which may perform additional operations on the input. The input travels through the chain of coroutines with each coroutine applying some operation on the input until the input reaches the last coroutine from where it is yielded to the original caller. Let's consider the following example, which computes the values for the expression <b>x<sup>2</sup> + 3</b> for the first hundred natural numbers. We manually work the data pipeline using the <code class="mthd">next()</code> method so we'll setup chain without worrying about the changes required to make it work with the asyncio's event loop. The setup is as follows:</p>

<ul>
<li><p>The first coroutine produces natural numbers starting from 1.</p></li>

<li><p>The second coroutine computes the square of each passed in input.</p></li>

<li><p>The last function is a generator and adds 3 to the value passed into it and yields the result.</p></li>
</ul> 

<b>

```python
def coro3(k):
    yield (k + 3)


def coro2(j):
    j = j * j
    yield from coro3(j)


def coro1():
    i = 0
    while True:
        yield from coro2(i)
        i += 1


if __name__ == "__main__":

    # The first 100 natural numbers evaluated for the following expression
    # x^2 + 3

    cr = coro1()
    for v in range(100):
        print("f({0}) = {1}".format(v, next(cr)))

```
</b>
</div>
</div>

<div>
   # Chaining Coroutines   
   <div>
<p>One of the most prominent uses of coroutines is to chain them to process data pipelines. We can chain coroutines in a fashion similar to how we pipe Unix commands in a shell.</p>

<p>The idea is that the input passes through the first coroutine, which may perform some actions on the input and then passes on the modified data to the second coroutine which may perform additional operations on the input. The input travels through the chain of coroutines with each coroutine applying some operation on the input until the input reaches the last coroutine from where it is yielded to the original caller. Let's consider the following example, which computes the values for the expression <b>x<sup>2</sup> + 3</b> for the first hundred natural numbers. We manually work the data pipeline using the <code>next()</code> method so we'll setup chain without worrying about the changes required to make it work with the asyncio's event loop. The setup is as follows:</p>

<ul>
<li><p>The first coroutine produces natural numbers starting from 1.</p></li>

<li><p>The second coroutine computes the square of each passed in input.</p></li>

<li><p>The last function is a generator and adds 3 to the value passed into it and yields the result.</p></li>
</ul> 

<b>

```python
def coro3(k):
    yield (k + 3)


def coro2(j):
    j = j * j
    yield from coro3(j)


def coro1():
    i = 0
    while True:
        yield from coro2(i)
        i += 1


if __name__ == "__main__":

    # The first 100 natural numbers evaluated for the following expression
    # x^2 + 3

    cr = coro1()
    for v in range(100):
        print("f({0}) = {1}".format(v, next(cr)))

```
</b>
</div>
</div>

This lesson explains how to chain coroutines with an example.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Chaining Coroutines

Chaining Coroutines