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

Marcus Sanatan

Sathiya Sarathi Gunasekaran

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.

How to Merge Two Dictionaries in Python

<h2 id="introduction">Introduction</h2>
An array is a linear data structure and arguably one of the most popular data structures used in Computer Science. Modifying an array is a commonly encountered operation. Here, we will discuss how to add an element in any position of an array in JavaScript.
An element can be added to an array at three places:
<ul>
<li>Start/First element</li>
<li>End/Last element</li>
<li>Anywhere else</li>
</ul>
<img src="https://stackabuse.s3.amazonaws.com/media/javascript-how-to-insert-elements-into-a-specific-index-of-an-array-1.png" alt="Insert an element in an array">
Let's get started by adding elements to the beginning of an array!
<h2 id="addingelementstothestartofanarray">Adding Elements to the Start of an Array</h2>
The <code>unshift()</code> method in array objects adds one or more elements to the start of an array. When executed, it also returns the new length of an array:
<pre><code class="hljs">const startArray = [3, 4, 5];
const newLength = startArray.unshift(2);
console.log(newLength);
console.log(startArray);

startArray.unshift(-1, 0, 2);
console.log(startArray);
</code></pre>
Which gives us the expected output:
<pre><code class="hljs">4
[ 2, 3, 4, 5 ]
[ -1, 0, 2, 2, 3, 4, 5 ]
</code></pre>
<h2 id="addingelementstotheendofanarray">Adding Elements to the End of an Array</h2>
<h3 id="usingthelastindexofthearray">Using the Last Index of the Array</h3>
To add an element to the end of an array, we can use the fact that the length of an array is always one less than the index.
Say, the length of an array is 5, then the last index at which the value will be 4. So, we can directly add the element at the <code>last+1</code> index. Let us take a look:
<pre><code class="hljs">const indexArray = [1, 2, 3];
console.log(indexArray.length);
console.log(indexArray[2]);
console.log(indexArray[3]);

indexArray[indexArray.length] = 4
console.log(indexArray);
</code></pre>
Running this in a JS console displays:
<pre><code class="hljs">3
3
undefined
[ 1, 2, 3, 4 ]
</code></pre>
The array is <code>3</code> in length, and the 2nd element is <code>3</code>. There is no 3rd element, so we're greeted with <code>undefined</code>. Finally, at that position, we insert the value of <code>4</code>.
<h3 id="thepushmethod">The push() Method</h3>
The <code>push()</code> method of an array appends one or more elements to the end of it. Just like <code>unshift()</code>, it also returns the new length of the array:
<pre><code class="hljs">const pushArray = [1, 2, 3]
const newLength = pushArray.push(4, 5, 6, 7);
console.log(newLength);
console.log(pushArray);
</code></pre>
Running the above code will display this:
<pre><code class="hljs">7
[ 1, 2, 3, 4, 5, 6, 7 ]
</code></pre>
<h3 id="theconcatmethod">The concat() Method</h3>
Merging or joining of two or more arrays is achieved by an array's <code>concat()</code> method. It creates a new copy of the output and does not affect the original arrays. Unlike the previous methods, it returns a new array. The values being concatenated always come at the end of the array using the method.
We can concatenate an array with another array:
<pre><code class="hljs">const example1Array1 = [1, 2, 3];
const valuesToAdd = [4, 5, 6];
const example1NewArray = example1Array1.concat(valuesToAdd);

console.log(example1NewArray);
console.log(example1Array1);
</code></pre>
Which prints this output:
<pre><code class="hljs">[ 1, 2, 3, 4, 5, 6 ]
[ 1, 2, 3 ]
</code></pre>
We can concatenate an array with a sequence of values:
<pre><code class="hljs">const array = [1,2,3];
const newArray = array.concat(&#x27;12&#x27;, true, null, 4,5,6,&#x27;hello&#x27;);
console.log(array);
console.log(newArray);
</code></pre>
Running the above code will log this to our consoles:
<pre><code class="hljs">[ 1, 2, 3 ]
[ 1, 2, 3, &#x27;12&#x27;, true, null, 4, 5, 6, &#x27;hello&#x27; ]
</code></pre>
We can concatenate an array with multiple arrays:
<pre><code class="hljs">const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const array3 = [7, 8, 9];
const oneToNine = array1.concat(array2, array3);

console.log(oneToNine);
</code></pre>
When executed, the above code prints a list of numbers from 1 to 9:
<pre><code class="hljs">[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
</code></pre>
<h2 id="addingelementsanywhereinanarray">Adding Elements Anywhere in an Array</h2>
Now we will discuss a masterstroke method that can be used to add an element anywhere in an array - start, end, middle, and anywhere else in-between.
The <code>splice()</code> method adds, removes and replaces elements in an array. It is commonly used for array management. This method does not create a new array but updates the one that called it.
Let's see <code>splice()</code> in action. We're going to take an array of weekdays, and add a &quot;wednesday&quot; element between &quot;tuesday&quot; and &quot;thursday&quot;:
<pre><code class="hljs">const weekdays = [&#x27;monday&#x27;, &#x27;tuesday&#x27;, &#x27;thursday&#x27;, &#x27;friday&#x27;]
const deletedArray = weekdays.splice(2, 0, &#x27;wednesday&#x27;);

console.log(weekdays);
console.log(deletedArray);
</code></pre>
The above code logs this to the console:
<pre><code class="hljs">[ &#x27;monday&#x27;, &#x27;tuesday&#x27;, &#x27;wednesday&#x27;, &#x27;thursday&#x27;, &#x27;friday&#x27; ]
[]
</code></pre>
Let's break down the above code. We wanted to add &quot;wednesday&quot; in the <code>weekdays</code> array at the 2nd position. No element needs to be deleted here. The code <code>weekdays.splice(2, 0, &quot;wednesday&quot;)</code> is read as at the second position, do not remove any element and add &quot;wednesday&quot;.
Here's the general syntax for using <code>splice()</code>:
<pre><code class="hljs">let removedItems = array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
</code></pre>
Where:
<ul>
<li><code>start</code> - The index at which to begin modifying the array.</li>
<li><code>deleteCount</code> - The optional number of items in the array to remove from <code>start</code>. If omitted, then all the items after <code>start</code> will be deleted.</li>
<li><code>item1, item2, ...</code> - The optional items to append to the array from <code>start</code>. If omitted, it will only remove elements from the array.</li>
</ul>
Let's see another example of <code>slice()</code> where we add and delete to the array at the same time. We'll be adding &quot;wednesday&quot; in the second position, however we'll also remove erroneous weekend values there:
<pre><code class="hljs">const weekdays = [&#x27;monday&#x27;, &#x27;tuesday&#x27;, &#x27;saturday&#x27;, &#x27;sunday&#x27;, &#x27;thursday&#x27;, &#x27;friday&#x27;]
const deletedArray = array.splice(2, 2, &#x27;wednesday&#x27;);

console.log(weekdays);
console.log(deletedArray);
</code></pre>
The above code will print:
<pre><code class="hljs">[ &#x27;monday&#x27;, &#x27;tuesday&#x27;, &#x27;wednesday&#x27;, &#x27;thursday&#x27;, &#x27;friday&#x27; ]
[ &#x27;saturday&#x27;, &#x27;sunday&#x27; ]
</code></pre>
In the above example, <code>array.splice(2, 2, 'wednesday')</code> removes two elements from the second position (start) and adds &quot;wednesday&quot; there. That right there is the power of <code>slice()</code>!
<h2 id="conclusion">Conclusion</h2>
In this article, we looked at many ways in JavaScript we can add elements to an array. We can add them to the beginning with <code>unshift()</code>. We can add them to the end using their index, the <code>pop()</code> method and the <code>concat()</code> method. We get even more control of where we place them with the <code>splice()</code> method.

In this article we'll insert elements into an array at its beginning, end and various positions. We'll use the unshift, push, concat and slice methods!

JavaScript: How to Insert Elements into a Specific Index of an Array

<h2 id="introduction">Introduction</h2>
<a target="_blank" href="https://stackabuse.com/python-data-visualization-with-matplotlib/">Matplotlib</a> is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this tutorial, we'll take a look at how to plot a line plot in Matplotlib - one of the most basic types of plots.
Line Plots display numerical values on one axis, and categorical values on the other. They can typically be used in much the same way <a target="_blank" href="/matplotlib-bar-plot-tutorial-and-examples/">Bar Plots</a> can be used, though, they're more commonly used to keep track of changes over time.
<h2 id="plotalineplotinmatplotlib">Plot a Line Plot in Matplotlib</h2>
To plot a line plot in Matplotlib, you use the generic <code>plot()</code> function from the PyPlot instance. There's no specific <code>lineplot()</code> function - the generic one automatically plots using lines or markers.
Let's make our own small dataset to work with:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5, 6]
y = [1, 5, 3, 5, 7, 8]

plt.plot(x, y)
plt.show()
</code></pre>
This results in a simple line plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-1.png" alt="simple line plot matplotlib">
Alternatively, we could've completely omitted the <code>x</code> axis, and just plotted <code>y</code>. This would result in the X-axis being filled with <code>range(len(y))</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
y = [1, 5, 3, 5, 7, 8]

plt.plot(y)
plt.show()
</code></pre>
This results in much the same line plot as before, as the values of <code>x</code> are inferred.
This results in much the same line plot as before, as the values of <code>x</code> are inferred. The <code>x</code> values, whether inferred or manually set by us, like in the first example, are meant to be in the same shape as <code>y</code>. If <code>y</code> has 10 values, <code>x</code> should too:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-2.png" alt="inferring x value matplotlib">
We can, however, change this behavior and go above that range, in which case, the <code>y</code> values will be mapped to those instead:
<pre><code class="hljs">import matplotlib.pyplot as plt
y = [1, 5, 3, 5, 7, 8]
x = [10, 20, 30, 40, 50, 60]

plt.plot(x, y)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-3.png" alt="uniform x values matplotlib">
We've been dealing with uniform <code>x</code> values thus far. Let's see what happens if we change the distribution:
<pre><code class="hljs">import matplotlib.pyplot as plt
y = [1, 5, 3, 5, 7, 8]
x = [1, 2, 3, 4, 5, 20]

plt.plot(x, y)
plt.show()
</code></pre>
The first couple of values sets the scale. And <code>1, 5, 3, 5, 7</code> are as usual, mapped to <code>1, 2, 3, 4, 5</code>. However, since <code>20</code> jumped in out of nowhere, <code>8</code> can't just be mapped to it outright.
The X-axis maintains its uniform scale, and adds a bunch of missing values from <code>5..20</code>, then, it maps <code>8</code> to <code>20</code>, resulting in a straight line from <code>7..8</code> on the Y-axis:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-4.png" alt="non uniform x values matplotlib">
<h2 id="plotalineplotlogarithmicallyinmatplotlib">Plot a Line Plot Logarithmically in Matplotlib</h2>
When dealing with datasets that have progressively larger numbers, and especially if their distribution leans towards being exponential, it's common to plot a line plot on a logarithmic scale.
Instead of the Y-axis being uniformly linear, this will change each interval to be exponentially larger than the last one.
This results in exponential functions being plotted essentially, as straight lines. When dealing with this type of data, it's hard to wrap your mind around exponential numbers, and you can make it much more intuitive by plotting the data logarithmically.
Let's use NumPy to generate an exponential function and plot it linearly, like we did before:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 5, 10) # [0, 0.55, 1.11, 1.66, 2.22, 2.77, 3.33, 3.88, 4.44, 5]
y = np.exp(x) # [1, 1.74, 3.03, 5.29, 9.22, 16.08, 28.03, 48.85, 85.15, 148.41]

plt.plot(x, y)
plt.show()
</code></pre>
This creates an array that's 10 in length, and contains values between <code>0..5</code>. We've then used the <code>exp()</code> function from NumPy to calculate the exponential values of these elements, resulting in an exponential function on a linear scale:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-5.png" alt="plot exponential function in matplotlib">
This sort of function, although simple, is hard for humans to conceptualize, and small changes can easily go unnoticed, when dealing with large datasets.
Now, let's change the scale of the Y-axis to logarithmic:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 5, 10)
y = np.exp(x)

plt.yscale(&#x27;log&#x27;)
plt.plot(x, y)
plt.show()
</code></pre>
Using the PyPlot instance, <code>plt</code>, we can set the scale of the X and Y axes. Here, we've set the Y-Axis on a logarithmic scale, via the <code>yscale()</code> function.
Here, we could've also used <code>linear</code>, <code>log</code>, <code>logit</code> and <code>symlog</code>. The default is <code>linear</code>.
Running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-6.png" alt="line plot on logarithmic scale matplotlib">
<h2 id="customizinglineplotsinmatplotlib">Customizing Line Plots in Matplotlib</h2>
You can easily customize regular Line Plots by passing arguments to the <code>plot()</code> function.
These will typically be arguments such as <code>linewidth</code>, <code>linestyle</code> or <code>color</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.random.randint(low=1, high=10, size=25)

plt.plot(x, color = &#x27;blue&#x27;, linewidth=3, linestyle=&#x27;dashed&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-7.png" alt="customizing line plots in matplotlib">
Instead of the <code>dashed</code> value, we could've used <code>dotted</code>, or <code>solid</code>, for example. Though, we could've also used special characters such as <code>:</code>, <code>-</code>, <code>--</code> and <code>-.</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.random.randint(low=1, high=10, size=25)

plt.plot(x, color = &#x27;blue&#x27;, linewidth=3, linestyle=&#x27;-.&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-line-plot-tutorial-and-examples-8.png" alt="customizing line plots in matplotlib">
There's <a rel="nofollow noopener" target="_blank" href="https://matplotlib.org/3.1.0/gallery/lines_bars_and_markers/linestyles.html">a lot of line styles</a>.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to plot a Line Plot using Matplotlib and Python. We've also covered how to plot on a logarithmic scale, as well as how to customize our line plots.
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 line plot in Matplotlib and Python. We'll go over simple line plots, as well as customize them to use logarithmic scale and customize elements.

Matplotlib Line Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
Closures are a somewhat abstract concept of the JavaScript language and sneak into the compiler-side of programming. However, understanding how JavaScript interprets functions, nested functions, scopes and lexical environments is imperative to harnessing its full potential.
In this article, we will try to demystify said concepts and provide a simple guide to JavaScript Closures.
<h2 id="whatisaclosure">What is a Closure?</h2>
First let's take a look at the official MDN definition of closure:
<blockquote>
A closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access to an outer function's scope from an inner function.
</blockquote>
In simpler terms, a closure is a function that has access to an outer function's scope. To understand this, let's take a look at how scopes work in JavaScript.
<h2 id="scopeinjavascript">Scope in JavaScript</h2>
Scope determines which variables are visible or can be referenced in a given context. Scope is broadly divided into two types - Global Scope and Local Scope:
<ul>
<li>
Global Scope - variables defined outside a function. Variables in this scope can be accessed and altered from anywhere in the program, hence the name &quot;global&quot;.
</li>
<li>
Local Scope - variables defined inside a function. These variables are specific to the function in which they are defined, hence named &quot;local&quot;.
</li>
</ul>
Let's take a look at a global and local variable in JavaScript:
<pre><code class="hljs">let name = &quot;Joe&quot;;

function hello(){
 let message = &quot;Hello&quot;;
 console.log(message + &quot; &quot; +name);
}
</code></pre>
In the example above, scope of <code>name</code> is global, i.e. it can be accessed anywhere. On the other hand, <code>message</code> is defined inside a function, its scope is local to the <code>hello()</code> function.
JavaScript uses Lexical Scoping when it comes to function scopes. Meaning that the scope of a variable is defined by the position of its definition in the source code. This lets us reference global variables within smaller scopes. A local variable can use a global variable, but vice-versa isn't possible.
On
<pre><code class="hljs">function outer(){
 let x = 10;
 
 function inner() {
 let y = 20;
 console.log(x);
 }
 
 inner();
 console.log(y)
}

outer();
</code></pre>
This code results in:
<pre><code class="hljs">10
error: Uncaught ReferenceError: y is not defined
</code></pre>
The <code>inner()</code> function can reference <code>x</code> since it's defined in the <code>outer()</code> function. However, the <code>console.log(y)</code> statement in the <code>outer()</code> function cannot reference the <code>y</code> variable because it's defined in the <code>inner()</code> function's scope.
Additionally, in this scenario:
<pre><code class="hljs">let x = 10;

function func1(){
 console.log(x);
}

function func2() {
 let x = 20;
 func1();
}

func2();
</code></pre>
The output will be:
<pre><code class="hljs">10
</code></pre>
When we call <code>func1()</code> from within <code>func2()</code>, we've got a locally scoped variable <code>x</code>. However, this variable is totally irrelevant to <code>func1()</code> as it's not accessible in <code>func1()</code>.
Thus, <code>func1()</code> checks if there's a global variable with that identifier available, and uses it, resulting in the value of <code>10</code>.
<h2 id="closuresunderthehood">Closures Under the Hood</h2>
A closure is a function which has access to it's parent's variables even after the outer function has returned. In other words, a closure has three scopes:
<ul>
<li>Local Scope - Access to variables in its own scope</li>
<li>Parent Function's scope - Access to variables within its parent</li>
<li>Global Scope - Access to global variables</li>
</ul>
Let's take a look at a closure at work, by making a function that returns another function:
<pre><code class="hljs">function outer() {
 let x = 3
 return function inner(y) {
 return x*y
 }
}

let multiplyByThree = outer();

console.log(multiplyByThree(2));
</code></pre>
This results in:
<pre><code class="hljs">6
</code></pre>
If we do a:
<pre><code class="hljs">console.log(multiplyByThree);
</code></pre>
We're greeted with:
<pre><code class="hljs">function inner(y) { return x * y; }
</code></pre>
Let's go through the code step-by-step to see what is happening under the hood:
<ol>
<li>The <code>outer()</code> function is defined in global scope.</li>
<li><code>outer()</code> is invoked, and it returns a function that is assigned to <code>multiplyByThree</code>.
<ol>
<li>New execution context is created for <code>outer()</code>.
<ul>
<li>Variable <code>x</code> is set to 3.</li>
</ul>
</li>
<li>Returns a function named <code>inner()</code>.</li>
<li>The reference to <code>inner()</code> is assigned to <code>multiplyByThree</code>.</li>
<li>As the outer function finishes execution, all the variables within its scope are deleted.</li>
</ol>
</li>
<li>Result of the function call <code>multiplyByThree(2)</code> is logged to the console.
<ol>
<li><code>inner() </code>is invoked with <code>2</code> as the argument. So, <code>y</code> is set to <code>2</code>.</li>
<li>As <code>inner()</code> preserves the scope chain of its parent function, at the time of execution it will still have access to the value of <code>x</code>.</li>
<li>It returns <code>6</code> which gets logged to the console.</li>
</ol>
</li>
</ol>
<blockquote>
In conclusion, even after the outer function ceases to exist, the inner function has access to the variables defined in the scope of the outer function.
</blockquote>
<h2 id="visualizingclosures">Visualizing Closures</h2>
Closures can be visualized through the developer console:
<pre><code class="hljs">function outer() {
 let x = 3
 return function inner(y) {
 return x*y
 }
}

let multiplyByThree = outside();
console.dir(multiplyByThree);
</code></pre>
By executing the code above in the developer console, we can see we have access to the context of <code>inner(y)</code>. Upon closer inspection, we can see that part its context is a <code>[[Scopes]]</code> array, which contains all three scopes we were talking about.
Lo and behold, the array of scopes contains its parent function's scope, which contains <code>x = 3</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/guide-to-closures-in-javascript-1.jpeg" alt="Closure element in developer console">
<h2 id="commonusecases">Common Use Cases</h2>
Closures are useful because they help us cluster data with functions that operate on that data. This might ring a bell to some of you who are familiar with Object-Oriented Programming (OOP). As a result, we can use closures anywhere we might use an object.
Another major use-case of closures is when we need our variables to be private, as variables defined in the scope of a closure is off-limits to the functions outside of it. At the same time, closures have access to variables in its scope chain.
Let's look at the following example to understand this better:
<pre><code class="hljs">const balance = (function() {
 let privateBalance = 0;

 return {
 increment: function(value){
 privateBalance += value;
 return privateBalance;
 },
 decrement: function(value){
 privateBalance -= value;
 return privateBalance;
 },
 show: function(){
 return privateBalance;
 }
 }
})()

console.log(balance.show()); // 0
console.log(balance.increment(500)); // 500
console.log(balance.decrement(200)); // 300
</code></pre>
In this example, we have defined a constant variable <code>balance</code> and set it as the return value of our anonymous function. Notice that <code>privateBalance</code> can only be changed by calling the methods on <code>balance</code>.
<h2 id="conclusion">Conclusion</h2>
Although closures are a fairly niche concept in JavaScript, they're an important tool in good JavaScript developer's toolkit. They can be used to elegantly implement solutions which would otherwise be a tall order.
In this article, we have first learned a bit about scopes and how they are implemented in JavaScript. We then used this knowledge to understand how closures work under the hood and how to use them.

Abhilash Kakumanu

In this tutorial, we'll go over how scopes work in JavaScript, as well as what closures are and how they work. We'll then go over examples and use-cases of closures.