<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>

David Landup

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.

Parse Datetime Strings with parsedatetime in Python

<h2 id="introduction">Introduction</h2>
In this article we'll be taking a look at how to read and write CSV files in Kotlin, specifically, using Apache Commons.
<h2 id="apachecommonsdependency">Apache Commons Dependency</h2>
Since we're working with an external library, let's go ahead and import it into our Kotlin project. If you're using Maven, simply include the <code>commons-csv</code> dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-csv&lt;/artifactId&gt;
 &lt;version&gt;1.5&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or, if you're using Gradle:
<pre><code class="hljs">implementation &#x27;org.apache.commons:commons-csv:1.5&#x27;
</code></pre>
Finally, with the library added to our project, let's define the CSV file we're going to read - <code>students.csv</code>:
<pre><code class="hljs">101,John,Smith,90
203,Mary,Jane,88
309,John,Wayne,96
</code></pre>
It'll be located under <code>/resources/students.csv</code>.
Also, since we'll be reading these records into custom objects, let's make a data class:
<pre><code class="hljs">data class Student (
 val studentId: Int,
 val firstName: String,
 val lastName: String,
 val score: Int
)
</code></pre>
<h2 id="readingacsvfileinkotlin">Reading a CSV File in Kotlin</h2>
Let's first read this file using a <code>BufferedReader</code>, which accepts a <code>Path</code> to the resource we'd like to read:
<pre><code class="hljs">val bufferedReader = new BufferedReader(Paths.get(&quot;/resources/students.csv&quot;));
</code></pre>
Then, once we've read the file into the buffer, we can use the buffer itself to initialize a <code>CSVParser</code> instance:
<pre><code class="hljs">val csvParser = CSVParser(bufferedReader, CSVFormat.DEFAULT);
</code></pre>
Given how volatile the CSV format can be - to remove the guesswork, you'll have to specify the <code>CSVFormat</code> when initializing the parser. This parser, initialized this way, can only then be used for this CSV format.
Since we're following the textbook example of the CSV format, and we're using the default separator, a comma (<code>,</code>) - we'll pass in <code>CSVFormat.DEFAULT</code> as the second argument.
Now, the <code>CSVParser</code> is an <code>Iterable</code>, that contains <code>CSVRecord</code> instances. Each line is a CSV record. Naturally, we can then iterate over the <code>csvParser</code> instance and extract records from it:
<pre><code class="hljs">for (csvRecord in csvParser) {
 val studentId = csvRecord.get(0);
 val studentName = csvRecord.get(1);
 val studentLastName = csvRecord.get(2);
 var studentScore = csvRecord.get(3);
 println(Student(studentId, studentName, studentLastName, studentScore));
}
</code></pre>
For each <code>CSVRecord</code>, you can get its respective cells using the <code>get()</code> method, and passing in the index of the cell, starting at <code>0</code>. Then, we can simply use these in the constructor of our <code>Student</code> data class.
This code results in:
<pre><code class="hljs">Student(studentId=101, firstName=John, lastName=Smith, score=90)
Student(studentId=203, firstName=Mary, lastName=Jane, score=88)
Student(studentId=309, firstName=John, lastName=Wayne, score=96)
</code></pre>
Though, this approach isn't great. We need to know the order of the columns, as well as how many columns there are to use the <code>get()</code> method, and changing anything in the CSV file's structure totally breaks our code.
<h3 id="readingacsvfilewithheadersinkotlin">Reading a CSV File with Headers in Kotlin</h3>
It's reasonable to know what columns exist, but a little less so in which order they're in.
Usually, CSV files have a header line that specifies the names of the columns, such as <code>StudentID</code>, <code>FirstName</code>, etc. When constructing the <code>CSVParser</code> instance, following the <a target="_blank" href="/the-builder-design-pattern-in-java">Builder Design Pattern</a>, we can specify whether the file we're reading has a header row or not, in the <code>CSVFormat</code>.
By default, the <code>CSVFormat</code> assumes that the file doesn't have a header. Let's first add a header row to our CSV file:
<pre><code class="hljs">StudentID,FirstName,LastName,Score
101,John,Smith,90
203,Mary,Jane,88
309,John,Wayne,96
</code></pre>
Now, let's initialize the <code>CSVParser</code> instance, and set a couple of optional options in the <code>CSVFormat</code> along the way:
<pre><code class="hljs">val bufferedReader = new BufferedReader(Paths.get(&quot;/resources/students.csv&quot;));

val csvParser = CSVParser(bufferedReader, CSVFormat.DEFAULT
 .withFirstRecordAsHeader()
 .withIgnoreHeaderCase()
 .withTrim());
</code></pre>
This way, the first record (row) in the file will be treated as the header row, and the values in that row will be used as the column names.
We've also specified that the header case doesn't mean much to us, turning the format into a case-insensitive one.
Finally, we've also told the parser to trim the records, which removes redundant whitespaces from the starts and ends of values if there are any. Some of the other options that you can fiddle around with are options such as:
<pre><code class="hljs">CSVFormat.DEFAULT
 .withDelimiter(&#x27;,&#x27;)
 .withQuote(&#x27;&quot;&#x27;)
 .withRecordSeparator(&quot;\r\n&quot;)
</code></pre>
These are used if you'd like to change the default behavior, such as set a new delimiter, specify how to treat quotes since they can oftentimes break the parsing logic and specify the record separator, present at the end of each record.
Finally, once we've loaded the file in and parsed it with these settings, you can retrieve <code>CSVRecord</code>s as previously seen:
<pre><code class="hljs">for (csvRecord in csvParser) {
 val studentId = csvRecord.get(&quot;StudentId&quot;);
 val studentName = csvRecord.get(&quot;FirstName);
 val studentLastName = csvRecord.get(&quot;LastName);
 var studentScore = csvRecord.get(&quot;Score);
 println(Student(studentId, studentName, studentLastName, studentScore));
}
</code></pre>
This is a much more forgiving approach, since we don't need to know the order of the columns themselves. Even if they get changed at any given time, the <code>CSVParser</code>'s got us covered.
Running this code also results in:
<pre><code class="hljs">Student(studentId=101, firstName=John, lastName=Smith, score=90)
Student(studentId=203, firstName=Mary, lastName=Jane, score=88)
Student(studentId=309, firstName=John, lastName=Wayne, score=96)
</code></pre>
<h2 id="writingacsvfileinkotlin">Writing a CSV File in Kotlin</h2>
Similar to reading files, we can also write CSV files using Apache Commons. This time around, we'll be using the <code>CSVPrinter</code>.
Just how the <code>CSVReader</code> accepts a <code>BufferedReader</code>, the <code>CSVPrinter</code> accepts a <code>BufferedWriter</code>, and the <code>CSVFormat</code> we'd like it to use while writing the file.
Let's create a <code>BufferedWriter</code>, and instantiate a <code>CSVPrinter</code> instance:
<pre><code class="hljs">val writer = new BufferedWriter(Paths.get(&quot;/resources/students.csv&quot;));

val csvPrinter = CSVPrinter(writer, CSVFormat.DEFAULT
 .withHeader(&quot;StudentID&quot;, &quot;FirstName&quot;, &quot;LastName&quot;, &quot;Score&quot;));
</code></pre>
The <code>printRecord()</code> method of the <code>CSVPrinter</code> instance is used to write out records. It accepts all the values for that record and prints it out in a new line. Calling the method over and over allows us to write many records. You can either specify each value in a list, or simply pass in a list of data.
There's no need to use the <code>printRecord()</code> method for the header row itself, since we've already specified it with the <code>withHeader()</code> method of the <code>CSVFormat</code>. Without specifying the header there, we would've had to print out the first row manually.
In general, you can use the <code>csvPrinter</code> like this:
<pre><code class="hljs">csvPrinter.printRecord(&quot;123&quot;, &quot;Jane Maggie&quot;, &quot;100&quot;);
csvPrinter.flush();
csvPrinter.close();
</code></pre>
Don't forget to <code>flush()</code> and <code>close()</code> the printer after use.
Since we're working with a list of students here, and we can't just print the record like this, we'll loop through the student list, put their info into a new list and print that list of data using the <code>printRecord()</code> method:
<pre><code class="hljs">val students = listOf(
 Student(101, &quot;John&quot;, &quot;Smith&quot;, 90), 
 Student(203, &quot;Mary&quot;, &quot;Jane&quot;, 88), 
 Student(309, &quot;John&quot;, &quot;Wayne&quot;, 96)
);

for (student in students) {
 val studentData = Arrays.asList(
 student.studentId,
 student.firstName,
 student.lastName,
 student.score)

 csvPrinter.printRecord(studentData);
}
csvPrinter.flush();
csvPrinter.close();
</code></pre>
This results in a CSV file, that contains:
<pre><code class="hljs">StudentID,FirstName,LastName,Score
101,John,Smith,90
203,Mary,Jane,88
309,John,Wayne,96
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to read and write CSV files in Kotlin, using the Apache Commons library.

In this tutorial, we'll go over how to read and write CSV files in Kotlin, using the Apache Commons library, with examples of reading and writing custom objects.

Reading and Writing CSV Files in Kotlin with Apache Commons

<h2 id="introduction">Introduction</h2>
It's typical for CLI apps to return text in the same color of the terminal. There are always cases when we want to highlight output to the user, for example, a warning or error message. In those cases, a dash of color could make a difference.
This article shows you how to print colored output in the terminal in Python with and without libraries.
<h2 id="ansiescapesequences">ANSI Escape Sequences</h2>
Your Teletypewriter (TTY), or rather your terminal, is not only capable of showing the output of a program. It can display a moving cursor, color the text, clear the entire screen, and much more than just static output. You may have seen command-line utilities with colorful text and progress bars. How do we control the presentation of the data we're outputting to the terminal?
We use ANSI Escape Sequences/Codes. These are special strings that modify the behavior of the terminal. A familiar example would be the <code>\n</code> character, which is a New Line sequence. Entering this character will print a new line in the output.
The text is colored on your terminal based on ANSI Escape sequences. This article focuses on the escape sequences to color text.
Two color schemes are widely used in the terminals:
<ul>
<li>16 colors (8 Background + 8 Foreground)</li>
<li>256 colors</li>
</ul>
Let's begin coloring our output with the 16 color option.
<h2 id="16colorsinrawpython">16 Colors in Raw Python</h2>
The 16 colors scheme comprises two sets of 8 colors each (8 backgrounds and 8 foregrounds) and they can be displayed in the terminal by using the following syntax:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-01.jpg" alt="16 colors syntax">
Let's put this to the test, by printing a cheesy color pattern with a red bold text and yellow background. The style code to represent bold text is <code>2</code>. The color codes for the foreground red text is <code>31</code> and <code>43</code> for the yellow background. So, with that in mind, the syntax for representing this layout is:
<pre><code class="hljs">print(&#x27;\033[2;31;43m CHEESY&#x27;)
</code></pre>
Run the above command in your Python interpreter (or a file). You will see this output:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-02.jpg" alt="16 colors - example1">
That's not quite right, our cheesy text is spilling over to the next line. We need a reset point to stop the printing of colors. This can be done by appending <code>\033[0;0m</code> to the string as:
<pre><code class="hljs">print(&#x27;\033[2;31;43m CHEESY \033[0;0m&#x27;)
</code></pre>
The <code>\033[0;0m</code> code represents a reset pattern that returns the terminal back to its original color scheme. This will provide the following output:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-03.jpg" alt="16 colors - example1">
Looks much better.
<h2 id="16colorsincoloramaabuiltinmodule">16 Colors In Colorama - A Built-in Module</h2>
Colorama is a Python package that provides methods to print colored text in Python. It only supports the 16-colors scheme. The module prepares the ANSI Escape sequences to produce the colored text. Let's install the module with <code>pip</code>:
<pre><code class="hljs">$ pip install colorama
</code></pre>
We recommend you install it within a <a href="/python-virtual-environments-explained/">virtual environment</a>. Once set up, let's get to printing colored text with Colorama:
<pre><code class="hljs"># colorama_demo.py
from colorama import init, Fore, Back, Style

# Initializes Colorama
init(autoreset=True)

print(Style.BRIGHT + Back.YELLOW + Fore.RED + &quot;CHEESY&quot;)
</code></pre>
We first import the functions: <code>init()</code> (to initialize the module and to set the <code>autoreset</code> to <code>True</code> so we don't have to reset it manually), <code>Fore</code> (Foreground text object), <code>Back</code> (Background Object) and <code>Style</code> (Style Object). Each object has its own set of constants that can be called in the <code>print()</code> function.
By appending these components in a human-friendly way, Colorama converts values like <code>YELLOW</code> to <code>43</code>, for the <code>Back</code> object, <code>RED</code> to <code>31</code> for the <code>Fore</code> object, etc. Under the hood, we end up with an ANSI Sequence, just like last time, though, we don't have to know the codes ourselves - Colorama does this for us.
No reset pattern is required, since we've set the <code>autoreset</code> argument to <code>True</code> while initializing the instance.
Running the code will display this:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-04.jpg" alt="Colorama - example">
<h2 id="256colorsinrawpython">256 Colors in Raw Python</h2>
With the advancement in technologies, the 256-color scheme is the most commonly found in terminals. If you are on a Linux based OS, you can check your terminal-supported color scheme by entering the following command:
<pre><code class="hljs">$ echo $TERM
</code></pre>
If this command returns <code>xterm-256color</code>, then your terminal supports a maximum of 256 colors.
<blockquote>
Wondering what those colors are?
</blockquote>
We can dive in right after we understand the syntax of a 256-color scheme. Working with 256 colors is a bit different than working with the 16-color scheme:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-05.jpg" alt="256 colors - syntax">
There's a placeholder to determine whether the color will be applied to the text or the background; 38;5; is for the text and 48;5; is for the background. This is followed by the color code ranging from 0 to 255.
Based on the above syntax, let's try recreating the StackAbuse logo in Python using an ANSI Escape Sequence.
The logo contains a pale gray background (<code>\033[48;5;236m</code>) with the words: Stack in white (<code>\033[38;5;231m</code>) and Abuse in orange (<code>\033[38;5;208m</code>). And of course, the reset code needs to be embedded in the string.
That being said, we can recreate the logo with this ANSI Sequence:
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;\033[48;5;236m\033[38;5;231mStack \033[38;5;208mAbuse\033[0;0m&quot;)
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-06.jpg" alt="Stack Abuse Logo - in Color">
Awesome! What other colors can the terminal print? Let's take a look, by printing all the 256 colors supported by the terminal:
<pre><code class="hljs"># colorspep8.py
def colors_16(color_):
 return(&quot;\033[2;{num}m {num} \033[0;0m&quot;.format(num=str(color_)))


def colors_256(color_):
 num1 = str(color_)
 num2 = str(color_).ljust(3, &#x27; &#x27;)
 if color_ % 16 == 0:
 return(f&quot;\033[38;5;{num1}m {num2} \033[0;0m\n&quot;)
 else:
 return(f&quot;\033[38;5;{num1}m {num2} \033[0;0m&quot;)

print(&quot;The 16 colors scheme is:&quot;)
print(&#x27; &#x27;.join([colors_16(x) for x in range(30, 38)]))
print(&quot;\nThe 256 colors scheme is:&quot;)
print(&#x27; &#x27;.join([colors_256(x) for x in range(256)]))
</code></pre>
This script contains two functions that print the variable you pass into them, in the respective ANSI Escape Sequences. Once we run the script, and pass in <code>x</code> in a certain range, such as <code>(30,38]</code> for the 16-color scheme, or <code>(0-255]</code> for the 256-color scheme, it'll print out the indices in the colors at those values.
This will print out both color-coded schemes in the terminal:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-print-colored-text-in-python-07.jpg" alt="Stack Abuse Logo - in Color">
This can be very helpful as a quick reference while building command-line utilities.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to print colored output, for the characters we send off to the <code>stdout</code> stream. We've explored how to do this using the built-in functionality Python offers, as well as how to use the Colorama library.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

This article shows you how we can print colored output in the terminal with and without Python libraries. Let's dive in by learning how it works!

How to Print Colored Text in Python

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to draw a vertical line on a Matplotlib plot, that allows us to mark and highlight certain regions of the plot, without zooming or <a target="_blank" href="/how-to-set-axis-range-xlim-ylim-in-matplotlib/">changing the axis range</a>.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's first create a simple plot with some random data:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

plt.show()
</code></pre>
Here, we've used NumPy to generate 150 random data points, in a range of <code>[0, 1)</code>.
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-1.png" alt="matplotlib plot random values">
Now, since we've set a <code>seed</code>, we can replicate this random image as many times as we'd like. For example, let's draw vertical lines on the <code>20</code> and <code>100</code> marks.
There are two ways we can draw lines, using the <code>vlines()</code> or <code>axvline()</code> functions of the PyPlot instance. Naturally, you can also call these methods on the <code>Axes</code> object.
<h2 id="drawverticallinesonmatplotlibplotwithpyplotvlines">Draw Vertical Lines on Matplotlib Plot with PyPlot.vlines()</h2>
Let's start off with the <code>vlines()</code> function:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.vlines([20, 100], 0, 1, linestyles=&#x27;dashed&#x27;, colors=&#x27;red&#x27;)

plt.show()
</code></pre>
The <code>vlines()</code> function accepts a few arguments - a scalar, or 1D array of X-values that you'd like to draw lines on. We've supplied <code>[20, 100]</code>, marking two points, though you can go from <code>0..n</code> points here. Then, the <code>ymin</code> and <code>ymax</code> arguments - these are the height of the lines. We've set them to be from <code>0</code> to <code>1</code>, since that's the distribution of the <code>np.random.rand()</code> call as well. Then, you can set styles, such as <code>linestyles</code> or <code>colors</code>, which accept the typical Matplotlib styling options.
Running this code will result in:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-2.png" alt="add vertical lines to matplotlib plot with vlines()">
We've got two vertical lines, which are dashed, in red color, at the <code>20</code> and <code>100</code> points on the X-axis.
This function allows us to set the <code>ymin</code> and <code>ymax</code> in concrete values, while <code>axvline()</code> lets us choose the height percentage-wise, or we simply let it plot from the bottom to the top by default.
This feature comes in handy when you'd like to make the lines shorter or longer, for example. Let's change the range of our Y-axis, to include the view from <code>-10</code> to <code>10</code>, instead of <code>0</code> and <code>1</code>. Our random data will still be in the range from <code>[0, 1)</code> so we'll have a better look at it from a different perspective:
<pre><code class="hljs">fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.set_ylim(-10, 10)
ax.vlines([20, 100], -2, 2, linestyles=&#x27;dashed&#x27;, colors=&#x27;red&#x27;)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-3.png" alt="change axis range and plot vertical lines on matplotlib plot">
Here, we've set the lines to be longer than the range of the random data itself, but still much smaller than the size of the <code>Axes</code> itself.
<h2 id="drawverticallinesonmatplotlibplotwithpyplotaxvline">Draw Vertical Lines on Matplotlib Plot with PyPlot.axvline()</h2>
Now, let's take a look at the <code>axvline()</code> function:
<pre><code class="hljs">fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.set_ylim(-10, 10)
ax.axvline(20, color=&#x27;red&#x27;)
ax.axvline(100, color=&#x27;red&#x27;)

plt.show()
</code></pre>
It has a few limitations that the other function doesn't have, such as being able to only plot on a single point at a time. If we want to plot on multiple points, such as <code>20</code> and <code>100</code>, we'll have to call the function twice.
It also doesn't really let us specify the <code>linestyle</code> like <code>vlines()</code> let us, though, it doesn't require the <code>ymin</code> and <code>ymax</code> arguments by default. If you omit them, like we have, they'll simply be from the top to the bottom of the <code>Axes</code>:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-4.png" alt="draw vertical line on matplotlib plot axvline">
However, you can change the height if you'd like - this time around though, you'll change the height in terms of percentages. These percentages take the top and bottom of the <code>Axes</code> into consideration so 0% will be at the very bottom, while 100% will be at the very top. Let's draw a line spanning from 50% to 80%:
<pre><code class="hljs">fig, ax = plt.subplots(figsize=(12, 6))

np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)

ax.set_ylim(-10, 10)
ax.axvline(20, 0.8, 0.5, color=&#x27;red&#x27;)
ax.axvline(100, 0.8, 0.5, color=&#x27;red&#x27;)
</code></pre>
This produces:
<img src="https://s3.stackabuse.com/media/articles/matplotlib-draw-vertical-lines-on-plot-5.png" alt="set percentage height of vertical plot on matplotlib axvline">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to draw vertical lines on a Matplotlib Plot.
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 draw vertical lines on a Matplotlib plot/axis, in Python, using vlines() and axvline(), with practical examples.

Matplotlib: Draw Vertical Lines on Plot

Ruslan Hasanov

In this tutorial, we’ll learn how to parse, validate and extract phone numbers in Python with the phonenumbers library.