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

Abhilash Kakumanu

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>

David Landup

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.

Validating and Formatting Phone Numbers in Python

Validating and Formatting Phone Numbers in Python with phonenumbers

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kind of operations that lead to the desired result.
The source of these elements is usually a Collection or an Array, from which data is provided to the stream.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result, but do not modify its source.
<h2 id="sortingalistofintegerswithstreamsorted">Sorting a List of Integers with Stream.sorted()</h2>
Found within the <code>Stream</code> interface, the <code>sorted()</code> method has two overloaded variations that we'll be looking into.
Both of these variations are instance methods, which require an object of its class to be created before it can be used:
<pre><code class="hljs">public final Stream&lt;T&gt; sorted() {}
</code></pre>
This methods returns a stream consisting of the elements of the stream, sorted according to natural order - the ordering provided by the JVM. If the elements of the stream are not <code>Comparable</code>, a <code>java.lang.ClassCastException</code> may be thrown upon execution.
Using this method is fairly simple, so let's take a look at a couple of examples:
<pre><code class="hljs">Arrays.asList(10, 23, -4, 0, 18).stream().sorted().forEach(System.out::println);
</code></pre>
Here, we make a <code>List</code> instance through the <code>asList()</code> method, providing a few integers and <code>stream()</code> them. Once streamed, we can run the <code>sorted()</code> method, which sorts these integers naturally. Once sorted, we've just printed them out, each in a line:
<pre><code class="hljs">-4
0
10
18
23
</code></pre>
If we wanted save the results of sorting after the program was executed, we would have to <code>collect()</code> the data back in a <code>Collection</code> (a <code>List</code> in this example), since <code>sorted()</code> doesn't modify the source.
Let's save this result into a <code>sortedList</code>:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(10, 23, -4, 0, 18);
List&lt;Integer&gt; sortedList = list.stream().sorted().collect(Collectors.toList());

System.out.println(list);
System.out.println(sortedList);
</code></pre>
Running this code will produce:
<pre><code class="hljs">[10, 23, -4, 0, 18]
[-4, 0, 10, 18, 23]
</code></pre>
Here we see that the original list stayed unmodified, but we did save the results of the sorting in a new list, allowing us to use both if we need so later on.
<h2 id="sortingalistofintegersindescendingorderwithstreamsorted">Sorting a List of Integers in Descending Order with Stream.sorted()</h2>
<code>Stream.sorted()</code> by default sorts in natural order. In the case of our integers, this means that they're sorted in ascending order.
Sometimes, you might want to switch this up and sort in descending order. There are two simple ways to do this - supply a <code>Comparator</code>, and switch the order, which we'll cover in a later section, or simply use <code>Collections.reverseOrder()</code> in the <code>sorted()</code> call:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(10, 23, -4, 0, 18);
List&lt;Integer&gt; sortedList = list.stream()
 .sorted(Collections.reverseOrder())
 .collect(Collectors.toList());

System.out.println(sortedList);
</code></pre>
This results in:
<pre><code class="hljs">[23, 18, 10, 0, -4]
</code></pre>
<h2 id="sortingalistofstringswithstreamsorted">Sorting a List of Strings with Stream.sorted()</h2>
Though, we don't always just sort integers. Sorting Strings is a tiny bit different, since it's a bit less intuitive on how to compare them.
Here, the <code>sorted()</code> method also follows the natural order, as imposed by the JVM. In case of Strings, they're sorted lexicographically:
<pre><code class="hljs">Arrays.asList(&quot;John&quot;, &quot;Mark&quot;, &quot;Robert&quot;, &quot;Lucas&quot;, &quot;Brandon&quot;).stream().sorted().forEach(System.out::println);
</code></pre>
Running this produces:
<pre><code class="hljs">Brandon
John
Lucas
Mark
Robert
</code></pre>
If we wanted the newly sorted list saved, the same procedure as with the integers applies here:
<pre><code class="hljs">List&lt;String&gt; list = Arrays.asList(&quot;John&quot;, &quot;Mark&quot;, &quot;Robert&quot;, &quot;Lucas&quot;, &quot;Brandon&quot;);
List&lt;String&gt; sortedList = list.stream().sorted().collect(Collectors.toList());

System.out.println(sortedList);
</code></pre>
This results in:
<pre><code class="hljs">[Brandon, John, Lucas, Mark, Robert]
</code></pre>
Sorting Strings in reverse order is as simple as sorting integers in reverse order:
<pre><code class="hljs">List&lt;String&gt; list = Arrays.asList(&quot;John&quot;, &quot;Mark&quot;, &quot;Robert&quot;, &quot;Lucas&quot;, &quot;Brandon&quot;);
List&lt;String&gt; sortedList = list.stream()
 .sorted(Collections.reverseOrder())
 .collect(Collectors.toList());
 
System.out.println(sortedList);
</code></pre>
This results in:
<pre><code class="hljs">[Robert, Mark, Lucas, John, Brandon]
</code></pre>
<h2 id="sortingcustomobjectswithstreamsortedcomparatorsupertcomparator">Sorting Custom Objects with Stream.sorted(Comparator&lt;? super T&gt; comparator)</h2>
In all of the previous examples, we've worked with <code>Comparable</code> types. However, if we're working with some custom objects, which might not be <code>Comparable</code> by design, and would still like to sort them using this method - we'll need to supply a <code>Comparator</code> to the <code>sorted()</code> call.
Let's define a <code>User</code> class, which isn't <code>Comparable</code> and see how we can sort them in a <code>List</code>, using <code>Stream.sorted()</code>:
<pre><code class="hljs">public class User {
 
 private String name;
 private int age;

 // Constructor, getters, setters and toString()
}
</code></pre>
In the first iteration of this example, let's say we want to sort our users by their age. If the age of the users is the same, the first one that was added to the list will be the first in the sorted order. Let's say we have the following code:
Let's sort them by age, first. If their age is the same, the order of insertion to the list is what defines their position in the sorted list:
<pre><code class="hljs">List&lt;User&gt; userList = new ArrayList&lt;&gt;(Arrays.asList(
 new User(&quot;John&quot;, 33), 
 new User(&quot;Robert&quot;, 26), 
 new User(&quot;Mark&quot;, 26), 
 new User(&quot;Brandon&quot;, 42)));

List&lt;User&gt; sortedList = userList.stream()
 .sorted(Comparator.comparingInt(User::getAge))
 .collect(Collectors.toList());

sortedList.forEach(System.out::println);
</code></pre>
When we run this, we get the following output:
<pre><code class="hljs">User:[name: Robert, age: 26]
User:[name: Mark, age: 26]
User:[name: John, age: 33]
User:[name: Brandon, age: 42]
</code></pre>
Here, we've made a list of <code>User</code> objects. We're streaming that list, and using the <code>sorted()</code> method with a <code>Comparator</code>. Specifically, we're using the <code>comparingInt()</code> method, and supplying the user's age, via the <code>User::getAge</code> method reference.
There are a few of these built-in comparators that work with numbers (<code>int</code>, <code>double</code>, and <code>long</code>) - <code>comparingInt()</code>, <code>comparingDouble()</code>, and <code>comparingLong()</code>. Ultimately, you can also just use the <code>comparing()</code> method, which accepts a sorting key function, just like the other ones.
All of them simply return a comparator, with the passed function as the sorting key. In our case, we're using the <code>getAge()</code> method as the sorting key.
We can easily reverse this order as well, simply by chaining the <code>reversed()</code> method after the <code>comparingInt()</code> call:
<pre><code class="hljs">List&lt;User&gt; sortedList = userList.stream()
 .sorted(Comparator.comparingInt(User::getAge).reversed())
 .collect(Collectors.toList());

sortedList.forEach(System.out::println);
</code></pre>
This results in:
<pre><code class="hljs">User:[name: Brandon, age: 42]
User:[name: John, age: 33]
User:[name: Robert, age: 26]
User:[name: Mark, age: 26]
</code></pre>
<h2 id="definingacustomcomparatorwithstreamsorted">Defining a Custom Comparator with Stream.sorted()</h2>
While <code>Comparator</code>s produced by methods such as <code>comparing()</code> and <code>comparingInt()</code>, are super-simple to work with and only require a sorting key - sometimes, the automated behavior is not what we're looking for.
If we sort the <code>User</code>s, and two of them have the same age, they're now sorted by the order of insertion, not their natural order, based on their names. <code>Mark</code> should be before <code>Robert</code>, in a list sorted by name, but in the list we've sorted previously, it's the other way around.
For cases like these, we'll want to write a custom <code>Comparator</code>:
<pre><code class="hljs">List&lt;User&gt; userList = new ArrayList&lt;&gt;(Arrays.asList(
 new User(&quot;John&quot;, 33),
 new User(&quot;Robert&quot;, 26),
 new User(&quot;Mark&quot;, 26),
 new User(&quot;Brandon&quot;, 42)));

List&lt;User&gt; sortedList = userList.stream()
 .sorted((o1, o2) -&gt; {
 if(o1.getAge() == o2.getAge())
 return o1.getName().compareTo(o2.getName());
 else if(o1.getAge() &gt; o2.getAge())
 return 1;
 else return -1;
 })
 .collect(Collectors.toList());

sortedList.forEach(System.out::println);
</code></pre>
And now, when we execute this code, we've got the natural order of names, as well as ages, sorted:
<pre><code class="hljs">User:[name: Mark, age: 26]
User:[name: Robert, age: 26]
User:[name: John, age: 33]
User:[name: Brandon, age: 42]
</code></pre>
Here, we've used a Lambda expression to create a new <code>Comparator</code> implicitly and defined the logic for sorting/comparison. Returning a positive number indicates that an element is greater than another. Returning a negative number indicates that an element is lesser than another.
We've used the respective comparison approaches for the names and ages - comparing names lexicographically using <code>compareTo()</code>, if the <code>age</code> values are the same, and comparing ages regularly via the <code>&gt;</code> operator.
If you're not used to Lambda expressions, you can create a <code>Comparator</code> beforehand, though, for the sake of code readability, it's advised to shorten it to a Lambda:
<pre><code class="hljs">Comparator&lt;User&gt; customComparator = new Comparator&lt;User&gt;() {
 @Override
 public int compare(User o1, User o2) {
 if(o1.getAge() == o2.getAge())
 return o1.getName().compareTo(o2.getName());
 else if(o1.getAge() &gt; o2.getAge())
 return 1;
 else return -1;
 }
};

List&lt;User&gt; sortedList = userList.stream()
 .sorted(customComparator)
 .collect(Collectors.toList());
</code></pre>
You can also technically make an anonymous instantiation of the comparator in the <code>sorted()</code> call:
<pre><code class="hljs">List&lt;User&gt; sortedList = userList.stream()
 .sorted(new Comparator&lt;User&gt;() {
 @Override
 public int compare(User o1, User o2) {
 if(o1.getAge() == o2.getAge())
 return o1.getName().compareTo(o2.getName());
 else if(o1.getAge() &gt; o2.getAge())
 return 1;
 else return -1;
 }
 })
 .collect(Collectors.toList());
</code></pre>
And this anonymous call is exactly what gets shortened to the Lambda expression from the first approach.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've covered everything you need to know about the <code>Stream.sorted()</code> method. We've sorted <code>Comparable</code> integers and Strings, in ascending and descending order, as well as used a built-in <code>Comparator</code> for custom objects.
Finally, we've used a custom <code>Comparator</code> and defined custom sorting logic.

Branko Ilic

In this tutorial guide, we'll cover everything you need to know about the Stream.sorted() API. We'll sort integers, strings and custom objects in ascending and descending order as well as define custom comparators in Java.

Java 8 – How to Sort List with Stream.sorted()

Darinka Zobenica

In this guide, we'll cover the theory and implementation of K-Means clustering, using Core Java, with practical examples and pros and cons of the algorithm.