<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://arrow.readthedocs.io/en/latest/">Arrow</a> is a Python module for working with date and time. Given that there are several modules that do this, most notably the built-in <code>datetime</code> module, what makes Arrow different?
Most notably, the library is inspired by <a rel="nofollow noopener" target="_blank" href="https://github.com/moment/moment">Moment.js</a>, a JavaScript library that overrides the default implementation of the Date/Time API.
In this guide, we'll take a look at some key features of Arrow, to see how it handles certain common tasks.
First, let's go ahead and install it:
<pre><code class="hljs">$ pip install Arrow
</code></pre>
<h2 id="thearrowclass">The Arrow Class</h2>
The <code>Arrow</code> class is an implementation of the <code>datetime</code> interface, with additional functionalities. Also, it's timezone-aware by default - we'll go into this a bit later, though.
You can easily create a new <code>Arrow</code> instance by supplying its constructor with a few arguments:
<pre><code class="hljs">import arrow
arrow_object = arrow.Arrow(2021, 1, 1)
print(arrow_object)
</code></pre>
This results in:
<pre><code class="hljs">2021-01-01T00:00:00+00:00
</code></pre>
You can also supply the hours, minutes and seconds through the constructor:
<pre><code class="hljs">import arrow
arrow_object = arrow.Arrow(2021, 1, 1, 14, 30, 21)
print(arrow_object)
</code></pre>
This results in:
<pre><code class="hljs">2021-01-01T14:30:21+00:00
</code></pre>
<h2 id="conversionsupportwitharrow">Conversion Support with Arrow</h2>
Parsing a date and time from a string is a straightforward process with Arrow - you simply use the <code>get()</code> method, and supply it with a valid string format. Also, Arrow lets you effortlessly convert between its own implementation of <code>datetime</code> class and the built-in <code>datetime</code> object.
<h3 id="convertstringtodatetimewitharrow">Convert String to Datetime with Arrow</h3>
If a string is already formatted in the ISO 8601 format (<code>YYYY-MM-DDTHH:MM:SS.mmmmmm</code>), it can be passed directly into the <code>get()</code> method:
<pre><code class="hljs">import arrow
datetime = arrow.get(&#x27;2021/03/30 12:05&#x27;)
print(datetime)
</code></pre>
This will print out the <code>Arrow</code> instance, which is Arrow's own implementation of the <code>datetime</code> interface:
<pre><code class="hljs">&lt;Arrow [2021-03-30T12:05:00+00:00]&gt;
</code></pre>
However, in practice, it is unlikely that we will be using correctly formatted strings, following the ISO specification.
Thankfully, we can still parse strings that don't adhere to conventions, by using correct Arrow format tokens. These are predefined and give Arrow the information needed to parse the string correctly:
<pre><code class="hljs">import arrow
datetime = arrow.get(&#x27;March 30 2021 12:05&#x27;, &#x27;MMMM DD YYYY HH:mm&#x27;)
print(datetime)
</code></pre>
Here, we've effectively told Arrow what the format is. It maps the supplied format tokens with the string we'd like to parse, and constructs an <code>Arrow</code> object based on that info. Running this results in:
<pre><code class="hljs">&lt;Arrow [2021-03-30T12:05:00+00:00]&gt;
</code></pre>
<h3 id="convertbetweenarrowanddatetimeobjects">Convert Between Arrow and datetime Objects</h3>
So far, we've been working with <code>Arrow</code> instances. However, many applications and libraries explicitly require you to use a <code>datetime</code> object. Conversion between these two formats is crucial.
Let's take a look at the <code>type()</code> of our variable:
<pre><code class="hljs">type(datetime)
</code></pre>
Output:
<pre><code class="hljs">arrow.arrow.Arrow
</code></pre>
To convert this to a <code>datetime</code> instance, we simply extract the <code>datetime</code> field from the <code>Arrow</code> object:
<pre><code class="hljs">datetime = datetime.datetime
print(datetime)
</code></pre>
This results in a time-zone aware <code>datetime</code> instance:
<pre><code class="hljs">datetime.datetime(2021, 3, 12, 12, 5, tzinfo=tzutc())
</code></pre>
Even though we haven't specified the timezone when creating the original <code>Arrow</code> object, the <code>datetime</code> object has the <code>tzinfo</code> defaulted to UTC. We will refer back to this in the next section, when taking a more detailed look into handling timezones.
For now, we can confirm it is indeed a <code>datetime</code> object type:
<pre><code class="hljs">type(now)
</code></pre>
This results in;
<pre><code class="hljs">datetime.datetime
</code></pre>
Similarly enough, you can easily convert <code>datetime</code> objects into <code>Arrow</code> objects, using the <code>fromdatetime()</code> function:
<pre><code class="hljs">datetime = datetime.datetime(2021, 1, 1, 0, 0)
arrow_object = arrow.Arrow.fromdatetime(datetime)
print(arrow_object)
</code></pre>
This results in:
<pre><code class="hljs">2021-01-01T00:00:00+00:00
</code></pre>
<h2 id="dealingwithtimezones">Dealing with Timezones</h2>
One of the major issues with the <code>datetime</code> module is the way it handles time zones. It is considered timezone-naive, meaning it contains no timezone related data. Arrow on the other hand contains a <code>tzinfo</code> parameter for each instantiation, which you can set through the constructor, or through methods. The <code>tzinfo</code> defaults to UTC, regardless of the user's location.
In practical terms this means that with <code>datetime</code>, a user in Hong Kong would be working in local Hong Kong time whereas a user in UK would be working in local UK time - unless otherwise specified:
<pre><code class="hljs">import datetime
datetime.datetime.now()
</code></pre>
The output for the Hong Kong based user would be:
<pre><code class="hljs">datetime.datetime(2021, 3, 31, 00, 35, 08, 114203)
</code></pre>
Whereas someone based in the UK would see:
<pre><code class="hljs">datetime.datetime(2021, 3, 30, 17, 35, 25, 119213)
</code></pre>
Having a standard default timezone is increasingly important with the rise in remote working as well the globalization of projects. Having to explicitly set timezones for <code>datetime</code> objects gets stale fast. Arrow automates this process, in a single, unified, default timezone. You can set it to other timezones, of course, or even local ones.
Irrespective of the user's geographical location, the following lines of code will give the same output:
<pre><code class="hljs">arrow.now()
</code></pre>
Output:
<pre><code class="hljs">&lt;Arrow [2021-03-30T17:37:28.374335+01:00]&gt;
</code></pre>
We can confirm this corresponds to the UTC time:
<pre><code class="hljs">arrow.utcnow()
</code></pre>
Output:
<pre><code class="hljs">&lt;Arrow [2021-03-30T16:37:59.721766+00:00]&gt;
</code></pre>
We can set time zones on the <code>Arrow</code> instance simply by passing in the timezone string in its constructor:
<pre><code class="hljs">arrow.now(&#x27;US/Pacific)
</code></pre>
This works alongside other parameters that we've used before. Setting a timezone while constructing an <code>Arrow</code> instance works both for converting strings and <code>datetime</code> objects and calling the constructor explicitly:
<pre><code class="hljs">import arrow
import datetime as datetime

date = &#x27;2021.01.01 00:00&#x27;
datetime = datetime.datetime(2021, 1, 1, 0, 0)

arrow_1 = arrow.Arrow(2021, 1, 1, 0, 0, tzinfo=&#x27;US/Pacific&#x27;)
arrow_2 = arrow.get(date, tzinfo=&#x27;US/Pacific&#x27;)
arrow_3 = arrow.Arrow.fromdatetime(datetime, tzinfo=&#x27;US/Pacific&#x27;)

print(arrow_1)
print(arrow_2)
print(arrow_3)
</code></pre>
Now, these <code>Arrow</code> instances will be set to the <code>US/Pacific</code> timezone, and set to the 1st of January, 2021:
<pre><code class="hljs">2021-01-01T00:00:00-08:00
2021-01-01T00:00:00-08:00
2021-01-01T00:00:00-08:00
</code></pre>
As you can see, the objects now have a <code>-08:00</code> suffix, since the <code>US/Pacific</code> timezone is 8 hours behind UTC.
You can also extract the naive versions of these datetimes by calling their <code>naive</code> field:
<pre><code class="hljs">print(arrow_1.naive)
print(arrow_2.naive)
print(arrow_3.naive)
</code></pre>
This will not strip them off their timezone awareness, resulting in what you'd expect when you're working with naive <code>datetime</code> objects:
<pre><code class="hljs">2021-01-01 00:00:00
2021-01-01 00:00:00
2021-01-01 00:00:00
</code></pre>
<h2 id="convertingbetweentimezoneswitharrow">Converting Between Time Zones with Arrow</h2>
Another area worth looking at is how we can convert between different time zones with Arrow by using the <code>to()</code> method. Whilst Arrow is fully compatible with timezone modules, there is no need to import any additional modules for timezone conversion.
To start with we can get the current time and assign it to a variable:
<pre><code class="hljs">utc=arrow.now()
print(utc)
</code></pre>
<pre><code class="hljs">&lt;Arrow [2021-03-30T17:41:08.765166+01:00]&gt;
</code></pre>
Now, let's convert this object to another timezone:
<pre><code class="hljs">utc.to(&#x27;US/Pacific&#x27;)
</code></pre>
This results in:
<pre><code class="hljs">&lt;Arrow [2021-03-30T09:41:08.765166-07:00]&gt;
</code></pre>
Or the time in Hong Kong:
<pre><code class="hljs">utc.to(&#x27;Asia/Hong_Kong&#x27;)
</code></pre>
<pre><code class="hljs">&lt;Arrow [2021-03-30T09:41:08.765166-07:00]&gt;
</code></pre>
We can even specify the time difference with number of hours:
<pre><code class="hljs">utc.to(&#x27;-05:00&#x27;)
</code></pre>
This is a much more intuitive way to convert between timezones, especially if you don't have a list of the appropriate names handy:
<pre><code class="hljs">&lt;Arrow [2021-03-30T11:41:08.765166-05:00]&gt;
</code></pre>
<h2 id="humanizingandshiftingdates">Humanizing and Shifting Dates</h2>
Oftentimes, when dealing with time spans, we don't really need a date. When talking to colleagues, we say:
<blockquote>
&quot;I went shopping yesterday&quot;.
</blockquote>
Not:
<blockquote>
&quot;I went shopping on 2021/12/03&quot;, which is the day before 2021/12/04&quot;, which is the day right now.
</blockquote>
In a lot of cases, you might want to humanize dates, such as annotating when a notification arrived, an email was sent or when someone performed a certain logged action. Thankfully, Arrow allows us to really easily humanize any date via the <code>humanize()</code> function.
This function works wonders with the <code>shift()</code> function, which can shift the dates by <code>0...n</code> days. You might want to make a system that notifies a person of when a certain date is coming up, in human-speak:
<pre><code class="hljs">import arrow

now = arrow.now()
tomorrow = now.shift(days=1)
yesterday = now.shift(days=-1)
next_week = now.shift(days=7)
notification = now.shift(days=-2, hours=-5, minutes=-7)

print(now.humanize())
print(tomorrow.humanize())
print(yesterday.humanize())
print(next_week.humanize())
print(notification.humanize(granularity=[&#x27;day&#x27;, &#x27;hour&#x27;, &#x27;minute&#x27;]))
</code></pre>
Here, we've created an <code>Arrow</code> object using the <code>now()</code> function. Then, we've created a series of objects by shifting the values up or down. The <code>shift()</code> function accepts arguments such as <code>years</code>, <code>months</code>, <code>days</code>, <code>hours</code>, <code>minutes</code> and <code>seconds</code>. We've created a <code>tomorrow</code> and <code>yesterday</code> object by shifting up and down by one day (not in-place), and an object for <code>next_week</code> and an arbitrary <code>notification</code> object that happened 2 days, 5 hours and 7 minutes ago.
Finally, when humanizing, you can specify the <code>granularity</code>, which lets Arrow know how detailed to be when it comes to reporting time in human-speak. By default, it'll set the granularity to <code>day</code> and/or <code>week</code>, depending on the time range. In our case, we've left the default settings on, except for the final object where we specifically want a bit of a finer granularity:
<pre><code class="hljs">just now
in a day
a day ago
in a week
2 days 5 hours and 7 minutes ago
</code></pre>
This is a very intuitive and human way to represent dates to your user - such as counting down days to an event, or counting days from an event.
<h2 id="advantagesofusingarrow">Advantages of Using Arrow</h2>
The advantages of using Arrow could be summarized with the official statements from their documentation:
<blockquote>
Sensible and human-friendly approach.
Supporting many common creation scenarios.
Help you work with dates and times with fewer imports and a lot less code.
</blockquote>
In these, it appears to succeed, and Arrow overcomes the major issues with the <code>datetime</code> library. From what we have seen in our examples above Arrow is certainly an improvement in terms of:
<ul>
<li>Reducing the need for importing multiple modules</li>
<li>Working in just one data type (Arrow)</li>
<li>Being timezone-aware</li>
<li>Simplifying the creation of the most commonly used date and time functions</li>
<li>Easy conversion between various types</li>
<li>Helpful humanization functions</li>
<li>Easily shifting values into the past and future</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've focused on some of the benefits of using the Arrow library to work with date and time in Python. It's inspired by Moment.js, and offers solutions to some of the known problems of the <code>datetime</code> library.
However, it is worth bearing in mind there are many other date and time modules available. It is also worth noting that being a built-in module gives <code>datetime</code> the advantage of needing users pro-actively looking to replace it.
It all comes down to how important the date and time element is to your project and your code.

Rikesh Nichani

Working with Datetime in Python with Arrow

<h2 id="introduction">Introduction</h2>
JavaScript has a lot of useful built-in methods for string manipulation, one of these methods is the <code>split()</code> method.
In this article we'll be taking a closer look at the <code>split()</code> method and how we can use it in conjunction with regular expressions to split a long string just the way we want.
<h2 id="javascriptssplitmethod">JavaScript's split() Method</h2>
When the <code>split(delimiter, limit)</code> method is used on a string, it returns an array of substrings, and uses the <code>delimiter</code> argument's value as the delimiter. The <code>delimiter</code> argument can also be specified as a regular expression, which will then be used to search through the original string to find delimiters that match the specified expression.
Additionally, we can specify the optional argument <code>limit</code>, which specifies how many elements we want in our resulting substring array. Setting <code>limit=2</code>, for example, will yield an array that contains the first two substrings separated by a delimiter in the original string:
<pre><code class="hljs">const str = &quot;JavaScript is the best programming language!&quot;;

const words = str.split(&quot; &quot;);
console.log(words);
</code></pre>
Here, the string will be broken down on each new word:
<pre><code class="hljs">[&quot;JavaScript&quot;, &quot;is&quot;, &quot;the&quot;, &quot;best&quot;, &quot;programming&quot;, &quot;language!&quot; ]
</code></pre>
If we set the delimiter to something else, such as:
<pre><code class="hljs">const chars = str.split(&quot;&quot;);
console.log(chars);
</code></pre>
The string will be broken down on every character:
<pre><code class="hljs">[&quot;J&quot;, &quot;a&quot;, &quot;v&quot;, &quot;a&quot;, &quot;S&quot;, &quot;c&quot;, &quot;r&quot;, &quot;i&quot;, &quot;p&quot;, &quot;t&quot;, &quot; &quot;, &quot;i&quot;, &quot;s&quot;, &quot; &quot;, &quot;t&quot;, &quot;h&quot;, &quot;e&quot;, &quot; &quot;, &quot;b&quot;, &quot;e&quot;, &quot;s&quot;, &quot;t&quot;, &quot; &quot;, &quot;p&quot;, &quot;r&quot;, &quot;o&quot;, &quot;g&quot;, &quot;r&quot;, &quot;a&quot;, &quot;m&quot;, &quot;m&quot;, &quot;i&quot;, &quot;n&quot;, &quot;g&quot;, &quot; &quot;, &quot;l&quot;, &quot;a&quot;, &quot;n&quot;, &quot;g&quot;, &quot;u&quot;, &quot;a&quot;, &quot;g&quot;, &quot;e&quot;, &quot;!&quot;]
</code></pre>
<h2 id="regularexpressionswiththesplitmethod">Regular Expressions with the split() Method</h2>
Now that we are comfortable with the use of the <code>split()</code> method, let's step it up a notch, and introduce regular expressions to the mix:
<pre><code class="hljs">const paragraph = `The Answer to the Ultimate Question of Life, the Universe, and Everything is 42. Forty two. That&#x27;s all there is.`;

// Split by words
const words = paragraph.split(&quot; &quot;);
console.log(words[2]);

// Split by sentences
const sentences = paragraph.split(/[!?.]/);
console.log(sentences[1]);

// Split all characters, with a limit of 2
const firstTwoChars = paragraph.split(&quot;&quot;, 2);
console.log(firstTwoChars);

// Split and reverse
const reverse = paragraph.split(&quot;&quot;).reverse().join(&quot;&quot;);
console.log(reverse);
</code></pre>
This results in:
<pre><code class="hljs">to
 Forty two
[&quot;T&quot;, &quot;h&quot; ]
.24 si gnihtyrevE dna ,esrevinU eht ,efiL fo noitseuQ etamitlU eht ot rewsnA ehT
</code></pre>
In the second example, we are passing a regular expression as the argument for the <code>split()</code> method.
<ul>
<li><code>/[!?.]/</code> represents a character set - <code>!</code> or <code>?</code> or <code>.</code></li>
</ul>
Put simply, we are splitting the string at any of the specified characters.
In the third example, we are passing <code>2</code> as the second argument, limiting the resulting substring array to two elements.
In the last example, we are reversing the string using the built-in <code>reverse()</code> method. Because <code>reverse()</code> is an array method, we'll first split the original string into an array of individual characters, by using the <code>split(&quot;&quot;)</code> method, and then <code>reverse()</code> it.
Finally, we can <code>join()</code> the results to create a reversed string from the array of characters.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we took a quick look at how to split a string in vanilla JavaScript. We've gone over the built-in <code>split()</code> method, as well as how to use it with regular expressions.

Abhilash Kakumanu

In this tutorial, we'll take a look at how to split a string in JavaScript, using the split() method with and without regular expressions.

How to Split a String in JavaScript

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to check if a string starts with a substring in JavaScript.
This is easily achieved either through the <code>startsWith()</code> method, or regular expressions.
<h2 id="checkifstringstartswithanotherstringwithstartswith">Check if String Starts with Another String with startsWith()</h2>
The <code>startsWith(searchString[, position])</code> method returns a boolean which indicates whether a string begins with the characters of a specified <code>searchString</code>. Optionally we can also use the <code>position</code> argument to specify the position of the string at which to begin searching.
Let's see this in action:
<pre><code class="hljs">const str = &quot;This is an example for startsWith() method&quot;;

console.log(str.startsWith(&quot;This&quot;)); // true
console.log(str.startsWith(&quot;is&quot;, 2)); // true
</code></pre>
In the first example, we are checking if the string <code>str</code> starts with <code>&quot;This&quot;</code>.
In the second example, we are checking if <code>str</code> starts with <code>&quot;is&quot;</code>, if we are starting our search from index 2 (i.e, 3rd character).
<h2 id="checkifstringstartswithanotherstringwithregularexpressions">Check if String Starts with Another String with Regular Expressions</h2>
Regular Expressions are really powerful, and allow us to match various patterns. This is a great use-case for them, since we're essentially checking for a pattern - if a string starts with a substring.
The <code>regexObj.test(reg)</code> method tries to match the specified regular expression <code>reg</code> to the original string and returns a <code>boolean</code> value which indicates if a match was found:
<pre><code class="hljs">const str = &quot;hello world&quot;;

const regEx = /^he/;

console.log(regEx.test(str)); // true
</code></pre>
In this approach, we are checking whether the pattern <code>regEx</code> occurs in the string <code>str</code>. The <code>^</code> meta character represents that the specified pattern <code>he</code> must be at the start of a line. Thus, the regular expression - <code>/^he/</code> checks if the specified line starts with the substring <code>he</code>.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to check if a string starts with a substring in vanilla JavaScript, using the <code>startsWith()</code> method, as well as Regular Expressions.

In this tutorial, we'll take a look at practical examples on how to check if a string starts with another string in JavaScript, using `startsWith()` and regex.

JavaScript: Check if String Starts with Substring

David Landup

Rayven Yor Esplanada

In this tutorial guide, we'll dive deep into understanding Java Generics - what they are, how to use them and when to choose which approach, with examples.

Guide to Understanding Generics in Java

<h2 id="introduction">Introduction</h2>
There are many data visualization libraries in Python, yet Matplotlib is the most popular library out of all of them. Matplotlib’s popularity is due to its reliability and utility - it's able to create both simple and complex plots with little code. You can also customize the plots in a variety of ways.
In this tutorial, we'll cover how to plot a Joint Plot in Matplotlib which consists of a <a target="_blank" href="/matplotlib-scatterplot-tutorial-and-examples/">Scatter Plot</a> and multiple Distribution Plots on the same <code>Figure</code>.
<blockquote>
Joint Plots are used to explore relationships between bivariate data, as well as their distributions at the same time.
</blockquote>
Note: This sort of task is much more fit for libraries such as Seaborn, which has a built-in <code>jointplot()</code> function. With Matplotlib, we'll construct a Joint Plot manually, using <code>GridSpec</code> and multiple <code>Axes</code> objects, instead of having Seaborn do it for us.
<h2 id="importingdata">Importing Data</h2>
We'll use the famous <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/uciml/iris">Iris Dataset</a>, since we can explore the relationship between features such as <code>SepalWidthCm</code> and <code>SepalLengthCm</code> through a Scatter Plot, but also explore the distributions between the <code>Species</code> feature with their sepal length/width in mind, through Distribution Plots at the same time.
Let's import the dataset and take a peek:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;iris.csv&#x27;)
print(df.head())
</code></pre>
This results in:
<pre><code class="hljs"> Id SepalLengthCm SepalWidthCm PetalLengthCm PetalWidthCm Species
0 1 5.1 3.5 1.4 0.2 Iris-setosa
1 2 4.9 3.0 1.4 0.2 Iris-setosa
2 3 4.7 3.2 1.3 0.2 Iris-setosa
3 4 4.6 3.1 1.5 0.2 Iris-setosa
4 5 5.0 3.6 1.4 0.2 Iris-setosa
</code></pre>
We'll be exploring the bivariate relationship between the <code>SepalLengthCm</code> and <code>SepalWidthCm</code> features here, but also their distributions. We can approach this in two ways - with respect to their <code>Species</code> or not.
We can totally disregard the <code>Species</code> feature, and simply plot histograms of the distributions of each flower instance. On the other hand, we can color-code and plot distribution plots of each flower instance, highlighting the difference in their <code>Species</code> as well.
We'll explore both options here, starting with the simpler one - disregarding the <code>Species</code> altogether.
<h2 id="plotajointplotinmatplotlibwithsingleclasshistograms">Plot a Joint Plot in Matplotlib with Single-Class Histograms</h2>
In the first approach, we'll just load in the flower instances and plot them as-is, with no regard to their <code>Species</code>.
We'll be using a <a rel="nofollow noopener" target="_blank" href="https://matplotlib.org/stable/tutorials/intermediate/gridspec.html"><code>GridSpec</code></a> to customize our figure's layout, to make space for three different plots and <code>Axes</code> instances.
To invoke the <code>GridSpec</code> constructor, we'll want to import it alongside the PyPlot instance:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
</code></pre>
Now, let's create our <code>Figure</code> and create the <code>Axes</code> objects:
<pre><code class="hljs">df = pd.read_csv(&#x27;iris.csv&#x27;)

fig = plt.figure()
gs = GridSpec(4, 4)

ax_scatter = fig.add_subplot(gs[1:4, 0:3])
ax_hist_y = fig.add_subplot(gs[0,0:3])
ax_hist_x = fig.add_subplot(gs[1:4, 3])

plt.show()
</code></pre>
We've created 3 <code>Axes</code> instances, by adding subplots to the figure, using our <code>GridSpec</code> instance to position them. This results in a <code>Figure</code> with 3 empty <code>Axes</code> instances:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-scatter-plot-with-distribution-plots-histograms-jointplot-1.png" alt="matplotlib gridspec for jointplot">
Now that we've got the layout and positioning in place, all we have to do is plot the data on our <code>Axes</code>. Let's update the script so that we plot the <code>SepalLengthCm</code> and <code>SepalWidthCm</code> features through a Scatter plot, on our <code>ax_scatter</code> axes, and each of these features on the <code>ax_hist_y</code> and <code>ax_hist_x</code> axes:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

df = pd.read_csv(&#x27;iris.csv&#x27;)

fig = plt.figure()
gs = GridSpec(4, 4)

ax_scatter = fig.add_subplot(gs[1:4, 0:3])
ax_hist_x = fig.add_subplot(gs[0,0:3])
ax_hist_y = fig.add_subplot(gs[1:4, 3])

ax_scatter.scatter(df[&#x27;SepalLengthCm&#x27;], df[&#x27;SepalWidthCm&#x27;])

ax_hist_x.hist(df[&#x27;SepalLengthCm&#x27;])
ax_hist_y.hist(df[&#x27;SepalWidthCm&#x27;], orientation = &#x27;horizontal&#x27;)

plt.show()
</code></pre>
We've set the <code>orientation</code> of <code>ax_hist_y</code> to <code>horizontal</code> so that it's plotted horizontally, on the right-hand side of the Scatter Plot, in the same orientation we've set our axes to, using the <code>GridSpec</code>:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-scatter-plot-with-distribution-plots-histograms-jointplot-2.png" alt="matplotlib simple joint plot with one class histogram">
This results in a Joint Plot of the relationship between the <code>SepalLengthCm</code> and <code>SepalWidthCm</code> features, as well as the distributions for the respective features.
<h2 id="plotajointplotinmatplotlibwithmultipleclasshistograms">Plot a Joint Plot in Matplotlib with Multiple-Class Histograms</h2>
Now, another case we might want to explore is the distribution of these features, with respect to the <code>Species</code> of the flower, since it could very possibly affect the range of sepal lengths and widths.
For this, we won't be using just one histogram for each axis, where each contains all flower instances, but rather, we'll be overlaying a histogram for each <code>Species</code> on both axes.
To do this, we'll first have to dissect the <code>DataFrame</code> we've been using before, by the flower <code>Species</code>:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

df = pd.read_csv(&#x27;iris.csv&#x27;)

setosa = df[df[&#x27;Species&#x27;]==&#x27;Iris-setosa&#x27;]
virginica = df[df[&#x27;Species&#x27;]==&#x27;Iris-virginica&#x27;]
versicolor = df[df[&#x27;Species&#x27;]==&#x27;Iris-versicolor&#x27;]
species = df[&#x27;Species&#x27;]
colors = {
 &#x27;Iris-setosa&#x27; : &#x27;tab:blue&#x27;, 
 &#x27;Iris-versicolor&#x27; : &#x27;tab:red&#x27;,
 &#x27;Iris-virginica&#x27; : &#x27;tab:green&#x27;
 }

</code></pre>
Here, we've just filtered out the <code>DataFrame</code>, by the <code>Species</code> feature into three separate datasets. The <code>setosa</code>, <code>virginica</code> and <code>versicolor</code> datasets now contain only their respective instances.
We'll also want to color each of these instances with a different color, based on their <code>Species</code>, both in the Scatter Plot and in the Histograms. For that, we've simply cut out a <code>Series</code> of the <code>Species</code> feature, and made a <code>colors</code> dictionary, which we'll use to <code>map()</code> the <code>Species</code> of each flower to a color later on.
Now, let's make our <code>Figure</code>, <code>GridSpec</code> and <code>Axes</code> instances:
<pre><code class="hljs">fig = plt.figure()
gs = GridSpec(4, 4)

ax_scatter = fig.add_subplot(gs[1:4, 0:3])
ax_hist_y = fig.add_subplot(gs[0,0:3])
ax_hist_x = fig.add_subplot(gs[1:4, 3])
</code></pre>
Finally, we can plot out the Scatter Plot and Histograms, setting their colors and orientations accordingly:
<pre><code class="hljs">ax_scatter.scatter(df[&#x27;SepalLengthCm&#x27;], df[&#x27;SepalWidthCm&#x27;], c=species.map(colors))

ax_hist_y.hist(versicolor[&#x27;SepalLengthCm&#x27;], color=&#x27;tab:red&#x27;, alpha=0.4)
ax_hist_y.hist(virginica[&#x27;SepalLengthCm&#x27;], color=&#x27;tab:green&#x27;, alpha=0.4)
ax_hist_y.hist(setosa[&#x27;SepalLengthCm&#x27;], color=&#x27;tab:blue&#x27;, alpha=0.4)

ax_hist_x.hist(versicolor[&#x27;SepalWidthCm&#x27;], orientation = &#x27;horizontal&#x27;, color=&#x27;tab:red&#x27;, alpha=0.4)
ax_hist_x.hist(virginica[&#x27;SepalWidthCm&#x27;], orientation = &#x27;horizontal&#x27;, color=&#x27;tab:green&#x27;, alpha=0.4)
ax_hist_x.hist(setosa[&#x27;SepalWidthCm&#x27;], orientation = &#x27;horizontal&#x27;, color=&#x27;tab:blue&#x27;, alpha=0.4)

plt.show()
</code></pre>
The <code>map()</code> call results in a <code>Series</code> of colors:
<pre><code class="hljs">0 tab:blue
1 tab:blue
2 tab:blue
3 tab:blue
4 tab:blue
 ...
145 tab:green
146 tab:green
147 tab:green
148 tab:green
149 tab:green
</code></pre>
When provided to the <code>c</code> argument of the <code>scatter()</code> function, it applies colors to instances in that order, effectively coloring each instance with a color corresponding to its species.
For the Histograms, we've simply plotted three plots, one for each <code>Species</code>, with their respective colors. You can opt for a <code>step</code> Histogram here, and tweak the <code>alpha</code> value to create different-looking distributions.
Running this code results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-scatter-plot-with-distribution-plots-histograms-jointplot-3.png" alt="matplotlib joint plot with multi-class histogram">
Now, each <code>Species</code> has its own color and distribution, plotted separately from other flowers. Furthermore, they're color-coded with the Scatter Plot so it's a really intuitive plot that can easily be read and interpreted.
Note: If you find the overlapping colors, such as the orange that comprises of the red and blue Histograms distracting, setting the <code>histtype</code> to <code>step</code> will remove the filled colors:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-scatter-plot-with-distribution-plots-histograms-jointplot-4.png" alt="matplotlib joint plot, step histogram">
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to plot a Joint Plot in Matplotlib - a Scatter Plot with accompanying Distribution Plots (Histograms) on both axes of the plot, to explore the distribution of the variables that constitute the Scatter Plot itself.
Although this task is more suited for libraries like Seaborn, which have built-in support for Joint Plots, Matplotlib is the underlying engine that enables Seaborn to make these plots effortlessly.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with theses libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth, guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, cover core plotting libraries like Matplotlib and Seaborn, and show you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll take a look at how to plot Scatter Plots with Distribution Plots - Jointplots (Joint Plots) in Python with Matplotlib, with examples.

Matplotlib Scatter Plot with Distribution Plots (Joint Plot) - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
There are many data visualization libraries in Python, yet Matplotlib is the most popular library out of all of them. Matplotlib’s popularity is due to its reliability and utility - it's able to create both simple and complex plots with little code. You can also customize the plots in a variety of ways.
In this tutorial, we'll cover how to plot a Pie Chart in Matplotlib.
<blockquote>
Pie charts represent data broken down into categories/labels. They're an intuitive and simple way to visualize proportional data - such as percentages.
</blockquote>
<h2 id="plotapiechartinmatplotlib">Plot a Pie Chart in Matplotlib</h2>
To plot a pie chart in Matplotlib, we can call the <code>pie()</code> function of the PyPlot or <code>Axes</code> instance.
The only mandatory argument is the data we'd like to plot, such as a feature from a dataset:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]

fig, ax = plt.subplots()
ax.plot(x)
plt.show()
</code></pre>
This generates a rather simple, but plain, Pie Chart with each value being assigned to a proportionally large slice of the pie:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-1.png" alt="simple matplotlib pie chart">
Let's add some labels, so that it's easier to distinguish what's what here:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]
labels = [&#x27;Very Likely&#x27;, &#x27;Likely&#x27;, &#x27;Unsure&#x27;, &#x27;Unlikely&#x27;, &#x27;Very Unlikely&#x27;]

fig, ax = plt.subplots()
ax.pie(x, labels = labels)
ax.set_title(&#x27;Survery responses&#x27;)
plt.show()
</code></pre>
Now, the Pie Chart will have some additional data that allows us to interpret it a bit easier:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-2.png" alt="pie chart with labels matplotlib">
<h2 id="customizingpiechartsinmatplotlib">Customizing Pie Charts in Matplotlib</h2>
When preparing data visualizations for presentations, papers or simply to share them around with your peers - you might want to stylize and customize them a little bit, such as using different colors, that correlate to the categories, showing percentages on slices, instead of just relying on the visual perception, or exploding slices to highlight them.
Let's take a look at how Matplotlib lets us customize Pie Charts.
<h3 id="changepiechartcolors">Change Pie Chart Colors</h3>
To change the colors of a Pie Chart in Matplotlib, we'll need to supply an array of colors to the <code>colors</code> argument, while plotting it:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]
labels = [&#x27;Very Likely&#x27;, &#x27;Likely&#x27;, &#x27;Unsure&#x27;, &#x27;Unlikely&#x27;, &#x27;Very Unlikely&#x27;]
colors = [&#x27;tab:blue&#x27;, &#x27;tab:cyan&#x27;, &#x27;tab:gray&#x27;, &#x27;tab:orange&#x27;, &#x27;tab:red&#x27;]

fig, ax = plt.subplots()
ax.pie(x, labels = labels, colors = colors)
ax.set_title(&#x27;Survery responses&#x27;)
plt.show()
</code></pre>
Here, we've created a really simple correlation between the responses and the colors they're assigned. <code>Very Likely</code> will be <code>blue</code> in the Tableau Palette, while <code>Very Unlikely</code> will be <code>red</code>.
Running this code results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-3.png" alt="changing colors of matplotlib pie chart">
<h3 id="showpercentagesonslices">Show Percentages on Slices</h3>
Looking at the Pie Chart we've made so far, it's clear that there are more <code>Unsure</code> and <code>Likely</code> respondents than other categories individually. Though, it's oftentimes easier for us to both interpret a Pie Chart visually, and numerically.
To add numerical percentages to each slice, we use the <code>autopct</code> argument. It automatically sets the percentages in each wedge/slice, and accepts the standard Python string formatting notation:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]
labels = [&#x27;Very Likely&#x27;, &#x27;Likely&#x27;, &#x27;Unsure&#x27;, &#x27;Unlikely&#x27;, &#x27;Very Unlikely&#x27;]
colors = [&#x27;tab:blue&#x27;, &#x27;tab:cyan&#x27;, &#x27;tab:gray&#x27;, &#x27;tab:orange&#x27;, &#x27;tab:red&#x27;]

fig, ax = plt.subplots()
ax.pie(x, labels = labels, colors = colors, autopct=&#x27;%.0f%%&#x27;)
ax.set_title(&#x27;Survery responses&#x27;)
plt.show()
</code></pre>
By setting <code>autopct</code> to <code>%.0f%%</code>, we've chosen to format the percentages with 0 decimal places (only whole numbers), and added a <code>%</code> sign at the end. If we had omitted the surrounding <code>%..%</code> symbols, the strings wouldn't be formatted as percentages, but as literal values.
Running this code results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-4.png" alt="adding percentage labels to pie chart in matplotlib">
<h3 id="explodehighlightwedges">Explode/Highlight Wedges</h3>
Sometimes, it's important to highlight certain entries. For example, in our survey, a really small percentage of the respondents feel like the advent of something in question is <code>Very Unlikely</code>. Assuming that we'd want to point out the fact that most people don't think it's unlikely, we can explode the wedge:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]
labels = [&#x27;Very Likely&#x27;, &#x27;Likely&#x27;, &#x27;Unsure&#x27;, &#x27;Unlikely&#x27;, &#x27;Very Unlikely&#x27;]
colors = [&#x27;tab:blue&#x27;, &#x27;tab:cyan&#x27;, &#x27;tab:gray&#x27;, &#x27;tab:orange&#x27;, &#x27;tab:red&#x27;]
explode = [0, 0, 0, 0, 0.2]

fig, ax = plt.subplots()
ax.pie(x, labels = labels, colors = colors, autopct=&#x27;%.0f%%&#x27;, explode = explode)
ax.set_title(&#x27;Survery responses&#x27;)
plt.show()
</code></pre>
The <code>explode</code> argument accepts an array of values, from <code>0..1</code>, where the values themselves define how further away the wedge is from the center. By default, all wedges have an explode value of <code>0</code>, so they're all connected to the center.
Setting this value to <code>1</code> would offset it by a lot, relative to the chart, so usually, you'll explode wedges by <code>0.1</code>, <code>0.2</code>, <code>0.3</code>, and similar values. You can explode as many of them as you'd like, with different values to highlight different categories.
Running this code results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-5.png" alt="highlighting pie chart wedges with explode in matplotlib">
<h3 id="addingashadow">Adding a Shadow</h3>
To add a shadow to a Matplotlib pie chart, all you have to do is set the <code>shadow</code> argument to <code>True</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]
labels = [&#x27;Very Likely&#x27;, &#x27;Likely&#x27;, &#x27;Unsure&#x27;, &#x27;Unlikely&#x27;, &#x27;Very Unlikely&#x27;]
colors = [&#x27;tab:blue&#x27;, &#x27;tab:cyan&#x27;, &#x27;tab:gray&#x27;, &#x27;tab:orange&#x27;, &#x27;tab:red&#x27;]
explode = [0, 0, 0, 0, 0.2]

fig, ax = plt.subplots()
ax.pie(x, labels = labels, 
 colors = colors, 
 autopct=&#x27;%.0f%%&#x27;, 
 explode = explode, 
 shadow = True)
 
ax.set_title(&#x27;Survery responses&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-6.png" alt="adding a shadow to a pie chart in matplotlib">
<h3 id="rotatingpiechart">Rotating Pie Chart</h3>
Finally, you can also rotate the chart, by setting the starting angle. So far, it starts on 0 degrees (right-hand), and populated wedges counter-clockwise. By setting the <code>startangle</code> argument to a number between <code>0..360</code>, you can make a full circle:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [15, 25, 25, 30, 5]
labels = [&#x27;Very Likely&#x27;, &#x27;Likely&#x27;, &#x27;Unsure&#x27;, &#x27;Unlikely&#x27;, &#x27;Very Unlikely&#x27;]
colors = [&#x27;tab:blue&#x27;, &#x27;tab:cyan&#x27;, &#x27;tab:gray&#x27;, &#x27;tab:orange&#x27;, &#x27;tab:red&#x27;]
explode = [0, 0, 0, 0, 0.2]

fig, ax = plt.subplots()
ax.pie(x, labels = labels,
 colors = colors,
 autopct=&#x27;%.0f%%&#x27;,
 explode = explode,
 shadow = True,
 startangle = 180)

ax.set_title(&#x27;Survery responses&#x27;)
plt.show()
</code></pre>
This results in a Pie Chart, rotated by 180 degrees, effectively flipping it to the other side:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-pie-chart-tutorial-and-examples-7.png" alt="rotating pie charts in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to plot simple Pie Chart in Matplotlib with Python. We've gone over simple Pie Charts, and then dived into how to customize them both for aesthetic and practical uses.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with theses libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth, guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, cover core plotting libraries like Matplotlib and Seaborn, and show you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll go over how to plot a Pie Chart in Python with Matplotlib. We'll cover how to plot simple charts, as well as how to customize them, with examples.

Matplotlib Pie Chart - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this tutorial, we'll take a look at how to plot multiple line plots in Matplotlib - on the same <code>Axes</code> or <code>Figure</code>.
If you'd like to read more about plotting line plots in general, as well as customizing them, make sure to read our guide on <a target="_blank" href="/matplotlib-line-plot-tutorial-and-examples/">Plotting Lines Plots with Matplotlib</a>.
<h2 id="plotmultiplelineplotsinmatplotlib">Plot Multiple Line Plots in Matplotlib</h2>
Depending on the style you're using, OOP or MATLAB-style, you'll either use the <code>plt</code> instance, or the <code>ax</code> instance to plot, with the same approach.
To plot multiple line plots in Matplotlib, you simply repeatedly call the <code>plot()</code> function, which will apply the changes to the same <code>Figure</code> object:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5, 6]
y = [2, 4, 6, 5, 6, 8]
y2 = [5, 3, 7, 8, 9, 6]

fig, ax = plt.subplots()

ax.plot(x, y)
ax.plot(x, y2)
plt.show()
</code></pre>
Without setting any customization flags, the default colormap will apply, drawing both line plots on the same <code>Figure</code> object, and adjusting the color to differentiate between them:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-plot-multiple-line-plots-1.png" alt="">
Now, let's generate some random sequences using NumPy, and customize the line plots a tiny bit by setting a specific color for each, and labeling them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

line_1 = np.random.randint(low = 0, high = 50, size = 50)
line_2 = np.random.randint(low = -15, high = 100, size = 50)

fig, ax = plt.subplots()

ax.plot(line_1, color = &#x27;green&#x27;, label = &#x27;Line 1&#x27;)
ax.plot(line_2, color = &#x27;red&#x27;, label = &#x27;Line 2&#x27;)
ax.legend(loc = &#x27;upper left&#x27;)
plt.show()
</code></pre>
We don't have to supply the X-axis values to a line plot, in which case, the values from <code>0..n</code> will be applied, where <code>n</code> is the last element in the data you're plotting. In our case, we've got two sequences of data - <code>line_1</code> and <code>line_2</code>, which will both be plotted on the same X-axis.
While plotting, we've assigned colors to them, using the <code>color</code> argument, and labels for the legend, using the <code>label</code> argument. This results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-plot-multiple-line-plots-2.png" alt="">
<h2 id="plotmultiplelineplotswithdifferentscales">Plot Multiple Line Plots with Different Scales</h2>
Sometimes, you might have two datasets, fit for line plots, but their values are significantly different, making it hard to compare both lines. For example, if <code>line_1</code> had an exponentially increasing sequence of numbers, while <code>line_2</code> had a linearly increasing sequence - surely and quickly enough, <code>line_1</code> would have values so much larger than <code>line_2</code>, that the latter fades out of view.
Let's use NumPy to make an exponentially increasing sequence of numbers, and plot it next to another line on the same <code>Axes</code>, linearly:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

linear_sequence = np.linspace(0, 10, 10)
# [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 10]
exponential_sequence = np.exp(linear_sequence)
# [1.00e+00, 3.03e+00, 9.22e+00, 2.80e+01, 8.51e+01, 2.58e+02, 7.85e+02, 2.38e+03, 7.25e+03, 2.20e+04]

fig, ax = plt.subplots()

ax.plot(linear_sequence)
ax.plot(exponential_sequence)
plt.show()
</code></pre>
Running this code results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-plot-multiple-line-plots-3.png" alt="">
The exponential growth in the <code>exponential_sequence</code> goes out of proportion very fast, and it looks like there's absolutely no difference in the <code>linear_sequence</code>, since it's so minuscule relative to the exponential trend of the other sequence.
Now, let's plot the <code>exponential_sequence</code> on a logarithmic scale, which will produce a visually straight line, since the Y-scale will exponentially increase. If we plot it on a logarithmic scale, and the <code>linear_sequence</code> just increases by the same constant, we'll have two overlapping lines and we will only be able to see the one plotted after the first.
Let's change up the <code>linear_sequence</code> a bit to make it observable once we plot both:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

# Sequences
linear_sequence = [1, 2, 3, 4, 5, 6, 7, 10, 15, 20]
exponential_sequence = np.exp(np.linspace(0, 10, 10))

fig, ax = plt.subplots()

# Plot linear sequence, and set tick labels to the same color
ax.plot(linear_sequence, color=&#x27;red&#x27;)
ax.tick_params(axis=&#x27;y&#x27;, labelcolor=&#x27;red&#x27;)

# Generate a new Axes instance, on the twin-X axes (same position)
ax2 = ax.twinx()

# Plot exponential sequence, set scale to logarithmic and change tick color
ax2.plot(exponential_sequence, color=&#x27;green&#x27;)
ax2.set_yscale(&#x27;log&#x27;)
ax2.tick_params(axis=&#x27;y&#x27;, labelcolor=&#x27;green&#x27;)

plt.show()
</code></pre>
This time around, we'll have to use the OOP interface, since we're creating a new <code>Axes</code> instance. One <code>Axes</code> has one scale, so we create a new one, in the same position as the first one, and set its scale to a logarithmic one, and plot the exponential sequence.
This results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-plot-multiple-line-plots-4.png" alt="">
We've also changed the tick label colors to match the color of the line plots themselves, otherwise, it'd be hard to distinguish which line is on which scale.
<h2 id="plotmultiplelineplotswithmultipleyaxis">Plot Multiple Line Plots with Multiple Y-Axis</h2>
Finally, we can apply the same scale (linear, logarithmic, etc), but have different values on the Y-axis of each line plot. This is achieved through having multiple Y-axis, on different <code>Axes</code> objects, in the same position.
For example, the <code>linear_sequence</code> won't go above 20 on the Y-axis, while the <code>exponential_sequence</code> will go up to 20000. We can plot them both linearly, simply by plotting them on different <code>Axes</code> objects, in the same position, each of which set the Y-axis ticks automatically to accommodate for the data we're feeding in:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

# Sequences
linear_sequence = [1, 2, 3, 4, 5, 6, 7, 10, 15, 20]
exponential_sequence = np.exp(np.linspace(0, 10, 10))

fig, ax = plt.subplots()

# Plot linear sequence, and set tick labels to the same color
ax.plot(linear_sequence, color=&#x27;red&#x27;)
ax.tick_params(axis=&#x27;y&#x27;, labelcolor=&#x27;red&#x27;)

# Generate a new Axes instance, on the twin-X axes (same position)
ax2 = ax.twinx()

# Plot exponential sequence, set scale to logarithmic and change tick color
ax2.plot(exponential_sequence, color=&#x27;green&#x27;)
ax2.tick_params(axis=&#x27;y&#x27;, labelcolor=&#x27;green&#x27;)

plt.show()
</code></pre>
We've again created another <code>Axes</code> in the same position as the first one, so we can plot on the same place in the <code>Figure</code> but different <code>Axes</code> objects, which allows us to set values for each Y-axis individually.
Without setting the Y-scale to logarithmic this time, both will be plotted linearly:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-plot-multiple-line-plots-5.png" alt="">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to plot multiple Line Plots on the same <code>Figure</code> or <code>Axes</code> in Matplotlib and Python. We've covered how to plot on the same <code>Axes</code> with the same scale and Y-axis, as well as how to plot on the same <code>Figure</code> with different and identical Y-axis scales.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll take a look at how to plot multiple lines plots in Matplotlib. We'll plot on the same scale, as well as different scales, and multiple Y-axis, through examples.

Matplotlib: Plot Multiple Line Plots On Same and Different Scales

<h2 id="introduction">Introduction</h2>
There are many data visualization libraries in Python, yet Matplotlib is the most popular library out of all of them. Matplotlib’s popularity is due to its reliability and utility - it's able to create both simple and complex plots with little code. You can also customize the plots in a variety of ways.
In this tutorial, we'll cover how to plot Stack Plots in Matplotlib.
<blockquote>
Stack Plots are used to plot linear data, in a vertical order, stacking each linear plot on another. Typically, they're used to generate cumulative plots.
</blockquote>
<h2 id="importingdata">Importing Data</h2>
We'll be using a dataset on Covid-19 vaccinations, from <a rel="nofollow noopener" target="_blank" href="https://ourworldindata.org/covid-vaccinations">Our World in Data</a>, specifically, the dataset that contains the cumulative vaccinations per country.
We’ll begin by importing all the libraries that we need. We’ll import Pandas to read and parse the dataset, NumPy to generate values for the X-axis, and we’ll of course need to import the PyPlot module from Matplotlib:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
</code></pre>
Let's take a peek at the <code>DataFrame</code> we'll be using:
<pre><code class="hljs">dataframe = pd.read_csv(&quot;cumulative-covid-vaccinations.csv&quot;)
print(dataframe.head(25))
</code></pre>
We're interested in the <code>Entity</code> and <code>total_vaccinations</code>. While we could use the <code>Date</code> feature as well, to gain a better grasp of how the vaccinations are going day-by-day, we'll treat the first entry as Day 0 and the last entry as Day N:
<pre><code class="hljs"> Entity Code Date total_vaccinations
0 Albania ALB 2021-01-10 0
1 Albania ALB 2021-01-12 128
2 Albania ALB 2021-01-13 188
3 Albania ALB 2021-01-14 266
4 Albania ALB 2021-01-15 308
5 Albania ALB 2021-01-16 369
...
16 Albania ALB 2021-02-22 6728
17 Albania ALB 2021-02-25 10135
18 Albania ALB 2021-03-01 14295
19 Albania ALB 2021-03-03 15793
20 Albania ALB 2021-03-10 21613
21 Algeria DZA 2021-01-29 0
22 Algeria DZA 2021-01-30 30
23 Algeria DZA 2021-02-19 75000
24 Andorra AND 2021-01-25 576
</code></pre>
This dataset will require some preprocessing, since this is a specific use-case. Though, before preprocessing it, let's get acquainted with how Stack Plots are generally plotted.
<h2 id="plotastackplotinmatplotlib">Plot a Stack Plot in Matplotlib</h2>
Stack Plots are used to visualize multiple linear plots, stacked on top of each other. With a regular line plot, you'd plot the relationship between X and Y. Here, we're plotting multiple Y features on a shared X-axis, one on top of the other:
<pre><code class="hljs">import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y1 = [5, 6, 4, 5, 7]
y2 = [1, 6, 4, 5, 6]
y3 = [1, 1, 2, 3, 2]

fig, ax = plt.subplots()
ax.stackplot(x, y1, y2, y3)
plt.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-stack-plot-tutorial-and-examples-1.png" alt="simple stack plot">
Since it's a bit unwieldy to deal with multiple lists like this, you can simply use a dictionary, where each <code>yn</code> feature is an entry:
<pre><code class="hljs">import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]

y_values = {
 &quot;y1&quot;: [5, 6, 4, 5, 7],
 &quot;y2&quot;: [1, 6, 4, 5, 6],
 &quot;y3&quot; : [1, 1, 2, 3, 2]
}

fig, ax = plt.subplots()
ax.stackplot(x, y_values.values())
plt.show()
</code></pre>
This results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-stack-plot-tutorial-and-examples-2.png" alt="simple stack plot matplotlib">
Since this type of plot can easily get you lost in the stacks, it's really helpful to add labels attached to the colors, by setting the <code>keys()</code> from the <code>y_values</code> dictionary as the <code>labels</code> argument, and adding a legend to the plot:
<pre><code class="hljs">import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]

y_values = {
 &quot;y1&quot;: [5, 6, 4, 5, 7],
 &quot;y2&quot;: [1, 6, 4, 5, 6],
 &quot;y3&quot; : [1, 1, 2, 3, 2]
}

fig, ax = plt.subplots()
ax.stackplot(x, y_values.values(), labels=y_values.keys())
ax.legend(loc=&#x27;upper left&#x27;)
plt.show()
</code></pre>
Now, this results in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-stack-plot-tutorial-and-examples-3.png" alt="matplotlib stack plot with legend">

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The length of these lists has to be the same. You can't plot <code>y1</code> with 3 values, and <code>y2</code> with 5 values.

 </div>
 </div>
 </div>
 This brings us to our Covid-19 vaccination dataset. We'll preprocess the dataset to take the form of a dictionary like this, and plot the cumulative vaccines given to the general population.
Let's start off by grouping the dataset by <code>Entity</code> and <code>total_vaccinations</code>, since each <code>Entity</code> currently has numerous entries. Also, we'll want to drop the entities named <code>World</code> and <code>European Union</code>, since they're convenience entities, added for cases where you might want to plot just a single cumulative line.
In our case, it'll effectively more than double the <code>total_vaccination</code> count, since they include already plotted values of each country, as single entities:
<pre><code class="hljs">dataframe = pd.read_csv(&quot;cumulative-covid-vaccinations.csv&quot;)
indices = dataframe[(dataframe[&#x27;Entity&#x27;] == &#x27;World&#x27;) | (dataframe[&#x27;Entity&#x27;] == &#x27;European Union&#x27;)].index
dataframe.drop(indices, inplace=True)

countries_vaccinations = dataframe.groupby(&#x27;Entity&#x27;)[&#x27;total_vaccinations&#x27;].apply(list)
</code></pre>
This results in a completely different shape of the dataset - instead of each entry having their own <code>Entity</code>/<code>total_vaccinations</code> entry, each <code>Entity</code> will have a list of their total vaccinations through the days:
<pre><code class="hljs">Entity
Albania [0, 128, 188, 266, 308, 369, 405, 447, 483, 51...
Algeria [0, 30, 75000]
Andorra [576, 1036, 1291, 1622, 2141, 2390, 2526, 3611...
...
Croatia [7864, 12285, 13798, 20603, 24985, 30000, 3455...
Cyprus [3901, 6035, 10226, 17739, 25519, 32837, 44429...
Czechia [1261, 3560, 7017, 10496, 11813, 12077, 13335,...
</code></pre>
Now, let's convert this <code>Series</code> into a dictionary and see what it looks like:
<pre><code class="hljs">cv_dict = countries_vaccinations.to_dict()
print(cv_dict)
</code></pre>
This results in:
<pre><code class="hljs">{
&#x27;Albania&#x27;: [0, 128, 188, 266, 308, 369, 405, 447, 483, 519, 549, 550, 1127, 1701, 3049, 4177, 6728, 10135, 14295, 15793, 21613], 
&#x27;Algeria&#x27;: [0, 30, 75000], 
&#x27;Andorra&#x27;: [576, 1036, 1291, 1622, 2141, 2390, 2526, 3611, 4914],
...
}
</code></pre>
However, there's a problem here. We can't plot these entries if their shapes aren't the same. Algeria has 3 entries, while Andorra has 9, for example. To combat this, we'll want to find the key with the most values, and how many values there are.
Then, construct a new dictionary (inadvisable to modify original dictionary while iterating through it) and insert <code>0</code>s for each missing day in the past, since there were <code>0</code> total vaccinations at those days:
<pre><code class="hljs">max_key, max_value = max(cv_dict.items(), key = lambda x: len(set(x[1])))

cv_dict_full = {}
for k,v in cv_dict.items():
 if len(v) &lt; len(max_value):
 trailing_zeros = [0]*(len(max_value)-len(v))
 cv_dict_full[k] = trailing_zeros+v
 else:
 cv_dict_full[k] = v
 
print(cv_dict_full)
</code></pre>
Here, we simply check if the length of the list in each entry is shorter than the length of the list with the maximum length. If it is, we add the difference between those, in zeros, and append that value to the original list of values.
Now, if we print this new dictionary, we'll see something along the lines of:
<pre><code class="hljs">{
&#x27;Albania&#x27;: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 188, 266, 308, 369, 405, 447, 483, 519, 549, 550, 1127, 1701, 3049, 4177, 6728, 10135, 14295, 15793, 21613],
&#x27;Algeria&#x27;: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 75000],
&#x27;Andorra&#x27;: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 576, 1036, 1291, 1622, 2141, 2390, 2526, 3611, 4914],
...
}
</code></pre>
The country with the most input values is:
<pre><code class="hljs">print(max_key, len(max_value)) # Canada 90
</code></pre>
Now that we've fully prepared our dataset, and we can plot it as we've plotted the Stack Plots before it, let's generate the days and plot:
<pre><code class="hljs">dates = np.arange(0, len(max_value))

fig, ax = plt.subplots()
ax.stackplot(dates, cv_dict_full.values(), labels=cv_dict_full.keys())
ax.legend(loc=&#x27;upper left&#x27;, ncol=4)
ax.set_title(&#x27;Cumulative Covid Vaccinations&#x27;)
ax.set_xlabel(&#x27;Day&#x27;)
ax.set_ylabel(&#x27;Number of people&#x27;)

plt.show()
</code></pre>
Since there's a lot of countries in the world, the legend will be fairly crammed, so we've put it into 4 columns to at least fit in the plot:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-stack-plot-tutorial-and-examples-4.png" alt="matplotlib stackplot covid cases">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to plot simple Stack Plots, as well as how to preprocess datasets and shape data to fit Stack Plots, using Python's Pandas and Matplotlib frameworks.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll take a look at how to plot a stack plot in Matplotlib. We'll cover simple stack plots, and how to import and pre-process a dataset, with examples.

Matplotlib Stack Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
We oftentimes find ourselves counting the number of days from and to a date. Be it calculating when someone's due to return a book, when a subscription should be renewed, how many days have passed since a notification or when a new event is coming up.
In this tutorial, we'll take a look at how to get the number of days between dates in JavaScript.
<h2 id="thedateobjectinjavascript">The Date Object in JavaScript</h2>
A JavaScript <code>Date</code> is the <code>Number</code> of ticks (or milliseconds) that have elapsed since the beginning of the UNIX epoch (midnight on January 1, 1970, UTC).
Even though, at heart, a <code>Date</code> object is defined in terms of UTC, all of its methods fetch times and dates in the local time zone:
<pre><code class="hljs">Date(); // Constructor for a new Date object
Date.now(); // Number of milliseconds elapsed since January 1, 1970 00:00:00 UTC
</code></pre>
Now that we are familiar with the syntax, let's look at how to get the number of days between two dates using the <code>Date</code> object in JavaScript.
<h2 id="numberofdaysbetweendates">Number of Days Between Dates</h2>
To get the number of days between two dates, we'll make a simple function <code>getNumberOfDays()</code>, which accepts two <code>Date</code> objects:
<pre><code class="hljs">function getNumberOfDays(start, end) {
 const date1 = new Date(start);
 const date2 = new Date(end);

 // One day in milliseconds
 const oneDay = 1000 * 60 * 60 * 24;

 // Calculating the time difference between two dates
 const diffInTime = date2.getTime() - date1.getTime();

 // Calculating the no. of days between two dates
 const diffInDays = Math.round(diffInTime / oneDay);

 return diffInDays;
}

console.log(getNumberOfDays(&quot;2/1/2021&quot;, &quot;3/1/2021&quot;));
</code></pre>
This code results in:
<pre><code class="hljs">28
</code></pre>
The function accepts two <code>String</code>s, which represent dates. We firstly create <code>Date</code> objects from these strings, after which, we calculate the number of milliseconds in a day. The <code>getTime()</code> function returns the time in milliseconds, between the start of the Unix epoch and current time. So, if we subtract the <code>start</code> date, from the <code>end</code> date, we'll get the number of milliseconds between them.
We can then turn this number of milliseconds, into days, by dividing it with the number of milliseconds in a day, resulting in the number of days between two dates.
Note: This approach includes the <code>start</code> date, but excludes the <code>end</code> date.
<h2 id="getnumberofdaysbetweendatesinjavascriptwithjsjoda">Get Number of Days Between Dates in JavaScript with <code>js-joda</code></h2>
Developers familiar with Java will likely be familiar with the widely-used <a target="_blank" rel="nofollow noopener" href="https://www.joda.org/joda-time/">Joda-Time</a> library, which was extremely popular before the Java 8 revamp of the Date/Time API.
Joda-Time's influence inspired the creation of <a rel="nofollow noopener" target="_blank" href="https://js-joda.github.io/js-joda/">js-joda</a> - a general purpose date/time library for JavaScript, based on the ISO calendar system.
An added benefit is that it's extremely lightweight and really fast, and compared to other libraries such as Moment.js or <code>date-utils</code>, it provides its own implementation of date/time objects, instead of relying on the <code>Date</code> class from the native JavaScript implementation.
Let's import the library through vanilla JavaScript:
<pre><code class="hljs">&lt;script
 src=&quot;https://cdnjs.cloudflare.com/ajax/libs/js-joda/1.11.0/js-joda.min.js&quot; 
&lt;/script&gt;
</code></pre>
Or, if you're using NPM:
<pre><code class="hljs">$ npm install js-joda
</code></pre>
Now, we can use the <code>js-joda</code> API. Let's rewrite the previous function to use the <code>LocalDate</code> class, courtesy of <code>js-joda</code>:
<pre><code class="hljs">const JSJoda = require(&#x27;js-joda&#x27;);
const LocalDate = JSJoda.LocalDate;

function getNumberOfDays(start, end) {
 const start_date = new LocalDate.parse(start);
 const end_date = new LocalDate.parse(end);

 return JSJoda.ChronoUnit.DAYS.between(start_date, end_date);
}

console.log(getNumberOfDays(&quot;2021-02-01&quot;, &quot;2021-03-01&quot;));
</code></pre>
This also results in:
<pre><code class="hljs">28
</code></pre>
Note: This approach is also exclusive of the <code>end_date</code>.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to get the number of days between dates in JavaScript. Other than the built-in approach, relying on the <code>Date</code> class, we've also explored the <code>js-joda</code> library, which was inspired by the Java-driven Joda-Time library, for a much more succinct approach to solving this problem.

In this tutorial, we'll take a look at how to get the number of days between two dates in JavaScript, using built-in methods, as well as the js-joda library, with examples.