## What is Context in React? How to use Context in React?

What the hack is Context?Have you ever wondered about passing data or using states in between different components without using Props? Or passing a state from Parent to Child component without manually passing a prop at every level?  Let’s understand with an example below:Here we have a parent component app.js where we have defined our states. We want to access the data of state in the last child which is “Child 1.2” in the below chart.app.js Parent ComponentThe ideal or older approach in React is to pass the data from the root component to the last component is via Props. We have to pass props in each intermediary level so as to send in the last level. While this approach also works, the real problems begin if data is needed on a different branch i.e Child 2.1 or Child 2.2 in above chart…In order to solve this problem, we need to pass data from the root/top level of the application through all the intermediate components to the one where we want to pass the data, even though some intermediate components don't even need it.  This mind-numbing process is known as prop drilling,  Prop Drillingwhere you’re passing the state from your root component to the bottom and you end up passing the data via props through components that do not even necessarily need themOne really good solution to solve the above problem is using Context According to the React documentation:  “Context provides a way to pass data through the component tree without having to pass props down manually at every level”Ordinarily, we’d have used any state management library like Redux or have used HOC’s to pass the data in a tedious manner. But what if we don’t want to use it all? Here comes the role of new Context API!In layman words, it gives an approach to make specific data available to all components throughout the React component tree regardless of how deeply nested those components are.Context is just like a global object to the subtree of the React component.When to use the Context APIThe Context API is convenient for sharing data that is either global, such as setting the header and footer theme of a website or logic of user authentication and many more. In cases like these, we can use the Context API without using any extra library or external modules. It can also be used in a multilingual application where we want to implement multiple languages that can be translated into the required text with the help of ContextAPI. It will save prop-drilling   In fact, in any situation where we have to pass a prop through a component so it reaches another component, inside down the tree is where we can use the Context API.Introducing The Context APIThe context API is a way to pass data from top component to bottom ones, without manually passing it to via props. Context is fundamentally utilized when some data needs to be accessible by numerous components at different nesting levels. To create a new Context, we can use the React createContext function like below: const MyContext = React.createContext(defaultValue);In React, data is often passed from a parent to its child component as a property. Here, we can also omit the default value which we have passed to the context, if needed.React data passing from parent to its child Let’s Get Started With ContextThree things are needed to tap into the power of context: 1. The context itselfTo create a context we can use React.createContext method which creates a context object. This is used to ensure that the components at different level can use the same context to fetch the data.   In React.createContext, we can pass an input parameter as an argument which could be anything or it can be null as well.import React from react';  const ThemeContext = React.createContext('dark');  // Create our context        export default ThemeContext;In this example, a string is passed for the current Context which is “dark”. So we can say, the current theme required for a specific component is Dark.   Also, we have exported the object so that we can use it in other places. In one app, React also allows you to create multiple contexts. We should always try to separate context for different purposes, so as to maintain the code structure and better readability. We will see that later in our reading.   What next?? Now, to utilize the power of Context in our example, we want to provide this type of theme to all the components.  Context exposes a pair of elements which is a Provider Component and a Consumer Component.2. A context providerOkay, so now we have our Context object. And to make the context available to all our components we have to use a Provider.   But, what is Provider? According to the React documentation:"every context object comes with a Provider React component that allows consuming components to subscribe to context changes"In other words, Provider accepts a prop (value) and the data in this prop can be used in all the other child components. This value could be anything from the component state.// myProvider.js import React from 'react'; import Theme from './theme'; const myProvider = () => ( <Theme.Provider value='dark'> ... </Theme.Provider>  ); export default myProvider;We can say that a provider acts just like a delivery service.prop finding context and deliverling it to consumerWhen a consumer asks for something, it finds it in the context and delivers it to where it's needed.But wait, who or what is the consumer???3.  A context consumer What is Consumer? A consumer is a place to keep the stored information. It can request for the data using the provider and can even manipulate the global store if the provider allows it. In our previous example, let’s grab the theme value and use it in our Header component. // Header.js   import React from 'react'; import Theme from './theme';   const Header = () => (    <Theme.Provider value='dark'>        <Theme.Consumer>            {theme => <div>Selected theme is {theme}</div>}        </Theme.Consumer>    </Theme.Provider> );   export default Header;Dynamic Context:   We can also change the value of the provider by simply providing a dynamic context. One way of achieving it is by placing the Provider inside the component itself and grabbing the value from component state as below:// Footer.js   import React from 'react';   class Footer extends React.Component {    state = {        theme: 'dark'    };      render() {        return (            <MyThemeContext.Provider value={this.state.theme}>                <ThemedButtonHolder />            </MyThemeContext.Provider>        );    } }Simple, no? We can easily change the value of  the Provider to any Consumer.Consuming Context With Class-based ComponentsWe all pretty know that there are two methods to write components in React, which is Class based components and Function based components. We have already seen a demo of how we can use the power of Context in class based components.  One is to use the context from Consumer like “ThemeContext.Consumer” and the other method is by assigning context object from current Context to contextType property of our class.import React, { Component } from "react"; import MyThemeContext from "../Context/MyThemeContext"; import GlobalTheme from "../theme";   class Main extends Component {    constructor() {        super();    }    static contextType = MyThemeContext;  //assign context to component    render() {        const currentTheme = GlobalTheme[this.context];        return (            ...        );    }   }There is always a difference in how we want to use the Context. We can either provide it outside the render() method or use the Context Consumer as a component itself.  Here in the above example, we have used a static property named as contextType which is used to access the context data. It can be utilized by using this.context. This method however, limits you consuming, only one context at a time.Consuming Context With Functional ComponentsContext with Functional based components is quite easy and less tedious. In this we can access the context value through props with the help of useContext method in React. This hook (useContext) can be passed in as the argument along with our Context to consume the data in the functional component.const value = useContext(MyContext);It accepts a context object and returns the current context value. To read more about hooks, read here.  Our previous example looks like:import React, { useContext } from 'react' import MyThemeContext from './theme-context'   const User = props => {    const context = useContext(MyThemeContext)    return <p className={context.isLight ? 'light' : 'dark'}>...</p>Now, instead of wrapping our content in a Consumer component we have access to the theme context state through the ‘context’ variable.But we should avoid using context for keeping the states locally. Instead of  conext, we can use local state there.Use of Multiple ContextsIt may be possible that we want to add multiple contexts in our application. Like holding a theme for the entire app, changing the language based on the location, performing some A/B testing, using global parameters for login or user Profile… For instance, let’s say there is a requirement to keep both Theme context and userInfo Context, the code will look like as:<ThemeProvider>   <UserInfoProvider>     ...   </UserInfoProvider> </ThemeProvider>It’s quite possible in React to hold multiple Contexts, but this definitely hampers rendering, serving ‘n’ number of contexts in ‘m’ component and holding the updated value in each rendered component.To avoid this and to make re-rendering faster, it is suggested to make each context consumer in the tree as a separate node or into different contexts.<ThemeContext.Provider value={theme}>    <ColourContext.Provider value={colour}>        <NavItem />    </ColourContext.Provider> </ThemeContext.Provider>And we can perform the nesting in context as:<ThemeContext.Consumer>    {theme => (        <ColourContext.Consumer>            {colour => (                <p>Theme: {theme} and colour: {colour}</p>            )}        </ColourContext.Consumer>    )} </ThemeContext.Consumer>It’s worth noting that when a value of a context changes in the parent component, the child components or the components’ holding that value should be rerendered or changed. Hence, whenever there is a change in the value of provider, it will cause its consumers to re-render.ConclusionDon’t you think this concept is just amazing?? Writing a global context like theme or language or userProfile and using the data of them directly in the child or other components? Implementing these stateful logic by global preferences was never so easy, but Context made this transportation job a lot simple and achievable! Hope you find this article useful. Happy Coding!Having challenge learning to code? Let our experts help you with customized courses!
Rated 4.0/5 based on 1 customer reviews

# What is Context in React? How to use Context in React?

8K

## What the hack is Context?

Have you ever wondered about passing data or using states in between different components without using Props? Or passing a state from Parent to Child component without manually passing a prop at every level?

Let’s understand with an example below:

Here we have a parent component app.js where we have defined our states. We want to access the data of state in the last child which is “Child 1.2” in the below chart.
app.js Parent Component

The ideal or older approach in React is to pass the data from the root component to the last component is via Props. We have to pass props in each intermediary level so as to send in the last level. While this approach also works, the real problems begin if data is needed on a different branch i.e Child 2.1 or Child 2.2 in above chart…

In order to solve this problem, we need to pass data from the root/top level of the application through all the intermediate components to the one where we want to pass the data, even though some intermediate components don't even need it.

This mind-numbing process is known as prop drilling,
Prop Drilling

where you’re passing the state from your root component to the bottom and you end up passing the data via props through components that do not even necessarily need them

One really good solution to solve the above problem is using Context

According to the React documentation:

“Context provides a way to pass data through the component tree without having to pass props down manually at every level”

Ordinarily, we’d have used any state management library like Redux or have used HOC’s to pass the data in a tedious manner. But what if we don’t want to use it all? Here comes the role of new Context API!

In layman words, it gives an approach to make specific data available to all components throughout the React component tree regardless of how deeply nested those components are.

Context is just like a global object to the subtree of the React component.

## When to use the Context API

The Context API is convenient for sharing data that is either global, such as setting the header and footer theme of a website or logic of user authentication and many more. In cases like these, we can use the Context API without using any extra library or external modules.

It can also be used in a multilingual application where we want to implement multiple languages that can be translated into the required text with the help of ContextAPI. It will save prop-drilling

In fact, in any situation where we have to pass a prop through a component so it reaches another component, inside down the tree is where we can use the Context API.

## Introducing The Context API

The context API is a way to pass data from top component to bottom ones, without manually passing it to via props. Context is fundamentally utilized when some data needs to be accessible by numerous components at different nesting levels.

To create a new Context, we can use the React createContext function like below:

const MyContext = React.createContext(defaultValue);

In React, data is often passed from a parent to its child component as a property. Here, we can also omit the default value which we have passed to the context, if needed.React data passing from parent to its child

## Let’s Get Started With Context

Three things are needed to tap into the power of context:

### 1. The context itself

To create a context we can use React.createContext method which creates a context object. This is used to ensure that the components at different level can use the same context to fetch the data.

In React.createContext, we can pass an input parameter as an argument which could be anything or it can be null as well.

import React from react';
const ThemeContext = React.createContext('dark');  // Create our context
export default ThemeContext;

In this example, a string is passed for the current Context which is “dark”. So we can say, the current theme required for a specific component is Dark.

Also, we have exported the object so that we can use it in other places.

In one app, React also allows you to create multiple contexts. We should always try to separate context for different purposes, so as to maintain the code structure and better readability.

We will see that later in our reading.

What next??

Now, to utilize the power of Context in our example, we want to provide this type of theme to all the components.  Context exposes a pair of elements which is a Provider Component and a Consumer Component.

### 2. A context provider

Okay, so now we have our Context object. And to make the context available to all our components we have to use a Provider.

But, what is Provider?

According to the React documentation:

"every context object comes with a Provider React component that allows consuming components to subscribe to context changes"

In other words, Provider accepts a prop (value) and the data in this prop can be used in all the other child components. This value could be anything from the component state.

// myProvider.js
import React from 'react';
import Theme from './theme';
const myProvider = () => (
<Theme.Provider value='dark'>
...
</Theme.Provider>
);
export default myProvider;

We can say that a provider acts just like a delivery service.prop finding context and deliverling it to consumerWhen a consumer asks for something, it finds it in the context and delivers it to where it's needed.

But wait, who or what is the consumer???

### 3.  A context consumer

What is Consumer?

A consumer is a place to keep the stored information. It can request for the data using the provider and can even manipulate the global store if the provider allows it.

In our previous example, let’s grab the theme value and use it in our Header component.

// Header.js

import React from 'react';
import Theme from './theme';

const Header = () => (
<Theme.Provider value='dark'>
<Theme.Consumer>
{theme => <div>Selected theme is {theme}</div>}
</Theme.Consumer>
</Theme.Provider>
);

export default Header;

## Dynamic Context:

We can also change the value of the provider by simply providing a dynamic context. One way of achieving it is by placing the Provider inside the component itself and grabbing the value from component state as below:

// Footer.js

import React from 'react';

class Footer extends React.Component {
state = {
theme: 'dark'
};

render() {
return (
<MyThemeContext.Provider value={this.state.theme}>
<ThemedButtonHolder />
</MyThemeContext.Provider>
);
}
}

Simple, no? We can easily change the value of  the Provider to any Consumer.

## Consuming Context With Class-based Components

We all pretty know that there are two methods to write components in React, which is Class based components and Function based components. We have already seen a demo of how we can use the power of Context in class based components.

One is to use the context from Consumer like “ThemeContext.Consumer” and the other method is by assigning context object from current Context to contextType property of our class.

import React, { Component } from "react";
import MyThemeContext from "../Context/MyThemeContext";
import GlobalTheme from "../theme";

class Main extends Component {
constructor() {
super();
}
static contextType = MyThemeContext;  //assign context to component
render() {
const currentTheme = GlobalTheme[this.context];
return (
...
);
}

}

There is always a difference in how we want to use the Context. We can either provide it outside the render() method or use the Context Consumer as a component itself.

Here in the above example, we have used a static property named as contextType which is used to access the context data. It can be utilized by using this.context. This method however, limits you consuming, only one context at a time.

## Consuming Context With Functional Components

Context with Functional based components is quite easy and less tedious. In this we can access the context value through props with the help of useContext method in React.

This hook (useContext) can be passed in as the argument along with our Context to consume the data in the functional component.

const value = useContext(MyContext);

It accepts a context object and returns the current context value. To read more about hooks, read here.

Our previous example looks like:

import React, { useContext } from 'react'
import MyThemeContext from './theme-context'

const User = props => {
const context = useContext(MyThemeContext)
return <p className={context.isLight ? 'light' : 'dark'}>...</p>

Now, instead of wrapping our content in a Consumer component we have access to the theme context state through the ‘context’ variable.

But we should avoid using context for keeping the states locally. Instead of  conext, we can use local state there.

## Use of Multiple Contexts

It may be possible that we want to add multiple contexts in our application. Like holding a theme for the entire app, changing the language based on the location, performing some A/B testing, using global parameters for login or user Profile…

For instance, let’s say there is a requirement to keep both Theme context and userInfo Context, the code will look like as:

<ThemeProvider>
<UserInfoProvider>
...
</UserInfoProvider>
</ThemeProvider>

It’s quite possible in React to hold multiple Contexts, but this definitely hampers rendering, serving ‘n’ number of contexts in ‘m’ component and holding the updated value in each rendered component.

To avoid this and to make re-rendering faster, it is suggested to make each context consumer in the tree as a separate node or into different contexts.

<ThemeContext.Provider value={theme}>
<ColourContext.Provider value={colour}>
<NavItem />
</ColourContext.Provider>
</ThemeContext.Provider>

And we can perform the nesting in context as:

<ThemeContext.Consumer>
{theme => (
<ColourContext.Consumer>
{colour => (
<p>Theme: {theme} and colour: {colour}</p>
)}
</ColourContext.Consumer>
)}
</ThemeContext.Consumer>

It’s worth noting that when a value of a context changes in the parent component, the child components or the components’ holding that value should be rerendered or changed. Hence, whenever there is a change in the value of provider, it will cause its consumers to re-render.

## Conclusion

Don’t you think this concept is just amazing?? Writing a global context like theme or language or userProfile and using the data of them directly in the child or other components?

Implementing these stateful logic by global preferences was never so easy, but Context made this transportation job a lot simple and achievable!

Having challenge learning to code? Let our experts help you with customized courses!

### KnowledgeHut

Author

KnowledgeHut is an outcome-focused global ed-tech company. We help organizations and professionals unlock excellence through skills development. We offer training solutions under the people and process, data science, full-stack development, cybersecurity, future technologies and digital transformation verticals.
Website : https://www.knowledgehut.com

## Join the Discussion

rhode 27 Aug 2020

Thanks...it really helps

SPECIAL OFFER Upto 20% off on all courses
Enrol Now

## Scala Vs Python Vs R Vs Java - Which language is better for Spark & Why?

Rated 4.5/5 based on 1 customer reviews
8242
Scala Vs Python Vs R Vs Java - Which language is b...

One of the most important decisions for the Big da... Read More

## How to use sys.argv in Python

Rated 4.0/5 based on 14 customer reviews
5988
How to use sys.argv in Python

The sys module is one of the common and frequently... Read More

## Introduction to Yield in Python

When we write a function, which should perform some operation and provide some result back, we generally use the return statement for returning the result.The yield statement is only used when defining a generator function and is only used in the body of the generator function. Yield are used in Python generators. A python generator is defined like a normal function, but whenever it will needto generate a value, it does so with the yield keyword rather than return. If the body of a def function contains yield, the function will becomea generator function. A Python generator is a function return a generator iterator (just an object we can iterate over) by calling yield .Yield maybe called with a value, in which case that value is treated as the "generated" value. Yield is a keyword in Python that will used to return from a function without destroying the states of its local variable and when the function is called, the execution starts from the last yield statement. Return sends a value back to its caller, whereas yield can produce a sequence of values. We must use yield when we want to iterate over a sequence but don't want to store the entire sequence in memory so in that case you can use yield Python generators. The function will continue the execution immediately after the last yield run. It will allow its code to produce a series of values and sending them back like a list.Example:In the above example, yield is the keyword and 1, 2, 3 are the values that will store in the generator and to print the value inside the generator we are using for loop. We can use yield when we want to iterate over a sequence, but don't want to store the entire sequence in memory.Explaining the Iterables: To understand what yield does, you must understand what generators are. And before generators come iterables.Aniterable is any Python object capable of returning its members one at a time, permitting it to be iterated over in a for-loop. Ex- iterables include lists, tuples, and strings - any such sequence can be iterated over in a for-loop. In simpler words, whatever that will appear on the right-side of a for-loop: for x in iterable:  is aniterable.Iterablecan be anything that you can loop over with a for loop.An object can becallediterable,if we can get an iterator from iterable. Maximum built-in containers in Python like: list, tuple, string etc. areiterables.Important property(Method) of an iterable is that it has an __iter__() method or iter() method which allows any iterable to return an iterator object. Sequences Sequences are a very common type of iterable. Ex- for built-in sequence types are lists, strings, and tuples.Iterable will support element access using integer indices via the __getitem()__ special method (indexing) and define a __length()__ method that returns the length of the sequence. Also, we can use the slicing technique on them.Other IterablesMany things in Python are iterables, but not all of them are sequences. Dictionaries, file objects, sets, and generators all are iterables, but none of them is a sequence.We can loop over an iterable without using a for loop. Some of us may think that we can use a while loop and generate indices to get this output.It seems that this approach works very well for lists and other sequence objects as well. What about the non-sequence objects? They don’t support indexing, so this approach will not work for them, we will get an error.But how the Python’s for loop works on these iterables then? We can see that it works with sets.When you create a list, you can read its items one by oneWhat is an Iterator? Iterator is an object which can be looped through and maintains its state during the iteration which means it remembers where it is during an iteration. An iterator is an object that enables a programmer to traverse a container, particularly lists. Different types of iterators are often provided via a container's interface. It has a __next__() method that returns the next value from the iteration and updates the state to point at the next value. Iterator is simplyan object that can be iterated upon. An object it will return data, one element at a time.Python iterator object must implement two special methods, that is __iter__() and __next__() , collectively called the iterator protocol.Thepurpose of an iterator is allow to process with every element of a container while isolating the user from the internal structure of the container. The container provides the methods for creating iterators. Iterator is an object and it will represent a stream of data. You can create an iterator object by applying the iter() function to an iterable.Difference between iterable and iterator. Iterable is an object, which can iterate over. It will create an Iterator when passed to iter() method. Iterator is an object, which is used to iterate over an iterable object using __next__() method. For example, a list is iterable but a list is not an iterator.When we will apply the iter() function to an iterable we will get an iterator. If we will call the iter() function on an iterator it will give us itself back in python.You can use an iterator to manually loop over the iterable it came from. if repeated passing of iterator to the built-in function next() it will return successive items in the stream. Once, when you consumed an item from an iterator, it has gone. When data aren’t available it will give us a StopIteration and exception is raised.Iterators also have the __iter__() method and it will return self object.List is an iterable. When you will use a list comprehension, you create a list, and so an iterableThese iterables are handy because you can read them, but you store all the values in memory and it’s not always what you want when you have a lot of values. Iterator Protocol The iterator objects are required to support the following two methods, which together form the iterator protocol: iterator.__iter__() Return the iterator object itself. This is required to allow both containers and iterators to be used with the for statements. iterator.__next__() Return the next item from the container. If there are no items, then it will raise the StopIteration exception. We have seen some examples with iterators. Python has many built-in-classes that are iterators. Ex- an enumerate and reversed objects are iterators. Enumerate ExampleReversed ExampleThe Python’s zip, map and filer objects are also iterators. Explaining the Generators: A Generator is a function use to store the value by using yield keyword. A function which returns a generator iterator. This is a normal function only except that it will contains yield expressions for producing a series of values usable in a for-loop or that can be retrieved one at a time with the next() function in python.If function will contains the yield keyword then that function will become a generator and you can print the value by using for loop.You can convert a function into generator simply you need to use yield keyword in below example you can see that we can use multiple yield statement to return the dataIn above example, we defined new_generator() function in this we have assign a variable n and giving the value as 1 then print the statement and then yield the valueIf we execute generator function as a normal function then it will give us the object so for that we have to store the function in the variable x then we have use next method for executionYielding into Python List:We can use directly generator for making a list and we can store the value inside the mylist then we can print the mylist by using for loopPython Generators with a Loop:In the below example, we defined a function i.e. reverse_string and it is a generator because we are using yield keyword and we are iterating each word from the statementGenerator Expressions in Python: We use a generator function or generator expression when we want to create a custom iterator. They are simpler to use and need less code to achieve the output. Generator expressions are similar to the list comprehensions,Just like a list comprehension, the general expressions are concise. In most cases, they use to written in one line of code.An expression that returns an iterator. It looks like a normal expression followed by a for expression defining a loop variable, range, and an optional if expression ex,We can also add a conditional expression on the iterable. You can see in the above example, we did square root of the even number, we directly print the value without store the single value and we print the class i.e. generator  Explaining the Yield: Yield is a simple statement. Its primary job is to control the flow of a generator function similar tothat return statements. Yield that is used to return from a function without destroying the states of its local variable and when the function is called, the execution starts from the last yield statement. Any function that will present a yield keyword is termed as generator When you call a generator function or use a generator expression, you return a iterator called a generator. You can try to assign this generator to a variable in order to use it. When you will call to special methods on the generator, such as next(), the code within the function is executed till yield. When the yield statement is hit, the program suspends function execution and returns the yielded value to the caller. (Return stops function execution completely.) When a function is suspended, the state of that function is saved. This includes any variable bindings local to the generator in python, the instruction pointer, the internal stack, and any exception handling. This allows you to resume function execution whenever you will call one of the generator’s methods. Like this, all function evaluation picks back up right after yield. You can see this in action by using multiple yield statements:In the above example, we defined a function i.e. counter consist of while loop which has one condition (x < 5) and is yielding the value of x and then it will increment by 1. If we use yield keyword in the function then that function will become as Generator Yield is the special keyword in python, yield will know what it execute in the last time.In the above function, when we executed first time we are getting 0 as output but in the second execution it will increment by 1 and we got 1 as output and again it will iterate the loop till the condition will not satisfy. When we use yield keyword in the function it will store the state of the local variableExample:In the above example, you can see that with the help of yield keyword It is easy to find the word inside the string statement and it will count the number of times that word will occur because yield keyword will know the last state Benefits of yield: Using a yield statement in a function definition is sufficient to cause that definition to create a generator function instead of a normal function. We should use yield when we want to iterate over a sequence but don't want to store the entire sequence in memory yield is used in Python generators. A generator function or expression will defined like a normal function, but whenever it needs to generate a value, it does so with the yield keyword rather than return. Conclusion: In this tutorial, you have learned about Iterable, Generator functions, Yield Iterable: An iterable is something you can loop over. Sequences are a very common type of iterable. So many things in Python are iterables, but not all of them are in sequences. An iterator is an object and it will represent a stream of data. It does the iterating over an iterable. You can use an iterator in python to get the next value or to loop over it. Once, your loop over an iterator, there are no more stream values. Additionally, in Python, the iterators are also iterables which act as their own iterators. However, the difference is that iterators don’t have some of the features that some iterables have. They don’t have length and can’t be indexed. Many built-in classes in Python are iterators. Generator: We have learnt, how to use and write generator functions and generator expressions A generator function is a function which returns an iterator. A generator expression is an expression that returns an iterator. Yield: The yield keyword in python is used to return a value from a function(just like return ) but this keyword also maintains the state of the local variables of the function and when the function is called again in python, the execution is started from the yield statement executed last time.We should use python yield when we want to iterate over a sequence but don't want to store the entire sequence in memory
Rated 4.0/5 based on 13 customer reviews
7928
Introduction to Yield in Python

When we write a function, which should perform som... Read More