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

Guide to K-Means Clustering in Java

Guide to K-Means Clustering with Java

<h2 id="introduction">Introduction</h2>
At some point in your software development path, you'll have to convert files from one format to another.
DOCX (used by Microsoft Word) is a pretty common file format for a lot of people to use. And sometimes, we'd like to convert Word Documents into HTML.
This can easily be achieved via the Mammoth package. It's an easy, efficient, and fast library used to convert DOCX files to HTML. In this article, we'll learn how to use Mammoth in Python to convert DOCX to HTML.
<h2 id="installingmammoth">Installing Mammoth</h2>
As a good practice, remember to have your <a href="/python-virtual-environments-explained/" target="_blank">virtual environment</a> ready and activated before the installation:
<pre><code class="hljs">$ python3 -m venv myenv
$ . myenv/bin/activate
</code></pre>
Let's then install Mammoth with <code>pip</code>:
<pre><code class="hljs">$ pip3 install mammoth
</code></pre>
This tutorial uses the Mammoth version <code>1.4.15</code>. Here's a <a href="https://github.com/rhasoff/SA-Convert-Docx-To-Html-With-Python-Mammoth/raw/main/file-sample_100kB.docx" target="_blank" rel="noopener nofollow">sample document</a> you can use throughout this tutorial. If you have a document to convert, make sure that it's a <code>.docx</code> file!
Now that you're ready to go, let's get started with extracting the text and writing that as HTML.
<h2 id="extracttherawtextofadocxfile">Extract the Raw Text of a DOCX File</h2>
Preserving the formatting while converting to HTML is one of the best features of Mammoth. However, if you just need the text of the DOCX file, you'll be pleasantly surprised at how few lines of code are needed.
You can use the <code>extract_raw_text()</code> method to retrieve it:
<pre><code class="hljs">import mammoth

with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.extract_raw_text(docx_file)
 text = result.value # The raw text
 with open(&#x27;output.txt&#x27;, &#x27;w&#x27;) as text_file:
 text_file.write(text)
</code></pre>
Note that this method does not return a valid HTML document. It only returns the text on the page, hence why we save it with the <code>.txt</code> extension. If you do need to keep the layout and/or formatting, you'll want to extract the HTML contents.
<h2 id="convertdocxtohtmlwithcustomstylemapping">Convert Docx to HTML with Custom Style Mapping</h2>
By default, Mammoth converts your document into HTML but it does not give you a valid HTML page. While web browsers can display the content, it is missing an <code>&lt;html&gt;</code> tag to encapsulate the document, and a <code>&lt;body&gt;</code> tag to contain the document. How you choose to integrate its output is up to you. Let's say you're using a web framework that has templates. You'd likely define a template to display a Word Document and load Mammoth's output inside the template's body.
Mammoth is not only flexible with how you can use its output but how you can create it as well. In Particular, we have a lot of options when we want to style the HTML we produce. We map styles by matching each DOCX formatting rule to the equivalent (or as close as we can get) CSS rule.
To see what styles your DOCX file has, you have two options:
<ol>
<li>You can open your docx file with MS Word and check the Styles toolbar.</li>
<li>You can dig into the XML files by opening your DOCX file with an archive manager, and then navigate to the <code>/word/styles.xml</code> and locate your styles.</li>
</ol>
The second option can be used by those who don't have access to MS Word or an alternative word processor that can interpret and display the styles.
Mammoth already has some of the most common style maps covered by default. For instance, the <code>Heading1</code> docx style is mapped to the <code>&lt;h1&gt;</code> HTML element, bold is mapped to the <code>&lt;strong&gt;</code> HTML element, etc.
We can also use Mammoth to customize the document's styles while mapping them. For example, if you wanted to change all bold occurrences in the DOCX file to italic in the HTML, you can do this:
<pre><code class="hljs">import mammoth

custom_styles = &quot;b =&gt; i&quot;

with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.convert_to_html(docx_file, style_map = custom_styles)
 text = result.value
 with open(&#x27;output.html&#x27;, &#x27;w&#x27;) as html_file:
 html_file.write(text)
</code></pre>
With the <code>custom_styles</code> variable, the style on the left is from the DOCX file, while the one on the right is the corresponding CSS.
Let's say we wanted to omit the bold occurrences altogether, we can leave the mapping target blank:
<pre><code class="hljs">custom_styles = &quot;b =&gt; &quot;
</code></pre>
Sometimes the document we're porting has many styles to retain. It quickly becomes impractical to create a variable for every style we want to map. Luckily we can use <code>docstrings</code> to map as many styles as we want in one go:
<pre><code class="hljs">custom_styles = &quot;&quot;&quot; b =&gt; del
 u =&gt; em
 p[style-name=&#x27;Heading 1&#x27;] =&gt; i&quot;&quot;&quot;
</code></pre>
You may have noticed that the last mapping was a bit different from the others. When mapping styles, we can use square brackets <code>[]</code> with a condition inside them so that only a subset of elements are styled that way.
In our example, <code>p[style-name='Heading 1']</code> selects paragraphs that have a style name <code>Heading 1</code>. We can also use <code>p[style-name^='Heading']</code> to select each paragraph that has a style name starting with <code>Heading</code>.
Style mapping also allows us to map styles to custom CSS classes. By doing so, we can shape the style of HTML as we like. Let's do an example where we define our basic custom CSS in a docstring like this:
<pre><code class="hljs">custom_css =&quot;&quot;&quot;
 &lt;style&gt;
 .red{
 color: red;
 }
 .underline{
 text-decoration: underline;
 }
 .ul.li{
 list-style-type: circle;
 }
 table, th, td {
 border: 1px solid black;
 }
 &lt;/style&gt;
 &quot;&quot;&quot;
</code></pre>
Now we can update our mapping to reference the CSS classes we've defined in the <code>&lt;style&gt;</code> block:
<pre><code class="hljs">custom_styles = &quot;&quot;&quot; b =&gt; b.red
 u =&gt; em.red
 p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.red.underline&quot;&quot;&quot;
</code></pre>
Now all we need to do is merge the CSS and the HTML together:
<pre><code class="hljs">edited_html = custom_css + html
</code></pre>
If your DOCX file has any of those elements, you will be able to see the results.
Now that we know how to map styles, let's use a more well-known CSS framework (along with the JS) to give our HTML a better look and practice a more likely real-life scenario.
<h3 id="mappingstyleswithbootstraporanyotheruiframework">Mapping Styles with Bootstrap (or Any Other UI Framework)</h3>
Just like we did with the <code>custom_css</code>, we need to ensure that the CSS is loaded with the HTML. We need to add the Bootstrap file URI or CDN to our HTML:
<pre><code class="hljs">bootstrap_css = &#x27;&lt;link href=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css&quot; rel=&quot;stylesheet&quot; integrity=&quot;sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl&quot; crossorigin=&quot;anonymous&quot;&gt;&#x27;
bootstrap_js = &#x27;&lt;script src=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js&quot; integrity=&quot;sha384-b5kHyXgcpbZJO/tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;&#x27;
</code></pre>
We'll also slightly tweak our <code>custom_styles</code> to match our new CSS classes:
<pre><code class="hljs">custom_styles = &quot;&quot;&quot; b =&gt; b.mark
 u =&gt; u.initialism
 p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.card
 table =&gt; table.table.table-hover
 &quot;&quot;&quot;
</code></pre>
In the first line, we're mapping bold DOCX style to the <code>b</code> HTML element with a class <code>mark</code>, which is a Bootstrap class equivalent of the HTML <code>&lt;mark&gt;</code> tag, used for highlighting part of the text.
In the second line, we're adding the <code>initialism</code> class to the <code>u</code> HTML element, slightly decreasing the font size and transforming the text into the uppercase.
In the third line, we're selecting all paragraphs that have the style name <code>Heading 1</code> and converting them to <code>h1</code> HTML elements with the Bootstrap class of <code>card</code>, which sets multiple style properties such as background color, position, and border for the element.
In the last line, we're converting all tables in our docx file to the <code>table</code> HTML element, with Bootstrap's <code>table</code> class to give it a new look, also we're making it highlight when hovered, by adding the Bootstrap class of <code>table-hover</code>.
Like before, we use dot-notation to map multiple classes to the same HTML element, even though the styles come from another source.
Finally, add the Bootstrap CDNs to our HTML:
<pre><code class="hljs">edited_html = bootstrap_css + html + bootstrap_js
</code></pre>
Our HTML is now ready to be shared, with a polished look and feel! Here's the full code for reference:
<pre><code class="hljs">import mammoth

input_filename = &quot;file-sample_100kB.docx&quot;

custom_styles = &quot;&quot;&quot; b =&gt; b.mark
 u =&gt; u.initialism
 p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.card
 table =&gt; table.table.table-hover
 &quot;&quot;&quot;


bootstrap_css = &#x27;&lt;link href=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css&quot; rel=&quot;stylesheet&quot; integrity=&quot;sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl&quot; crossorigin=&quot;anonymous&quot;&gt;&#x27;
bootstrap_js = &#x27;&lt;script src=&quot;https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js&quot; integrity=&quot;sha384-b5kHyXgcpbZJO/tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;&#x27;


with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.convert_to_html(docx_file, style_map = custom_styles)
 html = result.value 

edited_html = bootstrap_css + html + bootstrap_js

output_filename = &quot;output.html&quot;
with open(output_filename, &quot;w&quot;) as f: 
 f.writelines(edited_html)
</code></pre>
Also, another point to note here is that in a real-life scenario, you probably will not add Bootstrap CSS directly to the HTML content as we did here. Instead, you would load/inject the HTML content to a special HTML page, which already would have the necessary CSS and JS bundles.
So far you've seen how much flexibility we have to style our output. Mammoth also allows us to modify the content we're converting. Let's take a look at that now.
<h2 id="dealingwithimageswedontwantshared">Dealing With Images We Don't Want Shared</h2>
Let's say we'd like to omit images from our DOCX file from being converted. The <code>convert_to_html()</code> method accepts a <code>convert_image</code> argument, which is an image handler function. It returns a list of images that should be converted and added to the HTML document.
Naturally, if we override it and return an empty list, they'll be omitted from the converted page:
<pre><code class="hljs">def ignore_image(image):
 return []
</code></pre>
Now, let's pass that function as a parameter into the <code>convert_to_html()</code> method:
<pre><code class="hljs">with open(input_filename, &quot;rb&quot;) as docx_file:
 result = mammoth.convert_to_html(docx_file, style_map = custom_styles, convert_image=ignore_image)
 html = result.value
 with open(&#x27;output.html&#x27;, &#x27;w&#x27;) as html_file:
 html_file.write(text)
</code></pre>
That's it! Mammoth will ignore all the images when generating an HTML file.
We've been programmatically using Mammoth with Python so far. Mammoth is also a CLI tool, therefore we have another interface to do DOCX to HTML conversations. Let's see how that works in the next section.
<h2 id="convertdocxtohtmlusingcommandlinetool">Convert DOCX to HTML Using Command Line Tool</h2>
File conversion with Mammoth, using the CLI, typically looks like this:
<pre><code class="hljs">$ mammoth path/to/input_filename.docx path/to/output.html
</code></pre>
If you wanted to separate the images from the HTML, you can specify an output folder:
<pre><code class="hljs">$ mammoth file-sample_100kB.docx --output-dir=imgs
</code></pre>
We can also add custom styles as we did in Python. You need to first create a custom style file:
<pre><code class="hljs">$ touch my-custom-styles
</code></pre>
Then we'll add our custom styles in it, the syntax is same as before:
<pre><code class="hljs">b =&gt; b.red
u =&gt; em.red
p[style-name=&#x27;Heading 1&#x27;] =&gt; h1.red.underline
</code></pre>
Now we can generate our HTML file with custom style:
<pre><code class="hljs">$ mammoth file-sample_100kB.docx output.html --style-map=my-custom-styles
</code></pre>
And you're done! Your document would have been converted with the defined custom styles.
<h2 id="conclusion">Conclusion</h2>
File type-casting is a common situation when working on web technologies. Converting DOCX files into well-known and easy to manipulate HTML allows us to reconstruct the data as much as we need. With Mammoth, we've learned how to extract the text from a docx and how to convert it to HTML.
When converting to HTML we can style the output with CSS rules we create or ones that come with common UI frameworks. We can also omit data we don't want to be available in the HTML. Lastly, we've seen how to use the Mammoth CLI as an alternative option for file conversion.
You can find a sample docx file along with the full code of the tutorial on <a rel="nofollow noopener" target="_blank" href="https://github.com/rhasoff/SA-Convert-Docx-To-Html-With-Python-Mammoth">this GitHub repository</a>.

Marcus Sanatan

Ruslan Hasanov

Mammoth is a tool that can convert docx files to HTML. Let's learn how to use Mammoth with Python to convert DOCX files into HTML while keeping their formatting.

How to Convert DOCX To Html With Python Mammoth

François Dupire

Guide to JPA with Hibernate - Inheritance Mapping

<h2 id="introduction">Introduction</h2>
Splitting strings and lists are common programming activities in Python and other languages. Sometimes we have to split our data in peculiar ways, but more commonly - into even chunks.
The language does not have a built-in function to do this and in this tutorial, we'll take a look at how to split a list into even chunks in Python.
For most cases, you can get by using generators:
<pre><code class="hljs">def chunk_using_generators(lst, n):
 for i in range(0, len(lst), n):
 yield lst[i:i + n]
</code></pre>
Though, there are other interesting ways to do this, each with their own pros and cons!
<h2 id="splitalistintoevenchunksofnelements">Split a List Into Even Chunks of N Elements</h2>
A list can be split based on the size of the chunk defined. This means that we can define the size of the chunk. If the subset of the list doesn't fit in the size of the defined chunk, fillers need to be inserted in the place of the empty element holders. We will be using <code>None</code> in those cases.
Let's create a new file called <code>chunk_based_on_size.py</code> and add the following contents:
<pre><code class="hljs">def chunk_based_on_size(lst, n):
 for x in range(0, len(lst), n):
 each_chunk = lst[x: n+x]

 if len(each_chunk) &lt; n:
 each_chunk = each_chunk + [None for y in range(n-len(each_chunk))]
 yield each_chunk

print(list(chunk_based_on_size([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 7)))
</code></pre>
The above <code>chunk_based_on_size()</code> function takes the arguments: <code>lst</code> for the list and <code>chunk_size</code> for a number to split it by. The function iterates through the list with an increment of the chunk size <code>n</code>. Each chunk is expected to have the size given as an argument. If there aren't enough elements to make a split of the same size, the remaining unused elements are filled with <code>None</code>.
Running this script returns the following list of lists:
<pre><code class="hljs">$ python3 chunk_based_on_size.py
[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, None]]
</code></pre>
The list has been split into equal chunks of 7 elements each.
Python has utilities to simplify this process. We can use the <code>zip_longest</code> function from <code>itertools</code> to simplify the previous function. Let's create a new file <code>chunk_using_itertools.py</code> and add the following code:
<pre><code class="hljs">from itertools import zip_longest

def chunk_using_itertools(lst):
 iter_ = iter(lst)
 return list(zip_longest(iter_, iter_, iter_, iter_, iter_, iter_, iter_))

print(chunk_using_itertools([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]))
</code></pre>
This code iterates elements and returns a chunk of the desired length - based on the arguments you provide. We've put 7 <code>iter_</code> arguments here. The <code>zip_longest()</code> function aggregates and returns elements from each iterable. In this case, it would aggregate the elements from the list that's iterated 7 times in one go. This then creates numerous iterators that contain 7 sequential elements, which are then converted to a list and returned.
When you execute this snippet, it'll result in:
<pre><code class="hljs">$ python3 chunk_using_itertools.py
[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, None]]
</code></pre>
This shorter function produces the same input. However, it's much more limited as we have to manually write how many elements we want in the code, and it's a bit awkward to just put a bunch of <code>iter_</code>s in the <code>zip_longest()</code> call.
The best solution would be using generators. Let's create a new file, <code>chunk_using_generators.py</code>:
<pre><code class="hljs">def chunk_using_generators(lst, n):
 for i in range(0, len(lst), n):
 yield lst[i:i + n]

print(list(chunk_using_generators([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 7)))
</code></pre>
This generator yields a sublist containing <code>n</code> elements. At the end, it would have yielded a sublist for every chunk. Running this code produces this output:
<pre><code class="hljs">$ python3 chunk_using_generators.py
[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13]]
</code></pre>
This solution works best if you don't need padding with <code>None</code> or otherwise.
<h2 id="splitalistintoanevenchunks">Split a List Into a N Even Chunks</h2>
In the previous section, we split the list based on the size of individual chunks so that each chunk has the same amount of elements. There's another way to interpret this problem. What do we do when we want to split a list not based on the number of elements in each chunk, but on the number of chunks we want to be created?
For example, instead of splitting a list into chunks where every chunk has 7 elements, we want to split a list into 7 even chunks. In this case, we may not know the size of each chunk.
The logic is similar to the previous solutions, however, the size of the chunk is the ceiling value of the length of the list divided by the number of chunks required. Similar to the previous code samples, if a chunk happens to have vacant spots, those will be filled by the filler value <code>None</code>:
<pre><code class="hljs">import math

def chunk_based_on_number(lst, chunk_numbers):
 n = math.ceil(len(lst)/chunk_numbers)

 for x in range(0, len(lst), n):
 each_chunk = lst[x: n+x]

 if len(each_chunk) &lt; n:
 each_chunk = each_chunk + [None for y in range(n-len(each_chunk))]
 yield each_chunk

print(list(chunk_based_on_number([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], chunk_numbers=7)))
</code></pre>
We determine how many lists we need to create and store that value in <code>n</code>. We then create a sublist for the two elements at a time, padding the output in case our chunk size is smaller than the desired length.
When we execute that file we'll see:
<pre><code class="hljs">$ python3 chunk_based_on_number.py
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, None]]
</code></pre>
As seen in the output above, the list has been split into 7 individual lists of equal sizes, based on the argument <code>chunk_numbers</code> provided.
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen some of the ways by which a list can be split into even-sized chunks and lists based on custom methods and by using the built-in modules.
The solutions mentioned in this tutorial, are not limited to the ones defined here, but there are multiple other creative ways by which you can split your list into even-chunks too.

Sathiya Sarathi Gunasekaran

In this article, we show how to split a list into even sized chunks in Python - splitting into chunks of N elements and into N chunks of equal size.

How to Split a List Into Even Chunks in Python

How to Split a List into Even Chunks in Python

<h2 id="introduction">Introduction</h2>
The <code>print()</code> function in Python appends a newline to the output when displayed on the tty (teletypewriter A.K.A the terminal). When you don't want your message displayed with newlines or with spaces, how can you change the behavior of <code>print()</code>?
This can easily be achieved by altering the default values of the <code>sep</code> and <code>end</code> parameters of the <code>print()</code> function.
<h2 id="printingwithoutanewline">Printing without a Newline</h2>
Until Python version 2.x, <code>print</code> was a reserved keyword that acts as a special statement. Since Python version 3.x, the <code>print</code> command has evolved into a function.
This version of <code>print()</code> is capable of taking the following arguments:
<img src="https://stackabuse.s3.amazonaws.com/media/python-how-to-print-without-a-newline-space-1.jpg" alt="Print function - syntax">
The values (<code>value1</code>, <code>value2</code>) mentioned above can be any string or any of the data types like list, float, string, etc. The other arguments include a separator (<code>sep</code>) used to divide the values given as arguments whereas the argument <code>end</code> is the <code>\n</code> newline character by default. This is the reason why whenever the <code>print()</code> function is called, the cursor slides to the next line.
In Python 3.x, the most straightforward way to print without a newline is to set the <code>end</code> argument as an empty string i.e. <code>''</code>. For example, try executing the following snippet in your Python interpreter:
<pre><code class="hljs">print(&quot;I am a sentence&quot;, &quot;I am also a sentence&quot;)
</code></pre>
The interpreter would output the following:
<pre><code class="hljs">I am a sentence I am also a sentence
&gt;&gt;&gt;
</code></pre>
We are printing two strings, so Python will use the value of <code>sep</code>, a blank space by default, to print them together. Python also adds a newline character at the end, so the interpreter prompt goes to the end line.
Now modify the previous statement to look like this:
<pre><code class="hljs">print(&quot;I am a sentence&quot;, &quot;I am also a sentence&quot;, sep=&quot;; &quot;, end=&quot;&quot;)
</code></pre>
Upon executing it in the interpreter, you will get an output resembling:
<pre><code class="hljs">I am a sentence; I am also a sentence&gt;&gt;&gt;
</code></pre>
Two things happened here - the separator between the two strings now also includes a semicolon. The interpreter prompt also appears on the same line because we removed the automatically appended newline character.
<h2 id="printingwithoutanewlineinpython2x">Printing Without a Newline in Python 2.X</h2>
For earlier versions of Python - less than 3 but greater than 2.6 - you can import <code>print_function</code> from the <code>__future__</code> module. This will override the existing <code>print</code> keyword with the <code>print()</code> function as shown below:
<pre><code class="hljs">from __future__ import print_function

print(&quot;I am a sentence&quot;, &quot;I am also a sentence&quot;, sep=&quot;; &quot;, end=&quot;&quot;)
</code></pre>
This will also yield:
<pre><code class="hljs">I am a sentence; I am also a sentence&gt;&gt;&gt;
</code></pre>
This is how you can use Python version 3's <code>print()</code> function in Python 2.x.
<h2 id="usingstdoutwrite">Using stdout.write()</h2>
The <code>sys</code> module has built-in functions to write directly to the file or the tty. This function is available for Python 2.x and 3.x versions. We can use the <code>write()</code> method of the <code>sys</code> module's <code>stdout</code> object to print on the console like this:
<pre><code class="hljs">import sys

sys.stdout.write(&quot;I am a line&quot;)
</code></pre>
Let's execute this and take a look at the output:
<pre><code class="hljs">I am a line&gt;&gt;&gt;
</code></pre>
Although this gives the output of what we are trying to achieve, there are quite a few differences between the <code>write()</code> function and the <code>print()</code> function. The <code>print()</code> function can print multiple values at a time, can accept non-string values, and is friendlier to developers.
<h2 id="conclusion">Conclusion</h2>
In this article, we have explored the different ways by which values can be printed without a newline character/carriage return. This strategy can come quite handy while printing the elements in the outputs of algorithms such as a binary tree or printing the contents of a list next to each other.

In this tutorial, we'll take a look at how to print without a newline or space in Python, using the print() and write() functions, through examples.

Python: How to Print Without Newline or Space

Python: How to Print without Newline or Space

<h2 id="introduction">Introduction</h2>
Application properties may vary in different environments like how the hosts on your QA environment may vary from your local and production environments. Using Spring Boot, different environments can be configured and updated separately without affecting other environments with the use of property files.
In this article, we'll be demonstrating ways to access values defined within a property file in a Spring Boot project and ways to manipulate them in the code.
<h2 id="springbootpropertyfiles">Spring Boot Property Files</h2>
Spring Boot provides a way to externalize configurations using property files that are located within the project's classpath. This is very useful for multi-environment set-ups so that properties can be dynamically configured per environment.
The default property file that Spring Boot generates is named <code>application.properties</code> which is located in the project's <code>src/main/resources/</code> directory. When initializing a project, the default property file is blank.
Here's an example of an <code>application.properties</code> file containing two sample properties:
<pre><code class="hljs">spring.datasource.username=user
logging.level.root=INFO
</code></pre>
This sample file contains values for the username of a <code>datasource</code> and the root logging level of the application. The properties follow the same <code>key=value</code> syntax.
<h3 id="yamlpropertyfiles">YAML Property Files</h3>
Alternatively, instead of the default <code>.properties</code> syntax, Spring Boot also supports property files in YAML format. So instead of the default <code>application.properties</code> file, you can create a new property file <code>application.yml</code> if you prefer your properties in YAML format:
<pre><code class="hljs">spring:
 datasource:
 username: user
logging:
 level: 
 root: INFO
</code></pre>
The only difference that this would entail is the formatting of the contents within the file so the choice is based solely on preference.
Spring Boot allows the declaration of multiple property files using the <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/PropertySource.html">@PropertySource</a> annotation defined through a configuration class.
<h2 id="accessingvalueswithinpropertyfilesinspringboot">Accessing Values Within Property Files in Spring Boot</h2>
Now we move on to the main topic which is - how to access the values within the aforementioned property files.
<h3 id="usingthevalueannotation">Using the @Value Annotation</h3>
The <code>@Value</code> annotation is a predefined annotation used to read values from any property files under the project's classpath.
To access a single property's value from a property file using this annotation, you provide the property name as the argument:
<pre><code class="hljs">@Value(&quot;${spring.sample.property}&quot;)
</code></pre>
Following this syntax, let's take a look at an example where we set the value of a string variable to the <code>datasource.username</code> defined within the property file in the example above:
<pre><code class="hljs">@Value(&quot;${spring.datasource.username}&quot;)
String username;
</code></pre>
If we print the variable above without any further manipulation, the output should be the value of the specified property declared in the <code>@Value</code> annotation. In this case, it should print out the string <code>user</code>:
<pre><code class="hljs">System.out.println(username);
// user
</code></pre>
If the property declared in the annotation does not exist within any property file, then the default initialization of the data type will be observed. In this case, the variable <code>username</code> would be set to <code>null</code>.
Updating the value of the variable annotated with the <code>@Value</code> annotation also changes the actual value of the property injected into the variable during runtime:
<pre><code class="hljs">username = &quot;new_user&quot; 
</code></pre>
This changes the value of the variable <code>username</code> as well as temporarily changing the value of the property <code>spring.datasource.username</code>.
Note that the changes made during runtime will be flushed once the program stops running so the changes won't reflect in the actual property file. This implies that property values are more dynamic instead of just being a constant value.
Here's a link to our comprehensive guide on the <a target="_blank" href="https://stackabuse.com/the-value-annotation-in-spring"><code>@Value</code> annotation</a> if you want to know more about it.
<h3 id="usingtheenvironmentobject">Using the Environment Object</h3>
Another method to access values defined in Spring Boot is by autowiring the <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/env/Environment.html"><code>Environment</code></a> object and calling the <code>getProperty()</code> method to access the value of a property file.
The <code>getProperty()</code> method accepts a single required parameter which is a string containing the property name and returns the value of that property if it exists. If the property doesn't exist, the method will return a <code>null</code> value.
For this example, let's access the <code>logging.level.root</code> property and store it within a string value:
<pre><code class="hljs">@Autowired
private Environment env;

public void getRootLogLevel() {
 return env.getProperty(&quot;logging.level.root&quot;);
}
</code></pre>
If the <code>getRootLogLevel()</code> method is called and printed out, it will print out the value of the property if it exists. With the example property file stated above, this method should output <code>INFO</code>.
<h3 id="usingtheconfigurationpropertiesannotation">Using the @ConfigurationProperties Annotation</h3>
The <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/context/properties/ConfigurationProperties.html"><code>@ConfigurationProperties</code></a> annotation is a more expansive approach than the <code>@Value</code> annotation and the <code>Environment</code> object.
This method is used to access related groups of properties by storing the configuration in a POJO (Plain Old Java Object) and using the POJO for further access, unlike the previous solutions where the properties are accessed individually.
The <code>@ConfigurationProperties</code> annotation will map values given the prefix of the group of properties.
For this solution, let's make a new <code>application.properties</code> file:
<pre><code class="hljs">spring.demo.username=user
spring.demo.password=password
spring.demo.email=emailadd@email.com
</code></pre>
All 3 properties configured in the file all have the same prefix <code>spring.demo</code>.
Now, let's create a configuration class to map the values of these properties using the <code>@ConfigurationProperties</code> annotation.
Note that besides annotating the class with <code>@ConfigurationProperties</code>, you also need to annotate it with <code>@Configuration</code> to inform the system that the class is a configuration class.
Also, the variable names within the class must be the same as the names within the property file with the given prefix. Let's make a <code>DemoProperties</code> class:
<pre><code class="hljs">@ConfigurationProperties(prefix=&quot;spring.demo&quot;)
@Configuration
public class DemoProperties {
 private String username;
 private String password;
 private String email;
 
 // Getters, Setters, Constructors, etc...
}
</code></pre>
Now that the configuration is declared, the <code>DemoProperties</code> instance can be used anywhere within the service layer to access property values just by autowiring the class:
<pre><code class="hljs">@Autowired
private DemoProperties demoProperties;

public void printDemoProperties() {
 System.out.println(&quot;Username: &quot; + demoProperties.getUsername());
 System.out.println(&quot;Password: &quot; + demoProperties.getPassword());
 System.out.println(&quot;Email Address: &quot; + demoProperties.getEmail());
}
</code></pre>
Calling the <code>printDemoProperties()</code> method will output:
<pre><code class="hljs">Username: user
Password: password
Email Address: emailadd@email.com
</code></pre>
<h2 id="conclusion">Conclusion</h2>
This article covered three different ways of accessing values defined in Spring Boot. All of which are fairly easy to comprehend and apply to your projects!
The <code>@Value</code> annotation is the most commonly used solution to access property values in Spring Boot. The <code>Environment</code> object isn't used as often but still is a viable way to access a property value.
The <code>@ConfigurationProperties</code> annotation is a bit more comprehensive and should only be used for bigger groups of properties that have the same prefix and the same context since you would need to accommodate this solution by creating a POJO to store the group of property values.

David Landup

Rayven Yor Esplanada

In this tutorial, we'll take a look at how to access application.properties and application.yml values in Spring Boot applications, with practical examples.

How to Access Property File Values in Spring Boot

<h2 id="introduction">Introduction</h2>
Pandas is an extremely popular data manipulation and analysis library. It's the go-to tool for loading in and analyzing datasets for many.
Correctly sorting data is a crucial element of many tasks regarding data analysis. In this tutorial, we'll take a look at how to sort a Pandas DataFrame by date.
Let's start off with making a simple <code>DataFrame</code> with a few dates:
<pre><code class="hljs">import pandas as pd

data = {&#x27;Name&#x27;:[&quot;John&quot;, &quot;Paul&quot;, &quot;Dhilan&quot;, &quot;Bob&quot;, &quot;Henry&quot;], 
&#x27;Date of Birth&#x27;: [&quot;01/06/86&quot;, &quot;05/10/77&quot;, &quot;11/12/88&quot;, &quot;25/12/82&quot;, &quot;01/06/86&quot;]}
df = pd.DataFrame(data) 

print(df)
</code></pre>
By default our output is sorted by the <code>DataFrame</code>s index:
<pre><code class="hljs"> Name Date of Birth
0 John 01/06/86
1 Paul 05/10/77
2 Dhilan 11/12/88
3 Bob 25/12/82
4 Henry 01/06/86
</code></pre>
The eagle-eyed may notice that John and Paul have the same date of birth - this is on-purpose as we'll see in a moment.
<h2 id="convertstringstodatetimeinpandasdataframe">Convert Strings to Datetime in Pandas DataFrame</h2>
We have input <code>Date of Birth</code> in date format and it appears to be formatted as such. However, the first thing we need to do is ensure Pandas recognizes and understands that this date is in fact a date.
The way Pandas stores and manipulates data in a <code>DataFrame</code> is determined by its data type.
The data type of each value is assigned automatically, based on what it looks like. <code>60</code> will be assigned an integer type, while <code>John</code> will be assigned a string type. Let's check the current data type of each column:
<pre><code class="hljs">print(df.dtypes)
</code></pre>
This gives us our list of data types:
<pre><code class="hljs">Name object
Date of Birth object
dtype: object
</code></pre>
We can see our <code>Date of Birth</code> column has been assigned a basic string object type by default. However, in order to correctly sort, analyze or manipulate our dates correctly we need Pandas to recognize this column contains dates.
Let's explicitly change the data type in our <code>Date of Birth</code> column from an <code>object</code> type to a <code>datetime</code> type.
The easiest way to do this is to use the <code>to_datetime()</code> function:
<pre><code class="hljs">df[&quot;Date of Birth&quot;] = pd.to_datetime(df[&quot;Date of Birth&quot;])
print(df.dtypes)
</code></pre>
Now, if we check our output:
<pre><code class="hljs">Name object
Date of Birth datetime64[ns]
dtype: object
</code></pre>
So, we can see we have successfully changed our data type to <code>datetime</code>.
Alternatively, we can manually specify the data type of our column, provided of course we know what data type we want it to be:
<pre><code class="hljs">df[&quot;Date of Birth&quot;] = df[&quot;Date of Birth&quot;].astype(&#x27;datetime64[ns]&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Name object
Date of Birth datetime64[ns]
dtype: object
</code></pre>
Whilst both of these methods produce the same result, the <code>to_datetime()</code> method is preferred as it was explicitly designed for this purpose.
<h2 id="sortingadataframebydateinpandas">Sorting a DataFrame by Date in Pandas</h2>
Now that Pandas correctly recognizes our data types, let's sort the <code>DataFrame</code>.

 <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: All of the methods we'll use don't sort in-place, so you'll have to either reassign the changed <code>DataFrame</code> to a new (or the same) reference variable to persist the change - or you can use the <code>inplace</code> argument to change the default behavior.

 </div>
 </div>
 </div>
 <h2 id="sortbysingledatecolumninascendingorder">Sort by Single Date Column in Ascending Order</h2>
The <code>sort_values()</code> method will, by default, sort data in ascending order. For dates this would mean the first or earliest in order will appear at the top of the list:
<pre><code class="hljs">df.sort_values(by=&#x27;Date of Birth&#x27;, inplace=True)
print(df)
</code></pre>
Running this code results in:
<pre><code class="hljs"> Name	Date of Birth
1	Paul	1977-05-10
3	Bob	1982-12-25
0	John	1986-01-06
4	Henry	1986-01-06
2	Dhilan	1988-11-12
</code></pre>
Alternatively, if you don't want to use the <code>inplace</code> argument, you can simply re-assign the returned <code>DataFrame</code> from the <code>sort_values()</code> method to <code>df</code> (or any other reference variable:
<pre><code class="hljs">df = df.sort_values(by=&#x27;Date of Birth&#x27;)
</code></pre>
As we gave John and Henry the same birthday, the order is based on their corresponding index number.
<h2 id="sortbysingledatecolumnindescendingorder">Sort by Single Date Column in Descending Order</h2>
Changing our order of sort to descending can be done by setting the <code>ascending</code> argument to <code>False</code> when calling the <code>sort_values()</code> function:
<pre><code class="hljs">df.sort_values(by=&#x27;Date of Birth&#x27;, ascending = False, inplace=True)
</code></pre>
This time we get our data sorted in descending order, meaning the last or most recent will appear at the top of our list. Again as John and Henry have the same birthday their order is based on their index number:
<pre><code class="hljs"> Name	Date of Birth
2	Dhilan	1988-11-12
0	John	1986-01-06
4	Henry	1986-01-06
3	Bob	1982-12-25
1	Paul	1977-05-10
</code></pre>
<h2 id="sortbymultipledatecolumns">Sort by Multiple Date Columns</h2>
So, what happens if we have multiple date columns that we want to sort by?
Let’s add another date-related column to our <code>DataFrame</code> and make sure both our data types are correctly assigned:
<pre><code class="hljs"># Values for the new column
employment_start = [&quot;22/05/16&quot;, &quot;17/08/10&quot;, &quot;22/05/16&quot;, &quot;11/06/19&quot;, &quot;16/06/05&quot;]
# Adding columns to DataFrame
df[&#x27;Employment Start&#x27;] = employment_start

# Applying to_datetime() function to multiple columns at once
df[[&#x27;Date of Birth&#x27;, &#x27;Employment Start&#x27;]] = df[[&#x27;Date of Birth&#x27;, &#x27;Employment Start&#x27;]].apply(pd.to_datetime)

print(df.dtypes)
print(df)
</code></pre>
Now, let's check if things look good:
<pre><code class="hljs">Name object
Date of Birth datetime64[ns]
Employment Start datetime64[ns]
dtype: object

 Name Date of Birth Employment Start
0 John 1986-01-06 2016-05-22
1 Paul 1977-05-10 2010-08-17
2 Dhilan 1988-11-12 2016-05-22
3 Bob 1982-12-25 2019-11-06
4 Henry 1986-01-06 2005-06-16
</code></pre>
<h3 id="sortbymultipledatecolumnsinascendingorder">Sort by Multiple Date Columns in Ascending Order</h3>
To sort the <code>DataFrame</code> by both <code>Date of Birth</code> and <code>Employment Start</code> in ascending order, we simply need to add both column names to our <code>sort_values()</code> method. Just bear in mind the priority of the sort is determined by which column is entered first:
<pre><code class="hljs">df.sort_values(by=[&#x27;Date of Birth&#x27;, &#x27;Employment Start&#x27;], inplace=True)
</code></pre>
As this method defaults to ascending order, our output will be:
<pre><code class="hljs"> Name	Date of Birth	Employment Start
1	Paul	1977-05-10	 2010-08-17
3	Bob	1982-12-25	 2019-11-06
4	Henry	1986-01-06	 2005-06-16
0	John	1986-01-06	 2016-05-22
2	Dhilan	1988-11-12	 2016-05-22
</code></pre>
As <code>Date of Birth</code> is the first column entered in our method, Pandas is prioritizing it. Since John and Henry have the same <code>Date of Birth</code>, they're sorted by the <code>Employment Start</code> column instead.
<h3 id="sortbymultipledatecolumnsindescendingorder">Sort by Multiple Date Columns in Descending Order</h3>
As with the single column sort, we can change the order to descending order by changing the <code>ascending</code> parameter to <code>False</code>:
<pre><code class="hljs">df.sort_values(by=[&#x27;Date of Birth&#x27;, &#x27;Employment Start&#x27;], ascending = False, inplace=True)
</code></pre>
Now, our output in descending order is:
<pre><code class="hljs">Name	Date of Birth	Employment Start
2	Dhilan	1988-11-12	2016-05-22
0	John	1986-01-06	2016-05-22
4	Henry	1986-01-06	2005-06-16
3	Bob 	1982-12-25	2019-11-06
1	Paul	1977-05-10	2010-08-17
</code></pre>
As we can see John and Henry both appear higher in the list as the birthdays are displayed in descending order. This time though, John takes priority over Henry due to his more recent <code>Employment Start</code> date.
<h3 id="sortbymultipledatecolumnsandvariableordersorts">Sort by Multiple Date Columns and Variable Order Sorts</h3>
Now, what if we not only want to sort using multiple columns but also have these columns sorted using different ascending criteria? With Pandas, this can be implemented within the same <code>sort_values()</code> method we've used so far. We just have to pass the correct and corresponding list of values in the <code>ascending</code> parameter.
In this example let’s assume we want to sort our <code>Employment Start</code> in ascending order, i.e. longest serving first, but then their <code>Date of Birth</code> in descending order i.e. youngest first:
<pre><code class="hljs">df.sort_values(by=[&#x27;Employment Start&#x27;, &#x27;Date of Birth&#x27;], ascending = [True, False], inplace=True)
</code></pre>
The data is first sorted by <code>Employment Start</code> in ascending order, this takes priority as this was the first column passed in our method. We then sort <code>Date of Birth</code> in descending order. As Dhilan and John share the same <code>Employment Start</code> date, Dhilan now takes priority as he is younger than John:
<pre><code class="hljs">Name	Date of Birth	Employment Start
4	Henry	1986-01-06	2005-06-16
1	Paul	1977-05-10	2010-08-17
2	Dhilan	1988-11-12	2016-05-22
0	John	1986-01-06	2016-05-22
3	Bob	1982-12-25	2019-11-06
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Given the popularity of the Pandas library, it is hardly surprising that sorting data based on columns is a straightforward process. We took a look at the flexibility of using the <code>sort_values()</code> method across single and multiple columns, in ascending, descending and even a variable order. Whilst we have focused on sorting by date, this method can be used across multiple data types.
When looking to sort by date in particular, the first, and arguably most important step, is making sure we have correctly assigned the <code>datetime</code> type to our data. Without correctly defining our data type we risk Pandas not recognizing our dates at all.

Rikesh Nichani

In this tutorial, we'll take a look at how to sort a Pandas DataFrame by single and multiple Date columns, in ascending and descending order in Python with examples.

How to Sort a Pandas DataFrame by Date

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to check if a list contains an element or value in Python. We'll use a list of strings, containing a few animals:
<pre><code class="hljs">animals = [&#x27;Dog&#x27;, &#x27;Cat&#x27;, &#x27;Bird&#x27;, &#x27;Fish&#x27;]
</code></pre>
<h2 id="checkiflistcontainselementwithforloop">Check if List Contains Element With for Loop</h2>
A simple and rudimentary method to check if a list contains an element is looping through it, and checking if the item we're on matches the one we're looking for. Let's use a <code>for</code> loop for this:
<pre><code class="hljs">for animal in animals:
 if animal == &#x27;Bird&#x27;:
 print(&#x27;Chirp!&#x27;)
</code></pre>
This code will result in:
<pre><code class="hljs">Chirp!
</code></pre>
<h2 id="checkiflistcontainselementwithinoperator">Check if List Contains Element With in Operator</h2>
Now, a more succinct approach would be to use the built-in <code>in</code> operator, but with the <code>if</code> statement instead of the <code>for</code> statement. When paired with <code>if</code>, it returns <code>True</code> if an element exists in a sequence or not. The syntax of the <code>in</code> operator looks like this:
<pre><code class="hljs">element in list
</code></pre>
Making use of this operator, we can shorten our previous code into a single statement:
<pre><code class="hljs">if &#x27;Bird&#x27; in animals: print(&#x27;Chirp&#x27;)
</code></pre>
This code fragment will output the following:
<pre><code class="hljs">Chirp
</code></pre>
This approach has the same efficiency as the <code>for</code> loop, since the <code>in</code> operator, used like this, calls the <code>list.__contains__</code> function, which inherently loops through the list - though, it's much more readable.
<h2 id="checkiflistcontainselementwithnotinoperator">Check if List Contains Element With not in Operator</h2>
By contrast, we can use the <code>not in</code> operator, which is the logical opposite of the <code>in</code> operator. It returns <code>True</code> if the element is not present in a sequence.
Let's rewrite the previous code example to utilize the <code>not in</code> operator:
<pre><code class="hljs">if &#x27;Bird&#x27; not in animals: print(&#x27;Chirp&#x27;)
</code></pre>
Running this code won't produce anything, since the <code>Bird</code> is present in our list.
But if we try it out with a <code>Wolf</code>:
<pre><code class="hljs">if &#x27;Wolf&#x27; not in animals: print(&#x27;Howl&#x27;)
</code></pre>
This code results in:
<pre><code class="hljs">Howl
</code></pre>
<h2 id="checkiflistcontainselementwithlambda">Check if List Contains Element With Lambda</h2>
Another way you can check if an element is present is to filter out everything other than that element, just like sifting through sand and checking if there are any shells left in the end. The built-in <code>filter()</code> method accepts a lambda function and a list as its arguments. We can use a lambda function here to check for our <code>'Bird'</code> string in the <code>animals</code> list.
Then, we wrap the results in a <code>list()</code> since the <code>filter()</code> method returns a <code>filter</code> object, not the results. If we pack the <code>filter</code> object in a list, it'll contain the elements left after filtering:
<pre><code class="hljs">retrieved_elements = list(filter(lambda x: &#x27;Bird&#x27; in x, animals))
print(retrieved_elements)
</code></pre>
This code results in:
<pre><code class="hljs">[&#x27;Bird&#x27;]
</code></pre>
Now, this approach isn't the most efficient. It's fairly slower than the previous three approaches we've used. The <code>filter()</code> method itself is equivalent to the generator function:
<pre><code class="hljs">(item for item in iterable if function(item))
</code></pre>
The slowed down performance of this code, amongst other things, comes from the fact that we're converting the results into a list in the end, as well as executing a function on the item on each iteration.
<h2 id="checkiflistcontainselementusingany">Check if List Contains Element Using any()</h2>
Another great built-in approach is to use the <code>any()</code> function, which is just a helper function that checks if there are any (at least 1) instances of an element in a list. It returns <code>True</code> or <code>False</code> based on the presence or lack thereof of an element:
<pre><code class="hljs">if any(element in &#x27;Bird&#x27; for element in animals):
 print(&#x27;Chirp&#x27;)
</code></pre>
Since this results in <code>True</code>, our <code>print()</code> statement is called:
<pre><code class="hljs">Chirp
</code></pre>
This approach is also an efficient way to check for the presence of an element. It's as efficient as the first three.
<h2 id="checkiflistcontainselementusingcount">Check if List Contains Element Using count()</h2>
Finally, we can use the <code>count()</code> function to check if an element is present or not:
<pre><code class="hljs">list.count(element)
</code></pre>
This function returns the occurrence of the given element in a sequence. If it's greater than 0, we can be assured a given item is in the list.
Let's check the results of the <code>count()</code> function:
<pre><code class="hljs">if animals.count(&#x27;Bird&#x27;) &gt; 0:
 print(&quot;Chirp&quot;)
</code></pre>
The <code>count()</code> function inherently loops the list to check for the number of occurrences, and this code results in:
<pre><code class="hljs">Chirp
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to check if an element is present in a list or not. We've used the <code>for</code> loop, <code>in</code> and <code>not in</code> operators, as well as the <code>filter()</code>, <code>any()</code> and <code>count()</code> methods.

Guest Contributor

In this tutorial, we'll take a look at how to check if a Python list contains an element or value. We'll use several approaches with examples and performance comparison.