Coroutines In Python

NITIN GUPTA

Coroutines are mostly used in cases of time-consuming programs, such as tasks related to machine learning or deep learning algorithms, or in cases where the program has to read a file containing a large number of data. In such situations, we do not want the program to read the file or data again and again, so we use coroutines to make the program more efficient and faster. Coroutines run endlessly in a program because they use a while loop with a true or 1 condition, so it may run until infinite time. Even after yielding the value to the caller, it still awaits further instruction or calls. We have to stop the execution of the coroutine by calling the coroutine.close() function. It is crucial to close a coroutine because its continuous running can take up memory space, as we have discussed in Tutorial #75, related to function caching. We can define a coroutine using the following statements.

def myfunc():
    while True:
        value = (yield)

The while block continues the execution of the coroutine for as long as it receives values. The value is collected through the yield statement.

Coroutine Execution:- 

Execution is the same as of a generator. When you call a coroutine, nothing happens. They only run in response to the next() and send() methods. Coroutine requires the use of the next statement first so it may start its execution. Without a next(), it will not start executing. We can search a coroutine by sending it the keywords as input using object name along with send(). The keywords to be searched are send inside the parenthesis. 

When we run the next() function the first time, the coroutine executes and waits for new input. After the input is sent to it using the send() function, it executes it and again waits for next input, and the process goes on like this because we have set the while loop as true, so it will never exit its execution. In order to make the execution stop, we have to close the coroutine using coroutine.close() function.

  • send() — used to send data to coroutine
  •  close() — to close the coroutine

Example:

def myfunc():
    print("Code With Harry")
    while True:
        value = (yield)
        print(value)

coroutine =myfunc()
next(coroutine)
coroutine.send("Python")
coroutine.send(" Tutorial ")
coroutine.close()

Output:-

Code With Harry
 Python 
 Tutorial

After closing the coroutine, if we send values, it will raise the StopIteration exception. Coroutines are used for data processing mechanisms. Coroutines are similar to generators, except they wait for information to be sent to it using send() function.

Code as described/written in the video


def searcher():
    import time
    # Some 4 seconds time consuming task
    book = "This is a book on harry and code with harry and good"
    time.sleep(4)

    while True:
        text = (yield)
        if text in book:
            print("Your text is in the book")
        else:
            print("Text is not in the book")

search = searcher()
print("search started")
next(search)
print("Next method run")
search.send("harry")

search.close()
search.send("harry")
# input("press any key")
# search.send("harry and")
# input("press any key")
# search.send("thi si")
# input("press any key")
# search.send("joker")
# input("press any key")
# search.send("like this video")

Comments

Post a Comment

Popular posts from this blog

HOW IMPORT WORKS IN PYTHON?

NITIN GUPTA
  How does the import keyword work? When we write a certain module name along with the  import  keyword, it will start searching for a file with that name having an extension  .py . After finding the file, it will import it into our program, which means that it will permit our program to use the functions of the certain module we imported. We can import a module named  “sys”  to see the path that our import statement takes while searching for a module. import sys print ( sys . path ) Copy sys.path  prints out a list of directories. When we tell Python to import something, then it looks in each of the listed locations in order.  A common mistake that most of the beginners do and also the primary reason for making this tutorial is, why can’t we name our file, the same as the name of a module. The reason is associated with the path. When we give our file a name same as the name of a module, then instead of importing the original module, the system ...
Read more

Exercise 5: Health Management System

NITIN GUPTA
  Exercise#5 The task is to create a " Health Management System ." Suppose you are a fitness trainer and nutritionist. You have to deal with three clients, i.e., (Harry, Rohan, Hammad). For each client, you have to design their exercise and diet plan. Instructions: Create a food log file for each client Create an exercise log file for each client. Ask the user whether they want to log or retrieve client data. Write a function that takes the user input of the client's name. After the client's name is entered, it will display a message as "What you want to log- Diet or Exercise". Use function def getdate ( ) : import datetime return datetime . datetime . now ( ) Copy The purpose of this function is to give time with every record of food or exercise added in the file. Write a function to retrieve exercise or food file records for any client. You are advised to participate in solving this problem. This task helps you to become a good pr...
Read more

*args and **kwargs In Python

NITIN GUPTA
  Before discussing *args and **kwargs, we should have a basic knowledge about types of arguments. In Python programming, there are two types of arguments that can be passed in a function. positional arguments keyword arguments Positional arguments  are the one in which an order has to be followed while passing arguments. We have been dealing with them until now. We know how normal functions work with positional arguments, so now we will directly start exploring keyword arguments. But to understand them, we have to know about asterisk or more commonly known in Perl 6 and ruby as a splat operator.  Asterisk is used in python as a mathematical symbol for multiplication, but in case of arguments, it refers to unpacking. The unpacking could be for a list, tuple, or a dictionary. We will discover more about it by defining *args and **kwargs. *args: args is a short form used for arguments. It is used to unpack an argument. In the case of *args, the argument could be a list or t...
Read more