Python Asynchronous Programming Fresco Play handson Solution

Lab 1: Welcome to asyncio - Threads

Hands-On - Multithreading

Solution: Hands-On - Multithreading

import threading
 
# Task 1: Create a function `square_it()` which takes a single argument `n` and makes the function print (not return) the square of `n`.
def square_it(n):
  print(n**2)
 
 
# Task 2: Create an another function `do_it()` which takes two integers a and b as arguments and creates two threads targeting `square_it()` function with a and b as argument respectively
def do_it(a, b):
  t1 = threading.Thread(target=square_it, args=(a,))
  t2 = threading.Thread(target=square_it, args=(b,))
 
  # Task 3:  Start the threads to view them in action.
  t1.start()
  t2.start()

 

Lab 2: Welcome to asyncio - Multiprocessing

Hands-On - Multiprocessing

Solution: fresco play Multiprocessing handson.

 
import multiprocessing
from multiprocessing import Pool
 
# Task 1:  Create a function `calc_it()` that accepts two integers: `start' and `end`. It should then return the sum of all integers between `start' and `end' (including `start' and `end`) and return the resultant value.
 
def calc_it(start, end):
  sum = 0
  for i in range(start,end+1):
      sum +=i
  return sum
 
 
# Task 2: Create an another function `do_it()` that accepts a single integer: `n'. It should return the sum of all integers from 1 to `n' (including and `n`) using multiple processes and also effectively should spawn 4 processes targeting the `calc_it()` function.
 
# Hint: Use the `Pool` class and split the 1 to n range of the `do_it()` function into 4 sub ranges which are the passed to the sub-processes to be used as parameters to the `calc_it()` function.
 
def do_it(n):
    num_processes = 4
    # Calculate the range each process will handle
    chunk_size = (n + num_processes - 1) // num_processes
    ranges = [(i * chunk_size + 1, min((i + 1) * chunk_size, n)) for i in range(num_processes)]
 
    with Pool(processes=num_processes) as pool:
        results = pool.starmap(calc_it, ranges)
    # Sum up the results from all processes
    total_sum = sum(results)
    print(total_sum)
    return total_sum
    
     

Lab 3: Welcome to asyncio - Basic asyncio program

Hands-On - Hands-On - asyncio coroutines

Solution: fresco play Hands-On - asyncio coroutines handson.

import asyncio
 
#Let's try out a basic asyncio program. Make two coroutines (functions with `async`) named `question()` and `answer()'.
 
# Task 1: The question()` should display three questions. After each question, it should await on `answer()` to receive the answer. The answer is the same for all three questions.
 
# The questions that need to be displayed by `question()` are:
# "Is asyncio better for I0 bound programs than the CPU bound ones?"
# "Is async a keyword in the latest Python3?"
# "Is event loop the heart of an asyncio program?"

async def question():
    #Complete this coroutine
    print("Is asyncio better for IO bound programs than the CPU bound ones?")
    # await asyncio.sleep(1)
    await answer()
    print("Is async a keyword in the latest Python3?")
    await answer()
    print("Is event loop the heart of an asyncio program?")
    await answer()
 
# Task 2: The `answer()` should contain just a `print()` giving the message "Yes, it is!".
async def answer():
    #Complete this coroutine
    print("Yes, it is!")
 
asyncio.run(question())