<h2 id="introduction">Introduction</h2>
There are many data visualization libraries in Python, yet Matplotlib is the most popular library out of all of them. Matplotlib’s popularity is due to its reliability and utility - it's able to create both simple and complex plots with little code. You can also customize the plots in a variety of ways.
In this tutorial, we'll cover how to plot Box Plots in Matplotlib.
<blockquote>
Box plots are used to visualize summary statistics of a dataset, displaying attributes of the distribution like the data’s range and distribution.
</blockquote>
<h2 id="importingdata">Importing Data</h2>
To create a Box Plot, we'll need some data to plot. We'll need to choose a dataset that contains continuous variables as features, since Box Plots visualize continuous variable distribution. We'll be working with the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/uciml/red-wine-quality-cortez-et-al-2009">Wine Quality</a> dataset.
We’ll begin by importing all the libraries that we need. We’ll import Pandas to read and parse the dataset, and we’ll of course need to import Matplotlib as well, or more accurately, the PyPlot module:
<pre><code class="hljs">import pandas as pd
from matplotlib import pyplot as plt
</code></pre>
Let’s check to make sure that our dataset is ready to use. We’ll print out the head of the dataset to make sure the data has been loaded properly, and we’ll also check to ensure that there are no missing data entries:
<pre><code class="hljs">dataframe = pd.read_csv(&quot;winequality-red.csv&quot;)
print(dataframe.head())
print(dataframe.isnull().values.any())
</code></pre>
<pre><code class="hljs"> fixed acidity volatile acidity citric acid ... sulphates alcohol quality
0 7.4 0.70 0.00 ... 0.56 9.4 5
1 7.8 0.88 0.00 ... 0.68 9.8 5
2 7.8 0.76 0.04 ... 0.65 9.8 5
3 11.2 0.28 0.56 ... 0.58 9.8 6
4 7.4 0.70 0.00 ... 0.56 9.4 5

[5 rows x 12 columns]
False
</code></pre>
The second print statement returns <code>False</code>, which means that there isn't any missing data. If there were, we'd have to <a target="_blank" href="/python-how-to-handle-missing-dataframe-values-in-pandas">handle missing DataFrame values</a>.
<h2 id="plotaboxplotinmatplotlib">Plot a Box Plot in Matplotlib</h2>
Let’s select some features of the dataset and visualize those features with the <code>boxplot()</code> function. We’ll make use of Pandas to extract the feature columns we want, and save them as variables for convenience:
<pre><code class="hljs">fixed_acidity = dataframe[&quot;fixed acidity&quot;]
free_sulfur_dioxide = dataframe[&#x27;free sulfur dioxide&#x27;]
total_sulfur_dioxide = dataframe[&#x27;total sulfur dioxide&#x27;]
alcohol = dataframe[&#x27;alcohol&#x27;]
</code></pre>
As usual, we can call plotting functions on the PyPlot instance (<code>plt</code>), the <code>Figure</code> instance or <code>Axes</code> instance:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

dataframe = pd.read_csv(&quot;winequality-red.csv&quot;)

fixed_acidity = dataframe[&quot;fixed acidity&quot;]
free_sulfur_dioxide = dataframe[&#x27;free sulfur dioxide&#x27;]
total_sulfur_dioxide = dataframe[&#x27;total sulfur dioxide&#x27;]
alcohol = dataframe[&#x27;alcohol&#x27;]

fig, ax = plt.subplots()
ax.boxplot(fixed_acidity)
plt.show()
</code></pre>
Here, we've extracted the <code>fig</code> and <code>ax</code> objects from the return of the <code>subplots()</code> function, so we can use either of them to call the <code>boxplot()</code> function. Alternatively, we could've just called <code>plt.boxplot()</code>.
In any case, this results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-1.png" alt="simple box plot matplotlib">
After creating the plot, we can see some of the summary statistics for our data. The Box Plot shows the median of the dataset (the vertical line in the middle), as well as the interquartile ranges (the ends of the boxes) and the minimum and maximum values of the chosen dataset feature (the far end of the “whiskers”).
We can also plot multiple columns on one figure, simply by providing more columns. This again, can be done on either the <code>plt</code> instance, the <code>fig</code> object or the <code>ax</code> object:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

dataframe = pd.read_csv(&quot;winequality-red.csv&quot;)

fixed_acidity = dataframe[&quot;fixed acidity&quot;]
free_sulfur_dioxide = dataframe[&#x27;free sulfur dioxide&#x27;]
total_sulfur_dioxide = dataframe[&#x27;total sulfur dioxide&#x27;]
alcohol = dataframe[&#x27;alcohol&#x27;]

columns = [fixed_acidity, free_sulfur_dioxide, total_sulfur_dioxide, alcohol]

fig, ax = plt.subplots()
ax.boxplot(columns)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-2.png" alt="box plot matplotlib multiple columns">
Now, we've got a lot more going on, since we've decided to plot multiple columns.
<h2 id="customizingtheplot">Customizing the Plot</h2>
As you can see, while the plots have successfully been generated, without tick labels on the X and Y-axis, it is difficult to interpret the graph.
We can customize the plot and add labels to the X-axis by using the <code>xticks</code> function. Let's pass in the number of labels we want to add and then the labels for each of those columns:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.boxplot(columns)
plt.xticks([1, 2, 3, 4], [&quot;Fixed acidity&quot;, &quot;Free sulfur dioxide&quot;, &quot;Total sulfur dioxide&quot;, &quot;Alcohol&quot;], rotation=10)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-3.png" alt="label customization box plot matplotlib">
If we wanted to we could also change the orientation of the plot by altering the <code>vert</code> parameter. <code>vert</code> controls whether or not the plot is rendered vertically and it is set to <code>1</code> by default:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.boxplot(fixed_acidity, vert=0)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-4.png" alt="vertical box plot matplotlib">
The <code>notch=True</code> attribute creates the notch format to the box plot, <code>patch_artist=True</code> fills the boxplot with colors:
<pre><code class="hljs">fig, ax = plt.subplots()
columns = [free_sulfur_dioxide, total_sulfur_dioxide]
ax.boxplot(columns, notch=True, patch_artist=True)
plt.xticks([1, 2], [&quot;Free sulfur dioxide&quot;, &quot;Total sulfur dioxide&quot;])
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-5.png" alt="notches and patches box plot matplotlib">
We can make use of the <code>meanline</code> argument to render the mean on the box, although this should be avoided if we are also showing notches, since they can conflict.
This must be combined with the <code>showmean</code> parameter. If possible, the mean will be visualized as a line that runs all the way across the box. If not possible, the mean will be shown as points:
<pre><code class="hljs">fig, ax = plt.subplots()
columns = [free_sulfur_dioxide, total_sulfur_dioxide]
ax.boxplot(columns, patch_artist=True, meanline=True, showmeans=True)
plt.xticks([1, 2], [&quot;Free sulfur dioxide&quot;, &quot;Total sulfur dioxide&quot;])
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-6.png" alt="showmean box plot matplotlib">
We can color the different feature columns by creating a list of hex color values and using the <code>set_facecolor</code> argument. In the below example, we <code>zip</code> the <code>boxes</code> element of the <code>box</code> variable together with the colors we want to use and then set the face color for each of those boxes.
<pre><code class="hljs">columns = [fixed_acidity, free_sulfur_dioxide, total_sulfur_dioxide, alcohol]
fig, ax = plt.subplots()
box = ax.boxplot(columns, notch=True, patch_artist=True)
plt.xticks([1, 2, 3, 4], [&quot;Fixed acidity&quot;, &quot;Free sulfur dioxide&quot;, &quot;Total sulfur dioxide&quot;, &quot;Alcohol&quot;])

colors = [&#x27;#0000FF&#x27;, &#x27;#00FF00&#x27;,
 &#x27;#FFFF00&#x27;, &#x27;#FF00FF&#x27;]

for patch, color in zip(box[&#x27;boxes&#x27;], colors):
 patch.set_facecolor(color)

plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-box-plot-tutorial-and-examples-7.png" alt="change box plot colors matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned how to create a Box Plot in Matplotlib and Python. Then, we took a look at how you can customize it using arguments like <code>vert</code>, <code>meanline</code>, and <code>set_facecolor</code>.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

Dan Nelson

In this tutorial, we'll cover how to plot Box Plots in Matplotlib with Python. We'll cover basic Box Plots and Customization with examples in detail.

Matplotlib Box Plot - Tutorial and Examples

Geoffery, Joseph

In this tutorial, we'll go over everything you need to know to Integrate MongoDB with Flask and Python by building a functional CRUD application.

Integrating MongoDB with Flask Using Flask-PyMongo

<h2 id="introduction">Introduction</h2>
Seaborn is one of the most widely used data visualization libraries in Python, as an extension to Matplotlib. It offers a simple, intuitive, yet highly customizable API for data visualization.
In this tutorial, we'll take a look at how to plot a boxplot in Seaborn.
<blockquote>
Boxplots are used to visualize summary statistics of a dataset, displaying attributes of the distribution like the data’s range and distribution.
</blockquote>
<h2 id="importdata">Import Data</h2>
We’ll need to select a dataset with continuous features in order to create a boxplot, because boxplots display summary statistics for continuous variables - the median and range of a dataset. We’ll be working with the <a rel="nofollow noopener" target="_blank" href="http://archive.ics.uci.edu/ml/datasets/Forest+Fires">Forest Fires</a> dataset.
We’ll begin with importing Pandas to load and parse the dataset. We’ll obviously want to import Seaborn as well. Finally, we’ll import the Pyplot module from Matplotlib, so that we can show the visualizations:
<pre><code class="hljs">import pandas as pd
from matplotlib import pyplot as plt
import seaborn as sns
</code></pre>
Let's use Pandas to read the CSV file and check how our <code>DataFrame</code> looks by printing its head. Additionally, we'll want to check if the dataset contains any missing values:
<pre><code class="hljs">dataframe = pd.read_csv(&quot;forestfires.csv&quot;)
print(dataframe.head())
print(dataframe.isnull().values.any())
</code></pre>
<pre><code class="hljs"> X Y month day FFMC DMC DC ISI temp RH wind rain area
0 7 5 mar fri 86.2 26.2 94.3 5.1 8.2 51 6.7 0.0 0.0
1 7 4 oct tue 90.6 35.4 669.1 6.7 18.0 33 0.9 0.0 0.0
2 7 4 oct sat 90.6 43.7 686.9 6.7 14.6 33 1.3 0.0 0.0
3 8 6 mar fri 91.7 33.3 77.5 9.0 8.3 97 4.0 0.2 0.0
4 8 6 mar sun 89.3 51.3 102.2 9.6 11.4 99 1.8 0.0 0.0
False
</code></pre>
The second print statement returns <code>False</code>, which means that there isn't any missing data. If there were, we'd have to <a target="_blank" href="/python-how-to-handle-missing-dataframe-values-in-pandas">handle missing DataFrame values</a>.
After we check for the consistency of our dataset, we want to select the continuous features that we want to visualize. We’ll save these as their own variables for convenience:
<pre><code class="hljs">FFMC = dataframe[&quot;FFMC&quot;]
DMC = dataframe[&quot;DMC&quot;]
DC = dataframe[&quot;DC&quot;]
RH = dataframe[&quot;RH&quot;]
ISI = dataframe[&quot;ISI&quot;]
temp = dataframe[&quot;temp&quot;]
</code></pre>
<h2 id="plottingaboxplotinseaborn">Plotting a Boxplot in Seaborn</h2>
Now that we have loaded in the data and selected the features that we want to visualize, we can create the Boxplots!
We can create the boxplot just by using Seaborn’s <code>boxplot</code> function. We pass in the dataframe as well as the variables we want to visualize:
<pre><code class="hljs">sns.boxplot(x=DMC)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-1.png" alt="seaborn simple boxplot">
If we want to visualize just the distribution of a categorical variable, we can provide our chosen variable as the <code>x</code> argument. If we do this, Seaborn will calculate the values on the Y-axis automatically, as we can see on the previous image.
However, if there’s a specific distribution that we want to see segmented by type, we can also provide a categorical X-variable and a continuous Y-variable.
<pre><code class="hljs">day = dataframe[&quot;day&quot;]
sns.boxplot(x=DMC, y=day)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-2.png" alt="seaborn x and y variable boxplot">
This time around, we can see a boxplot generated for each day in the week, as specified in the dataset.
If we want to visualize multiple columns at the same time, what do we provide to the <code>x</code> and <code>y</code> arguments? Well, we provide the labels for the data we want, and provide the actual data using the <code>data</code> argument.
We can create a new <code>DataFrame</code> containing just the data we want to visualize, and <code>melt()</code> it into the <code>data</code> argument, providing labels such as <code>x='variable'</code> and <code>y='value'</code>:
<pre><code class="hljs">df = pd.DataFrame(data=dataframe, columns=[&quot;FFMC&quot;, &quot;DMC&quot;, &quot;DC&quot;, &quot;ISI&quot;])
sns.boxplot(x=&quot;variable&quot;, y=&quot;value&quot;, data=pd.melt(df))
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-3.png" alt="seaborn data argument boxplot">
<h2 id="customizeaseabornboxplot">Customize a Seaborn Boxplot</h2>
<h3 id="changeboxplotcolors">Change Boxplot Colors</h3>
Seaborn will automatically assign the different colors to different variables so we can easily visually differentiate them. Though, we can also supply a list of colors to be used if we'd like to specify them.
After choosing a list of colors with hex values (or any valid Matplotlib color), we can pass them into the <code>palette</code> argument:
<pre><code class="hljs">day = dataframe[&quot;day&quot;]
colors = [&#x27;#78C850&#x27;, &#x27;#F08030&#x27;, &#x27;#6890F0&#x27;,&#x27;#F8D030&#x27;, &#x27;#F85888&#x27;, &#x27;#705898&#x27;, &#x27;#98D8D8&#x27;]
sns.boxplot(x=DMC, y=day, palette=colors)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-4.png" alt="seaborn change colors boxplot">
<h3 id="customizeaxislabels">Customize Axis Labels</h3>
We can adjust the X-axis and Y-axis labels easily using Seaborn, such as changing the font size, changing the labels, or rotating them to make the ticks easier to read:
<pre><code class="hljs">df = pd.DataFrame(data=dataframe, columns=[&quot;FFMC&quot;, &quot;DMC&quot;, &quot;DC&quot;, &quot;ISI&quot;])
boxplot = sns.boxplot(x=&quot;variable&quot;, y=&quot;value&quot;, data=pd.melt(df))
boxplot.axes.set_title(&quot;Distribution of Forest Fire Conditions&quot;, fontsize=16)
boxplot.set_xlabel(&quot;Conditions&quot;, fontsize=14)
boxplot.set_ylabel(&quot;Values&quot;, fontsize=14)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-5.png" alt="seaborn customize boxplot axis labels">
<h3 id="orderingboxplots">Ordering Boxplots</h3>
If we want to view the boxes in a specific order, we can do that by making use of the <code>order</code> argument, and supplying the column names in the order you want to see them in:
<pre><code class="hljs">df = pd.DataFrame(data=dataframe, columns=[&quot;FFMC&quot;, &quot;DMC&quot;, &quot;DC&quot;, &quot;ISI&quot;])
boxplot = sns.boxplot(x=&quot;variable&quot;, y=&quot;value&quot;, data=pd.melt(df), order=[&quot;DC&quot;, &quot;DMC&quot;, &quot;FFMC&quot;, &quot;ISI&quot;])
boxplot.axes.set_title(&quot;Distribution of Forest Fire Conditions&quot;, fontsize=16)
boxplot.set_xlabel(&quot;Conditions&quot;, fontsize=14)
boxplot.set_ylabel(&quot;Values&quot;, fontsize=14)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-6.png" alt="seaborn order boxplots">
<h2 id="creatingsubplots">Creating Subplots</h2>
If we wanted to separate out the plots for the individual features into their own subplots, we could do that by creating a figure and axes with the <code>subplots</code> function from Matplotlib. Then, we use the <code>axes</code> object and access them via their index. The <code>boxplot()</code> function accepts an <code>ax</code> argument, specifying on which <code>axes</code> it should be plotted on:
<pre><code class="hljs">fig, axes = plt.subplots(1, 2)
sns.boxplot(x=day, y=DMC, orient=&#x27;v&#x27;, ax=axes[0])
sns.boxplot(x=day, y=DC, orient=&#x27;v&#x27;, ax=axes[1])
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-7.png" alt="seaborn create boxplot subplots">
<h2 id="boxplotwithdatapoints">Boxplot with Data Points</h2>
We could even overlay a swarmplot onto the boxplot in order to see the distribution and samples of the points comprising that distribution, with a bit more detail.
In order to do this, we just create a single figure object and then create two different plots. The <code>stripplot()</code> will be overlaid over the <code>boxplot()</code>, since they're on the same <code>axes</code>/<code>figure</code>:
<pre><code class="hljs">df = pd.DataFrame(data=dataframe, columns=[&quot;FFMC&quot;, &quot;DMC&quot;, &quot;DC&quot;, &quot;ISI&quot;])
boxplot = sns.boxplot(x=&quot;variable&quot;, y=&quot;value&quot;, data=pd.melt(df), order=[&quot;DC&quot;, &quot;DMC&quot;, &quot;FFMC&quot;, &quot;ISI&quot;])
boxplot = sns.stripplot(x=&quot;variable&quot;, y=&quot;value&quot;, data=pd.melt(df), marker=&quot;o&quot;, alpha=0.3, color=&quot;black&quot;, order=[&quot;DC&quot;, &quot;DMC&quot;, &quot;FFMC&quot;, &quot;ISI&quot;])
boxplot.axes.set_title(&quot;Distribution of Forest Fire Conditions&quot;, fontsize=16)
boxplot.set_xlabel(&quot;Conditions&quot;, fontsize=14)
boxplot.set_ylabel(&quot;Values&quot;, fontsize=14)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-box-plot-tutorial-and-examples-8.png" alt="seaborn overlay stripplot over boxplot">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a boxplot using Seaborn and Python. We've also covered how to customize the colors, labels, ordering, as well as overlay swarmplots and subplot multiple boxplots.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll cover how to plot a Box Plot in Seaborn and Python with detailed examples of plotting and customization.

Seaborn Box Plot - Tutorial and Examples

Seaborn Boxplot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Scheduling a job in Jenkins is very useful when it comes to developing a great product. Imagine what a great advantage it is to transform a time-consuming task into an automated job. It doesn't need any supervision and as long as there are no errors in the workflow, you shouldn't have any worries.
In today's article we'll make a job that will run every five minutes and has the following output:
<pre><code class="hljs">Hello, World!
Today&#x27;s:
&lt;&lt;date&gt;&gt;
Here&#x27;s the current time:
&lt;&lt;time&gt;&gt;
</code></pre>
Additionally, we'll build a job that watches another project, and depending on its status, prints out an automated statement.
<h2 id="usecasesforautomationwithjenkins">Use-Cases for Automation with Jenkins</h2>
But before we dive into the technical part, let's take a moment to consider what can be automated in Jenkins. Of course, with a little imagination, you can tackle most problems and automate them. Let's take a look at an example that could be automated with Jenkins if you have a little (more) patience and you're also eager to deepen your Jenkins skills.
Products like Amazon Echo and Alexa could be configured to call Jenkins jobs that perform various actions. You could relatively easily integrate it into your smart home:
<ol>
<li>Say, &quot;Alexa, lock the doors&quot; (that would be the trigger, meaning Jenkins will listen to that event).</li>
<li>Alexa skill activates a Jenkins job.</li>
<li>Jenkins' job will use a script to call the smart doors locking system API.</li>
<li>Alexa waits for the Jenkins job to finish and tells you how it went, i.e. &quot;Door successfully locked&quot;, &quot;The doors are already locked&quot; or &quot;The doors could not be locked&quot;.</li>
</ol>
Of course, that's not a CI/CD job, but is well within the domain of possibilities for existing tech with Jenkins.
<h2 id="requirements">Requirements</h2>
<ul>
<li>A Jenkins server – for this tutorial, we'll use the official Docker image to set up a Jenkins server</li>
<li>A job that you'd like automated</li>
</ul>
<h2 id="creatingajenkinsjob">Creating a Jenkins Job</h2>
Login in to your Jenkins application and click on Create a Job. The type of job doesn't matter. It can be Freestyle, Maven, etc. All that matters is how we configure the scheduler.
For this article, we'll go with Pipeline. Choose a name for your project and save it:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-1.png" alt="create jenkins project">
Now, before we deal with the scheduling part, let's set up the Pipeline Groovy script which will print the message from the introduction.
Scroll down to Pipeline and add the following script:
<pre><code class="hljs">pipeline {
 agent any

 stages {
 stage(&#x27;Write Greetings&#x27;) {
 steps {
 echo &#x27;Hello, World!&#x27;
 }
 }
 
 stage(&#x27;Write Date&#x27;) {
 steps {
 print &#x27;Today\&#x27;s &#x27;
 print new Date().format(&quot;dd-MM-yyyy&quot;, TimeZone.getTimeZone(&quot;UTC&quot;))
 }
 }
 
 stage(&#x27;Write Hour&#x27;) {
 steps {
 print &#x27;Here\&#x27;s the current time &#x27;
 print new Date().format(&quot;HH:mm:ss&quot;, TimeZone.getTimeZone(&quot;UTC&quot;))
 }
 }
 }
}
</code></pre>
The script has three stages: Write Greetings, Write Date, and Write Hour. We use stages in order to better define and structure our script. Also, the stages can be viewed in the Jenkins UI.
In case one of them fails, you'll know which one:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-2.png" alt="Pipeline Groovy Script">
<h2 id="runningthejob">Running the Job</h2>
We have our job ready to be triggered! Let's click on Build Now and check the output:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-3.png" alt="Build the jenkins job">
<pre><code class="hljs">Started by user Alex
Running in Durability level: MAX_SURVIVABILITY
Running on Jenkins in /var/jenkins_home/workspace/Scheduled Pipeline
Hello, World!
Today&#x27;s:
24-12-2020
Here&#x27;s the current time:
16:00:38
Finished: SUCCESS
</code></pre>
You can also see on the Job's page the average time for every stage:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-4.png" alt="Jenkins Job Stage Details">
There are many ways to trigger a Jenkins job: manually (of course), using a Cron Expression, hooks, watching other projects, etc.
<h2 id="schedulingjenkinsjobswithcron">Scheduling Jenkins Jobs with Cron</h2>
Let's start with triggering a job via the Cron utility. We'll choose Build periodically and for the Schedule field use the following expression:
<pre><code class="hljs">H/5 * * * *
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-5.png" alt="Schedule the Jenkins Job">
This expression means the job will be executed every 5 minutes. A few useful examples of other patterns could be:
<ul>
<li><code>0 0 13 1/1 * ? *</code> – every hour, starting with 13:00;</li>
<li><code>0 0 17 ? * MON-FRI *</code> – every working day, at 5 PM;</li>
</ul>
If you don't want to learn this type of formatting in order to schedule your job, you can use a Cron Expression generator like <a rel="nofollow noopener" target="_blank" href="http://www.cronmaker.com/?1">CronMaker</a>.
Let's see the result. For this, we'll have to wait. After 10 minutes you should see that 2 jobs were triggered automatically:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-6.png" alt="Jenkins Job Results">
Notice the first job was executed at 9:12 PM, then at 9:17 PM, and the last at 9:22 PM. So the rule worked! We have a job which runs every 5 minutes.
<h2 id="schedulingajenkinsjobbywatchingotherprojects">Scheduling a Jenkins Job by Watching Other Projects</h2>
Now that we've seen how we can schedule a job periodically, let's create another one that triggers itself every time the first one was successful. Create another Pipeline project, and add the following code:
<pre><code class="hljs">pipeline {
 agent any

 stages {
 stage(&#x27;It worked&#x27;) {
 steps {
 echo &#x27;The other job worked!&#x27;
 }
 }
 }
}
</code></pre>
We have our pipeline script, let's schedule it. In the Build Triggers tab, select Build after other projects are built.
Enter the project which needs to be watched and select the cases when this one should be triggered:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-7.png" alt="Watch Projects">
Save it and let's wait for a little while. You should see the new job trigger itself every time the first one succeeds. You can see the details of the first run of this second job that was triggered by the job created before:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-8.png" alt="Jenkins Job Details">
Here's the output:
<pre><code class="hljs">Started by upstream project &quot;Scheduled Pipeline&quot; build number 7
originally caused by:
 Started by timer
Running in Durability level: MAX_SURVIVABILITY
Running on Jenkins in /var/jenkins_home/workspace/The other job worked
The other job worked!
Finished: SUCCESS
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Automation is very useful and one of the key things technology brings us, regardless of the process you want to automate.
In this article, we've gone over how to schedule a job in Jenkins to run periodically using a Cron pattern, as well as to run when other projects are built.

Alex Chirea

In this tutorial, we'll go over examples on how to schedule a job in Jenkins to run periodically using Cron and how to run by watching other projects.

How to Schedule a Job with Jenkins

<h2 id="introduction">Introduction</h2>
Dictionaries are one of the most used data structures in all of software development, and for a good reason. They allow us to store our data in neat key, value pairs, which in turn gives us the ability to, on average, access our data in <code>O(1)</code> time.
While using a dictionary it's important to know how to iterate over it. Not being able to recover the data you stored makes it practically useless.
In this article, we'll see how to iterate through a Python dictionary with all kinds of iterators and the <code>for</code> loop.
<h2 id="usingthekeysmethod">Using the keys() Method</h2>
Python dictionaries have a handy method which allows us to easily iterate through all initialized keys in a dictionary, <code>keys()</code>.
Keep in mind that since Python 3, this method does not return a list, it instead returns a view object. A view object is exactly like the name says, a view of some data.
This means that we can iterate through said data no problem, but if we want to actually store the list of keys, we need to materialize it. Which can easily be done by forwarding the provided view object to a <code>list</code> constructor.
Let's take a look at how it all works:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

# Here we&#x27;re just &#x27;looking&#x27; at the keys,
# we&#x27;re not actually constructing a list 
# out of them
key_view = my_dict.keys()
print(&quot;Key view:&quot;, key_view)
print(&quot;Type:&quot;, type(key_view),end=&quot;\n\n&quot;)

# Here we&#x27;re materializing the keys
# into a list ofo keys
key_list = list(my_dict.keys())
print(&quot;Key list:&quot;, key_list)
print(&quot;Type: &quot;, type(key_list),end=&quot;\n\n&quot;)

# And as we can see, view can be easily be
# used for iterating over a dictionary
for key in my_dict.keys():
 print(key, &#x27;:&#x27;, my_dict[key]) 
</code></pre>
Running the code gives us the following output:
<pre><code class="hljs">Key view: dict_keys([&#x27;alpha&#x27;, &#x27;beta&#x27;, &#x27;gamma&#x27;])
Type: &lt;class &#x27;dict_keys&#x27;&gt;

Key list: [&#x27;alpha&#x27;, &#x27;beta&#x27;, &#x27;gamma&#x27;]
Type: &lt;class &#x27;list&#x27;&gt;

alpha : 5
beta : 4
gamma : 3 
</code></pre>
An alternative way of doing this would be:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

for key in my_dict:
 print(key, &#x27;:&#x27;, my_dict[key])
</code></pre>
When using the <code>in</code> keyword in conjunction with a dictionary, the dictionary invokes its <code>__iter__()</code> method. This method then returns an iterator which is used to implicitly go through the keys of the provided dictionary.
<h2 id="usingthevaluesmethod">Using the values() Method</h2>
Just like the <code>keys()</code> method, the <code>values()</code> method also return a view object, but instead of iterating through keys, it iterates through values:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

# Inspecting the view of the values
# in the dictionary
key_list = list(my_dict.values())
print(&quot;Value list:&quot;, key_list)
print(&quot;Type: &quot;, type(key_list), end=&quot;\n\n&quot;)

for value in my_dict.values():
 print(value, end=&quot; &quot;)
</code></pre>
Running the code gives us the following output:
<pre><code class="hljs">Value list: [5, 4, 3]
Type: &lt;class &#x27;list&#x27;&gt;
5 4 3 
</code></pre>
Unlike the previous method, this one only provides values. It is useful when you are not concerned about keys.
<h2 id="usingtheitemsmethod">Using the items() method</h2>
Just like the <code>keys()</code> and <code>values()</code> methods, the <code>items()</code> method also returns a view object, but instead of just iterating through either <code>keys</code> or <code>values</code>, it iterates through <code>(key,value)</code> pairs.
Let's take a look at how it all works:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

# Inspecting the view of the (key,value) pairs
key_list = list(my_dict.items())
print(&quot;(key,value) pair list:&quot;, key_list)
print(&quot;Type: &quot;, type(key_list), end=&quot;\n\n&quot;)

for item in my_dict.items():
 print(item, end=&quot; &quot;)
</code></pre>
Running the code gives us the following output:
<pre><code class="hljs">(key,value) pair list: [(&#x27;alpha&#x27;, 5), (&#x27;beta&#x27;, 4), (&#x27;gamma&#x27;, 3)]
Type: &lt;class &#x27;list&#x27;&gt;
(&#x27;alpha&#x27;, 5) (&#x27;beta&#x27;, 4) (&#x27;gamma&#x27;, 3) 
</code></pre>
To immediately assign both keys and values simultaneously, we can use tuple unpacking and extract them by using variables for each value in a tuple:
<pre><code class="hljs">for key, value in my_dict.items():
 print(key,&#x27;:&#x27;,value)
</code></pre>
It is important to note that in older Python 2 versions where <code>items()</code>, <code>keys()</code>, and <code>values()</code> returned a copy of data from a dictionary. While in Python 3 they return a view object.
These are more effective as they provide a dynamic view and, additionally if any changes are made in the original dictionary, they will immediately be reflected in the view object (and vice versa).
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered different ways to iterate over a Python dictionary. This includes the <code>keys()</code>, <code>values()</code> and <code>items()</code> methods, with a <code>for</code> loop.

Guest Contributor

In this tutorial, we'll go over how to iterate through a dictionary in Python, using keys(), values() and items() and a for loop, with examples.

How to Iterate Over a Dictionary in Python

<h2 id="introduction">Introduction</h2>
A Stream is a sequence of objects that supports many different methods that can be combined to produce the desired result.
They can be created from numerous data sources, which are most often collections but can also be I/O channels, <code>Arrays</code>, primitive data types etc.
It's important to emphasize that a stream is not a data structure, since it doesn't store any data. It's just a data source wrapper which allows us to operate with data faster, easier and with cleaner code.
A stream also never modifies the original data structure, it just returns the result of the pipelined methods.
<h2 id="typesofstreams">Types of Streams</h2>
Streams can be sequential (created with <code>stream()</code>), or parallel (created with <code>parallelStream()</code>). Parallel streams can operate on multiple threads, while sequential streams can't.
Operations on streams can be either intermediate or terminal:
Intermediate operations on streams return a stream. This is why we can chain multiple intermediate operations without using semicolons. Intermediate operations include the following methods:
<ul>
<li><code>map(op)</code> - Returns a new stream in which the provided <code>op</code> function is applied to each of the elements in the original stream</li>
<li><code>filter(cond)</code> - Returns a new stream which only contains the elements from the original stream that satisfy the condition <code>cond</code>, specified by a predicate</li>
<li><code>sorted()</code> - Returns the original stream, but with the elements being sorted</li>
</ul>
Terminal operations are either void or return a non-stream result. They're called terminal because we can't chain any more stream operations once we've used a terminal one, without creating a new stream from it and starting again.
Some of the terminal operations are:
<ul>
<li><code>collect()</code> - Returns the result of the intermediate operations performed on the original stream</li>
<li><code>forEach()</code> - A void method used to iterate through the stream</li>
<li><code>reduce()</code> - Returns a single result produced from an entire sequence of elements in the original stream</li>
</ul>
In this tutorial, we'll go over the <code>map()</code> operation and how we can use it with Streams to convert/map objects of various types.
<h2 id="streammapexamples">Stream.map() Examples</h2>
Let's take a look at a couple of examples and see what we can do with the <code>map()</code> operation.
<h3 id="streamofintegerstostreamofstrings">Stream of Integers to Stream of Strings</h3>
<pre><code class="hljs">Arrays.asList(1, 2, 3, 4).stream()
 .map(n -&gt; &quot;Number &quot; + String.valueOf(n))
 .forEach(n -&gt; System.out.println(n + &quot; as a &quot; + n.getClass().getName()));
</code></pre>
Here, we've made a list of integers and called <code>stream()</code> on the list to create a new stream of data. Then, we've mapped each number <code>n</code> in the list, via the <code>map()</code> method, to a String. The Strings simply consist of <code>&quot;Number&quot;</code> and the <code>String.valueOf(n)</code>.
So for each number in our original list, we'll now have a <code>&quot;Number n&quot;</code> String corresponding to it.
Since <code>map()</code> returns a <code>Stream</code> again, we've used the <code>forEach()</code> method to print each element in it.
Running this code results in:
<pre><code class="hljs">Number 1 as a java.lang.String
Number 2 as a java.lang.String
Number 3 as a java.lang.String
Number 4 as a java.lang.String
</code></pre>
Note: This hasn't altered the original list in the slightest. We've simply processed the data and printed the results. If we wanted to persist this change, we'd <code>collect()</code> the data back into a <code>Collection</code> object such as a <code>List</code>, <code>Map</code>, <code>Set</code>, etc:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(1, 2, 3, 4);
 
List&lt;String&gt; mappedList = list.stream()
 .map(n -&gt; &quot;Number &quot; + String.valueOf(n))
 .collect(Collectors.toList());

System.out.println(list);
System.out.println(mappedList);
</code></pre>
This results in:
<pre><code class="hljs">[1, 2, 3, 4]
[Number 1, Number 2, Number 3, Number 4]
</code></pre>
<h3 id="streamofstringsintostreamofintegers">Stream of Strings into Stream of Integers</h3>
Now, let's do it the other way around - convert a stream of strings into a stream of integers:
<pre><code class="hljs">Arrays.asList(&quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;).stream()
 .map(n -&gt; Integer.parseInt(n))
 .forEach(n -&gt; System.out.println(n));
</code></pre>
As expected, this code will produce the following output:
<pre><code class="hljs">1
2
3
4
</code></pre>
<h3 id="listofobjectsintolistofotherobjects">List of Objects into List of Other Objects</h3>
Let's say we have a class <code>Point</code> that represents one point in a cartesian coordinate system:
<pre><code class="hljs">public class Point {
 int X;
 int Y;
 
 Point(int x, int y){
 this.X=x;
 this.Y=y;
 }
 
 @Override
 public String toString() {
 return &quot;(&quot; + this.X + &quot;, &quot; + this.Y + &quot;)&quot;;
 }
 
}
</code></pre>
Then, say we want to scale a certain shape by a factor of <code>2</code>, this means we have to take all the points we have, and double both their <code>X</code> and <code>Y</code> values. This can be done by mapping the original values to their scaled counterparts.
Then, since we'd like to use the new coordinates, we'll collect this data into a new list of scaled points:
<pre><code class="hljs">List&lt;Point&gt; originalPoints = Arrays.asList(new Point(1, 2),
 new Point(3, 4),
 new Point(5, 6),
 new Point(7, 8));
System.out.println(&quot;Original vertices: &quot; + originalPoints);
 
List&lt;Point&gt; scaledPoints = originalPoints
 .stream()
 .map(n -&gt; new Point(n.X * 2, n.Y * 2))
 .collect(Collectors.toList());

System.out.println(&quot;Scaled vertices: &quot; + scaledPoints);
</code></pre>
This example will produce the following output:
<pre><code class="hljs">Original vertices: [(1, 2), (3, 4), (5, 6), (7, 8)]
Scaled vertices: [(2, 4), (6, 8), (10, 12), (14, 16)]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we explained what streams are in Java. We mentioned some of the basic methods used on streams, and focused specifically on the <code>map()</code> method and how it can be used for stream manipulation.
It is important to mention that streams are not really a mandatory part of programming, however they are more expressive and can significantly improve the readability of your code, which is why they became a common programming practice.

Mila Lukic

In this tutorial, we've gone over examples of how to use the Stream.map() method in Java 8. We've included a refresher on streams and jumped into practical examples.

Java 8 - Stream.map() Examples

<h2 id="introduction">Introduction</h2>
Currency is a very important part of our modern world. So, it's equally important for us to be able to properly express it in Java.
In this tutorial, we'll go over how to format numbers as currency Strings in Java.
<h2 id="formatnumberascurrencystring">Format Number as Currency String</h2>
Here's how you can easily format a number, such as a <code>double</code> into a currency String:
<pre><code class="hljs">double currencyAmount = 1500.00;
// Create a new Locale
Locale usa = new Locale(&quot;en&quot;, &quot;US&quot;);
// Create a Currency instance for the Locale
Currency dollars = Currency.getInstance(usa);
// Create a formatter given the Locale
NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);

// Format the Number into a Currency String
System.out.println(dollars.getDisplayName() + &quot;: &quot; + dollarFormat.format(currencyAmount));
</code></pre>
If we run this code, it'll result in:
<pre><code class="hljs">US Dollar: $1,500.00
</code></pre>
Formatting numbers in different currencies involves a few Java classes. Our example made use of the <code>Locale</code> and <code>Currency</code> classes from the <code>java.util</code> package. Additionally, we used the <code>NumberFormat</code> class, which can be found in the <code>java.text</code> package.
Let's dive deeper into these classes and write a method that formats our number into multiple currencies, depending on an input.
<h2 id="thelocaleclass">The Locale Class</h2>
Each <code>Locale</code> object expresses a geopolitical region and includes information such as language and location. Countries have unique ways of expressing currency. Instead of us having to manually format each currency differently, using <code>Locale</code> objects allow us to automate this process.
To create a new <code>Locale</code> object, we can use one of the three available constructors:
<pre><code class="hljs">Locale(String language);
Locale(String language, String country);
Locale(String language, String country, String variant);
</code></pre>
Do note, however, that the <code>String</code> parameters for the constructors cannot be arbitrary. You can find a full list of all supported locales in Java 8 <a href="https://www.oracle.com/java/technologies/javase/jdk8-jre8-suported-locales.html" target="_blank" rel="noopener nofollow">here</a>.
Now let's create some example <code>Locale</code> objects. We will reference these later when we are creating the actual method for printing out currency:
<pre><code class="hljs">Locale usa = new Locale(&quot;en&quot;, &quot;US&quot;);
Locale germany = new Locale(&quot;de&quot;, &quot;DE&quot;);
Locale japan = new Locale(&quot;jp&quot;, &quot;JP&quot;);
</code></pre>
Since we are working with currency, the first <code>String</code> parameter, language, will dictate the formatting of the currency value (ex. 1,000,000.00 or 1.000.000,00). The second <code>String</code> parameter, region, will determine which currency sign is used (ex. $ or ¥).
<h2 id="thecurrencyclass">The Currency Class</h2>
The second class that we need to understand is the <code>Currency</code> class. Each <code>Currency</code> object represents a world currency. We want to get a currency given our <code>Locale</code>, so we will be using the following method:
<pre><code class="hljs">Currency.getInstance(Locale locale);
</code></pre>
This will return the corresponding <code>Currency</code> instance for the specified <code>Locale</code> parameter. So, using the <code>Locale</code> objects we created previously, this is what we will do:
<pre><code class="hljs">Currency dollars = Currency.getInstance(usa);
Currency euros = Currency.getInstance(germany);
Currency yen = Currency.getInstance(japan);
</code></pre>
Now that we have created our three <code>Currency</code> instances, we can move on to our next class.
<h2 id="thenumberformatclass">The NumberFormat Class</h2>
The <code>NumberFormat</code> class has methods to format numbers based on locales. Countries have different ways of grouping numbers. For example, one thousand can be represented as &quot;1000&quot;, &quot;1,000&quot;, &quot;1 000&quot; and other variations.
We'll be using the <code>NumberFormat.getCurrencyInstance(Locale l)</code> method. This method returns a <code>NumberFormat</code> object that corresponds to the <code>Locale</code> parameter specified. This is how we'll be using it in our method:
<pre><code class="hljs">NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);
NumberFormat eurosFormat = NumberFormat.getCurrencyInstance(germany);
NumberFormat yenFormat = NumberFormat.getCurrencyInstance(japan);
</code></pre>
<h2 id="creatingamethodtoprintanumberasacurrency">Creating a Method to Print a Number as a Currency</h2>
Now that we have learned about the three classes needed for this program, we can start writing the actual method to print a <code>double</code> with currency formatting.
We'll also accept a String, specifying which currency we'd like to print it as:
<pre><code class="hljs">public static void printCurrency(double currencyAmount, String outputCurrency) {
 Locale locale;
 
 if (outputCurrency.equals(&quot;Yen&quot;)) {
 locale = new Locale(&quot;jp&quot;, &quot;JP&quot;);
 } else if(outputCurrency.equals(&quot;Euros&quot;)) {
 locale = new Locale(&quot;de&quot;, &quot;DE&quot;);
 } else if (outputCurrency.equals(&quot;Dollars&quot;)) {
 locale = new Locale(&quot;en&quot;, &quot;US&quot;);
 } else {
 locale = new Locale(&quot;en&quot;, &quot;US&quot;);
 }
 
 Currency currency = Currency.getInstance(locale);
 NumberFormat numberFormat = NumberFormat.getCurrencyInstance(locale);
 
 System.out.println(currency.getDisplayName() + &quot;: &quot; + numberFormat.format(currencyAmount)); 

 }
}
</code></pre>
Let's test this method out by calling it and passing in the appropriate arguments:
<pre><code class="hljs">printCurrency(1000000.00, &quot;Yen&quot;);
printCurrency(1000000.00, &quot;Dollars&quot;);
printCurrency(1000000.00, &quot;Euros&quot;);
</code></pre>
This results in:
<pre><code class="hljs">Japanese Yen: JPY 1,000,000
US Dollar: $1,000,000.00
Euro: 1.000.000,00 €
</code></pre>
For this example, we used a <code>double</code> and printed as currency with proper formatting. Other number types would work as well, but we advise to stick with <code>double</code> for currency values.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned a bit about the <code>Locale</code>, <code>Currency</code>, and <code>NumberFormat</code> classes. We then applied this knowledge in a method that allowed us to correctly format and print a <code>double</code> as currency.

In this guide, you will use Java to format a number into a currency string. We use Locale, Currency and NumberFormat objects.

How to Format Number as Currency String in Java

<h2 id="introduction">Introduction</h2>
In this article we're going to be taking a look at the try/except clause, and specifically how you can catch multiple exceptions in a single line, as well as how to use the <code>suppress()</code> method.
Both of these techniques will help you in writing more accessible and versatile code that adheres to DRY (don't repeat yourself) principles.
Let's start by looking at the problem:
<pre><code class="hljs">try:
 do_the_thing()
except TypeError as e:
 do_the_other_thing()
except KeyError as e:
 do_the_other_thing()
except IndexError as e:
 do_the_other_thing()
</code></pre>
Brutal.
As we can see, this is very WET code, we repeat the same invocation multiple times. Practices like this can make our code's reading and refactoring a living nightmare.
<blockquote>
Rather than writing exceptions one after another, wouldn't it be better to group all of these exception handlers into a single line?
</blockquote>
<h2 id="multipleexceptions">Multiple Exceptions</h2>
If you're just here for a quick answer, it's simple: use a tuple.
All the errors contained in the exception line tuple will be evaluated together:
<pre><code class="hljs">try:
 do_the_thing()
except (TypeError, KeyError, IndexError) as e:
 do_the_other_thing()
</code></pre>
Easy, right?
<h2 id="avoidingbadpractices">Avoiding Bad Practices</h2>
<blockquote>
&quot;Errors should never pass silently.&quot; - <a rel="nofollow noopener" target="_blank" href="https://www.python.org/dev/peps/pep-0020/#:~:text=Errors%20should%20never%20pass%20silently,obvious%20way%20to%20do%20it.">The Zen of Python</a>.
</blockquote>
try/except clauses are probably the most misused pattern in Python.
Used improperly, they end up being the cliché of drunks and lampposts, being used only when the Python interpreter starts caroling the &quot;12 Errors of Christmas&quot;.
It's very tempting to just put a <code>try</code> and a bare exception on a problem to &quot;make it go away&quot;. By doing that, we're effectively sweeping the exceptions under the rug, which is a shame, especially since they can be wonderfully helpful in recovering from potentially fatal errors, or shining a light on hidden bugs.
That's why when using except clauses you should always be sure to specify the errors you know you could encounter, and exclude the ones you don't.
Letting your program fail is okay, even preferred, to just pretending the problem doesn't exist.
<blockquote>
&quot;Errors should never pass silently... unless explicitly silenced.&quot;
</blockquote>
However, once in a blue moon when you do get the opportunity to ignore exception handling, you can use <code>suppress()</code>:
<pre><code class="hljs">from contextlib import suppress

with suppress(TypeError, KeyError, IndexError):
 do_the_thing()
</code></pre>
The <code>suppress()</code> method takes a number of exceptions as its argument, and performs a try/except/pass with those errors. As you can see it also lets you write multiple exceptions in a single line.
This let's you avoid writing a try/except/pass manually:
<pre><code class="hljs">try:
 do_the_thing()
except (TypeError, KeyError, IndexError) as e:
 pass
</code></pre>
Better yet, it's also standard in any version of Python 3.4 and above!
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered how to handle multiple exceptions in a single line. We've also briefly gone over some bad practices of ignoring exceptions, and used the <code>suppress()</code> function to suppress exceptions explicitly.

Spencer Porter

In this article, we've gone over how to catch multiple exceptions in one line in Python, with code examples. We've also covered some bad practices and how to avoid them.

Python: Catch Multiple Exceptions in One Line

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to check if a String starts with another String in Java.
This is is a fairly common task in programming, and is very similar to <a target="_blank" href="/java-check-if-string-contains-a-substring/">checking if a string contains a substring</a>. For example, this can come in useful if we want to filter out all of the words out of a huge selection starting with a specific String.
However, this problem differs from checking if a String only contains a specific substring, and there's a few ways to do so in both Core Java and Apache Commons:
<ul>
<li><a href="#stringstartswith">String.startsWith()</a></li>
<li><a href="#streamanymatch">Stream.anyMatch()</a></li>
<li><a href="#stringindexof">String.indexOf()</a></li>
<li><a href="#patternwithregexandmatcher">Pattern with Regex</a></li>
<li><a href="#usingaforloop">Using a for-loop</a></li>
<li><a href="#stringutilsindexof">StringUtils.indexOf()</a></li>
<li><a href="#stringutilsstartswith">StringUtils.startsWith()</a></li>
<li><a href="#stringutilsstartswithany">StringUtils.startsWithAny()</a></li>
<li><a href="#stringutilsstartswithignorecase">StringUtils.startsWithIgnoreCase()</a></li>
</ul>
<h2 id="corejava">Core Java</h2>
Let's start off with solutions that can easily be implemented using Core Java.
<h3 id="stringstartswith">String.startsWith()</h3>
This method does exactly what we need it to do - and is the most common way to solve this problem. It returns a <code>boolean</code>, which indicates if the string begins with the provided keyword:
<pre><code class="hljs">String string = &quot;every end is a new beginning&quot;;

System.out.println(string.toLowerCase().startsWith(&quot;new&quot;.toLowerCase()));
System.out.println(string.toLowerCase().startsWith(&quot;EVERY&quot;.toLowerCase()));
System.out.println(string.toLowerCase().startsWith(&quot;&quot;));
</code></pre>
Running this outputs:
<pre><code class="hljs">false
true
true
</code></pre>
Note: If the parameter passed is an empty string, the result is always <code>true</code>.
Of course, this method is case-sensitive, and should always be used in pair with <code>toLowerCase()</code> or <code>toUpperCase()</code> when we're just looking for a specific keyword and don't care if the cases match.
<h3 id="streamanymatch">Stream.anyMatch()</h3>
Another thing we could check for is if a String starts with multiple substrings. Say, we have a few standardized prefixes - we can use make a <code>Stream</code> of substrings, and run an <code>anyMatch()</code> check for the String we're checking in.
Let's take a look at how to do that:
<pre><code class="hljs">String string = &quot;every end is a new beginning&quot;;
System.out.println(Stream.of(&quot;every&quot;, &quot;none&quot;).anyMatch(string::startsWith));
</code></pre>
Here, we've created a <code>Stream</code> of possible substrings, and checked if any of them are present at the start of the given String with a method reference call to <code>startsWith()</code>.
This code results in:
<pre><code class="hljs">true
</code></pre>
<h3 id="stringindexof">String.indexOf()</h3>
The <code>indexOf()</code> method can be quite useful in solving a variety of problems concerning substrings, including checking if a string begins with a specific one.
The method returns the index of the first occurrence of a substring within a string if it's found, otherwise <code>-1</code>.
It has a few overloaded variants from which we'll only be needing just the one below, since the other ones have different appliances:
<pre><code class="hljs">public int indexOf(String str)
</code></pre>
If the <code>indexOf()</code> method returns <code>0</code>, that means our String begins with another we've given it as a parameter.
For example:
<pre><code class="hljs">String string = &quot;Just a sample String&quot;;

System.out.println(string.toLowerCase().indexOf(&quot;just&quot;.toLowerCase()));
System.out.println(string.toLowerCase().indexOf(&quot;String&quot;.toLowerCase()));
System.out.println(string.toLowerCase().indexOf(&quot;something else&quot;.toLowerCase()));
</code></pre>
will output:
<pre><code class="hljs">0
14
-1
</code></pre>
<ul>
<li>The answer we're looking for is found within our first example, as it returned <code>0</code> - exactly what we need, meaning our string begins with a given parameter.</li>
<li>We can clearly see that in the second example, the <code>&quot;String&quot;</code> parameter we've given is indeed found within our String, but at the position <code>14</code>, which is not what we were looking for.</li>
<li>The third example isn't even contained within our String, and returns <code>-1</code>.</li>
</ul>
Using the information above, we can accumulate the logic in a function:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 return text.toLowerCase().indexOf(keyword.toLowerCase()) == 0;
}
</code></pre>
<h3 id="patternwithregexandmatcher">Pattern with Regex and Matcher</h3>
The <code>Pattern</code> class is a compiled representation of a regular expression. With this <code>Pattern</code> we can then generate an engine that recognizes said regular expression - we can generate a <code>Matcher</code>.
We'll be using the <code>find()</code> method in combination with <code>start()</code> to check if our <code>Matcher</code> instance begins with a given String:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 String inputString = text.toLowerCase();
 String subString = keyword.toLowerCase();


 // We compile the regular expression to generate a Pattern object
 Pattern pattern = Pattern.compile(subString);

 // Then we generate an engine (Matcher) which can be used
 // to recognize and match the regular expression it was
 // generated from (in our case &quot;this&quot;).
 Matcher matcher = pattern.matcher(inputString);

 // find() compares the assigned and compiled patterns, and will return a boolean value indicating if they match.
 // That&#x27;s where the start() method comes into play; it returns the index of the position 
 // where the two strings matched, or -1 if it&#x27;s not found.
 if (matcher.find()) {
 return matcher.start() == 0;
 }
 return false;
}
</code></pre>
Let's test this method out:
<pre><code class="hljs">System.out.println(startsWithSubstring(string, &quot;every&quot;));
</code></pre>
This results in:
<pre><code class="hljs">true
</code></pre>
<h3 id="usingaforloop">Using a for-loop</h3>
A more low-level way of solving this problem would be using a for-loop.
We iterate through the whole length of the search string, we compare the first <code>searchString.length()</code> characters and return <code>true</code> if the all match.
Let's see how this all works in code:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 for (int i = 0; i &lt; keyword.length(); i++) {
 if (text.toLowerCase().charAt(i) != keyword.toLowerCase().charAt(i)) {
 System.out.println(&quot;String doesn&#x27;t start with &quot; + &quot;\&quot;&quot; + keyword + &quot;\&quot;&quot;);
 return false;
 } else if (i == keyword.length() - 1) {
 System.out.println(&quot;String starts with &quot; + &quot;\&quot;&quot; + keyword + &quot;\&quot;&quot;);
 return true;
 }
 }
 return false;
}
</code></pre>
Let's test this method out:
<pre><code class="hljs">String string = &quot;Just a sample String&quot;;

System.out.println(startsWithSubstring(string, &quot;just&quot;));
System.out.println(startsWithSubstring(string, &quot;String&quot;));
System.out.println(startsWithSubstring(string, &quot;something else&quot;));
</code></pre>
This results in:
<pre><code class="hljs">String starts with &quot;just&quot;
true
String doesn&#x27;t start with &quot;String&quot;
false
String doesn&#x27;t start with &quot;something else&quot;
false
</code></pre>
By default, if we hadn't used <code>toLowerCase()</code> to even out the letters in the method itself, this approach would've been case-sensitive.
<h2 id="apachecommons">Apache Commons</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library provides functionality that expands on the core Java Framework. It's one of the top third-party libraries and is present in many modern Java projects.
Apache Commons offers the <code>StringUtils</code> class, which contains many methods used to manipulate strings. Most of these methods are quite similar to the ones found in <code>java.lang.String</code>. The main difference being that all methods within the <code>StringUtils</code> class are null-safe.
However, for this task we'll need only a few methods from this class:
<ol>
<li><code>.indexOf()</code></li>
<li><code>.startsWith()</code></li>
<li><code>.startsWithIgnoreCase()</code>.</li>
</ol>
If not already, include the Apache Commons library in your project by adding a dependency to your <code>pom.xml</code> file if you're using Maven:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
 &lt;version&gt;3.11&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or by adding it to Gradle:
<pre><code class="hljs">compile group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: &#x27;3.11&#x27;
</code></pre>
<h3 id="stringutilsindexof">StringUtils.indexOf()</h3>
This method has a few overloaded variants all of which return an <code>int</code> value indicating the index of the first occurrence of the substring, or <code>-1</code> if the substring doesn't appear at all.
We'll be focusing on the following variant of this method:
<pre><code class="hljs">public static int indexOf(CharSequence seq, CharSequence searchSeq)
</code></pre>
This method takes two <code>String</code>s/<code>CharSequence</code>s.
The <code>seq</code> parameter represents the String we'll be searching through to find <code>searchSeq</code>. Same logic applies as before - if this function returns <code>0</code>, we'll know that our string begins with a given <code>searchSeq</code> substring.
Also keep in mind that this method, like its counterpart, is also case-sensitive, so using <code>.toLowerCase()</code> or <code>.toUpperCase()</code> is required to achieve a case-insensitive behavior.
Using this method is very similar to using the <code>indexOf()</code> from <code>java.lang.String</code>:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;a simple&quot;.toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;string&quot;.toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;something&quot;.toLowerCase()));
</code></pre>
This will yield:
<pre><code class="hljs">0
9
-1
</code></pre>
And thus, we can use this as a convenience method:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 return StringUtils.indexOf(text.toLowerCase(), keyword.toLowerCase()) == 0;
}
</code></pre>
<h3 id="stringutilsstartswith">StringUtils.startsWith()</h3>
This method does exactly what you'd expect. It's also case-sensitive like it's predecessors, and accepts the same two parameters.
It returns <code>true</code> if the <code>text</code> begins with the <code>keyword</code>, or <code>false</code> if it doesn't.
Comparing two <code>null</code> values will result in <code>true</code>:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWith(string.toLowerCase(), &quot;A SIMPLE&quot;));
System.out.println(StringUtils.startsWith(string.toLowerCase(), &quot;A SIMPLE&quot;.toLowerCase()));
System.out.println(StringUtils.startsWith(null, null));
</code></pre>
Running this will output:
<pre><code class="hljs">false
true
true
</code></pre>
<h3 id="stringutilsstartswithany">StringUtils.startsWithAny()</h3>
The <code>startsWithAny()</code> doesn't have a counterpart in the <code>java.lang.String</code> class, and is unique to <code>StringUtils</code>.
However, it is very close to what we did with <code>anyMatch()</code> on a Stream - It checks if a <code>String</code> begins with any of the given substrings, returning <code>true</code> or <code>false</code> appropriately.
It's also case-sensitive:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;a simple&quot;));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;string&quot;));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, null));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;&quot;));
</code></pre>
Running this gives us:
<pre><code class="hljs">true
false
false
true
</code></pre>
<h3 id="stringutilsstartswithignorecase">StringUtils.startsWithIgnoreCase()</h3>
Since it can get annoying to call <code>toLowerCase()</code> all the time on Strings during comparison, you can alternatively sue the <code>startsWithIgnoreCase()</code> method.
Like the <code>startsWith()</code> method from the same class, it takes two Strings (or <code>CharSequence</code>) types, and the return value is <code>true</code> or <code>false</code> depending on if the text actually starts with the provided keyword:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;something&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;A SIMPLE&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, null));
</code></pre>
Running this outputs:
<pre><code class="hljs">false
true
true
false
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over all the different method of checking if a <code>String</code> begins with another <code>String</code>, both in core Java and utilizing the Apache Commons library.
In conclusion, there are many different ways to accomplish this task. In reality, we could have combined any of the methods above in order to find an index that a substring starts on, and from there on check where the substring is positioned at.
Most of the time, just using the <code>startsWith()</code> methods, or <code>startsWithIgnoreCase()</code> would be enough to solve this problem and would also give the cleanest, shortest code.

Branko Ilic

In this tutorial, we'll go over examples of how to check if a String starts with a substring in Java. We'll cover Core Java as well as Apache Commons methods.