David Landup

Rayven Yor Esplanada

In this tutorial, we'll build a demo Spring Boot REST API application, with CRUD functionality. We'll cover database setup, the domain model, persistence layer as well as the business layer.

Build a Spring Boot REST API with Java - Full Guide

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to rotate tick text/labels in a Matplotlib plot.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's create a simple plot first:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/%7Frotate-axis-labels-in-matplotlib-1.png" alt="simple matplotlib plot">
<h2 id="rotatexaxisticklabelsinmatplotlib">Rotate X-Axis Tick Labels in Matplotlib</h2>
Now, let's take a look at how we can rotate the X-Axis tick labels here. There are two ways to go about it - change it on the Figure-level using <code>plt.xticks()</code> or change it on an Axes-level by using <code>tick.set_rotation()</code> individually, or even by using <code>ax.set_xticklabels()</code> and <code>ax.xtick_params()</code>.
Let's start off with the first option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.xticks(rotation = 45) # Rotates X-Axis Ticks by 45-degrees
plt.show()
</code></pre>
Here, we've set the <code>rotation</code> of <code>xticks</code> to 45, signifying a 45-degree tilt, counterclockwise:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-2.png" alt="rotate x-axis label with xticks">

 <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: This function, like all others here, should be called after <code>plt.plot()</code>, lest the ticks end up being potentially cropped or misplaced.

 </div>
 </div>
 </div>
 Another option would be to get the current <code>Axes</code> object and call <code>ax.set_xticklabels()</code> on it. Here we can set the labels, as well as their rotation:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

ax.set_xticklabels(ax.get_xticks(), rotation = 45)

plt.show()
</code></pre>

 <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: For this approach to work, you'll need to call <code>plt.draw()</code> before accessing or setting the X tick labels. This is because the labels are populated after the plot is drawn, otherwise, they'll return empty text values.

 </div>
 </div>
 </div>
 <img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-3.png" alt="rotate x axis labels with xticklabels">
Alternatively, we could've iterated over the <code>tick</code>s in the <code>ax.get_xticklabels()</code> list. Then, we can call <code>tick.set_rotation()</code> on each of them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

for tick in ax.get_xticklabels():
 tick.set_rotation(45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-4.png" alt="rotate x axis labels with set_rotation">
And finally, you can use the <code>ax.tick_params()</code> function and set the label rotation there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
ax.tick_params(axis=&#x27;x&#x27;, labelrotation = 45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-4.png" alt="rotate x axis labels with tick_params">
<h2 id="rotateyaxisticklabelsinmatplotlib">Rotate Y-Axis Tick Labels in Matplotlib</h2>
The exact same steps can be applied for the Y-Axis tick labels.
Firstly, you can change it on the Figure-level with <code>plt.yticks()</code>, or on the Axes-level by using <code>tick.set_rotation()</code> or by manipulating the <code>ax.set_yticklabels()</code> and <code>ax.tick_params()</code>.
Let's start off with the first option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.yticks(rotation = 45)
plt.show()
</code></pre>
Same as last time, this sets the <code>rotation</code> of <code>yticks</code> by 45-degrees:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-5.png" alt="rotate y axis labels yticks">
Now, let's work directly with the <code>Axes</code> object:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

ax.set_yticklabels(ax.get_yticks(), rotation = 45)

plt.show()
</code></pre>
The same note applies here, you have to call <code>plt.draw()</code> before this call to make it work correctly.
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-6.png" alt="rotate y axis labels with yticklabels">
Now, let's iterate over the list of <code>tick</code>s and <code>set_rotation()</code> on each of them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

for tick in ax.get_yticklabels():
 tick.set_rotation(45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-7.png" alt="rotate y axis labels with set_rotation">
And finally, you can use the <code>ax.tick_params()</code> function and set the label rotation there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
ax.tick_params(axis=&#x27;y&#x27;, labelrotation = 45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-7.png" alt="rotate y axis labels with tick_params">
<h2 id="rotatedatestofitinmatplotlib">Rotate Dates to Fit in Matplotlib</h2>
Most often, the reason people rotate ticks in their plots is because they contain dates. Dates can get long, and even with a small dataset, they'll start overlapping and will quickly become unreadable.
Of course, you can rotate them like we did before, usually, a 45-degree tilt will solve most of the problems, while a 90-degree tilt will free up even more.
Though, there's another option for rotating and fixing dates in Matplotlib, which is even easier than the previous methods - <code>fig.autofmt__date()</code>.
This function can be used either as <code>fig.autofmt_xdate()</code> or <code>fig.autofmt_ydate()</code> for the two different axes.
Let's take a look at how we can use it on the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rtatman/did-it-rain-in-seattle-19482017">Seattle Weather Dataset</a>:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

weather_data = pd.read_csv(&quot;seattleWeather.csv&quot;)

fig = plt.figure()
plt.plot(weather_data[&#x27;DATE&#x27;], weather_data[&#x27;PRCP&#x27;])
fig.autofmt_xdate()
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-8.png" alt="auto format dates to fit in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to rotate Axis text/labels in a Matplotlib plot, including a specific way to format and fit dates .
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 go over examples on how to rotate the axis text or labels in a Matplotlib plot. We'll work on a figure-level and an axes-level, with several methods.

Rotate Axis Labels in Matplotlib

<h2 id="introduction">Introduction</h2>
Key-value stores are essential and often used, especially in operations that require fast and frequent lookups. They allow an object - the key - to be mapped to another object, the value. This way, the values can easily be retrieved, by looking up the key.
In Java, the most popular <code>Map</code> implementation is the <code>HashMap</code> class. Aside from key-value mapping, it's used in code that requires frequest insertions, updates and lookups. The insert and lookup time is a constant O(1).
In this tutorial, we'll go over how to get the Keys and Values of a map in Java.
<h2 id="getkeysandvaluesentriesfromjavamap">Get Keys and Values (Entries) from Java Map</h2>
Most of the time, you're storing key-value pairs because both pieces of info are important. Thus, in most cases, you'll want to get the key-value pair together.
The <code>entrySet()</code> method returns a set of <code>Map.Entry&lt;K, V&gt;</code> objects that reside in the map. You can easily iterate over this set to get the keys and their associated values from a map.
Let's populate a <code>HashMap</code> with some values:
<pre><code class="hljs">Map&lt;String, Integer&gt; map = new HashMap&lt;&gt;();
 
map.put(&quot;David&quot;, 24);
map.put(&quot;John&quot;, 35);
map.put(&quot;Jane&quot;, 19);
map.put(&quot;Billy&quot;, 21);
</code></pre>
Now, let's iterate over this map, by going over each <code>Map.Entry&lt;K,V&gt;</code> in the <code>entrySet()</code>, and extracing the key and value from each of those entries:
<pre><code class="hljs">for (Map.Entry&lt;String, Integer&gt; pair : map.entrySet()) {
 System.out.println(String.format(&quot;Key (name) is: %s, Value (age) is : %s&quot;, pair.getKey(), pair.getValue())); 
}
</code></pre>
This results in:
<pre><code class="hljs">Key (name) is: Billy, Value (age) is: 21
Key (name) is: David, Value (age) is: 24
Key (name) is: John, Value (age) is: 35
Key (name) is: Jane, Value (age) is: 19
</code></pre>
<h2 id="getkeysandvaluesentriesfromjavamapwithforeach">Get Keys and Values (Entries) from Java Map with forEach()</h2>
Java 8 introduces us to the <code>forEach()</code> method for collections. It accepts a <code>BiConsumer&lt;? super K, ? super V&gt; action</code>. The <code>forEach()</code> method performs the given <code>BiConsumer</code> action on each entry of the <code>HashMap</code>.
Let's use the same map from before, but this time, add a year to each of the entries' ages:
<pre><code class="hljs">map.forEach((key, value) -&gt; System.out.println(key + &quot; : &quot; + value));
</code></pre>
This prints out:
<pre><code class="hljs">Billy : 21
David : 24
John : 35
Jane : 19
</code></pre>
Or, instead of consuming each <code>key</code> and <code>value</code> from the map, you can use a regular <code>Consumer</code> and just consume entire entries from the <code>entrySet()</code>:
<pre><code class="hljs">map.entrySet()
 .forEach((entry) -&gt; System.out.println(entry.getKey() + &quot; : &quot; + entry.getValue()));
</code></pre>
This also results in:
<pre><code class="hljs">Billy : 21
David : 24
John : 35
Jane : 19
</code></pre>
<h2 id="getkeysfromajavamap">Get Keys from a Java Map</h2>
To retrieve just keys, if you don't really need any information from the values, instead of the entry set, you can get the key set:
<pre><code class="hljs">for(String key: map.keySet()){
 System.out.println(key);
}
</code></pre>
Output:
<pre><code class="hljs">Billy
David
John
Jane
</code></pre>
<h2 id="getvaluesfromajavamap">Get Values from a Java Map</h2>
Similarly, one may desire to retrieve and iterate through the values only, without the keys. For this, we can use <code>values()</code>:
<pre><code class="hljs">for(String value: map.values()){
 System.out.println(value);
}
</code></pre>
Output:
<pre><code class="hljs">21
54
35
19
</code></pre>
<h2 id="checkifmapcontainsakey">Check if Map Contains a Key</h2>
The <code>HashMap</code> class has a <code>containsKey()</code> method, which checks if the passed key exists in the <code>HashMap</code>, and returns a boolean value signifying the presence of the element or lack thereof.
Let's check if a key, <code>5</code> exists:
<pre><code class="hljs">boolean result = map.containsKey(5);
System.out.println(result);
</code></pre>
This prints out:
<pre><code class="hljs">false
</code></pre>
And for an existing key:
<pre><code class="hljs">boolean result = map.containsKey(&quot;John&quot;);
System.out.println(result);
</code></pre>
This prints out:
<pre><code class="hljs">true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few ways to get keys and values (entries) of a Map in Java. We've covered using an iterator and going through each <code>Map.Entry&lt;K, V&gt;</code>, as well as using a <code>forEach()</code> method both on the map itself, as well as its entry set.
Finally, we've gone over how to get the key set and values separately, and check if a map contains a given key.

Guest Contributor

In this tutorial, we'll go over examples on how to get the keys and values (entries) of a map in Java. We'll use forEach as well as iterators.

Java: How to Get Keys and Values from a Map

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this tutorial, we'll take a look at how to change the background of a plot in Matplotlib.
<h2 id="importingdataandlibraries">Importing Data and Libraries</h2>
Let's import the required libraries first. We'll obviously need Matplotlib, and we'll use Pandas to read the data:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
</code></pre>
Specifically, we'll be using the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rtatman/did-it-rain-in-seattle-19482017">Seattle Weather Dataset</a>:
<pre><code class="hljs">weather_data = pd.read_csv(&quot;seattleWeather.csv&quot;)
print(weather_data.head())
</code></pre>
<pre><code class="hljs"> DATE PRCP TMAX TMIN RAIN
0 1948-01-01 0.47 51 42 True
1 1948-01-02 0.59 45 36 True
2 1948-01-03 0.42 45 35 True
3 1948-01-04 0.31 45 34 True
4 1948-01-05 0.17 45 32 True
</code></pre>
<h2 id="creatingaplot">Creating a Plot</h2>
Now, let's create a simple <a target="_blank" href="/matplotlib-scatterplot-tutorial-and-examples/">Matplotlib Scatter Plot</a>, with a few different variables we want to visualize:
<pre><code class="hljs">PRCP = weather_data[&#x27;PRCP&#x27;]
TMAX = weather_data[&#x27;TMAX&#x27;]
TMIN = weather_data[&#x27;TMIN&#x27;]
</code></pre>
Now, we'll construct a scatter plot between the minimum temperature and precipitation and <code>show()</code> it using Matplotlib's PyPlot:
<pre><code class="hljs">plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-1.png" alt="matplotlib scatter plot">
The graph that we have produced is interpretable, but it is looking a little plain. Let's try customizing it. We want to customize the background of our plot using a couple of different methods.
<h2 id="changeplotbackgroundinmatplotlib">Change Plot Background in Matplotlib</h2>
Now, let's go ahead and change the background of this plot. We can do this with two different approaches. We can change the color of the face, which is currently set to <code>white</code>. Or, we can input a picture using <code>imshow()</code>.
<h3 id="changeaxesbackgroundinmatplotlib">Change Axes Background in Matplotlib</h3>
Let's first change the color of the face. This can either be done with the <code>set()</code> function, passing in the <code>face</code> argument and its new value, or via the dedicated <code>set_facecolor()</code> function:
<pre><code class="hljs">ax = plt.axes()
ax.set_facecolor(&quot;orange&quot;)
# OR
ax.set(facecolor = &quot;orange&quot;)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-2.png" alt="change axes background color matplotlib">
Either of these approaches produces the same result, as they both call on the same function under the hood.
<h3 id="changefigurebackgroundinmatplotlib">Change Figure Background in Matplotlib</h3>
If you would like to set the background for the figure and need the axes to be transparent, this can be done with the <code>set_alpha()</code> argument when you create the figure. Let's create a figure and an axes object. Of course, you can also use the <code>set()</code> function, and pass the <code>alpha</code> attribute instead.
The color of the entire figure will be blue and we will initially set the <code>alpha</code> of the axes object to <code>1.0</code>, meaning fully opaque. We color the axes object orange, giving us an orange background within the blue figure:
<pre><code class="hljs">fig = plt.figure()
fig.patch.set_facecolor(&#x27;blue&#x27;)
fig.patch.set_alpha(0.6)

ax = fig.add_subplot(111)
ax.patch.set_facecolor(&#x27;orange&#x27;)
ax.patch.set_alpha(1.0)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-3.png" alt="change figure background matplotlib">
Now let's see what happens when we adjust the alpha of the axes subplot down to <code>0.0</code>:
<pre><code class="hljs">fig = plt.figure()
fig.patch.set_facecolor(&#x27;blue&#x27;)
fig.patch.set_alpha(0.6)

ax = fig.add_subplot(111)
ax.patch.set_facecolor(&#x27;orange&#x27;)
ax.patch.set_alpha(0.0)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-4.png" alt="change axes background matplotlib within figure">
Notice that the background of the plot itself is transparent now.
<h3 id="addimagetoplotbackgroundinmatplotlib">Add Image to Plot Background in Matplotlib</h3>
If you would like to use an image as the background for a plot, this can be done by using PyPlot's <code>imread()</code> function. This function loads an image into Matplotlib, which can be displayed with the function <code>imshow()</code>.
In order to plot on top of the image, the extent of the image has to be specified. By default, Matplotlib uses the upper left corner of the image as the image's origin. We can give a list of points to the <code>imshow()</code> function, specifying what region of the image should be displayed. When combined with subplots, another plot can be inserted on top of the image.
Let's use an image of rain as the background for our plot:
<pre><code class="hljs">img = plt.imread(&quot;rain.jpg&quot;)
fig, ax = plt.subplots()
ax.imshow(img, extent=[-5, 80, -5, 30])
ax.scatter(TMIN, PRCP, color=&quot;#ebb734&quot;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-5.png" alt="adding image to background matplotlib">
The <code>extent</code> argument takes in additional arguments in this order: <code>horizontal_min</code>, <code>horizontal_max</code>, <code>vertical_min</code>, <code>vertical_max</code>).
Here, we've read the image, cropped it and showed it on the axes using <code>imshow()</code>. Then, we plotted the scatter plot with a different color and showed the plot.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to change the background of a plot using Python and Matplotlib.
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 go over several examples of how to change the background of a plot (figure background and axes background) in Matplotlib using Python.

How to Change Plot Background in Matplotlib

<h2 id="introduction">Introduction</h2>
Sorting data is a frequent problem in computer science. Given a collection of elements, the goal is to rearrange them in some order. Common examples are sorting an array alphabetically or from smallest to largest.
Sorted data is a lot easier to manipulate. Finding the largest or smallest element of an array can be done in constant time if the array is sorted. Searching for an element is a lot faster using algorithms such as <a rel="nofollow" target="_blank" href="/binary-search-in-java/">Binary Search</a> which rely on the assumption that the array is already sorted.
One of the simplest algorithms for sorting data is Selection Sort. It's usually taught in beginner programming classes and tutorials to explain the concept of sorting, so we'll keep this article very beginner-friendly.
<h2 id="selectionsort">Selection Sort</h2>
Selection sort is an in-place comparison sorting algorithm that uses brute force to sort an array.
<blockquote>
In-place means that the algorithm uses a small constant amount of space for extra storage.
</blockquote>
It's called a &quot;brute force&quot; algorithm because it uses the simplest and most ineffective way of calculating the solution. However, it does make up for it with its straightforward implementation.
The algorithm divides the array into two subarrays:
<ul>
<li>A sorted subarray</li>
<li>An unsorted subarray</li>
</ul>
The sorted subarray is empty in the beginning. In every iteration, the smallest element of the unsorted array will be appended to the end of the sorted array by swapping. This way, the sorted array will eventually contain all the elements of the original array.
An example array we want to sort in ascending order:
<table>
 <tr>
 <td>Sorted array</td>
 <td>Unsorted array</td>
 <td>Minimal element of the unsorted array</td>
 </tr>
 <tr>
 <td>[]</td>
 <td>[16, 5, 30, 6, 2, 7]</td>
 <td>2</td>
 </tr>
 <tr>
 <td>[2]</td>
 <td>[16, 5, 20, 6, 7]</td>
 <td>5</td>
 </tr>
 <tr>
 <td>[2, 5]</td>
 <td>[16, 20, 6, 7]</td>
 <td>6</td>
 </tr>
 <tr>
 <td>[2, 5, 6]</td>
 <td>[16, 7, 20]</td>
 <td>7</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7]</td>
 <td>[16, 20]</td>
 <td>16</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7, 16]</td>
 <td>[20]</td>
 <td>20</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7, 16, 20]</td>
 <td>[]</td>
 <td></td>
 </tr>
</table>
<h2 id="implementation">Implementation</h2>
The <code>selectionSort()</code> method takes just one argument, the array that needs to be sorted. We'll iterate through the unsorted array, which will be between indexes <code>i</code> and <code>j</code>, find its minimum and place it into the sorted array by swapping:
<pre><code class="hljs">public static void selectionSort(int[] nums) {
 for (int i = 0; i &lt; nums.length; i++) {
 // min is the index of the smallest element with an index greater or equal to i
 int min = i;
 for (int j = i + 1; j &lt; nums.length; j++) {
 if (nums[j] &lt; nums[min]) {
 min = j;
 }
 }
 // Swapping i-th and min-th elements
 int swap = nums[i];
 nums[i] = nums[min];
 nums[min] = swap;
 }
}
</code></pre>
Let's test out the code:
<pre><code class="hljs">int[] array = new int[]{16, 5, 30, 6, 7, 2};
selectionSort(array);
System.out.println(Arrays.toString(array));
</code></pre>
This will print out:
<pre><code class="hljs">[2, 5, 6, 7, 16, 30]
</code></pre>
<h2 id="selectionsorttimecomplexity">Selection Sort Time Complexity</h2>
Time complexity is a way to describe how much time an algorithm needs to finish executing relative to the size of the input. Analyzing the time it takes for an algorithm to give output is of crucial importance. Imagine a telephone book application that would take a day to sort all the numbers after a new number was added. That would be way less useful than the same app that would do it almost instantly.
Performance depends on the hardware as well as software, but the same program can be run on many different types of hardware. The Big-O notation makes it easier to approximate the time needed for a program to execute, regardless of software.
The average and worst-case time complexity of Selection Sort is O(n2). This makes Selection Sort a lot slower than many other comparison sorting algorithms like <a target="_blank" href="/merge-sort-in-java/">Merge Sort</a> or <a target="_blank" href="/merge-sort-in-java/">Insertion Sort</a> which have the worst-case time complexity (O(nlogn)). Interestingly, O(nlogn) is the best that can be achieved by any comparison sorting algorithm.
<h2 id="timecomplexityanalysis">Time Complexity Analysis</h2>
Showing that Selection Sort has quadratic time complexity comes down to calculating the number of times the inner loop will be iterated. We can see this if we go through the code line by line and try to approximate the time it takes to execute each line of code:
<pre><code class="hljs">for (int i = 0; i &lt; nums.length; i++) {
</code></pre>
Everything in the inner block of the loop will be executed <code>n</code> times, where <code>n</code> is the length of a given array:
<pre><code class="hljs">int min = i;
</code></pre>
<code>min</code> will be initialized to <code>i</code> exactly <code>n</code> times. Now comes the tricky part:
<pre><code class="hljs">for (int j = i + 1; j &lt; nums.length; j++)
</code></pre>
Since this loop is nested, it takes a bit of math to calculate the number of times the block of code inside it will execute. Let's work it out.
When <code>i</code> is equal to 0, <code>j</code> will go from 1 to <code>n</code>, meaning every instruction in the inner block will execute <code>n</code> times. When <code>i</code> increases to 1, <code>j</code> will stay between 2 and <code>n</code>, which implies the inner block will execute <code>n-2</code> times. Summing this up:
<pre><code class="hljs">(n - 1) + (n - 2) + ... + 1
</code></pre>
The sum of a sequence of natural numbers is calculated using something called Gauss's trick, and it results in (n2 - n)/2. Simplifying this, results in O(n2) time complexity.
<blockquote>
Put simply, when calculating the complexity of an algorithm O(f(n)), we need to look for the highest power of n in the function f(n) and isolate it. This is because any part of the equation that has a lower power will not affect the result in any significant way.
For example, we have the function f(x) = x2+13x+23
O(f(x)) would be the highest power of x in the equation, which in this case is x2.
</blockquote>
Here's how it performed after sorting an array containing 10,000 integers in random order:
<pre><code class="hljs">public static void main(String[] args) {
 int[] array = new int[10000];
 for (int i = 0; i &lt; array.length; i++) {
 array[i] = i;
 }

 // Shuffle array
 Collections.shuffle(Arrays.asList(array));

 // Print shuffled collection
 System.out.println(Arrays.toString(array));
 
 long startTime = System.nanoTime();
 selectionSort(array);
 long endTime = System.nanoTime();
 
 // Print sorted collection
 System.out.println(Arrays.toString(array));

 // Print runtime in seconds
 System.out.println(&quot;Selection Sort runtime: &quot; + (endTime - startTime)/1000000000);
}
</code></pre>
Running it 10 times, this code produced the following results:
<table class="table table-striped">
 <tr>
 <td>Time(s)</td>
 <td>Selection Sort</td>
 </tr>
 <tr>
 <td>First Run</td>
 <td>0.024</td>
 </tr>
 <tr>
 <td>Second Run</td>
 <td>0.020</td>
 </tr>
 <tr>
 <td>Third Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Fourth Run</td>
 <td>0.020</td>
 </tr>
 <tr>
 <td>Fifth Run</td>
 <td>0.025</td>
 </tr>
 <tr>
 <td>Sixth Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Seventh Run</td>
 <td>0.021</td>
 </tr>
 <tr>
 <td>Eight Run</td>
 <td>0.031</td>
 </tr>
 <tr>
 <td>Ninth Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Tenth Run</td>
 <td>0.029</td>
 </tr>
</table>
The average run time was 0.0236 seconds, though, this will majorly depend on your machine as well.
<h2 id="selectionsortspacecomplexity">Selection Sort Space Complexity</h2>
Space Complexity is also a big factor in algorithm design. Our programs are bound, not only by the time that they need to execute but also by memory usage. There is a limited amount of memory on any computer, so a programmer should keep an eye on that too.
The space complexity of Selection Sort is constant(O(1)) because it is in-place, which is great. Worst case complexity of Selection Sort is, unfortunately, O(n2) as well, which means that even if the algorithm gets an already sorted array as input, it will still take a lot of time to return the unchanged array.
This algorithm has decent performance if the collection doesn't have a lot of elements. If the array has ~10 elements, the difference in performance between different sorting algorithms shouldn't be that noticeable, and Selection Sort might even outperform other divide-and-conquer algorithms.
Where Selection Sort shines, is when the number of swaps needs to be minimal. In the worst case, there will only be <code>n-1</code> swaps, which is the minimal possible number of swaps that need to be performed. This is quite intuitive if we consider that every element will be placed in its right spot in the sorted array right away.
<h2 id="conclusion">Conclusion</h2>
Selection Sort is a brute force in-place comparison sort which continuously finds the minimum of an unsorted subarray and places it in the correct position in the sorted subarray. Due to its simplicity, it's often one of the first algorithms that are taught in computer science courses all around the world.
Even if more efficient algorithms come built-it, it's still important to understand the underlying logic and complexity analysis to avoid common issues and to make sure that the tool being used is the one that's best suited for the job at hand.

Kristina Popovic

In this tutorial, we'll go over the theory and implementation of Selection Sort in Java. We'll also explore its time and space complexity with examples.

Selection Sort in Java

Marcus Sanatan

Ruslan Hasanov

WTForms is a popular Python library that validates form data. This tutorial shows you how to use WTForms with Flask to create and verify forms in your app.

Flask Form Validation with WTForms

Flask Form Validation with Flask-WTF

<h2 id="introduction">Introduction</h2>
Whether in Java, or any other programming language, it is a common occurrence to check if an array contains a value. This is one of the things that most beginners tend to learn, and it is a useful thing to know in general.
In this article, we'll take a look at how to check if an array contains a value or element in Java.
<ul>
<li><a href="#arraysaslistcontains">Arrays.asList().contains()</a></li>
<li><a href="#usingaforloop">Using a for-loop</a></li>
<li><a href="#collectionsbinarysearch">Collections.binarySearch()</a></li>
<li><a href="#java8streamapi">Java 8 Stream API</a></li>
<li><a href="#apachecommonsarrayutils">Apache Commons - ArrayUtils</a></li>
</ul>
<h2 id="arraysaslistcontains">Arrays.asList().contains()</h2>
This is perhaps the most common way of solving this problem, just because it performs really well and is easy to implement.
First, we convert the array to an <code>ArrayList</code>. There are various ways to <a target="_blank"
href="/how-to-convert-a-java-array-to-arraylist/">convert a Java array to an ArrayList</a>, though, we'll be using the most widely used approach.
Then, we can use the <code>contains()</code> method on the resulting <code>ArrayList</code>, which returns a boolean signifying if the list contains the element we've passed to it or not.
Array of an <code>Integer</code> type:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

List&lt;Integer&gt; intList = new ArrayList&lt;&gt;(Arrays.asList(intArray));
List&lt;String&gt; nameList = new ArrayList&lt;&gt;(Arrays.asList(nameArray));

System.out.println(intList.contains(12));
System.out.println(nameList.contains(&quot;John&quot;));
</code></pre>
Running this code results in:
<pre><code class="hljs">false
true
</code></pre>
<h2 id="usingaforloop">Using a for-loop</h2>
A more basic and manual approach to solving the problem is by using a <code>for</code> loop. In worst case, it'll iterate the entire array once, checking if the element is present.
Let's start out with primitive integers first:
<pre><code class="hljs">int[] intArray = new int[]{1, 2, 3, 4, 5};
boolean found = false;
int searchedValue = 2;

for(int x : intArray){
 if(x == searchedValue){
 found = true;
 break;
 }
}

System.out.println(found);
</code></pre>
The <code>found</code> variable is initially set to <code>false</code> because the only way to return <code>true</code> would be to find the element and explicitly assign a new value to the boolean. Here, we simply compare each element of the array to the value we're searching for, and return <code>true</code> if they match:
<pre><code class="hljs">true
</code></pre>
For Strings, and custom Objects you might have in your code, you'd be using a different comparison operator. Assuming you've validly ovverriden the <code>equals()</code> method, you can use it to check if an object is equal to another, returning <code>true</code> if they are:
<pre><code class="hljs">String[] stringArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};
boolean found = false;
String searchedValue = &quot;Michael&quot;;

for(String x : stringArray){
 if(x.equals(searchedValue)){
 found = true;
 break;
 }
}

System.out.println(found);
</code></pre>
Running this code will result in:
<pre><code class="hljs">false
</code></pre>
<h2 id="collectionsbinarysearch">Collections.binarySearch()</h2>
Additionally, we can find a specific value using a built-in method <code>binarySearch()</code> from the <code>Collections</code> class. The problem with binary search is that it requires our array be sorted. If our array is sorted though, <code>binarySearch()</code> outperforms both the <code>Arrays.asList().contains()</code> and the for-loop approaches.
If it's not sorted, the added time required to sort the array might make this approach less favorable, depending on the size of the array and the sorting algorithm used to sort it.
<code>binarySearch()</code> has many overloaded variants depending on the types used and our own requirements, but the most general one is:
<pre><code class="hljs">public static int binarySearch(Object[] a, Object[] key)
</code></pre>
Where <code>a</code> represents the array, and <code>key</code> the specified value we're looking for.
Now, the return value might be a bit confusing, so it's best to take Oracle's official documentation in mind:
<blockquote>
The return value of this method is the index of the searched key, if it is contained in the array; otherwise (-(insertion point) - 1), where insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or <code>a.length</code> if all elements in the array are less than the specified key.
</blockquote>
Let's try this out:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;Bill&quot;, &quot;Connor&quot;, &quot;Joe&quot;, &quot;John&quot;, &quot;Mark&quot;}; // Array is already sorted lexicographically

List&lt;Integer&gt; intList = new ArrayList&lt;&gt;(Arrays.asList(intArray));
List&lt;String&gt; nameList = new ArrayList&lt;&gt;(Arrays.asList(nameArray));
System.out.println(Collections.binarySearch(intList, 2));
System.out.println(Collections.binarySearch(nameList, &quot;Robin&quot;));
</code></pre>
This will output:
<pre><code class="hljs">1
-6
</code></pre>
The first element is found, at position <code>1</code>. The second element isn't found, and would be inserted at position <code>5</code> - at the end of the array. The return value is <code>-(insertion point)-1</code>, so the return value ends up being <code>-6</code>.
If the value is above equal to, or above <code>0</code>, the array contains the element, and it doesn't contain it otherwise.
<h2 id="java8streamapi">Java 8 Stream API</h2>
The Java 8 Stream API is very versatile and offers for concise solutions to various tasks related to processing collections of objects. Using Streams for this type of task is natural and intuitive for most.
Let's take a look at how we can use the Stream API to check if an array contains an integer:
<pre><code class="hljs">Integer[] arr = new Integer[]{1, 2, 3, 4, 5};

System.out.println(Arrays.stream(arr).anyMatch(x -&gt; x == 3));
</code></pre>
This will output:
<pre><code class="hljs">true
</code></pre>
And to do this with Strings or custom objects:
<pre><code class="hljs">String[] arr = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

String searchString = &quot;Michael&quot;;

boolean doesContain = Arrays.stream(arr)
 .anyMatch(x -&gt; x.equals(searchString));

System.out.println(doesContain);
</code></pre>
Or, you can make this shorter by using a method reference:
<pre><code class="hljs">boolean doesContain = Arrays.stream(arr)
 .anyMatch(searchString::equals);
 
System.out.println(doesContain);
</code></pre>
Both of these would output:
<pre><code class="hljs">false
</code></pre>
<h2 id="apachecommonsarrayutils">Apache Commons - ArrayUtils</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library provides many new interfaces, implementations and classes that expand on the core Java Framework, and is present in many projects.
The <code>ArrayUtils</code> class introduces many methods for manipulating arrays, including the <code>contains()</code> method:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

System.out.println(ArrayUtils.contains(intArray, 3));
System.out.println(ArrayUtils.contains(nameArray, &quot;John&quot;));
</code></pre>
This would result in:
<pre><code class="hljs">true
true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over several ways to check whether an array in Java contains a certain element or value. We've gone over converting the array to a list and calling the <code>contains()</code> method, using a for-loop, the Java 8 Stream API, as well as Apache Commons.

Branko Ilic

In this tutorial, we'll go over examples of how to check if a Java array contains a certain element or value. We'll be using a List, the Stream API as well as Apache Commons.

Java: Check if Array Contains Value or Element

Sathiya Sarathi Gunasekaran

This article will give you a crash course on web scraping in Python with Beautiful Soup - a popular Python library for parsing HTML and XML.

Parsing HTML with BeautifulSoup in Python

Guide to Parsing HTML with BeautifulSoup in Python

<h2 id="introduction">Introduction</h2>
The main purpose of writing code is so that a computer can interpret it as commands. However, it's also important that the code we write is also easily interpretable by fellow developers.
Have you ever gone back to a project and had difficulty understanding the internal logic? Well that's probably because said project hasn't been commented properly.
Comments are notes written in the code that are ignored by the JavaScript engine, which means they don't affect the output in any way. Their sole purpose is describing how and why code works to other developers, and yourself.
In this article, we will look at how to comment JavaScript code, as which types of comments exist, and some best practices.
<h2 id="singlelinecomments">Single-Line Comments</h2>
Single-line comments are generally used to comment a part of the line or full line of code. Single-line comments in JavaScript start with <code>//</code>. The interpreter will ignore everything to the right of this control sequence until the end of the line.
Let's see an example of a single-line comment in action:
<pre><code class="hljs">// Print &quot;Hello World&quot; in the console
console.log(&quot;Hello World&quot;);
</code></pre>
Here, we are using a single-line comment to describe what the next line of code is doing. 
If a single-line comment appears at the end of a line of code, it's called an inline comment.
These are generally used to add quick annotations:
<pre><code class="hljs">let c = a + b; // Assign sum of a, b to c
</code></pre>
<h2 id="multilinecommentsandjavascriptdocstrings">Multi-Line Comments and JavaScript DocStrings</h2>
If we'd like to add a note that is spread across multiple lines, we can opt for multi-line comments or block-level comments.
Multi-line comments start with <code>/*</code> and end with <code>*/</code>:
<pre><code class="hljs">/* The following program contains source code for a game called Tic-tac-toe.
It is a paper-and-pencil game for two players, X and O, who take turns marking the spaces in a 3×3 grid. 
The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row is the winner
*/
</code></pre>
Here, a multi-line comment is used to describe tic-tac-toe. Generally, multi-line comments are used to introduce and explain a section of code, where a single line/sentence isn't enough.
Another type of multi-line comment can oftentimes be seen as well:
<pre><code class="hljs">/**
* The following program contains source code for a game called Tic-tac-toe.
* It is a paper-and-pencil game for two players, X and O, who take turns marking the
* spaces in a 3×3 grid. 
* The player who succeeds in placing three of their marks in a horizontal, vertical, or 
* diagonal row is the winner
*/
</code></pre>
Oftentimes, these comments can include information about the proceeding code, such as the parameters of a function or even the author of the code:
<pre><code class="hljs">/**
* Function that greets a user
* @author John
* @param {String} name Name of the user
* @return {String} Greeting message
*/
function greetUser(name) {
 return `Greetings, ${name}!`;
}
</code></pre>
These comments are referred to as DocStrings, as they're essentially strings (comments) that constitute the documentation of your code.
These types of comments are really useful for other developers in your team, as you can clarify what the expected input is, what the output is, as well as who to contact if need be.
An added benefit is that you can generate documentation based on these DocStrings.
<h2 id="usingcommentsfordebugging">Using Comments for Debugging</h2>
Besides making notes, comments can also be used to quickly prevent code execution for debugging purposes. This is possible because JavaScript Engines do not interpret commented code. This is called as commenting out code.
If there's an erroneous line, that's causing problems, we can simply &quot;comment it out&quot; to disable it, without deleting the line. This can be paired with actual debuggers to help you assess what's going on.
Consider the following code:
<pre><code class="hljs">console.log(&quot;Working code&quot;);
console.log(&quot;Erroneous code);
</code></pre>
If we'd like to remove the second statement, but don't wish to delete it forever, we can simply comment it out:
<pre><code class="hljs">console.log(&quot;Working code&quot;);
//console.log(&quot;Erroneous code);
</code></pre>
Pro Tip: In most of the code editors, we can use the keyboard shortcut <code>Ctrl + /</code> for Windows and <code>Cmd + /</code> for Mac to comment out a single line of code.
Additionally, you can also comment out entire sections if you're unsure whether you'll delete them or not:
<pre><code class="hljs">/*console.log(&quot;Entering for loop&quot;);
for (let i = 0; i &lt; 100; i++) {
 console.log(i);
}*/
</code></pre>
<h2 id="goodcommentingpractices">Good Commenting Practices</h2>
First of all, commenting is not an excuse to write unreadable code, and then just patch it up with five paragraphs of comments explaining it. We first have to focus on writing clean, self-explanatory code, which can later be improved with constructive comments.
Use comments to explain why you did something, not how you did it. If you find yourself explaining how you did something, then it's time to take a step back and refactor your code into something self-explanatory.
Another piece of advice would be to not write comments which are obvious and are redundant by nature. For example, the following comment is completely unnecessary:
<pre><code class="hljs">// Prints out the result
console.log(result)
</code></pre>
There are useful tools, such as <a rel="nofollow noopener" target="_blank" href="https://github.com/jsdoc/jsdoc">JSDOC 3</a> that can generate documentation, based just on the comments within your code, which are formatted as DocStrings outlined above.
<h2 id="conclusion">Conclusion</h2>
In this article, we have gone over what comments are and how to create them in JavaScript. We have looked at different types of comments - single-line and multi-line comments, as well as mentioned JavaScript Docstrings.
We've also seen how to debug our code using a technique called &quot;commenting out&quot;, and finally summed up some good commenting practices.

Abhilash Kakumanu

In this tutorial, we'll go over how to comment code in JavaScript. We'll go over the types of comments, including DocStrings, and some best practices for writing comments in JavaScript.