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.

Abhilash Kakumanu

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.

JavaScript: Get Number of Days Between Dates

<h2 id="introduction">Introduction</h2>
Arrays are one the most used structures in JavaScript programming, which is why it's important to know its built-in methods like the back of your pocket.
In this tutorial, we'll take a look at how to split an array into chunks of <code>n</code> size in JavaScript.
Specifically, we'll take a look at two approaches:
<ol>
<li>Using the <code>slice()</code> method and a <code>for</code> loop</li>
<li>Using the <code>splice()</code> method and a <code>while</code> loop</li>
</ol>
<h2 id="splittingthearrayintoevenchunksusingslicemethod">Splitting the Array Into Even Chunks Using slice() Method</h2>
The easiest way to extract a chunk of an array, or rather, to slice it up, is the <code>slice()</code> method:
<blockquote>
<code>slice(start, end)</code> - Returns a part of the invoked array, between the <code>start</code> and <code>end</code> indices.
</blockquote>
Note: Both <code>start</code> and <code>end</code> can be negative integers, which just denotes that they're enumerated from the end of the array. <code>-1</code> being the last element of the array, <code>-2</code> being the next to last and so on...
The array returned by <code>slice()</code> returns a shallow copy, meaning that any references within the original array will just be copied over as-is, and won't allocate memory for completely new objects.
So, to slice a list or array into even chunks, let's use the <code>slice()</code> method:
<pre><code class="hljs">function sliceIntoChunks(arr, chunkSize) {
 const res = [];
 for (let i = 0; i &lt; arr.length; i += chunkSize) {
 const chunk = arr.slice(i, i + chunkSize);
 res.push(chunk);
 }
 return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));
</code></pre>
Running the code above yields the following output:
<pre><code class="hljs">[[ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ], [ 10 ]]
</code></pre>
In the code above, we break down <code>arr</code> into smaller chunks of size <code>3</code>, by iterating through the array and slicing it every <code>chunkSize</code>. In the last iteration, there'll be only one element (<code>10</code>) left, which will have to make up its own chunk.
<h2 id="splittingthearrayintoevenchunksusingsplicemethod">Splitting the Array Into Even Chunks Using splice() Method</h2>
Even though the <code>splice()</code> method may seem similar to the <code>slice()</code> method, its use and side-effects are very different. Let's take a closer look:
<pre><code class="hljs">// Splice does the following two things:
// 1. Removes deleteCount elements starting from startIdx (in-place)
// 2. Inserts the provided new elements (newElem1, newElem2...) into myArray starting with index startIdx (also in-place)
// The return value of this method is an array that contains all the deleted elements
myArray.splice(startIdx, deleteCount, newElem1, newElem2...)

let arrTest = [2, 3, 1, 4]
let chunk = arrTest.splice(0,2)
console.log(chunk) // [2, 3]
console.log(arrTest) // [1, 4]
</code></pre>
Let's see this in action through a code example:
<pre><code class="hljs">function spliceIntoChunks(arr, chunkSize) {
 const res = [];
 while (arr.length &gt; 0) {
 const chunk = arr.splice(0, chunkSize);
 res.push(chunk);
 }
 return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(spliceIntoChunks(arr, 2));
</code></pre>
Running this code yields:
<pre><code class="hljs">[ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ]
</code></pre>
Here we are using a <code>while</code> loop to traverse the array. In each iteration we perform the splicing operation and push each chunk into a resulting array until there are no more elements left in the original array (<code>arr.length &gt; 0</code>).
A very important thing to note is that <code>splice()</code> changes the original array. where as <code>slice()</code> creates a copy of the original array, so there won't be any change in the original one.
<h2 id="conclusion">Conclusion</h2>
In this article, we have went over a couple of easy ways to split a list into even chunks in JavaScript. While doing so, we learned how to work with couple of built-in array methods like <code>slice()</code> and <code>splice()</code>.

In this tutorial, we'll take a look at how to split an array or list into even chunks of N size in JavaScript, using slice() and splice(), with examples.

How to Split an Array Into Even Chunks in JavaScript

How to Split an Array into Even Chunks in JavaScript

<h2 id="introduction">Introduction</h2>
In JavaScript, an object is defined as a collection of key-value pairs. An object is also a non-primitive data type.
You'll oftentimes need to combine objects into a single one which contains all the individual properties of its constituent parts. This operation is called merging. The two most common ways of doing this are:
<ul>
<li>Using the spread operator (<code>...</code>)</li>
<li>Using the <code>Object.assign()</code> method</li>
</ul>
In this tutorial, we'll take a look at how to merge two objects dynamically in JavaScript.
After that, we'll cover the difference between shallow merge and deep merge, because it is essential to fully understanding object merging.
<h2 id="mergejavascriptobjectsusingthespreadoperator">Merge JavaScript Objects Using the Spread Operator</h2>
We can merge different objects into one using <a target="_blank" href="/spread-operator-in-javascript/">the spread operator (<code>...</code>)</a>. This is also the most common method of merging two or more objects.
This is an immutable approach to merging two objects, i.e., the starting two objects which are used to make the merged one are not changed in any way due to side effects. In the end, you've got a new object, constructed from the two, while they're still intact.
Let's create two objects and merge them:
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;,
 age: 24
}
const job = {
 title: &quot;Full stack developer&quot;,
 location: &quot;Remote&quot;
}

const employee = {...person, ...job};

console.log(employee);
</code></pre>
This results in:
<pre><code class="hljs">{
 name: &quot;John Doe&quot;, 
 age: 24, 
 title: &quot;Full stack developer&quot;, 
 location: &quot;Remote&quot;
}
</code></pre>
Note: If there are common properties between these two objects, such as both of them having a <code>location</code>, the properties from the second object (<code>job</code>) will overwrite the properties of the first object (<code>person</code>):
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;,
 location: &quot;Remote&quot;
}
const job = {
 title: &quot;Full stack developer&quot;,
 location: &quot;Office&quot;
}
const employee = {...person, ...job}

console.log(employee);
</code></pre>
This results in:
<pre><code class="hljs">{
 name: &#x27;John Doe&#x27;,
 location: &#x27;Office&#x27;,
 title: &#x27;Full stack developer&#x27;
}
</code></pre>
If more than two objects are being merged, the rightmost object overrides the ones to the left.
<h2 id="mergejavascriptobjectsusingobjectassign">Merge JavaScript Objects Using Object.assign()</h2>
Another common way to merge two or more objects is to use the built-in <code>Object.assign()</code> method:
<pre><code class="hljs">Object.assign(target, source1, source2, ...);
</code></pre>
This method copies all the properties from one or more source objects into the target object. Just like with the spread operator, while overwriting, the right-most value is used:
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;, 
 age: 24,
 location: &quot;U.S.A&quot;
}
const job = {
 title: &quot;Full stack developer&quot;,
 location: &quot;Remote&quot;
}

const employee = Object.assign(person, job);

console.log(employee);
</code></pre>
Running the code above will result in the following output:
<pre><code class="hljs">{
 name: &quot;John Doe&quot;, 
 age: 24,
 location: &quot;Remote&quot;,
 title: &quot;Full stack developer&quot;
}
</code></pre>
Again, keep in mind that the object referenced by <code>employee</code> is a completely new object, and is in no way linked to the objects referenced by <code>person</code> or <code>job</code>.
<h2 id="shallowmergevsdeepmerge">Shallow Merge vs Deep Merge</h2>
In the case of a shallow merge, if one of the properties on a source object is another object, the target object contains the reference to the same object that exists in the source object. A new object is not created in this case.
Let's tweak the previous <code>person</code> object, and make <code>location</code> an object for itself:
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;,
 location: {
 city: &quot;London&quot;, 
 country: &quot;England&quot;
 }
}
const job = {
 title: &quot;Full stack developer&quot;
}

const employee = {...person, ...job};

console.log(employee.location === person.location);
</code></pre>
This results in:
<pre><code class="hljs">true
</code></pre>
We can see that the reference to the <code>location</code> object in both <code>person</code> and <code>employee</code> object is the same. In fact, both the spread operator (<code>...</code>) and <code>Object.assign()</code> perform a shallow merge.
JavaScript has no deep merge support out of the box. However, there are third-party modules and libraries which do support it, like Lodash's <a class="udemy-link" rel="nofollow" target="_blank" href="https://www.npmjs.com/package/lodash.merge">_.merge</a>.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to merge two objects in JavaScript. We've explored the spread operator (<code>...</code>) and the <code>Object.assign()</code> method, which both perform a shallow merge of two or more objects, into a new one, without affecting the constituent parts.
<h2 id="introduction">Introduction</h2>
In JavaScript, an object is defined as a collection of key-value pairs. An object is also a non-primitive data type.
You'll oftentimes need to combine objects into a single one which contains all the individual properties of its constituent parts. This operation is called merging. The two most common ways of doing this are:
<ul>
<li>Using the spread operator (<code>...</code>)</li>
<li>Using the <code>Object.assign()</code> method</li>
</ul>
In this tutorial, we'll take a look at how to merge two objects dynamically in JavaScript.
After that, we'll cover the difference between shallow merge and deep merge, because it is essential to fully understanding object merging.
<h2 id="mergejavascriptobjectsusingthespreadoperator">Merge JavaScript Objects Using the Spread Operator</h2>
We can merge different objects into one using <a target="_blank" href="/spread-operator-in-javascript/">the spread operator (<code>...</code>)</a>. This is also the most common method of merging two or more objects.
This is an immutable approach to merging two objects, i.e., the starting two objects which are used to make the merged one are not changed in any way due to side effects. In the end, you've got a new object, constructed from the two, while they're still intact.
Let's create two objects and merge them:
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;,
 age: 24
}
const job = {
 title: &quot;Full stack developer&quot;,
 location: &quot;Remote&quot;
}

const employee = {...person, ...job};

console.log(employee);
</code></pre>
This results in:
<pre><code class="hljs">{
 name: &quot;John Doe&quot;, 
 age: 24, 
 title: &quot;Full stack developer&quot;, 
 location: &quot;Remote&quot;
}
</code></pre>
Note: If there are common properties between these two objects, such as both of them having a <code>location</code>, the properties from the second object (<code>job</code>) will overwrite the properties of the first object (<code>person</code>):
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;,
 location: &quot;Remote&quot;
}
const job = {
 title: &quot;Full stack developer&quot;,
 location: &quot;Office&quot;
}
const employee = {...person, ...job}

console.log(employee);
</code></pre>
This results in:
<pre><code class="hljs">{
 name: &#x27;John Doe&#x27;,
 location: &#x27;Office&#x27;,
 title: &#x27;Full stack developer&#x27;
}
</code></pre>
If more than two objects are being merged, the rightmost object overrides the ones to the left.
<h2 id="mergejavascriptobjectsusingobjectassign">Merge JavaScript Objects Using Object.assign()</h2>
Another common way to merge two or more objects is to use the built-in <code>Object.assign()</code> method:
<pre><code class="hljs">Object.assign(target, source1, source2, ...);
</code></pre>
This method copies all the properties from one or more source objects into the target object. Just like with the spread operator, while overwriting, the right-most value is used:
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;, 
 age: 24,
 location: &quot;U.S.A&quot;
}
const job = {
 title: &quot;Full stack developer&quot;,
 location: &quot;Remote&quot;
}

const employee = Object.assign(person, job);

console.log(employee);
</code></pre>
Running the code above will result in the following output:
<pre><code class="hljs">{
 name: &quot;John Doe&quot;, 
 age: 24,
 location: &quot;Remote&quot;,
 title: &quot;Full stack developer&quot;
}
</code></pre>
Again, keep in mind that the object referenced by <code>employee</code> is a completely new object, and is in no way linked to the objects referenced by <code>person</code> or <code>job</code>.
<h2 id="shallowmergevsdeepmerge">Shallow Merge vs Deep Merge</h2>
In the case of a shallow merge, if one of the properties on a source object is another object, the target object contains the reference to the same object that exists in the source object. A new object is not created in this case.
Let's tweak the previous <code>person</code> object, and make <code>location</code> an object for itself:
<pre><code class="hljs">const person = {
 name: &quot;John Doe&quot;,
 location: {
 city: &quot;London&quot;, 
 country: &quot;England&quot;
 }
}
const job = {
 title: &quot;Full stack developer&quot;
}

const employee = {...person, ...job};

console.log(employee.location === person.location);
</code></pre>
This results in:
<pre><code class="hljs">true
</code></pre>
We can see that the reference to the <code>location</code> object in both <code>person</code> and <code>employee</code> object is the same. In fact, both the spread operator (<code>...</code>) and <code>Object.assign()</code> perform a shallow merge.
JavaScript has no deep merge support out of the box. However, there are third-party modules and libraries which do support it, like Lodash's <a class="udemy-link" rel="nofollow" target="_blank" href="https://www.npmjs.com/package/lodash.merge">_.merge</a>.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to merge two objects in JavaScript. We've explored the spread operator (<code>...</code>) and the <code>Object.assign()</code> method, which both perform a shallow merge of two or more objects, into a new one, without affecting the constituent parts.

In this tutorial, we'll go over how to merge two objects dynamically in JavaScript, using the spread operator and the Object.assign() method, with practical examples.

Merge Properties of Two Objects Dynamically in JavaScript

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to parse Datetime with <code>parsedatetime</code> in Python.
To use the <code>parsedatetime</code> package we first need to install it using pip:
<pre><code class="hljs">$ pip install parsedatetime
</code></pre>
Should <code>pip install parsedatetime</code> fail, the package is also open-source and available on <a rel="nofollow noopener" target="_blank" href="https://github.com/bear/parsedatetime">GitHub</a>.
<h2 id="convertstringtopythonsdatetimeobjectwithparsedatetime">Convert String to Python's Datetime Object with parsedatetime</h2>
The first, and most common way to use <code>parsedatetime</code> is to parse a string into a <code>datetime</code> object. First, you'll want to import the <code>parsedatetime</code> library, and instantiate a <code>Calendar</code> object, which does the actual input, parsing and manipulation of dates:
<pre><code class="hljs">import parsedatetime
calendar = parsedatetime.Calendar()
</code></pre>
Now we can call the <code>parse()</code> method of the <code>calendar</code> instance with a string as an argument. You can put in regular datetime-formatted strings, such as <code>1-1-2021</code> or human-readable values such as <code>tomorrow</code>, <code>yesterday</code>, <code>next year</code>, <code>last week</code>, <code>lunch tomorrow</code>, etc... We can also use <code>'End of Day'</code> structures with <code>tomorrow eod</code>
Let's convert a datetime and human-readable string to a <code>datetime</code> object using <code>parsedatetime</code>:
<pre><code class="hljs">import parsedatetime
from datetime import datetime

calendar = parsedatetime.Calendar()

print(calendar.parse(&#x27;tomorrow&#x27;))
print(calendar.parse(&#x27;1-1-2021&#x27;))
</code></pre>
This results in two printed tuples:
<pre><code class="hljs">(time.struct_time(tm_year=2021, tm_mon=3, tm_mday=19, tm_hour=9, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=78, tm_isdst=-1), 1)
(time.struct_time(tm_year=2021, tm_mon=1, tm_mday=1, tm_hour=18, tm_min=5, tm_sec=14, tm_wday=3, tm_yday=77, tm_isdst=0), 1)
</code></pre>
This isn't very human-readable... The returned tuple for each conversion consists of the <code>struct_time</code> object, which contains information like the year, month, day of month, etc. The second value is the status code - an integer denoting how the conversion went.
<code>0</code> means unsuccessful parsing, <code>1</code> means successful parsing to a <code>date</code>, <code>2</code> means successful parsing to a <code>time</code> and <code>3</code> means successful parsing to a <code>datetime</code>.
Let's parse this output:
<pre><code class="hljs">print(calendar.parse(&#x27;tomorrow&#x27;)[0].tm_mday)
print(calendar.parse(&#x27;1-1-2021&#x27;)[0].tm_mday)
</code></pre>
This code results in:
<pre><code class="hljs">19
1
</code></pre>
Then again, we're only getting the day of the month here. Usually, we'd like to output something similar to a <code>YYYY-mm-dd HH:mm:ss</code> format, or any variation of that.
Thankfully, we can easily use the <code>time.struct_time</code> result and generate a regular Python <code>datetime</code> with it:
<pre><code class="hljs">import parsedatetime
from datetime import datetime

calendar = parsedatetime.Calendar()

time_structure_tomorrow, parse_status_tomorrow = calendar.parse(&#x27;tomorrow&#x27;)
time_structure_2021, parse_status_2021 = calendar.parse(&#x27;1-1-2021&#x27;)

print(datetime(*time_structure_tomorrow[:6]))
print(datetime(*time_structure_2021[:6]))
</code></pre>
The <code>datetime()</code> constructor doesn't need all of the information from the time structure provided by <code>parsedatetime</code>, so we sliced it.
This code results in:
<pre><code class="hljs">2021-03-19 09:00:00
2021-01-01 18:11:06
</code></pre>
Keep in mind that the <code>datetime</code> on the 1st of January took the time of execution into consideration.
<h2 id="handlingtimezones">Handling Timezones</h2>
Sometimes, your application might have to take the timezones of your end-users into consideration. For timezone-support, we usually use the Pytz package, though, you can use other packages as well.
Let's install Pytz via <code>pip</code>:
<pre><code class="hljs">$ pip install pytz
</code></pre>
Now, we can import the <code>parsedatetime</code> and <code>pytz</code> packages into a script, and create a standard <code>Calendar</code> instance:
<pre><code class="hljs">import parsedatetime
import pytz
from pytz import timezone

calendar = parsedatetime.Calendar()
</code></pre>
Let's take a look at the supported timezones, by printing out <code>all_timezones</code>:
<pre><code class="hljs">print(pytz.all_timezones)
</code></pre>
This code will result in a huge list of all available timezones:
<pre><code class="hljs">[&#x27;Africa/Abidjan&#x27;, &#x27;Africa/Accra&#x27;, &#x27;Africa/Addis_Ababa&#x27;, &#x27;Africa/Algiers&#x27;, ...]
</code></pre>
Let's choose one of these, such as the first one, and pass it in as the <code>tzinfo</code> argument of <code>Calendar</code>'s <code>parseDT()</code> function. Other than that, we'll want to supply a <code>datetimeString</code> argument, which is the actual string we want to parse:
<pre><code class="hljs">datetime_object, status = calendar.parseDT(datetimeString=&#x27;tomorrow&#x27;, tzinfo=timezone(&#x27;Africa/Abidjan&#x27;))
</code></pre>
This method returns a tuple of a <code>Datetime</code> object, and the status code of the conversion, which is an integer - <code>1</code> meaning &quot;successful&quot;, and <code>0</code> meaning &quot;unsuccessful&quot;.
Let's go ahead and print the <code>datetime_object</code>:
<pre><code class="hljs">print(datetime_object)
</code></pre>
This code results in:
<pre><code class="hljs">2021-03-16 09:00:00+00:00
</code></pre>
<h2 id="calendarparsedate">Calendar.parseDate()</h2>
While <code>Calendar.parse()</code> is a general-level parsing method, that returns a tuple with the status code and <code>time.struct_time</code>, the <code>parseDate()</code> method is a method dedicated to short-form string dates, and simply returns a human-readable result:
<pre><code class="hljs">import parsedatetime
calendar = parsedatetime.Calendar()

result = calendar.parseDate(&#x27;5/5/91&#x27;)
print(result)
</code></pre>
The <code>result</code> now contains the calculated <code>struct_time</code> value of the date we've passed in:
<pre><code class="hljs">(1991, 5, 5, 14, 31, 18, 0, 74, 0)
</code></pre>
But, what do we do when we want to parse the 5th of May 2077? We can try to run the following code:
<pre><code class="hljs">import parsedatetime
calendar = parsedatetime.Calendar()
result = calendar.parseDate(&#x27;5/5/77&#x27;)
print(result)
</code></pre>
However, this code will result in:
<pre><code class="hljs">(1977, 5, 5, 14, 36, 21, 0, 74, 0)
</code></pre>
<code>Calendar.parseDate()</code> mistook the short-form date, for a more realistic <code>1977</code>. We can solve this in two ways:
<ul>
<li>Simply specify the full year - <code>2077</code>:</li>
</ul>
<pre><code class="hljs">import parsedatetime
calendar = parsedatetime.Calendar()
result = calendar.parseDate(&#x27;5/5/2077&#x27;)
print(result)
</code></pre>
<ul>
<li>Use a <code>BirthdayEpoch</code>:</li>
</ul>
<pre><code class="hljs">import parsedatetime
constants = parsedatetime.Constants()
constants.BirthdayEpoch = 80

# Pass our new constants to the Calendar
calendar = parsedatetime.Calendar(constants)
result = calendar.parseDate(&#x27;5/5/77&#x27;)
print(result)
</code></pre>
This code will result in:
<pre><code class="hljs">(2077, 5, 5, 14, 39, 47, 0, 74, 0)
</code></pre>
You can access the contents of the <code>parsedatetime</code> library through the <code>Constants</code> object. Here, we've set the <code>BirthdayEpoch</code> to <code>80</code>.
<code>BirthdayEpoch</code> controls how the package handles two-digit years, such as <code>77</code>. If the parsed value is lesser than the value we've set for the <code>BirthdayEpoch</code> - it'll add the parsed value to <code>2000</code>. Since we've set the <code>BirthdayEpoch</code> to <code>80</code>, and parsed <code>77</code>, it converts it to <code>2077</code>.
Otherwise, it'll add the parsed value to <code>1900</code>.
<h2 id="calendarparsedatetext">Calendar.parseDateText()</h2>
Another alternative to dealing with the issue of mistaken short-form dates is to, well, use long-form dates. For long-form dates, you can use the <code>parseDateText()</code> method:
<pre><code class="hljs">import parsedatetime

result2 = calendar.parseDateText(&#x27;May 5th, 1991&#x27;)
print(result2)
</code></pre>
This code will result in:
<pre><code class="hljs">(1991, 5, 5, 14, 31, 46, 0, 74, 0)
</code></pre>
<h2 id="usinglocales">Using Locales</h2>
Finally, we can use <code>parsedatetime</code> with locale information. The locale information comes from either <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/PyICU/">PyICU</a> or the previously used <code>Constants</code> class.
The <code>Constants</code> inner class has a lot of attributes, just like the <code>BirthdayEpoch</code> attribute. Two of these are <code>localeID</code> and <code>userPyICU</code>.
Let's try setting the <code>localeId</code> to Spanish and set the <code>usePyICU</code> to <code>False</code> since we won't use it:
<pre><code class="hljs">import parsedatetime

constants = parsedatetime.Constants(localeID=&#x27;es&#x27;, usePyICU=False)
calendar = parsedatetime.Calendar(constants)
result, code = calendar.parse(&#x27;Marzo 28&#x27;)
print(result)
</code></pre>
This results in:
<pre><code class="hljs">(time.struct_time(tm_year=2021, tm_mon=3, tm_mday=28, tm_hour=15, tm_min=0, tm_sec=5, tm_wday=0, tm_yday=74, tm_isdst=0), 1)
</code></pre>
The method returns a <code>struct_time</code>, so we can easily convert it into a <code>datetime</code>:
<pre><code class="hljs">print(datetime(*result[:6]))
</code></pre>
This results in:
<pre><code class="hljs">2021-03-28 22:08:40
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to parse datetime using the <code>parsedatetime</code> package in Python.
We went over the conversion between strings and <code>datetime</code> objects through <code>parsedatetime</code>, as well as handling timezones with <code>pytz</code> and locales, using the <code>Constants</code> instance of the <code>parsedatetime</code> library.

Guest Contributor

In this tutorial, we'll take a look at how to parse datetime strings in Python with parsedatetime, including timezones and locales, with examples.