<h2 id="introduction">Introduction</h2>
Working with arrays in JavaScript is a common activity. Sometimes we get a variable in JavaScript that we need to be an array, but we aren't sure that it is.
Non-primitive data types in JavaScripts are all objects (functions have their own type, but they too are objects). As a result, it's not sufficient to use the <code>typeof</code> operator that's commonly used to determine a data type:
<pre><code class="hljs">let result = { subject: &#x27;Science&#x27;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];

console.log(typeof result); // Object
console.log(typeof numbers); // Object
</code></pre>
In this article, we'll take a look at how to check if a given variable or value is an array or not, in JavaScript.
<h2 id="usingthearrayisarraymethod">Using the Array.isArray() Method</h2>
As the name suggests, this method can be used to identify whether the given argument is an array or not. It returns a boolean (<code>true</code>/<code>false</code>) value with the result.
For example, with the following variables the <code>Array.isArray()</code> method correctly determines if they are one or not:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 }; // Object
let numbers = [1, 2, 3, 4, 5]; // Array
let name = &quot;Mark&quot;; // String
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(Array.isArray(result)); // false
console.log(Array.isArray(numbers)); // true
console.log(Array.isArray(name)); // false
console.log(Array.isArray(names)); // true
</code></pre>
<h2 id="usinganobjectsconstructorproperty">Using an Object's constructor Property</h2>
Every object has a <code>constructor</code> property (except objects created with <code>Object.create(null)</code>, an unlikely occurrence). We can compare the constructor property directly with JavaScript's constructor functions. Therefore, if we compare it with the array constructor function, we'll know if it's an array.

 <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: A constructor function is a function that initializes an object. If you've created an object with the <code>new</code> keyword, you did so with a constructor function. For example, in <code>let myArray = new Array(1, 2)</code> the constructor function used is <code>Array()</code>.

 </div>
 </div>
 </div>
 You can use the constructor property to determine if a variable is an array:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(result.constructor === Array); // false
console.log(numbers.constructor === Array); // true
console.log(name.constructor === Array); // false
console.log(names.constructor === Array); // true
</code></pre>
<h2 id="usingtheinstanceofoperator">Using the instanceof Operator</h2>
The <code>instanceof</code> operator checks if a constructor function is found in the prototype chain of an object. If you're less familiar with JavaScript's prototypal inheritance, the operator checks if an object was created by a class, and if not, checks if the object was derived from that class.
Like the <code>typeof</code> operator, it returns a boolean value. To determine if a variable is an array, we can use <code>instanceof</code> like this:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(result instanceof Array); // false
console.log(numbers instanceof Array); // true
console.log(name instanceof Array); // false
console.log(names instanceof Array); // true
</code></pre>
<h2 id="usingtheobjectprototypecallmethod">Using the Object.prototype.call() Method</h2>
All objects in JavaScript inherit properties from the main prototype object, aptly named <code>Object.prototype</code>. A <code>toString()</code> method exists in <code>Object.prototype</code>, which is why every object has a <code>toString()</code> method of their own. The <code>toString()</code> method of <code>Object.prototype</code> displays the type of an object.
The <code>call()</code> method of objects executes a function but changes the value of <code>this</code> to the object passed in its arguments i.e. it allows an object to use a method from another object.
Therefore, we can use <code>Object.prototype.toString()</code> to print the type and then use <code>call()</code> so it's done for another object. We then compare that string value to determine if it's an array:
<pre><code class="hljs">let result = { subject: &quot;Science&quot;, marks: 97 };
let numbers = [1, 2, 3, 4, 5];
let name = &quot;Mark&quot;;
let names = new Array(&quot;Jill&quot;, &quot;Jane&quot;, &quot;Jacqueline&quot;);

console.log(Object.prototype.toString.call(result)); // [object Object]
console.log(Object.prototype.toString.call(numbers)); // [object Array]
console.log(Object.prototype.toString.call(name)); // [object String]
console.log(Object.prototype.toString.call(names)); // [object Array]

console.log(Object.prototype.toString.call(result) === &quot;[object Array]&quot;); // false
console.log(Object.prototype.toString.call(numbers) === &quot;[object Array]&quot;); // true
console.log(Object.prototype.toString.call(name) === &quot;[object Array]&quot;); // false
console.log(Object.prototype.toString.call(names) === &quot;[object Array]&quot;); // true
</code></pre>
It's unlikely that you'll use this method, but it never hurts to know more about JavaScript objects!
<h2 id="conclusion">Conclusion</h2>
In this article, we looked at a few ways in JavaScript to determine if an object is an array. The easiest method is the <code>Array.isArray()</code> method that will most likely be used in production.
However, we can always leverage the <code>instanceof</code> operator and other object properties to determine if it's an array.

Guest Contributor

In this article, we'll discuss various methods to determine whether an object is an array in JavaScript using the Arrays.isArray() method, instanceof operator, etc.

JavaScript: Check if Object is Array

Dan Nelson

In this tutorial, we'll go over how to plot Violin Plots with Seaborn. We'll go over simple and advanced customized Violin Plots with examples.

Seaborn Violin Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Python is supported by many libraries which simplify data transfer over HTTP. The <code>requests</code> library is one of the most popular Python packages as it's heavily used in web scraping. It's also popular for interacting with servers! The library makes it easy to upload data in a popular format like JSON, but also makes it easy to upload files as well.
In this tutorial, we will take a look at how to upload files using Python's <code>requests</code> library. The article will start by covering the <code>requests</code> library and the <code>post()</code> function signature. Next, we will cover how to upload a single file using the <code>requests</code> package. Last but not least, we upload multiple files in one request.
<h2 id="uploadingasinglefilewithpythonsrequestslibrary">Uploading a Single File with Python's Requests Library</h2>
This tutorial covers how to send the files, we're not concerned about how they're created. To follow along, create three files called <code>my_file.txt</code>, <code>my_file_2.txt</code> and <code>my_file_3.txt</code>.
The first thing we need to do is install our the <code>request</code> library in our workspace. While not necessary, it's recommended that you install libraries in a virtual environment:
<pre><code class="hljs">$ python3 -m venv .
</code></pre>
Activate the virtual environment so that we would no longer impact the global Python installation:
<pre><code class="hljs">$ . bin/activate
</code></pre>
Now let's install the <code>requests</code> library with <code>pip</code>:
<pre><code class="hljs">$ pip install requests
</code></pre>
Create a new file called <code>single_uploader.py</code> which will store our code. In that file, let's begin by importing the <code>requests</code> library:
<pre><code class="hljs">import requests
</code></pre>
Now we're set up to upload a file! When uploading a file, we need to open the file and stream the content. After all, we can't upload a file we don't have access to. We'll do this with the <code>open()</code> function.
The <code>open()</code> function accepts two parameters: the path of the file and the <a href="/file-handling-in-python/" target="_blank">mode</a>. The path of the file can be an absolute path or a relative path to where the script is being run. If you're uploading a file in the same directory, you can just use the file's name.
The second argument, mode, will take the &quot;read binary&quot; value which is represented by <code>rb</code>. This argument tells the computer that we want to open the file in the read mode, and we wish to consume the data of the file in a binary format:
<pre><code class="hljs">test_file = open(&quot;my_file.txt&quot;, &quot;rb&quot;)
</code></pre>
Note: it's important to read the file in binary mode. The <code>requests</code> library typically determines the <code>Content-Length</code> header, which is a value in bytes. If the file is not read in bytes mode, the library may get an incorrect value for <code>Content-Length</code>, which would cause errors during file submission.
For this tutorial, we'll make requests to the free httpbin service. This API allows developers to test their HTTP requests. Let's create a variable that stores the URL we'll post our files to:
<pre><code class="hljs">test_url = &quot;http://httpbin.org/post&quot;
</code></pre>
We now have everything to make the request. We'll use the <code>post()</code> method of the <code>requests</code> library to upload the file. We need two arguments to make this work: the URL of the server and <code>files</code> property. We'll also save the response in a variable, write the following code:
<pre><code class="hljs">test_response = requests.post(test_url, files = {&quot;form_field_name&quot;: test_file})
</code></pre>
The <code>files</code> property takes a dictionary. The key is the name of the form field that accepts the file. The value is the bytes of the opened file you want to upload.
Normally to check if your <code>post()</code> method was successful we check the HTTP status code of the response. We can use the <code>ok</code> property of the response object, <code>test_url</code>. If it's true, we'll print out the response from the HTTP server, in this case, it will echo the request:
<pre><code class="hljs">if test_response.ok:
 print(&quot;Upload completed successfully!&quot;)
 print(test_response.text)
else:
 print(&quot;Something went wrong!&quot;)
</code></pre>
Let's try it out! In the terminal, execute your script with the <code>python</code> command:
<pre><code class="hljs">python single_uploader.py
</code></pre>
Your output would be similar to this:
<pre><code class="hljs">Upload completed successfully!
{
 &quot;args&quot;: {}, 
 &quot;data&quot;: &quot;&quot;, 
 &quot;files&quot;: {
 &quot;form_field_name&quot;: &quot;This is my file\nI like my file\n&quot;
 }, 
 &quot;form&quot;: {}, 
 &quot;headers&quot;: {
 &quot;Accept&quot;: &quot;*/*&quot;, 
 &quot;Accept-Encoding&quot;: &quot;gzip, deflate&quot;, 
 &quot;Content-Length&quot;: &quot;189&quot;, 
 &quot;Content-Type&quot;: &quot;multipart/form-data; boundary=53bb41eb09d784cedc62d521121269f8&quot;, 
 &quot;Host&quot;: &quot;httpbin.org&quot;, 
 &quot;User-Agent&quot;: &quot;python-requests/2.25.0&quot;, 
 &quot;X-Amzn-Trace-Id&quot;: &quot;Root=1-5fc3c190-5dea2c7633a02bcf5e654c2b&quot;
 }, 
 &quot;json&quot;: null, 
 &quot;origin&quot;: &quot;102.5.105.200&quot;, 
 &quot;url&quot;: &quot;http://httpbin.org/post&quot;
}
</code></pre>
As a sanity check, you can verify the <code>form_field_name</code> value matches what's in your file.
<h2 id="uploadingmultiplefileswithpythonsrequestslibrary">Uploading Multiple Files with Python's requests Library</h2>
Uploading multiple files using requests is quite similar to a single file, with the major difference being our use of lists. Create a new file called <code>multi_uploader.py</code> and the following setup code:
<pre><code class="hljs">import requests

test_url = &quot;http://httpbin.org/post&quot;
</code></pre>
Now create a variable called <code>test_files</code> that's a dictionary with multiple names and files:
<pre><code class="hljs">test_files = {
 &quot;test_file_1&quot;: open(&quot;my_file.txt&quot;, &quot;rb&quot;),
 &quot;test_file_2&quot;: open(&quot;my_file_2.txt&quot;, &quot;rb&quot;),
 &quot;test_file_3&quot;: open(&quot;my_file_3.txt&quot;, &quot;rb&quot;)
}
</code></pre>
Like before, the keys are the names of the form fields and the values are the files in bytes.
We can also create our files variables as a list of tuples. Each tuple contains the name of the form field accepting the file, followed by the file's contents in bytes:
<pre><code class="hljs">test_files = [(&quot;test_file_1&quot;, open(&quot;my_file.txt&quot;, &quot;rb&quot;)),
 (&quot;test_file_2&quot;, open(&quot;my_file_2.txt&quot;, &quot;rb&quot;)),
 (&quot;test_file_3&quot;, open(&quot;my_file_3.txt&quot;, &quot;rb&quot;))]
</code></pre>
Either works so choose whichever one you prefer!
Once the list of files is ready, you can send the request and check its response like before:
<pre><code class="hljs">test_response = requests.post(test_url, files = test_files)

if test_response.ok:
 print(&quot;Upload completed successfully!&quot;)
 print(test_response.text)
else:
 print(&quot;Something went wrong!&quot;)
</code></pre>
Execute this script with the <code>python</code> command:
<pre><code class="hljs">$ python multi_uploader.py
</code></pre>
You'll see this output:
<pre><code class="hljs">Upload completed successfully!
{
 &quot;args&quot;: {}, 
 &quot;data&quot;: &quot;&quot;, 
 &quot;files&quot;: {
 &quot;test_file_1&quot;: &quot;This is my file\nI like my file\n&quot;, 
 &quot;test_file_2&quot;: &quot;All your base are belong to us\n&quot;, 
 &quot;test_file_3&quot;: &quot;It&#x27;s-a me, Mario!\n&quot;
 }, 
 &quot;form&quot;: {}, 
 &quot;headers&quot;: {
 &quot;Accept&quot;: &quot;*/*&quot;, 
 &quot;Accept-Encoding&quot;: &quot;gzip, deflate&quot;, 
 &quot;Content-Length&quot;: &quot;470&quot;, 
 &quot;Content-Type&quot;: &quot;multipart/form-data; boundary=4111c551fb8c61fd14af07bd5df5bb76&quot;, 
 &quot;Host&quot;: &quot;httpbin.org&quot;, 
 &quot;User-Agent&quot;: &quot;python-requests/2.25.0&quot;, 
 &quot;X-Amzn-Trace-Id&quot;: &quot;Root=1-5fc3c744-30404a8b186cf91c7d239034&quot;
 }, 
 &quot;json&quot;: null, 
 &quot;origin&quot;: &quot;102.5.105.200&quot;, 
 &quot;url&quot;: &quot;http://httpbin.org/post&quot;
}
</code></pre>
Good job! You can upload single and multiple files with <code>requests</code>!
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to upload files in Python using the <code>requests</code> library. Where it's a single file or multiple files, only a few tweaks are needed with the <code>post()</code> method. We also verified our response to ensure that our uploads were successful.

Marcus Sanatan

Mohamed Echout

In this tutorial, will learn how to upload files with the Python requests library. We'll cover uploading single and many files in one request.

How to Upload Files with Python's Requests Library

How to Upload Files with Python's requests Library

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

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.

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.