<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 Violin Plots in Matplotlib.
<blockquote>
Violin plots are used to visualize data distributions, displaying the range, median, and distribution of the data.
</blockquote>
Violin plots show the same summary statistics as box plots, but they also include Kernel Density Estimations that represent the shape/distribution of the data.
<h2 id="importingdata">Importing Data</h2>
Before we can create a Violin plot, we will need some data to plot. We’ll be using the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/tklimonova/gapminder-datacamp-2007?select=gapminder_full.csv">Gapminder dataset</a>.
We’ll start by importing the libraries we need, which include Pandas and Matplotlib:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt
</code></pre>
We’ll check to make sure that there are no missing data entries and print out the head of the dataset to ensure that the data has been loaded correctly. Be sure to set the encoding type to <code>ISO-8859-1</code>:
<pre><code class="hljs">dataframe = pd.read_csv(&quot;gapminder_full.csv&quot;, error_bad_lines=False, encoding=&quot;ISO-8859-1&quot;)
print(dataframe.head())
print(dataframe.isnull().values.any())
</code></pre>
<pre><code class="hljs"> country year population continent life_exp gdp_cap
0 Afghanistan 1952 8425333 Asia 28.801 779.445314
1 Afghanistan 1957 9240934 Asia 30.332 820.853030
2 Afghanistan 1962 10267083 Asia 31.997 853.100710
3 Afghanistan 1967 11537966 Asia 34.020 836.197138
4 Afghanistan 1972 13079460 Asia 36.088 739.981106
</code></pre>
<h2 id="plottingaviolinplotinmatplotlib">Plotting a Violin Plot in Matplotlib</h2>
To create a Violin Plot in Matplotlib, we call the <code>violinplot()</code> function on either the <code>Axes</code> instance, or the PyPlot instance itself:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

dataframe = pd.read_csv(&quot;gapminder_full.csv&quot;, error_bad_lines=False, encoding=&quot;ISO-8859-1&quot;)

population = dataframe.population
life_exp = dataframe.life_exp
gdp_cap = dataframe.gdp_cap

# Extract Figure and Axes instance
fig, ax = plt.subplots()

# Create a plot
ax.violinplot([population, life_exp, gdp_cap])

# Add title
ax.set_title(&#x27;Violin Plot&#x27;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-1.png" alt="matplotlib violin plot">
When we create the first plot, we can see the distribution of our data, but we will also notice some problems. Because the scale of the features are so different, it’s practically impossible the distribution of the Life expectancy and GDP columns.
For this reason, we want to plot each column on its own subplot.
We'll do a little sorting and slicing of the dataframe to make comparing the dataset columns easier. We'll group the dataframe by &quot;country&quot;, and select just the most recent/last entries for each of the countries.
We'll then sort by population and drop the entries with the largest populations (the large population outliers), so that the rest of the dataframe is in a more similar range and comparisons are easier:
<pre><code class="hljs">dataframe = dataframe.groupby(&quot;country&quot;).last()
dataframe = dataframe.sort_values(by=[&quot;population&quot;], ascending=False)
dataframe = dataframe.iloc[10:]
print(dataframe)
</code></pre>
Now, the dataframe looks something like:
<pre><code class="hljs"> year population continent life_exp gdp_cap
country
Philippines 2007 91077287 Asia 71.688 3190.481016
Vietnam 2007 85262356 Asia 74.249 2441.576404
Germany 2007 82400996 Europe 79.406 32170.374420
Egypt 2007 80264543 Africa 71.338 5581.180998
Ethiopia 2007 76511887 Africa 52.947 690.805576
... ... ... ... ... ...
Montenegro 2007 684736 Europe 74.543 9253.896111
Equatorial Guinea 2007 551201 Africa 51.579 12154.089750
Djibouti 2007 496374 Africa 54.791 2082.481567
Iceland 2007 301931 Europe 81.757 36180.789190
Sao Tome and Principe 2007 199579 Africa 65.528 1598.435089
</code></pre>
Great! Now we can create a figure and three axes objects with the <code>subplots()</code> function. Each of these axes will have a violin plot. Since we're working on a much more manageable scale now, let's also turn on the <code>showmedians</code> argument by setting it to <code>True</code>.
This will strike a horizontal line in the median of our violin plots:
<pre><code class="hljs"># Create figure with three axes
fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3)

# Plot violin plot on axes 1
ax1.violinplot(dataframe.population, showmedians=True)
ax1.set_title(&#x27;Population&#x27;)

# Plot violin plot on axes 2
ax2.violinplot(life_exp, showmedians=True)
ax2.set_title(&#x27;Life Expectancy&#x27;)

# Plot violin plot on axes 3
ax3.violinplot(gdp_cap, showmedians=True)
ax3.set_title(&#x27;GDP Per Cap&#x27;)

plt.show()
</code></pre>
Running this code now yields us:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-2.png" alt="matplotlib violin plot show medians">
Now we can get a good idea of the distribution of our data. The central horizontal line in the Violins is where the median of our data is located, and minimum and maximum values are indicated by the line positions on the Y-axis.
<h2 id="customizingviolinplotsinmatplotlib">Customizing Violin Plots in Matplotlib</h2>
Now, let's take a look at how we can customize Violin Plots.
<h3 id="addingxandyticks">Adding X and Y Ticks</h3>
As you can see, while the plots have successfully been generated, without tick labels on the X and Y-axis it can get difficult to interpret the graph. Humans interpret categorical values much more easily than numerical values.
We can customize the plot and add labels to the X-axis by using the <code>set_xticks()</code> function:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.violinplot(gdp_cap, showmedians=True)
ax.set_title(&#x27;violin plot&#x27;)
ax.set_xticks([1])
ax.set_xticklabels([&quot;Country GDP&quot;,])
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-3.png" alt="add x and y ticks to violin plots in matplotlib">
Here, we've set the X-ticks from a range to a single one, in the middle, and added a label that's easy to interpret.
<h3 id="plottinghorizontalviolinplotinmatplotlib">Plotting Horizontal Violin Plot in Matplotlib</h3>
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>True</code> by default:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.violinplot(gdp_cap, showmedians=True, vert=False)
ax.set_title(&#x27;violin plot&#x27;)
ax.set_yticks([1])
ax.set_yticklabels([&quot;Country GDP&quot;,])
ax.tick_params(axis=&#x27;y&#x27;, labelrotation = 90)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-4.png" alt="plot horizontal violin plot in matplotlib">
Here, we've set the Y-axis tick labels and their frequency, instead of the X-axis. We've also rotated the labels by 90 degrees
<h3 id="showingdatasetmeansinviolinplots">Showing Dataset Means in Violin Plots</h3>
We have some other customization parameters available to us as well. We can choose to show means, in addition to medians, by using the <code>showmean</code> parameter.
Let’s try visualizing the means in addition to the medians:
<pre><code class="hljs">fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3)
ax1.violinplot(population, showmedians=True, showmeans=True, vert=False)
ax1.set_title(&#x27;Population&#x27;)

ax2.violinplot(life_exp, showmedians=True, showmeans=True, vert=False)
ax2.set_title(&#x27;Life Expectancy&#x27;)

ax3.violinplot(gdp_cap, showmedians=True, showmeans=True, vert=False)
ax3.set_title(&#x27;GDP Per Cap&#x27;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-5.png" alt="show dataset means in violin plot in matplotlib">
Though, please note that since the medians and means essentially look the same, it may become unclear which vertical line here refers to a median, and which to a mean.
<h3 id="customizingkerneldensityestimationforviolinplots">Customizing Kernel Density Estimation for Violin Plots</h3>
We can also alter how many data points the model considers when creating the Gaussian Kernel Density Estimations, by altering the <code>points</code> parameter.
The number of points considered is 100 by default. By providing the function with fewer data points to estimate from, we may get a less representative data distribution.
Let's change this number to, say, 10:
<pre><code class="hljs">fig, ax = plt.subplots()
ax.violinplot(gdp_cap, showmedians=True, points=10)
ax.set_title(&#x27;violin plot&#x27;)
ax.set_xticks([1])
ax.set_xticklabels([&quot;Country GDP&quot;,])
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-6.png" alt="customize kernel density estimation for violin plots in matplotlib">
Notice that the shape of the violin is less smooth since fewer points have been sampled.
Typically, you would want to increase the number of points used to get a better sense of the distribution. This might not always be the case, if 100 is simply enough. Lets plot a 10-point, 100-point and 500-point sampled Violin Plot:
<pre><code class="hljs">fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3)
ax1.violinplot(gdp_cap, showmedians=True, points=10)
ax1.set_title(&#x27;GDP Per Cap, 10p&#x27;)

ax2.violinplot(gdp_cap, showmedians=True, points=100)
ax2.set_title(&#x27;GDP Per Cap, 100p&#x27;)

ax3.violinplot(gdp_cap, showmedians=True, points=500)
ax3.set_title(&#x27;GDP Per Cap, 500p&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-violin-plot-tutorial-and-examples-7.png" alt="various KDE sample sizes for violin plot">
There isn't any obvious difference between the second and third plot, though, there's a significant one between the first and second.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a Violin Plot using Matplotlib and Python. We've also covered how to customize them by adding X and Y ticks, plotting horizontally, showing dataset means as well as altering the KDE point sampling.
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 be going over how to plot a Violin Plot in Matplotlib and Python. We'll go over everything you need to know to plot and customize Violin Plots.

Matplotlib Violin Plot - Tutorial and Examples

Branko Ilic

In this guide, we'll go over the important functionalities of the Apache Commons StringUtils class in Java, with tutorials and examples of everything you need to know.

Guide to Apache Commons' StringUtils Class in Java

<h2 id="introduction">Introduction</h2>
Finding the right data we need is an age-old problem before computers. As developers, we create many search algorithms to retrieve data efficiently.
Search algorithms can be divided into two broad categories: sequential and interval searches. Sequential searches check each element in a data structure. Interval searches check various points of the data (called intervals), reducing the time it takes to find an item, given a sorted dataset.
In this article, you will cover Jump Search in Python - a hybrid combination of sequential search and interval search on sorted arrays.
<h2 id="jumpsearch">Jump Search</h2>
With Jump Search, the sorted array of data is split into subsets of elements called blocks. We find the search key (input value) by comparing the search candidate in each block. As the array is sorted, the search candidate is the highest value of a block.
When comparing the search key to a search candidate, the algorithm can then do 1 of 3 things:
<ol>
<li>If the search candidate is lesser than the search key, we'll check the subsequent block</li>
<li>If the search candidate is greater than the search key, we'll do a linear search on the current block</li>
<li>If the search candidate is the same as the search key, return the candidate</li>
</ol>
The size of the block is chosen as the square root of the array's length. Therefore, arrays with length <code>n</code> have a block size of <code>√n</code>, as this on average gives the best performance for most arrays.
It might be useful to illustrate how it works. Here's how Jump Search would find the value 78 in an array of 9 elements:
<img src="https://stackabuse.s3.amazonaws.com/media/jump-search-in-python-1.jpg" alt="Illustration finding the value 78 on a sorted array with jump search">
The above example finds the element in 5 steps, as there are two checks in the linear search section.
Now that we have a high-level appreciation for how it works, let's look at a pseudocode implementation of the algorithm.
<h2 id="jumpsearchsteps">Jump Search Steps</h2>
Inputs:
<ul>
<li>Array/list <code>A</code> of size <code>n</code></li>
<li>Search Key <code>item</code></li>
</ul>
Output:
<ul>
<li>Index of the matched Search Key or <code>-1</code> if the <code>item</code> is not found</li>
</ul>
<h3 id="steps">Steps</h3>
<ul>
<li>Step 1: Find the length of the sorted source list - <code>n = len(A)</code></li>
<li>Step 2: Determine the suitable Block Size - <code>m = √n</code></li>
<li>Step 3: Iteration begins at the index of the <code>item</code> at <code>i = 0</code> with a step of <code>m</code> and continues until the window reaches the end of the list.</li>
<li>Step 4: Compare <code>A[i+m]</code> (<code>i+m</code> is the last index of a block) and the <code>item</code>
<ul>
<li>a) If <code>A[i+m] == item</code>, Return <code>i+m</code>; Code Exits</li>
<li>b) If <code>A[i+m] &gt; item</code>, Proceed to the linear search inside the block known as derived list <code>B = A[i: i+m]</code>
<ul>
<li>Iterate and compare each element of the list with the search key and return the matching <code>i</code> if found; Code Exits</li>
</ul>
</li>
<li>c) If <code>A[i+m] &lt; item</code>, Proceed with the next iteration to Step 4 :arrows_clockwise:</li>
</ul>
</li>
<li>Step 5: Iterate the elements of the list that don't fit in the block and return the matching index <code>i</code>. If no matches were found, return <code>-1</code>; Code Exits</li>
</ul>
As we now understand how it works, let us implement this algorithm in Python!
<h2 id="implementation">Implementation</h2>
Knowing how Jump Search works, let's go ahead and implement it in Python:
<pre><code class="hljs">&#x27;&#x27;&#x27;
Jump Search function
Arguments:
A - The source list
item - Element for which the index needs to be found
&#x27;&#x27;&#x27;
import math

def jump_search(A, item):
 print(&quot;Entering Jump Search&quot;)
 n = len(A) # Length of the array
 m = int(math.sqrt(n)) # Step length
 i = 0 # Starting interval

 while i != len(A)-1 and A[i] &lt; item:
 print(&quot;Processing Block - {}&quot;.format(A[i: i+m]))
 if A[i+m-1] == item: # Found the search key
 return i+m-1
 elif A[i+m-1] &gt; item: # Linear search for key in block
 B = A[i: i+m-1]
 return linear_search(B, item, i)
 i += m

 B = A[i:i+m] # Step 5
 print(&quot;Processing Block - {}&quot;.format(B))
 return linear_search(B, item, i)
</code></pre>
The <code>jump_search()</code> function takes two arguments - the sorted list under evaluation as the first argument and the element that needs to be found in the second argument. The <code>math.sqrt()</code> function is used to find the block size. The iteration is facilitated by a <code>while</code> condition and the increment is made feasible by the incremented <code>i += m</code>.
You would have noticed that the <code>Step 4b</code> and <code>Step 5</code> have a <code>linear_search()</code> function invoked. The <code>linear_search()</code> function is triggered in one of the following scenarios.
<ul>
<li>
<code>Step 4b</code> - When there's a shift in comparison. If the last element of a block/window is greater than the <code>item</code>, the <code>linear_search()</code> is triggered.
</li>
<li>
<code>Step 5</code> - The remaining elements of the source list <code>A</code> that don't fit in a block are passed as a derived list to the <code>linear_search()</code> function.
</li>
</ul>
The <code>linear_search()</code> function can be written like this:
<pre><code class="hljs">&#x27;&#x27;&#x27;
Linear Search function
Arguments:
B - The derived list
item - Element for which the index needs to be found
loc - The Index where the remaining block begins
&#x27;&#x27;&#x27;

def linear_search(B, item, loc):
 print(&quot;\t Entering Linear Search&quot;)
 i = 0

 while i != len(B):
 if B[i] == item:
 return loc+i
 i += 1
 return -1
</code></pre>
In step 5, the remaining elements of the original list are passed to the <code>linear_search()</code> function as a derived list. The comparison is done against each element of the derived list <code>B</code>.
The matched index of the derived list is added to the index of the source block, to provide the exact index position of the element in the source list. If there are no matches found, we return <code>-1</code> to indicate that <code>item</code> was not found.
The complete snippet can be found on &lt;a rel=”nofollow noopener” href=&quot;https://github.com/StackAbuse/search-algorithms&quot; target=&quot;_blank&quot;&gt;GitHub</a>.
<h2 id="benchmarkingjumpsearchvslinearsearch">Benchmarking - Jump Search vs Linear Search</h2>
The runtime for the Jump Search can be benchmarked against Linear Search. The following visualization illustrates how the algorithms perform while searching for an element near the end of a sorted array. The shorter the bar, the better:
<img src="https://stackabuse.s3.amazonaws.com/media/jump-search-in-python-2.jpg" alt="Graph comparing Jump Search performance against Linear Search. For larger lists of numbers, jump search performs better">
As the number of elements in the list increases, Jump Search is quicker than the Linear Search algorithm.
<h2 id="bigoanalysis">Big-O Analysis</h2>
Let's do a more general analysis of how Jump Search performs. We'll once again consider the worst-case scenario where the element to be found is at the end of the list.
For a list of <code>n</code> elements and a block size of <code>m</code>, Jump Search would ideally perform <code>n/m</code> jumps. Considering the block size to be <code>√n</code>, the runtime too would be <code>O(√n)</code>.
This puts Jump Search in between Linear Search (worst) with a runtime complexity of <code>O(n)</code> and Binary Search (best) with a runtime complexity of <code>O(log n)</code>. Hence, Jump Search can be used in places where the binary search is not feasible and linear search is too costly.
<h2 id="conclusion">Conclusion</h2>
In this article, we have covered the basics of the Jump Search algorithm. We then examined how Jump Search works with pseudocode before implementing it in Python. Thereafter, we analyzed how Jump Search performs, as well as its theoretical speed bounds.

Marcus Sanatan

Sathiya Sarathi Gunasekaran

The Jump Search algorithm is a hybrid combination of sequential search and interval search on sorted arrays. Let's learn how to implement it in Python.

Jump Search in Python

<h2 id="introduction">Introduction</h2>
Spelling mistakes are common, and most people are used to software indicating if a mistake was made. From autocorrect on our phones, to red underlining in text editors, spell checking is an essential feature for many different products.
The first program to implement spell checking was written in 1971 for the DEC PDP-10. Called SPELL, it was capable of performing only simple comparisons of words and detecting one or two letter differences. As hardware and software advanced, so have spell checkers. Modern spell checkers are capable of handling morphology and using statistics to improve suggestions.
Python offers many modules to use for this purpose, making writing a simple spell checker an easy 20-minute ordeal.
One of these libraries being TextBlob, which is used for natural language processing that provides an intuitive API to work with.
In this article we'll take a look at how to implement spelling correction in Python with TextBlob.
<h2 id="installation">Installation</h2>
First, we'll need to install TextBlob, since it doesn't come preinstalled. Open up a console and install it using pip:
<pre><code class="hljs">$ pip install textblob
</code></pre>
This should install everything we need for this project. Upon finishing the installation, the console output should include something like:
<pre><code class="hljs">Successfully installed click-7.1.2 joblib-0.17.0 nltk-3.5 regex-2020.11.13 textblob-0.15.3
</code></pre>
TextBlob is built on top of NLTK, so it also comes with the installation.
<h2 id="thecorrectfunction">The correct() Function</h2>
The most straightforward way to correct input text is to use the <code>correct()</code> method. The example text we'll be using is a paragraph from Charles Darwin's &quot;On the Origin of Species&quot;, which is part of the public domain, packed into a file called <code>text.txt</code>.
In addition, we'll add some deliberate spelling mistakes:
<pre><code class="hljs">As far as I am abl to judg, after long attnding to the sbject, the condiions of lfe apear to act in two ways—directly on the whle organsaton or on certin parts alne and indirectly by afcting the reproducte sstem. Wit respct to te dirct action, we mst bea in mid tht in every cse, as Profesor Weismann hs latly insistd, and as I have inidently shwn in my wrk on &quot;Variatin undr Domesticcation,&quot; thcere arae two factrs: namly, the natre of the orgnism and the natture of the condiions. The frmer sems to be much th mre importannt; foor nealy siimilar variations sometimes aris under, as far as we cn juddge, disimilar conditios; annd, on te oter hannd, disssimilar variatioons arise undder conditions which aappear to be nnearly uniiform. The efffects on tthe offspring arre ieither definnite or in definite. They maay be considdered as definnite whhen allc or neearly all thhe ofefspring off inadividuals exnposed tco ceertain conditionas duriing seveal ggenerations aree moodified in te saame maner.
</code></pre>
It's full of spelling mistakes, in almost every word. Let's write up a simple script, using TextBlob, to correct these mistakes and print them back to the console:
<pre><code class="hljs">from textblob import TextBlob

with open(&quot;text.txt&quot;, &quot;r&quot;) as f: # Opening the test file with the intention to read
 text = f.read() # Reading the file
 textBlb = TextBlob(text) # Making our first textblob
 textCorrected = textBlb.correct() # Correcting the text
 print(textCorrected)
</code></pre>
If you've worked with TextBlob before, this flow will look familiar to you. We've read the file and the contents inside of it, and constructed a <code>TextBlob</code> instance by passing the contents to the constructor.
Then, we run the <code>correct()</code> function on that instance to perform spelling correction.
After running the script above, you should get an output similar to:
<pre><code class="hljs">Is far as I am all to judge, after long attending to the subject, the conditions of life appear to act in two ways—directly on the while organisation or on certain parts alone and indirectly by acting the reproduce system. It respect to te direct action, we must be in mid the in every case, as Professor Weismann he lately insisted, and as I have evidently shown in my work on &quot;Variation under Domesticcation,&quot; there are two facts: namely, the nature of the organism and the nature of the conditions. The former seems to be much th are important; for nearly similar variations sometimes arms under, as far as we in judge, similar condition; and, on te other hand, disssimilar variations arise under conditions which appear to be nearly uniform. The effects on the offspring are either definite or in definite. They may be considered as definite when all or nearly all the offspring off individuals exposed to certain conditions during several generations are modified in te same manner.
</code></pre>
<h2 id="howcorrectistextblobsspellingcorrection">How Correct is TextBlob's Spelling Correction?</h2>
As we can see, the text still has some spelling errors. Words like <code>&quot;abl&quot;</code> were supposed to be <code>&quot;able&quot;</code>, not <code>&quot;all&quot;</code>. Though, even with these, it's still better than the original.
<blockquote>
Now comes the question, how much better is it?
</blockquote>
The following code snippet is a simple script that test how good is TextBlob in correcting errors, based on this example:
<pre><code class="hljs">from textblob import TextBlob

# A function that compares two texts and returns 
# the number of matches and differences
def compare(text1, text2): 
 l1 = text1.split()
 l2 = text2.split()
 good = 0
 bad = 0
 for i in range(0, len(l1)):
 if l1[i] != l2[i]:
 bad += 1
 else:
 good += 1
 return (good, bad)

# Helper function to calculate the percentage of misspelled words
def percentageOfBad(x):
 return (x[1] / (x[0] + x[1])) * 100
</code></pre>
Now, with those two functions, let's run a quick analysis:
<pre><code class="hljs">with open(&quot;test.txt&quot;, &quot;r&quot;) as f1: # test.txt contains the same typo-filled text from the last example 
 t1 = f1.read()

with open(&quot;original.txt&quot;, &quot;r&quot;) as f2: # original.txt contains the text from the actual book 
 t2 = f2.read()

t3 = TextBlob(t1).correct()

mistakesCompOriginal = compare(t1, t2)
originalCompCorrected = compare(t2, t3)
mistakesCompCorrected = compare(t1, t3)

print(&quot;Mistakes compared to original &quot;, mistakesCompOriginal)
print(&quot;Original compared to corrected &quot;, originalCompCorrected)
print(&quot;Mistakes compared to corrected &quot;, mistakesCompCorrected, &quot;\n&quot;)

print(&quot;Percentage of mistakes in the test: &quot;, percentageOfBad(mistakesCompOriginal), &quot;%&quot;)
print(&quot;Percentage of mistakes in the corrected: &quot;, percentageOfBad(originalCompCorrected), &quot;%&quot;)
print(&quot;Percentage of fixed mistakes: &quot;, percentageOfBad(mistakesCompCorrected), &quot;%&quot;, &quot;\n&quot;)
</code></pre>
Running it will print out:
<pre><code class="hljs">Mistakes compared to original (126, 194)
Original compared to corrected (269, 51)
Mistakes compared to corrected (145, 175) 

Percentage of mistakes in the test: 60.62499999999999 %
Percentage of mistakes in the corrected: 15.937499999999998 %
Percentage of fixed mistakes: 54.6875 % 
</code></pre>
As we can see, the <code>correct</code> method managed to get our spelling mistake percentage from 60.6% to 15.9%, which is pretty decent, however there's a bit of a catch. It corrected 54.7% of the words, so why is there still a 15.9% mistake rate?
The answer is overcorrection. Sometimes, it can change a word that is spelled correctly, like the first word in our example text where <code>&quot;As&quot;</code> was corrected to <code>&quot;Is&quot;</code>. Other times, it just doesn't have enough information about the word and the context to tell which word the user was intending to type, so it guesses that it should replace <code>&quot;whl&quot;</code> with <code>&quot;while&quot;</code> instead of <code>&quot;whole&quot;</code>.
There is no perfect spelling corrector because so much of spoken language is contextual, so keep that in mind. In most use cases, there are way fewer mistakes than in our example, so TextBlob should be able to work well enough for the average user.
<h2 id="trainingtextblobwithcustomdatasets">Training TextBlob with Custom Datasets</h2>
What if you want to spellcheck another language which isn't supported by TextBlob out of the box? Or maybe you want to get just a little bit more precise? Well, there might be a way to achieve this. It all comes down to the way spell checking works in TextBlob.
TextBlob uses statistics of word usage in English to make smart suggestions on which words to correct. It keeps these statistics in a file called <code>en-spelling.txt</code>, but it also allows you to make your very own word usage statistics file.
Let's try to make one for our Darwin example. We'll use all the words in the &quot;On the Origin of Species&quot; to train. You can use any text, just make sure it has enough words that are relevant to the text you wish to correct.
In our case, the rest of the book will provide great context and additional information that TextBlob would need to be more accurate in the correction.
Let's rewrite the script:
<pre><code class="hljs">from textblob.en import Spelling 
import re

textToLower = &quot;&quot;

with open(&quot;originOfSpecies.txt&quot;,&quot;r&quot;) as f1: # Open our source file
 text = f1.read() # Read the file 
 textToLower = text.lower() # Lower all the capital letters

words = re.findall(&quot;[a-z]+&quot;, textToLower) # Find all the words and place them into a list 
oneString = &quot; &quot;.join(words) # Join them into one string

pathToFile = &quot;train.txt&quot; # The path we want to store our stats file at
spelling = Spelling(path = pathToFile) # Connect the path to the Spelling object
spelling.train(oneString, pathToFile) # Train
</code></pre>
If we look into the <code>train.txt</code> file, we'll see:
<pre><code class="hljs">a 3389
abdomen 3
aberrant 9
aberration 5
abhorrent 1
abilities 1
ability 4
abjectly 1
able 54
ably 5
abnormal 17
abnormally 2
abodes 2
...
</code></pre>
This indicates that the word <code>&quot;a&quot;</code> shows up as a word 3389 times, while <code>&quot;ably&quot;</code> shows up only 5 times. To test out this trained model, we'll use <code>suggest(text)</code> instead of <code>correct(text)</code>, which is a list of word-confidence tuples. The first element in the list will be the word it's most confident about, so we can access it via <code>suggest(text)[0][0]</code>.
Note that this might be slower, so go word by word while spell-checking, as dumping huge amounts of data can result in a crash:
<pre><code class="hljs">from textblob.en import Spelling 
from textblob import TextBlob

pathToFile = &quot;train.txt&quot; 
spelling = Spelling(path = pathToFile)
text = &quot; &quot;

with open(&quot;test.txt&quot;, &quot;r&quot;) as f: 
 text = f.read()

words = text.split()
corrected = &quot; &quot;
for i in words :
 corrected = corrected +&quot; &quot;+ spelling.suggest(i)[0][0] # Spell checking word by word

print(corrected)
</code></pre>
And now, this will result in:
<pre><code class="hljs">As far as I am all to judge after long attending to the subject the conditions of life appear to act in two ways—directly on the whole organisation or on certain parts alone and indirectly by acting the reproduce system It respect to the direct action we most be in mid the in every case as Professor Weismann as lately insisted and as I have incidently shown in my work on &quot;Variatin under Domesticcation,&quot; there are two facts namely the nature of the organism and the nature of the conditions The former seems to be much th are important for nearly similar variations sometimes arise under as far as we in judge dissimilar conditions and on the other hand dissimilar variations arise under conditions which appear to be nearly uniform The effects on the offspring are either definite or in definite They may be considered as definite when all or nearly all the offspring off individuals exposed to certain conditions during several generations are modified in the same manner.
</code></pre>
This fixes around 2 out of 3 of misspelled words, which is pretty good, considering the run without much context.
<h2 id="conclusion">Conclusion</h2>
In this article we'll used TextBlob to implement a basic spelling corrector, both with the stock prediction model a custom one.
Correcting man-made spelling errors has become a common task for software developers. Even though it has become easier and more efficient via data mining, many spelling mistakes need context to be corrected.
In conclusion, proofreaders are probably not going to get automated out of work any time soon, though some basic corrections can be automated to save time and effort.

Kristina Popovic

In this tutorial, we'll go over how to create a simple and powerful spelling correction script in Python using TextBlob. We'll go over stock spelling correction as well as training the model with custom data.

Spelling Correction in Python with TextBlob

<h2 id="introduction">Introduction</h2>
Notifications provide a great way to engage users of your applications and can be used to provide or solicit feedback. In this tutorial, we will be examining how to send notifications using Node.js and <code>node-notifier</code>.
<a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/node-notifier"><code>node-notifier</code></a> is a library for sending cross-platform native notifications in Node JS.
<h2 id="creatinganotificationwithnodenotifier">Creating a Notification with node-notifier</h2>
Let's create a directory for our project and initialize a Node project with default settings in it:
<pre><code class="hljs">$ cd node-native-notifications
$ npm init -y
$ npm install --save node-notifier
</code></pre>
Next, in the <code>index.js</code> file, we'll import <code>node-notifier</code>:
<pre><code class="hljs">const notifier = require(&#x27;node-notifier&#x27;);
</code></pre>
There are two ways to create and push a simple notification using <code>node-notifier</code>. Passing a string to the <code>notify()</code> function:
<pre><code class="hljs">notifier.notify(&#x27;Hello!&#x27;);
</code></pre>
Or, alternatively, you can pass an object, and set attributes such as the <code>title</code> and <code>message</code>:
<pre><code class="hljs">notifier.notify({
 title: &#x27;Greetings&#x27;,
 message: &#x27;Hello!&#x27;
});
</code></pre>
Let's run this code to see the notification in action:
<pre><code class="hljs">$ node index.js
</code></pre>
The notifications are layered over our desktop screen and we can see the two messages we've pushed:
<img src="https://stackabuse.s3.amazonaws.com/media/sending-notifications-with-node-notifier-mac-windows-linux-1.png" alt="sending notifications using node-notifier">
<h2 id="customizingnotifications">Customizing Notifications</h2>
Apart from the <code>title</code> and <code>message</code> options, you can also set an <code>icon</code> to appear, use <code>sound</code> to add a notification sound or use <code>wait</code> to wait for a user action..
The <code>sound</code> and <code>wait</code> are <code>false</code> by default.
Let's add an icon, which can be any image file, as well as a sound to our notification. Additionally, we'll wait for the user to perform an action as well:
<pre><code class="hljs">const path = require(&#x27;path&#x27;);

notifier.notify({
 title: &#x27;Salutations!&#x27;,
 message: &#x27;Hey there!&#x27;,
 icon: path.join(__dirname, &#x27;icon.jpg&#x27;),
 sound: true,
 wait: true
 },
 function (err, response) {
 console.log(response);
 }
);
</code></pre>
In the code above, we are including the <code>path</code> module to help us get the path to our file. We are also passing a callback function to the <code>notify()</code> function and logging the response or user interaction with our notification to the console.
Running the code above, you will get a notification with the image you have chosen as the icon of the notification. A sound of a new notification might also be accompanied with the notification display depending on the operating system OS of your computer and the version.
The notification will look like this:
<img src="https://stackabuse.s3.amazonaws.com/media/sending-notifications-with-node-notifier-mac-windows-linux-2.png" alt="notification with icon using node-notifier">
If you click the button to dismiss the notification, the string <code>dismissed</code> will be logged to your console. If there's no interaction with the notification till it disappears, it displays <code>timeout</code>. If the notification itself is clicked it logs <code>undefined</code> to the console.
<h2 id="customizingoptionsfordifferentplatforms">Customizing Options for Different Platforms</h2>
As stated in the previous section there might be variations in behavior of the notifications sent out due to differences in the reporting systems used by the operating system of the user.
<code>node-notifer</code> tries to use the system with the best user experience but it prefers native solutions. It provides fallbacks for each platform as defined in their <a rel="nofollow noopener" target="_blank" href="https://github.com/mikaelbr/node-notifier/blob/HEAD/DECISION_FLOW.md">decision flow</a>.
However, you can create a customized reporter for each of the reporting systems to have control over the behavior of the notifications you send out in your application. There are five reporters: Notification Center, Windows Toaster, Windows Balloons, Growl, and notify-send.
The <code>wait</code> option does not apply when using Windows Toaster or notify-send reporters as Windows Toasters always wait and notify-send doesn't support the <code>wait</code> option.
The <code>sound</code> option can only used for Notification Center and Windows Toaster reporters. The <code>icon</code> option takes in the absolute path to the image file and does not work for Windows Balloon reporter.
<h3 id="growl">Growl</h3>
This is the reporter that is the fallback when other reporters fail or are not available for the OS. It builds on the open-source <a rel="nofollow noopener" target="_blank" href="https://github.com/theabraham/growly/">Growly</a> package and sends messages using the <a rel="nofollow noopener" target="_blank" href="https://g.co/kgs/ecqghS">Growl</a> utility to send native notifications.
Add the following to your code to customize the Growl reporter for your application:
<pre><code class="hljs">const fs = require(&#x27;fs);
const Growl = require(&#x27;node-notifier&#x27;).Growl;
// Or
// const Growl = require(&#x27;node-notifier/notifiers/growl&#x27;);
 
let growlNotifier = new Growl({
 name: &#x27;Node&#x27;
 host: &#x27;localhost&#x27;,
 port: 23053
});
 
growlNotifier.notify({
 title: &#x27;Greetings&#x27;,
 message: &#x27;Hello user!&#x27;,
 icon: fs.readFileSync(__dirname + &#x27;/icon.jpg&#x27;),
 wait: false,
 
 // Other growl options like sticky etc.
 sticky: false,
 label: undefined,
 priority: undefined
});
</code></pre>
In the code above, we are creating a new <code>Growl</code> instance with a few options set up, such as its name, the host and port it'll be running on.
Next, we call the <code>notify()</code> method with our usual options. Growl introduces us to some more options, which are documented <a rel="nofollow noopener" target="_blank" href="https://github.com/theabraham/growly/#growlynotifytext-opts-callback">here</a>.
<h3 id="windowstoaster">Windows Toaster</h3>
This is a reporter specifically for the Windows OS which supports notifications since Windows 8 and newer.
Let's use the Windows Toaster reporter to push a notification:
<pre><code class="hljs">const WindowsToaster = require(&#x27;node-notifier&#x27;).WindowsToaster;
// Or
// const WindowsToaster = require(&#x27;node-notifier/notifiers/toaster&#x27;);
 
let windowsToasterNotifier = new WindowsToaster({
 withFallback: true
});
 
windowsToasterNotifier.notify({
 title: &quot;Windows Toaster Notification&quot;,
 message: &quot;This is a notification sent from the Windows Toaster Notifier&quot;,
 icon: path.join(__dirname, &#x27;icon.jpg&#x27;),
 sound: &quot;SMS&quot;,
 },
 function (error, response) {
 console.log(response);
 }
);
</code></pre>
Here, we're instantiating a <code>WindowsToaster</code> instance, setting the <code>withFallback</code> argument as <code>true</code>. If this notifier doesn't work, it'll fallback to Growl or Windows Balloons.
Then we are calling the <code>.notify()</code> method with the usual options.
<h3 id="windowsballoon">Windows Balloon</h3>
This is a reporter specifically for all Windows OS versions below Windows 8. It uses taskbar balloons to show notifications. To customize options for this reporter specifically, you can write your code thus:
<pre><code class="hljs">const WindowsBalloon = require(&#x27;node-notifier&#x27;).WindowsBalloon;
// Or
// const WindowsBallon = require(&#x27;node-notifier/notifiers/windowsballon&#x27;);
 
const windowsBalloonNotifier = new WindowsBalloon({
 withFallback: true
});
 
windowsBalloonNotifier.notify({
 title: &quot;Windows Balloon Notification&quot;,
 message: &quot;This notification was sent using Windows Balloons.&quot;,
 sound: true,
 time: 1000,
 wait: false,
 type: &#x27;warn&#x27;
 },
 function (error, response) {
 console.log(response);
 }
);
</code></pre>
As usual, we're constructing an instance of the notifier, and passing in our options to the <code>notify()</code> function.
Here, we can specify the <code>time</code> in milliseconds, after which the notification will disappear. We won't wait for the user to perform an action against the notification, so <code>wait</code> is set to <code>false</code>.
Also, we've set the notification <code>type</code> to <code>warn</code>, and <code>sound</code> to <code>true</code>. This will notify the user as a warning. We could've also used <code>info</code> or <code>error</code> depending on what you'd like to convey.
<h3 id="notificationcenter">Notification Center</h3>
This reporter is for sending notifications for macOS systems. It requires macOS version 10.8 above. For earlier versions, it will use Growl as the fallback. If Growl is not installed, an error is returned in the callback function.
To set up the Notification Center reporter, you can write your code as shown below:
<pre><code class="hljs">const NotificationCenter = require(&#x27;node-notifier&#x27;).NotificationCenter;
// Or
// const NotificationCenter = require(&#x27;node-notifier/notifiers/notificationcenter&#x27;);
 
const notificationCenterNotifier = new NotificationCenter({
 withFallback: true
});
 
notificationCenterNotifier.notify({
 title: &quot;Notification Center Notifications&quot;,
 subtitle: &quot;For macOS &gt; 10.8&quot;,
 message: &quot;This is a notification sent using Notification Center&quot;,
 sound: &#x27;Frog&#x27;,
 icon: path.join(__dirname, &#x27;icon.jpg&#x27;),
 contentImage: path.join(__dirname, &#x27;content_image.jpg&#x27;),
 open: undefined,
 wait: false,
 },
 function (error, response, metadata) {
 console.log(response, metadata);
 }
);
</code></pre>
The <code>sound</code> parameter takes in a bunch of values such as <code>Basso</code>, <code>Blow</code>, <code>Bottle</code>, etc. The default value is <code>Bottle</code> if set to <code>true</code>. Alternatively, you can set a specific sound you'd like.
<h3 id="notifysend">Notify-send</h3>
This reporter is used for customizing notifications to send on a Linux based system. It can be used as shown below:
<pre><code class="hljs">const NotifySend = require(&#x27;node-notifier&#x27;).NotifySend;
// Or
// const NotifySend = require(&#x27;node-notifier/notifiers/notifysend&#x27;);
 
let notifySendNotifier = new NotifySend();
 
notifySendNotifier.notify({
 title: &#x27;Notify-send Notification&#x27;,
 message: &#x27;This notification was sent using the notify-send reporter&#x27;,
 icon: __dirname + &#x27;/icon.jpg&#x27;,
 wait: true,
 timeout: 5
});
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Notifications provide a way for users to interact with your applications and native notifications are those that display on the users desktop as opposed to being displayed in the browser.
In this article, we've covered how to use <code>node-notifier</code> to send notifications to your users.

Aniuchi Adaobi

In this tutorial, we'll cover how to send notifications to users on Mac, Windows and Linux using Node.js and node-notifier.

Sending Notifications with node-notifier (Mac, Windows, Linux)

<h2 id="introduction">Introduction</h2>
In Spring Boot, the controller class is responsible for processing incoming REST API requests, preparing a model, and returning the view to be rendered as a response.
The controller classes in Spring are annotated either by the <code>@Controller</code> or the <code>@RestController</code> annotation. These mark controller classes as a request handler to allow Spring to recognize it as a RESTful service during runtime.
In this tutorial, we'll cover the definition of the <code>@Controller</code> and the <code>@RestController</code> annotations, their use-cases, and the difference between the two annotations.
If you are new to Spring Boot, you might also want to check out our full guide on <a target="_blank" href="/build-a-spring-boot-rest-api-with-java-full-guide/">How to Build a Spring Boot REST API</a>.
<h2 id="springbootrestapiworkflow">Spring Boot REST API Workflow</h2>
Before defining the two annotations, we'll quickly go through the workflow of how Spring Boot handles REST API requests and processes and returns a response:
<img src="https://stackabuse.s3.amazonaws.com/media/controller-and-restcontroller-annotations-in-spring-boot-1.jpeg" alt="Dispatcher servlet spring boot">
First, the request is received by the <code>DispatcherServlet</code>, which is responsible for processing any incoming URI requests and mapping them to their corresponding handlers in the form of controller methods. After the controller method has been executed, the resource is then processed as a response which can either be JSON or XML.
In the diagram above, the two processes encapsulated in the rectangle are the processes actually implemented by a developer. The rest are executed by Spring services that are running in the background, including the <code>DispatcherServlet</code>.
<h2 id="thecontrollerannotation">The @Controller Annotation</h2>
The <code>@Controller</code> annotation is a specialization of the generic stereotype <code>@Component</code> annotation, which allows a class to be recognized as a Spring-managed component.
The <code>@Controller</code> annotation extends the use-case of <code>@Component</code> and marks the annotated class as a business or presentation layer. When a request is made, this will inform the <code>DispatcherServlet</code> to include the controller class in scanning for methods mapped by the <code>@RequestMapping</code> annotation.
Now, we'll declare the actual controller to define the business logic and handle all the requests related to the model <code>Tree</code>.
First, mark the class with the <code>@Controller</code> annotation together with <code>@RequestMapping</code> and specify the path to <code>/api/tree</code>:
<pre><code class="hljs">@Controller
@ResponseBody
@RequestMapping(&quot;/api/tree&quot;)
public class TreeController {

 @Autowired
 private TreeRepository repository;
 
 @GetMapping(&quot;/{id}&quot;)
 public Tree getTreeById(@PathVariable int id) {
 return repository.findById(id);
 }
 
 @GetMapping
 public Tree getTreeById(@RequestParam String name, 
 @RequestParam int age) {
 return repository.findFirstByCommonNameIgnoreCaseAndAge(name, age);
 }
}
</code></pre>
The <code>@Autowired</code> annotation is used to automatically inject dependencies of the specified type into the current bean. In this case, the <code>TreeRepository</code> bean is injected as a dependency of <code>TreeController</code>.
<code>@GetMapping</code> is a shortcut for <code>@RequestMapping(method = RequestMethod.GET)</code>, and is used to map HTTP <code>GET</code> requests to the mapped controller methods.
We've applied a <code>@ResponseBody</code> annotation to the class-level of this controller. When the request handlers return data back, such as <code>return repository.findById()</code>, the response will be serialized to JSON before being returned to the client.
Alternatively, you could've annotated each response type with the <code>@ResponseBody</code> annotation instead:
<pre><code class="hljs"> @GetMapping(&quot;/{id}&quot;)
 public @ResponseBody Tree getTreeById(@PathVariable int id) {
 return repository.findById(id);
 }
</code></pre>
If we run this application, assuming we've already got a <code>Tree</code> instance saved to the database, with the ID of 1, and hit the <code>localhost:8080/1</code> endpoint, we'd be greeted with:
<pre><code class="hljs">{&quot;species&quot;:&quot;Salix babylonica&quot;,&quot;commonName&quot;:&quot;Weeping willow&quot;, &quot;age&quot;:&quot;150&quot;}
</code></pre>
Because of the <code>@ResponseBody</code> annotation, the fields from the fetched object are serialized into JSON and returned to the client that requested it.
<h2 id="therestcontrollerannotation">The @RestController Annotation</h2>
The <code>@RestController</code> annotation in Spring is essentially just a combination of <code>@Controller</code> and <code>@ResponseBody</code>. This annotation was added during Spring 4.0 to remove the redundancy of declaring the <code>@ResponseBody</code> annotation in your controller.
That's one less annotation declaration! If you also look at the interface definition of the two annotations to see the difference between the two:
<pre><code class="hljs">@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
 //..
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
 //..
}
</code></pre>
The <code>RestController</code> interface is annotated by <code>@Controller</code> and <code>@ResponseBody</code> instead of directly annotating it with <code>@Component</code>.
If we replace the annotation of our controller with <code>@RestController</code>, we won't need to change the domain and persistence layer as they still will be compatible with this annotation.
Using the example controller <code>TreeController</code> above, let's compare the changes when we use this annotation:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/api/tree&quot;)
public class TreeController {

 @Autowired
 private TreeRepository repository;
 
 @GetMapping(&quot;/{id}&quot;)
 public Tree getTreeById(@PathVariable int id) {
 return repository.findById(id);
 }
 
 @GetMapping
 public Tree getTreeById(@RequestParam String name, 
 @RequestParam int age) {
 return repository.findFirstByCommonNameIgnoreCaseAndAge(name, age);
 }
}
</code></pre>
Now, all methods have the <code>@ResponseBody</code> annotation applied to them, as <code>@RestController</code> applies it at class-level.
If we run this application, assuming we've already got a <code>Tree</code> instance saved to the database, with the ID of 1, and hit the <code>localhost:8080/1</code> endpoint, we'd be greeted with:
<pre><code class="hljs">{&quot;species&quot;:&quot;Salix babylonica&quot;,&quot;commonName&quot;:&quot;Weeping willow&quot;, &quot;age&quot;:&quot;150&quot;}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Essentially, <code>@RestController</code> extends the capabilities of both the <code>@Controller</code> and <code>@ResponseBody</code> annotations.
Other than the fact that <code>@RestController</code> exists to allow Spring controllers to be one line shorter, there aren't any major differences between the two annotations.
The primary function of both annotations is to allow a class to be recognized as a Spring-managed component and to allow handling of HTTP requests using REST API.

David Landup

Rayven Yor Esplanada

In this tutorial, we'll go over what's the difference between @Controller and @RestController in Spring Boot, through examples.

@Controller and @RestController Annotations in Spring Boot

Mehreen Saeed

In this article, we'll go over the theory behind Pearson Correlation, as well as examples of strong positive and negative coorelations, using Python, Numpy and Matplotlib.

Calculating Pearson Correlation Coefficient in Python with Numpy

<h2 id="introduction">Introduction</h2>
Dictionary (also known as “map”, “hash” or “associative array”) is a built-in Python container that stores elements as a key-value pair.
Just like other containers have numeric indexing, here we use keys as indexes. Keys can be numeric or string values. However, no mutable sequence or object can be used as a key, like a list.
In this article, we'll take a look at how to check if a key exists in a dictionary in Python.
In the examples, we'll be using this <code>fruits_dict</code> dictionary:
<pre><code class="hljs">fruits_dict = dict(apple= 1, mango= 3, banana= 4)
</code></pre>
<pre><code class="hljs">{&#x27;apple&#x27;: 1, &#x27;banana&#x27;: 4, &#x27;mango&#x27;: 3}
</code></pre>
<h2 id="checkifkeyexistsusinginoperator">Check if Key Exists using in Operator</h2>
The simplest way to check if a key exists in a dictionary is to use the <code>in</code> operator. It's a special operator used to evaluate the membership of a value.
Here it will either evaluate to <code>True</code> if the key exists or to <code>False</code> if it doesn't:
<pre><code class="hljs">key = &#x27;orange&#x27;

if key in fruits_dict:
 print(&#x27;Key Found&#x27;)
else:
 print(&#x27;Key not found&#x27;)
</code></pre>
Now, since we don't have an <code>orange</code> in our dictionary, this is the result:
<pre><code class="hljs">Key not found
</code></pre>
This is the intended and preferred approach by most developers. Under the hood, it uses the <code>__contains__()</code> function to check if a given key is <code>in</code> a dictionary or not.
<h2 id="checkifkeyexistsusingget">Check if Key Exists using get()</h2>
The <code>get()</code> function accepts a <code>key</code>, and an optional value to be returned if the <code>key</code> isn't found. By default, this optional value is <code>None</code>. We can try getting a key, and if the returned value is <code>None</code>, that means it's not present in the dictionary:
<pre><code class="hljs">key = &#x27;orange&#x27;

if fruits_dict.get(key) == None:
 print(&#x27;Key not found&#x27;)
else:
 print(&#x27;Key found&#x27;) 
</code></pre>
This results in:
<pre><code class="hljs">Key not found
</code></pre>
<h2 id="checkifkeyexistsusingkeys">Check if Key Exists using keys()</h2>
The <code>keys()</code> function returns the keys from our dictionary as a sequence:
<pre><code class="hljs">fruits_dict.keys()
</code></pre>
This sequence contains:
<pre><code class="hljs">dict_keys([&#x27;apple&#x27;, &#x27;mango&#x27;, &#x27;banana&#x27;])
</code></pre>
Using this sequence, we can check if the key is present. You can do this through a loop, or better yet, use the <code>in</code> operator:
<pre><code class="hljs">key = &#x27;orange&#x27;

if key in fruits_dict.keys():
 print(&#x27;Key found&#x27;)
else:
 print(&#x27;Key not found&#x27;)
</code></pre>
This also results in:
<pre><code class="hljs">Key not found
</code></pre>
<h2 id="checkifkeyexistsusinghas_key">Check if Key Exists using has_key()</h2>
Instead of manually getting the keys and running a check if the value we're searching for is present, we can use the short-hand <code>has_key()</code> function:
<pre><code class="hljs">key = &#x27;orange&#x27;

if fruits_dict.has_key(key):
 print(&#x27;Key found&#x27;)
else:
 print(&#x27;Key not found&#x27;)
</code></pre>
It returns <code>True</code> or <code>False</code>, based on the presence of the key. This code outputs:
<pre><code class="hljs">Key not found
</code></pre>
<h2 id="handlingkeyerrorexception">Handling 'KeyError' Exception</h2>
An interesting way to avoid problems with a non-existing key or in other words to check if a key exists in our dictionary or not is to use the <code>try</code> and <code>except</code> clause to handle the <code>KeyError</code> exception.
The following exception is raised whenever our program fails to locate the respective key in the dictionary.
It is a simple, elegant, and fast way to handle key searching:
<pre><code class="hljs">try:
 fruits_dict[key]
except KeyError as err:
 print(&#x27;Key not found&#x27;)
</code></pre>
This approach, although it may sound unintuitive, is actually significantly faster than some other approaches we've covered so far.

 <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: Please note, exceptions shouldn't be used to alter code flow or to implement logic. They fire really fast, but recovering from them is really slow. This approach shouldn't be favored over other approaches, when possible.

 </div>
 </div>
 </div>
 Let's compare the performance of them to get a better idea of how fast they can execute.
<h2 id="performancecomparison">Performance Comparison</h2>
<pre><code class="hljs">import timeit

code_setup = &quot;&quot;&quot;
key = &#x27;orange&#x27;
fruits_dict = dict(apple= 1, mango= 3, banana= 4)
&quot;&quot;&quot;

code_1 = &quot;&quot;&quot;
if key in fruits_dict:
 # print(&#x27;Key Found&#x27;)
 pass
else:
 # print(&#x27;Key not found&#x27;)
 pass 
&quot;&quot;&quot;

code_2 = &quot;&quot;&quot;
if fruits_dict.get(key):
 # print(&#x27;Key found&#x27;)
 pass
else:
 # print(&#x27;Key not found&#x27;)
 pass 
&quot;&quot;&quot;

code_3 = &quot;&quot;&quot;
if fruits_dict.__contains__(key):
 # print(&#x27;Key found&#x27;)
 pass
else:
 # print(&#x27;Key not found&#x27;)
 pass 
&quot;&quot;&quot;

code_4 = &quot;&quot;&quot;
try:
 # fruits_dict[key]
 pass
except KeyError as err:
 # print(&#x27;Key not found&#x27;)
 pass 
&quot;&quot;&quot;
 
code_5 = &quot;&quot;&quot;
if key in fruits_dict.keys():
 # print(&#x27;Key found&#x27;)
 pass
else:
 # print(&#x27;Key not found&#x27;)
 pass 
&quot;&quot;&quot;

print(&#x27;Time of code_1: &#x27;, timeit.timeit(setup = code_setup , stmt= code_1, number= 10000000))
print(&#x27;Time of code_2: &#x27;, timeit.timeit(setup = code_setup , stmt= code_2, number= 10000000))
print(&#x27;Time of code_3: &#x27;, timeit.timeit(setup = code_setup , stmt= code_3, number= 10000000))
print(&#x27;Time of code_4: &#x27;, timeit.timeit(setup = code_setup , stmt= code_4, number= 10000000))
print(&#x27;Time of code_5: &#x27;, timeit.timeit(setup = code_setup , stmt= code_5, number= 10000000))
</code></pre>
This outputs:
<pre><code class="hljs">Time of code_1: 0.2753713619995324
Time of code_2: 0.8163219139996727
Time of code_3: 0.5563563220002834
Time of code_4: 0.1561058730003424
Time of code_5: 0.7869278369998938
</code></pre>
The most popular choice and approach, of using the <code>in</code> operator is fairly fast, and it's also the intended approach for solving this problem.
<h2 id="conclusion">Conclusion</h2>
In this article, we discussed multiple ways to check if a key exists in our dictionary or not. Then we made a performance comparison.

Guest Contributor

In this tutorial, we'll go over examples on how to check if a key exists in a dictionary in Python. We'll go over the most popular and niche approaches and do a performance comparison.

Python: Check if Key Exists in Dictionary

<h2 id="introduction">Introduction</h2>
It's not uncommon to have two dictionaries in Python which you'd like to combine. When merging dictionaries, we have to consider what will happen when the two dictionaries have the same keys. But first, we have to define what should happen when we merge.
<blockquote>
In this article, we will take a look at various ways on how to merge two dictionaries in Python. Some solutions are not available to all Python versions, so we will examine ways to merge for selected releases too.
</blockquote>
<h2 id="mergingdictionariesinpython">Merging Dictionaries in Python</h2>
Merges usually happen from the right to left, as <code>dict_a &lt;- dict_b</code>. When there's a common key holder in both the dictionaries, the second dictionary's value overwrites the first dictionary's value.
This can be demonstrated in the illustration given below, where the components of the dictionary B gets merged to A, with the green suit of dictionary B taking the place of the orange suit:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-merge-two-dictionaries-in-python-1.jpg" alt="A dictionary merge where the values with the same key in the second set overwrite the values of the first set">
Throughout this article, we will be using the following dictionaries.
<ul>
<li>Dictionaries with values:</li>
</ul>
<pre><code class="hljs">&gt;&gt;&gt; a = {1:&#x27;peanut&#x27;, 2:&#x27;butter&#x27;, 3:&#x27;jelly&#x27;, 4:&#x27;time&#x27;}
&gt;&gt;&gt; b = {1:&#x27;fish&#x27;, 2:&#x27;chips&#x27;}
</code></pre>
<ul>
<li>Dictionaries with nested values:</li>
</ul>
<pre><code class="hljs">&gt;&gt;&gt; c = {1: [&#x27;peanut&#x27;,&#x27;butter&#x27;,&#x27;jelly&#x27;,&#x27;time&#x27;], 2:[&#x27;fish&#x27;,&#x27;chips&#x27;]}
&gt;&gt;&gt; d = {1: [&#x27;fish&#x27;,&#x27;chips&#x27;], 2:[&#x27;peanut&#x27;,&#x27;butter&#x27;,&#x27;jelly&#x27;,&#x27;time&#x27;]}
</code></pre>
<h2 id="usingthemergeoperatorpython39andabove">Using the Merge Operator | (Python 3.9 and Above)</h2>
From Python version 3.9 onward, we can use the merge operators (represented by <code>|</code> ) to combine two dictionaries:
<pre><code class="hljs">&gt;&gt;&gt; x = a | b
&gt;&gt;&gt; print(x)
{1: &#x27;fish&#x27;, 2: &#x27;chips&#x27;, 3: &#x27;jelly&#x27;, 4: &#x27;time&#x27;}
</code></pre>
The dictionary merge operators can also be used in the place of nested dictionaries too. Here, the complete overwrite of the value of the matching key takes place:
<pre><code class="hljs">&gt;&gt;&gt; y = c | d
&gt;&gt;&gt; print(y)
{1: [&#x27;fish&#x27;, &#x27;chips&#x27;], 2: [&#x27;peanut&#x27;, &#x27;butter&#x27;, &#x27;jelly&#x27;, &#x27;time&#x27;]}
</code></pre>
<h2 id="usingdictunpackingpython3andabove">Using Dict Unpacking (Python 3 and Above)</h2>
For earlier versions of Python 3, we're unfortunately unable to use the merge operators. Instead, we can merge by unpacking both the dictionaries, using the <code>**</code> double asterisks, inside another dictionary:
<pre><code class="hljs">&gt;&gt;&gt; x = {**a, **b}
&gt;&gt;&gt; print(x)
{1: &#x27;fish&#x27;, 2: &#x27;chips&#x27;, 3: &#x27;jelly&#x27;, 4: &#x27;time&#x27;}
</code></pre>
The same applies to the dictionaries with the nested list values. The values of the overlapping keys will be overwritten:
<pre><code class="hljs">&gt;&gt;&gt; y = {**c, **d}
&gt;&gt;&gt; print(y)
{1: [&#x27;fish&#x27;, &#x27;chips&#x27;], 2: [&#x27;peanut&#x27;, &#x27;butter&#x27;, &#x27;jelly&#x27;, &#x27;time&#x27;]}
</code></pre>
<h2 id="python2andabove">Python 2 and Above</h2>
In legacy Python versions, the snippets above will not work. Instead, the merge can be facilitated by combining the items of the dictionary, or <code>dict_items</code> of both variables.
We can also use the <code>copy()</code> and <code>update()</code> dictionary methods. Lastly, we can loop through a dictionary's items and use the <code>extend()</code> method to add it to another dictionary.
<h3 id="usingitems">Using items()</h3>
Let's begin by combining with <code>items()</code>:
<pre><code class="hljs">&gt;&gt;&gt; x = dict(a.items() + b.items())
&gt;&gt;&gt; print(x)
{1: &#x27;fish&#x27;, 2: &#x27;chips&#x27;, 3: &#x27;jelly&#x27;, 4: &#x27;time&#x27;}
</code></pre>
The syntax above holds good for simple values. For a nested dictionary containing list values, the <code>items()</code> call needs to be cast to a <code>list()</code> and then combined:
<pre><code class="hljs">&gt;&gt;&gt; y = dict(list(c.items()) + list(d.items()))
&gt;&gt;&gt; print(y)
{1: [&#x27;fish&#x27;, &#x27;chips&#x27;], 2: [&#x27;peanut&#x27;, &#x27;butter&#x27;, &#x27;jelly&#x27;, &#x27;time&#x27;]}
</code></pre>
This solution works well because the keys were numerical, the original keys were preserved. For keys of different types, you would prefer the following option.
<h3 id="usingdictionaryupdate">Using Dictionary update()</h3>
Another way to perform the merge is to copy one of the dictionaries and update it with the other:
<pre><code class="hljs">&gt;&gt;&gt; x = a.copy()
&gt;&gt;&gt; x.update(b)
&gt;&gt;&gt; print (x)
{1: &#x27;fish&#x27;, 2: &#x27;chips&#x27;, 3: &#x27;jelly&#x27;, 4: &#x27;time&#x27;}
</code></pre>
<h2 id="appendinglistvaluesinallpythonversions">Appending List Values in All Python Versions</h2>
In the previous sections, we have overwritten nested values of the merged dictionaries. There are cases where the nested values need to be appended instead of overwritten. This can be done by using the <code>extend()</code> method:
<pre><code class="hljs">&gt;&gt;&gt; for k, v in d.items():
... if k in c:
... c[k].extend(v)
... else:
... c[k] = v
&gt;&gt;&gt;
&gt;&gt;&gt; print(c)
{1: [&#x27;peanut&#x27;, &#x27;butter&#x27;, &#x27;jelly&#x27;, &#x27;time&#x27;, &#x27;fish&#x27;, &#x27;chips&#x27;], 2: [&#x27;fish&#x27;, &#x27;chips&#x27;, &#x27;peanut&#x27;, &#x27;butter&#x27;, &#x27;jelly&#x27;]}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have learned how dictionary merges work, and how we can merge two dictionaries in different versions of Python. Merging dictionaries can be quite handy in situations like reading multiple JSON files, building a map of objects or even building indexes of content.

Dimitrije Stamenic

In this article, we will look at various ways to merge two dictionaries in Python version 3.9, earlier versions of 3 and Python 2.