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

Python: Check if Array/List Contains Element/Value

<h2 id="introduction">Introduction</h2>
Having to manually format a number as a currency string can be a tedious process. Even though this can oftentimes be done in a few lines of code, it's good practice to follow a standardized norm rather than hardcode it yourself, plus it's way easier for the developer writing the code.
In this tutorial, we'll take a look at how to format a currency string in JavaScript.
<h2 id="formattingstringsascurrencywithlocale">Formatting Strings as Currency with Locale</h2>
A locale is a set of parameters that specify anything on your computer that's region specific:
<ul>
<li>Number format setting</li>
<li>Character classification, case conversion settings</li>
<li>Date-time format setting</li>
<li>Currency format setting</li>
<li>Paper size setting</li>
<li>Weekday format/ first day of the week</li>
<li>Units of measurement</li>
</ul>
Windows users know locale parameters as <code>Region settings</code>. On the other hand, Linux users might not know that you can use the <code>locale</code> command to inspect said parameters.
In JavaScript, the easiest and most popular way to format numbers as currency strings is via the <code>Intl.NumberFormat()</code> method. This approach lets you format numbers using custom locale parameters - and in this article, we'll focus on currencies.
The <code>Intl.NumberFormat()</code> constructor accepts two arguments, the first being a locale string, with which we define the locale we want to format to:
<pre><code class="hljs">const price = 1470000.15;

let dollarUSLocale = Intl.NumberFormat(&#x27;en-US&#x27;);
let dollarIndianLocale = Intl.NumberFormat(&#x27;en-IN&#x27;);

console.log(&quot;US Locale output: &quot; + dollarUSLocale.format(price));
console.log(&quot;Indian Locale output: &quot; + dollarIndianLocale.format(price));
</code></pre>
This outputs:
<pre><code class="hljs">1,470,000.15
14,70,000.15
</code></pre>
Here, we've got localized variants of the <code>price</code>, formatted as a simple number. Though, there are certain options we can also tweak to further customize this formatting process.
The second argument can be used to specify the options you want to apply while formatting. This is a JavaScript object that can contain, but is not limited to:
<ul>
<li><code>style</code></li>
<li><code>currency</code></li>
<li><code>useGrouping</code></li>
<li><code>maximumSignificantDigits</code></li>
</ul>
Let's take a look at these properties individually.
<h3 id="style">Style</h3>
The <code>style</code> field specifies the type of formatting you want to use. Possible values include:
<ul>
<li><code>decimal</code> - Decimal number formatting.</li>
<li><code>currency</code> - Currency formatting.</li>
<li><code>unit</code> - Metric or Imperial unit formatting.</li>
</ul>
In our scenario, we'll just be formatting to <code>currency</code> strings.
<h3 id="currency">Currency</h3>
Using the <code>currency</code> field, you can specify which specific currency you want to format to, such as <code>'USD'</code>, <code>'CAD'</code> or <code>'INR'</code>.
Let's format our <code>price</code> into different currencies:
<pre><code class="hljs">const price = 1470000.15;

// Format the price above to USD, INR, EUR using their locales.
let dollarUS = Intl.NumberFormat(&quot;en-US&quot;, {
 style: &quot;currency&quot;,
 currency: &quot;USD&quot;,
});

let rupeeIndian = Intl.NumberFormat(&quot;en-IN&quot;, {
 style: &quot;currency&quot;,
 currency: &quot;INR&quot;,
});

let euroGerman = Intl.NumberFormat(&quot;de-DE&quot;, {
 style: &quot;currency&quot;,
 currency: &quot;EUR&quot;,
});

console.log(&quot;Dollars: &quot; + dollarUS.format(price));
// Dollars: $147,000,000.15

console.log(&quot;Rupees: &quot; + rupeeIndian.format(price));
// Rupees: ₹14,70,000.15

console.log(&quot;Euros: &quot; + euroEU.format(price));
// Euros: 1.470.000,15 €
</code></pre>
<h2 id="additionaloptions">Additional Options</h2>
The <code>useGrouping</code> field is a boolean field that enables you to group the number using commas (or periods, for some locales). By default, it is set to <code>true</code>, as we could've seen in the outputs above.
Let's turn it off:
<pre><code class="hljs">let dollarUS = Intl.NumberFormat(&quot;en-US&quot;, {
 style: &quot;currency&quot;,
 currency: &quot;USD&quot;,
 useGrouping: false,
}); 
// $1470000.15
</code></pre>
The <code>maximumSignificantDigits</code> field allows you to set the number of significant digits for the price. This can be used to round your price variable based on the number of significant digits you have set.
Significant digits, in simplified terms, are the digits of a number's representation that carry any weight in terms of accuracy.
Ironically, the accuracy of a number is defined as the number of its significant digits.
Significant digits include:
<ol>
<li>All non-zero digits</li>
<li>Zeros that occur anywhere between two non-zero digits</li>
<li>Zeros that are to the right of all non-zero digits, but only if they denote a higher accuracy</li>
</ol>
Non-significant digits include:
<ol>
<li>Zeros to the left of all non-zero digits</li>
<li>Zeros that are to the right of all non-zero digits which do not denote accuracy</li>
</ol>
For example, in the number <code>000003.1240000</code> there are only 4 significant digits if our accuracy is 4 significant digits (<code>3.124</code>). However, there can also be 5 significant digits if our accuracy is 5 significant digits (<code>3.1240</code>).
An example is shown below:
<pre><code class="hljs">const price = 147741.15;

// Format the above price dollar currency
let dollarUS = Intl.NumberFormat(&quot;en-US&quot;, {
 style: &quot;currency&quot;,
 currency: &quot;USD&quot;,
 useGrouping: true,
 maximumSignificantDigits: 3,
}); // $148,000

let dollarUS2 = Intl.NumberFormat(&quot;en-US&quot;, {
 style: &quot;currency&quot;,
 currency: &quot;USD&quot;,
 useGrouping: true,
}); // $147,741.15
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to format a number as a currency string in JavaScript. We've used the <code>Intl.NumberFormat()</code> method to do this, with the desired locale and several settings we can use to customize the formatting process.

Osama Akhtar

In this tutorial, we'll take a look at formatting numbers as currency strings in Javascript. We'll use the Intl.NumberFormat() method to format numbers.

How to Format Number as Currency String in JavaScript

In this tutorial, we'll take a look at how to plot a Line Plot using Python and Seaborn. We'll plot simple and advanced Line Plots using a real-world dataset.