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

Guest Contributor

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>

David Landup

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.

Guide to JavaScript Closures

<h2 id="introduction">Introduction</h2>
Executing Python scripts requires a lot of prerequisites like having Python installed, having a plethora of modules installed, using the command line, etc. while executing an <code>.exe</code> file is very straightforward.
If you want to create a simple application and distribute it to lots of users, writing it as a short Python script is not difficult, but assumes that the users know how to run the script and have Python already installed on their machine.
Examples like this show that there is a valid reason to convert <code>.py</code> programs into equivalent <code>.exe</code> programs on Windows. <code>.exe</code> stands for &quot;Executable File&quot;, which is also known as a Binary.
The most popular way to achieve this is by using the <code>py2exe</code> module. In this article, we'll quickly go through the basics of <code>py2exe</code> and troubleshoot some common issues. To follow along, no advanced Python knowledge is needed, however you will have to use Windows.
Converting an interpreted language code into an executable file is a practice commonly called freezing.
<h2 id="installingpy2exe">Installing py2exe</h2>
To use the <code>py2exe</code> module, we'll need to install it. Let's do so with <code>pip</code>:
<pre><code class="hljs">$ pip install py2exe
</code></pre>
<h2 id="convertingpythonscripttoexe">Converting Python Script to .exe</h2>
First, let's write up a a program that's going to print some text to the console:
<pre><code class="hljs">import math
print(&quot;Hannibal ante Portas&quot;)
print(factorial(4))
</code></pre>
Let's run the following commands in the Windows command line to make a directory (<code>exampDir</code>), move the code we already wrote to said directory, and finally, execute it:
<pre><code class="hljs">$ mkdir exampDir
$ move example.py exampDir
$ cd exampDir
$ py example.py
</code></pre>
This should output:
<pre><code class="hljs">Hannibal ante Portas
24
</code></pre>
Always test out the scripts before turning them into executables to make sure that if there is an error, it isn't caused by the source code.
<h3 id="setupandconfiguration">Setup and Configuration</h3>
Make another file called <code>setup.py</code> in the same folder. Here we will keep configuration details on how we want to compile our program. We'll just put a couple of lines of code into it for now:
<pre><code class="hljs">from distutils.core import setup # Need this to handle modules
import py2exe 
import math # We have to import all modules used in our program

setup(console=[&#x27;example.py&#x27;]) # Calls setup function to indicate that we&#x27;re dealing with a single console application
</code></pre>
If we were dealing with an app with a graphical UI, we would replace <code>console</code> with <code>windows</code> like so:
<pre><code class="hljs">setup(windows=[&#x27;example.py&#x27;])
</code></pre>
Now open Command Prompt as administrator and navigate to the directory we just mentioned and run the <code>setup.py</code> file:
<pre><code class="hljs">$ cd exampDir
$ python setup.py py2exe

running py2exe
*** searching for required modules ***
*** parsing results ***
...
</code></pre>
<h3 id="distfolder">dist folder</h3>
If all is done correctly, this should produce a subdirectory called <code>dist</code>. Inside it, there will be a few different files depending on your program, and one of them should be <code>example.exe</code>. To execute it from the console run:
<pre><code class="hljs">$ example
</code></pre>
And you'll be greeted by our Latin quote, followed by the value of 4!:
<pre><code class="hljs">Hannibal ante Portas
24
</code></pre>
Or, you can double click it and it'll run in the console.
If you'd like to bundle up all the files, add <code>bundle_files</code> and <code>compressed</code>, and set <code>zipfile</code> to None like so:
<pre><code class="hljs">from distutils.core import setup
import py2exe

setup(
 options = {&#x27;py2exe&#x27;: {&#x27;bundle_files&#x27;: 1, &#x27;compressed&#x27;: True}},
 console = [{&#x27;script&#x27;: &quot;example.py&quot;}],
 zipfile = None,
)
</code></pre>
And re-run the commands to generate the .exe file.
Now, your end-users can run your scripts without any knowledge or prerequisites installed on their local machines.
<h2 id="troubleshooting">Troubleshooting</h2>
Errors while converting <code>.py</code> files to <code>.exe</code> files are common, so we'll list some common bugs and solutions.
<h3 id="howtofixmissingdllsafterusingpy2exe">How to Fix Missing DLL-s After Using py2exe</h3>
A common issue with py2exe is missing <code>.dll</code>-s.
<blockquote>
DLL stands for &quot;dynamic-link library&quot;, and they're not there just to make bugs, promise. DLLs contain code, data, and resources which our program might need during execution.
</blockquote>
After running the <code>.exe</code>, if you get a system error that says something like:
<pre><code class="hljs">The program can&#x27;t start because something.dll is missing from your computer. Try reinstalling the program to fix this problem. 
</code></pre>
Or the command line says:
<pre><code class="hljs">ImportError: (DLL load failed: The specified module could not be found.)
</code></pre>
The solution is to find the missing <code>.dll</code> and past it into your dist folder. There are two ways to do this.
<ol>
<li>Search your computer for the file and then copy it. This will work most of the time.</li>
<li>Find the missing <code>.dll</code> online and download it. Try not to download it from some shady website.</li>
</ol>
<h3 id="howtogenerate3264bitexecutablesusingpy2exe">How to Generate 32/64-bit Executables Using py2exe?</h3>
To make a 64-bit executable, install 64 bit Python on your device. The same goes for the 32-bit version.
<h2 id="howtousepy2exeonlinuxormac">How to use py2exe on Linux or Mac</h2>
<code>py2exe</code> doesn't support on Linux or Mac, as it's aimed to create .exe files which is a Windows-unique format. You can download a Windows virtual machine on both Mac and Linux, use Wine or use a different tool like Pyinstaller on Linux, or py2app on Mac.
<h2 id="conclusion">Conclusion</h2>
To make Python projects easier to run on Windows devices, we need to generate an executable file. We can use many different tools, like Pyinstaller, auto-py-to-exe, cx_Freeze, and py2exe.
Binary files may use DLL-s, so make sure to include them with your project.

Kristina Popovic

In this tutorial, we'll go over how to convert a Python script to an .exe File on Windows using Py2Exe, with examples.

Creating Executable Files from Python Scripts with py2exe

<h2 id="introduction">Introduction</h2>
Arrays are one of the most widely used data structures in Computer Science. While dealing with a list of items (array), we are often required to look for a particular value in the list. JavaScript contains a few built-in methods to check whether an array has a specific value, or object.
In this article, we'll take a look at how to check if an array includes/contains a value or element in JavaScript.
<h2 id="checkarrayofprimitivevaluesincludesavalue">Check Array of Primitive Values Includes a Value</h2>
<h3 id="arrayincludesfunction">Array.includes() Function</h3>
The simplest way to check for a primitive value in an array is to use the <code>includes()</code> method:
<pre><code class="hljs">let isInArray = arr.includes(valueToFind[, fromIndex])
// arr - array we&#x27;re inspecting
// valueToFind - value we&#x27;re looking for
// fromIndex - index from which the search will start (defaults to 0 if left out)
// isInArray - boolean value which tells us if array contains valueToFind
</code></pre>
For example, let's check whether the array of animals contains the dog and cat emojis:
<pre><code class="hljs">let animals = [&quot;🐘&quot;, &quot;🐒&quot;, &quot;🐶&quot;, &quot;🐍&quot;]

animals.includes(&quot;🐶&quot;) // true
animals.includes(&quot;🐱&quot;) // false
</code></pre>
The function returns a boolean value, signifying the value's presence or lack thereof.
<h3 id="arrayindexoffunction">Array.indexOf() Function</h3>
In cases where we need the exact location of the element we're looking for, we can use the <code>indexOf(elem)</code> method, which looks for <code>elem</code> in the specified array and returns the index of its first occurrence, and <code>-1</code> if the array does not contain <code>elem</code>.
For example, we can look for the first occurrence of a grade in an array containing grades:
<pre><code class="hljs">let grades = [&quot;B&quot;, &quot;D&quot;, &quot;C&quot;, &quot;A&quot;]

grades.indexOf(&quot;A&quot;) // 3
grades.indexOf(&quot;F&quot;) // -1
</code></pre>
In the first instance, the element is present, and its position is returned. In the second instance, the return value signifies that the element is not present.
We can use this to alter code flow easily:
<pre><code class="hljs">let grades = [&quot;B&quot;, &quot;D&quot;, &quot;C&quot;, &quot;A&quot;]

if (grades.indexOf(&quot;F&quot;) &gt;= 0) {
 console.log(&quot;Element is present&quot;);
} else {
 console.log(&quot;Element is not present&quot;);
}
</code></pre>
If we pass in <code>F</code>, the adequate message is printed:
<pre><code class="hljs">Element is not present
</code></pre>
<h2 id="checkingifarrayofobjectsincludesobject">Checking if Array of Objects Includes Object</h2>
<h3 id="somefunction">some() Function</h3>
When searching for an object, <code>includes()</code> checks whether the provided object reference matches the one in the array. This is rarely what we want, because objects can have identical fields with corresponding values but different references.
We can use the <code>some()</code> method to search by object's contents. The <code>some()</code> method takes one argument and accepts a callback, which is executed once for each value in the array until it finds an element which meets the condition set by the <code>callback</code> function, and returns <code>true</code>.
Let's look at <code>some()</code> in action to understand it better:
<pre><code class="hljs">let animals = [{name: &quot;dog&quot;}, {name: &quot;snake&quot;}, {name: &quot;monkey&quot;}, {name: &quot;donkey&quot;}]
let element = {name: &quot;monkey&quot;}

animals.some(animal =&gt; animal.name === element.name)
</code></pre>
The callback function returns <code>false</code> for the first two cases, but returns <code>true</code> for the third element, as the names match. After this, <code>some()</code> halts execution and returns <code>true</code>.
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over the few ways to check whether an array contains a value or not, in JavaScript.
We've covered the <code>includes()</code> function, which returns a boolean value if the value is present. The <code>indexOf()</code> function returns the index of a value if it's present, and <code>-1</code> if it isn't.
Finally, for objects, the <code>some()</code> function helps us search for object presence based on their contents.

In this tutorial, we'll go over examples of how to check if an array includes/contains an element or value in JavaScript.

JavaScript: Check if Array Includes a Value/Element

JavaScript: Check if Array Contains a Value/Element

Marcus Sanatan

Naazneen Jatu

In this article, you will learn how to read data from an XML file and load it into a Pandas DataFrame. You'll also export data from a Pandas DataFrame to an XML file.

Reading and Writing XML Files with Pandas

Reading and Writing XML Files in Python with Pandas

<h2 id="introduction">Introduction</h2>
Seaborn is one of the most widely used data visualization libraries in Python, as an extension to Matplotlib. It offers a simple, intuitive, yet highly customizable API for data visualization.
In this tutorial, we'll take a look at how to plot a Bar Plot in Seaborn.
Bar graphs display numerical quantities on one axis and categorical variables on the other, letting you see how many occurrences there are for the different categories.
<blockquote>
Bar charts can be used for visualizing a time series, as well as just categorical data.
</blockquote>
<h2 id="plotabarplotinseaborn">Plot a Bar Plot in Seaborn</h2>
Plotting a Bar Plot in Seaborn is as easy as calling the <code>barplot()</code> function on the <code>sns</code> instance, and passing in the categorical and continuous variables that we'd like to visualize:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style(&#x27;darkgrid&#x27;)

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

sns.barplot(x, y)
plt.show()
</code></pre>
Here, we've got a few categorical variables in a list - <code>A</code>, <code>B</code> and <code>C</code>. We've also got a couple of continuous variables in another list - <code>1</code>, <code>5</code> and <code>3</code>. The relationship between these two is then visualized in a Bar Plot by passing these two lists to <code>sns.barplot()</code>.
This results in a clean and simple bar graph:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-1.png" alt="basic bar plot in seaborn">
Though, more often than not, you'll be working with datasets that contain much more data than this. Sometimes, operations are applied to this data, such as ranging or counting certain occurrences.
Whenever you're dealing with means of data, you'll have some error padding that can arise from it. Thankfully, Seaborn has us covered, and applies error bars for us automatically, as it by default calculates the mean of the data we provide.
Let's import the classic Titanic Dataset and visualize a Bar Plot with data from there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

# Set Seaborn style
sns.set_style(&#x27;darkgrid&#x27;)
# Import Data
titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

# Construct plot
sns.barplot(x = &quot;sex&quot;, y = &quot;survived&quot;, data = titanic_dataset)
plt.show()
</code></pre>
This time around, we've assigned <code>x</code> and <code>y</code> to the <code>sex</code> and <code>survived</code> columns of the dataset, instead of the hard-coded lists.
If we print the head of the dataset:
<pre><code class="hljs">print(titanic_dataset.head())
</code></pre>
We're greeted with:
<pre><code class="hljs"> survived pclass sex age sibsp parch fare ...
0 0 3 male 22.0 1 0 7.2500 ...
1 1 1 female 38.0 1 0 71.2833 ...
2 1 3 female 26.0 0 0 7.9250 ...
3 1 1 female 35.0 1 0 53.1000 ...
4 0 3 male 35.0 0 0 8.0500 ...

[5 rows x 15 columns]
</code></pre>
Make sure you match the names of these features when you assign <code>x</code> and <code>y</code> variables.
Finally, we use the <code>data</code> argument and pass in the dataset we're working with and from which the features are extracted from. This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-2.png" alt="plot bar plot from dataset in seaborn">
<h2 id="plotahorizontalbarplotinseaborn">Plot a Horizontal Bar Plot in Seaborn</h2>
To plot a Bar Plot horizontally, instead of vertically, we can simply switch the places of the <code>x</code> and <code>y</code> variables.
This will make the categorical variable be plotted on the Y-axis, resulting in a horizontal plot:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

sns.barplot(y, x)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-3.png" alt="plot horizontal bar plot seaborn">
Going back to the Titanic example, this is done in much the same way:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;survived&quot;, y = &quot;class&quot;, data = titanic_dataset)
plt.show()
</code></pre>
Which results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-4.png" alt="plot horizontal bar plot of dataset seaborn">
<h2 id="changebarplotcolorinseaborn">Change Bar Plot Color in Seaborn</h2>
Changing the color of the bars is fairly easy. The <code>color</code> argument accepts a Matplotlib color and applies it to all elements.
Let's change them to <code>blue</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

sns.barplot(x, y, color=&#x27;blue&#x27;)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-5.png" alt="change bar plot color in seaborn">
Or, better yet, you can set the <code>palette</code> argument, which accepts <a rel="nofollow noopener" target="_blank" href="https://seaborn.pydata.org/tutorial/color_palettes.html">a wide variety of palettes</a>. A pretty common one is <code>hls</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;embark_town&quot;, y = &quot;survived&quot;, palette = &#x27;hls&#x27;, data = titanic_dataset)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-6.png" alt="set color palette in seaborn bar plot">
<h2 id="plotgroupedbarplotinseaborn">Plot Grouped Bar Plot in Seaborn</h2>
Grouping Bars in plots is a common operation. Say you wanted to compare some common data, like, the survival rate of passengers, but would like to group them with some criteria.
We might want to visualize the relationship of passengers who survived, segregated into classes (first, second and third), but also factor in which town they embarked from.
This is a fair bit of information in a plot, and it can easily all be put into a simple Bar Plot.
To group bars together, we use the <code>hue</code> argument. Technically, as the name implies, the <code>hue</code> argument tells Seaborn how to color the bars, but in the coloring process, it groups together relevant data.
Let's take a look at the example we've just discussed:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;class&quot;, y = &quot;survived&quot;, hue = &quot;embark_town&quot;, data = titanic_dataset)
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-7.png" alt="plot grouped bar plot in seaborn">
Now, the error bars for the Queenstown data are pretty large. This indicates that the data on passengers who survived, and embarked from Queenstown varies a lot for the first and second class.
<h2 id="orderinggroupedbarsinabarplotwithseaborn">Ordering Grouped Bars in a Bar Plot with Seaborn</h2>
You can change the order of the bars from the default order (whatever Seaborn thinks makes most sense) into something you'd like to highlight or explore.
This is done via the <code>order</code> argument, which accepts a list of the values and the order you'd like to put them in.
For example, so far, it ordered the classes from the first to the third. What if we'd like to do it the other way around?
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;class&quot;, y = &quot;survived&quot;, hue = &quot;embark_town&quot;, order = [&quot;Third&quot;, &quot;Second&quot;, &quot;First&quot;], data = titanic_dataset)
plt.show()
</code></pre>
Running this code results in:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-8.png" alt="ordering grouped bar plots in seaborn">
<h2 id="changeconfidenceintervalonseabornbarplot">Change Confidence Interval on Seaborn Bar Plot</h2>
You can also easily fiddle around with the confidence interval by setting the <code>ci</code> argument.
For example, you can turn it off, by setting it to <code>None</code>, or use standard deviation instead of the mean by setting <code>sd</code>, or even put a cap size on the error bars for aesthetic purposes by setting <code>capsize</code>.
Let's play around with the confidence interval attribute a bit:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

sns.barplot(x = &quot;class&quot;, y = &quot;survived&quot;, hue = &quot;embark_town&quot;, ci = None, data = titanic_dataset)
plt.show()
</code></pre>
This now removes our error bars from before:
<img src="https://stackabuse.s3.amazonaws.com/media/seaborn-bar-plot-tutorial-and-examples-9.png" alt="change confidence interval of error bars in seaborn">
Or, we could use standard deviation for the error bars and set a cap size:
<pre><code class="hljs">import matplotlib.pyplot as plt
import seaborn as sns

titanic_dataset = sns.load_dataset(&quot;titanic&quot;)

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

In this tutorial, we'll go over how to plot a bar plot with Seaborn and Python. We'll go over basic bar plots, as well as customize them, how to group and order bars, etc.

Seaborn Bar Plot - Tutorial and Examples

<h2 id="introduction">Introduction</h2>
The constant growth of data on the Internet creates a demand for tools that process textual information.
Moreover, it's highly important that this instrument of text analysis could implement solutions for both low and high-level NLP tasks such as counting word frequencies, calculating sentiment analysis of the texts or detecting patterns in relationships between words.
<a rel="nofollow noopener" target="_blank" href="https://textblob.readthedocs.io/en/dev/">TextBlob</a> is a great lightweight library for a wide variety of NLP tasks.
In this tutorial we will shed some light how to perform N-Grams Detection in Python using TextBlob.
<h2 id="whatarengrams">What are N-Grams?</h2>
N-grams represent a continuous sequence of N elements from a given set of texts. In broad terms, such items do not necessarily stand for strings of words, they also can be phonemes, syllables or letters, depending on what you'd like to accomplish.
However, in Natural Language Processing it is more commonly referring to N-grams as strings of words, where n stands for an amount of words that you are looking for.
The following types of N-grams are usually distinguished:
<ul>
<li>
Unigram - An N-gram with simply one string inside (for example, it can be a unique word - YouTube or TikTok from a given sentence e.g. YouTube is launching a new short-form video format that seems an awful lot like TikTok).
</li>
<li>
2-gram or Bigram - Typically a combination of two strings or words that appear in a document: short-form video or video format will be likely a search result of bigrams in a certain corpus of texts (and not format video, video short-form as the word order remains the same).
</li>
<li>
3-gram or Trigram - An N-gram containing up to three elements that are processed together (e.g. short-form video format or new short-form video) etc.
</li>
</ul>
N-grams found its primary application in an area of probabilistic language models. As they estimate the probability of the next item in a word sequence.
This approach for language modeling assumes a tight relationship between the position of each element in a string, calculating the occurrence of the next word with respect to the previous one. In particular, the N-gram model determines the probability as follows - <code>N-1</code>.
For instance, a trigram model (with N = 3) will predict the next word in a string based on the preceding two words as <code>N-1 = 2</code>.
The other cases of implementation of N-grams models in the industry can be detection of plagiarism, where N-grams obtained from two different texts are compared with each other to figure out the degree of similarity of the analyzed documents.
<h2 id="ngramdetectioninpythonusingtextblob">N-gram Detection in Python Using TextBlob</h2>
<h3 id="analysisofasentence">Analysis of a Sentence</h3>
To start out detecting the N-grams in Python, you will first have to install the TexBlob package.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: This library is applicable for both Python 2 and Python 3.

 </div>
 </div>
 </div>
 We'll also want to download the required text corpora for it to work with:
<pre><code class="hljs">$ pip install -U textblob 
$ python -m textblob.download_corpora
</code></pre>
Once the environment is set up, you are ready to load the package and compute N-grams in a sample sentence. In the beginning, we will look at N-grams in the quote of M. Mullenweg: Technology is best when it brings people together.
Let's get started:
<pre><code class="hljs">from textblob import TextBlob

# Sample sentence for N-gram detection
sentence = &quot;Technology is best when it brings people together&quot;
</code></pre>
We've created a <code>sentence</code> string containing the sentence we want to analyze. We've then passed that string to the <code>TextBlob</code> constructor, injecting it into the <code>TextBlob</code> instance that we'll run operations on:
<pre><code class="hljs">ngram_object = TextBlob(sentence)
</code></pre>
Now, let's run N-gram detection. For starters, let's do 2-gram detection. This is specified in the argument list of the <code>ngrams()</code> function call:
<pre><code class="hljs">ngrams = ngram_object.ngrams(n=2) # Computing Bigrams
print(ngrams) 
</code></pre>
The <code>ngrams()</code> function returns a list of tuples of n successive words. In our sentence, a bigram model will give us the following set of strings:
<pre><code class="hljs">[WordList([&#x27;Technology&#x27;, &#x27;is&#x27;]), 
WordList([&#x27;is&#x27;, &#x27;best&#x27;]), 
WordList([&#x27;best&#x27;, &#x27;when&#x27;]), 
WordList([&#x27;when&#x27;, &#x27;it&#x27;]), 
WordList([&#x27;it&#x27;, &#x27;brings&#x27;]), 
WordList([&#x27;brings&#x27;, &#x27;people&#x27;]), 
WordList([&#x27;people&#x27;, &#x27;together&#x27;])]
</code></pre>
<h3 id="documentanalysis">Document Analysis</h3>
Despite the simple nature of this Python library, TextBlob also provides a range of advanced features for analysis. More often than not, we aren't working with single sentences for N-grams detection. It's much more common to work with documents, articles or larger corporas.
In our next example, we will use <a rel="nofollow noopener" target="_blank" href="https://www.cnbc.com/2020/10/15/bill-gates-antitrust-should-look-at-tech-companies-separately.html">an article</a> from the CNBC news portal regarding Bill Gates.
Let's create a text document and call it something along the lines of <code>Input.txt</code> for the next analysis:
<pre><code class="hljs">import sys

# Opening and reading the `Input.txt` file
corpus = open(&quot;Input.txt&quot;).read()
</code></pre>
Then, as usual, we'll instantiate a <code>TextBlob</code> instance, by passing the <code>corpus</code> to the constructor, and run the <code>ngrams()</code> function:
<pre><code class="hljs">ngram_object = TextBlob(corpus)
trigrams = ngram_object.ngrams(n=3) # Computing Trigrams
print(trigrams) 
</code></pre>
This will print out the Trigrams of the content we've provided. However, note that the output can differ depending on the approach you apply to handle punctuation marks:
<pre><code class="hljs">[WordList([&#x27;Bill&#x27;, &#x27;Gates&#x27;, &#x27;says&#x27;]), 
WordList([&#x27;Gates&#x27;, &#x27;says&#x27;, &#x27;that&#x27;]),
WordList([&#x27;says&#x27;, &#x27;that&#x27;, &#x27;antitrust&#x27;]), 
WordList([&#x27;that&#x27;, &#x27;antitrust&#x27;, &#x27;regulators&#x27;]),
WordList([&#x27;antitrust&#x27;, &#x27;regulators&#x27;, &#x27;should&#x27;])
&lt;...&gt;]
</code></pre>
In comparison, Bigram analysis for the given article will provide us a different list:
<pre><code class="hljs">ngram_object = TextBlob(corpus)
Bigram = ngram_object.ngrams(n=) # Computing Bigrams
print(Bigram) 
</code></pre>
A snippet from the output:
<pre><code class="hljs">[WordList([&#x27;Bill&#x27;, &#x27;Gates&#x27;]),
WordList([&#x27;Gates&#x27;, &#x27;says&#x27;]),
WordList([&#x27;says&#x27;, &#x27;that&#x27;]),
WordList([&#x27;that&#x27;, &#x27;antitrust&#x27;]),
WordList([&#x27;antitrust&#x27;, &#x27;regulators&#x27;])
&lt;...&gt;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
N-Grams detection is a simple and common task in a lot of NLP projects. In this article, we've gone over how to perform N-Gram detection in Python using TextBlob.

Natalia Kuzminykh

In this tutorial, we'll go over the theory and examples on how to perform N-Grams detection in Python using TextBlob for NLP tasks and projects.

Simple NLP in Python with TextBlob: N-Grams Detection

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this tutorial, we'll take a look at how to plot a bar plot in Matplotlib.
Bar graphs display numerical quantities on one axis and categorical variables on the other, letting you see how many occurrences there are for the different categories.
<blockquote>
Bar charts can be used for visualizing a time series, as well as just categorical data.
</blockquote>
<h2 id="plotabarplotinmatplotlib">Plot a Bar Plot in Matplotlib</h2>
Plotting a Bar Plot in Matplotlib is as easy as calling the <code>bar()</code> function on the PyPlot instance, and passing in the categorical and numerical variables that we'd like to visualize.
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

plt.bar(x, y)
plt.show()
</code></pre>
Here, we've got a few categorical variables in a list - <code>A</code>, <code>B</code> and <code>C</code>. We've also got a couple of continuous variables in another list - <code>1</code>, <code>5</code> and <code>3</code>. The relationship between these two is then visualized in a Bar Plot by passing these two lists to <code>plt.bar()</code>.
This results in a clean and simple bar graph:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-1.png" alt="basic bar plot in matplotlib">
<h2 id="plotahorizontalbarplotinmatplotlib">Plot a Horizontal Bar Plot in Matplotlib</h2>
Oftentimes, we might want to plot a Bar Plot horizontally, instead of vertically. This is easily achievable by switching the <code>plt.bar()</code> call with the <code>plt.barh()</code> call:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

plt.barh(x, y)
plt.show()
</code></pre>
This results in a horizontally-oriented Bar Plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-2.png" alt="horizontal bar plot in matplotlib">
<h2 id="changebarplotcolorinmatplotlib">Change Bar Plot Color in Matplotlib</h2>
Changing the color of the bars themselves is as easy as setting the <code>color</code> argument with a list of colors. If you have more bars than colors in the list, they'll start being applied from the first color again:
<pre><code class="hljs">import matplotlib.pyplot as plt

x = [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;C&#x27;]
y = [1, 5, 3]

plt.bar(x, y, color=[&#x27;red&#x27;, &#x27;blue&#x27;, &#x27;green&#x27;])
plt.show()
</code></pre>
Now, we've got a nicely colored Bar Plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-3.png" alt="change bar plot color in matplotlib">
Of course, you can also use the shorthand versions or even HTML codes:
<pre><code class="hljs">plt.bar(x, y, color=[&#x27;red&#x27;, &#x27;blue&#x27;, &#x27;green&#x27;])
plt.bar(x, y, color=[&#x27;r&#x27;, &#x27;b&#x27;, &#x27;g&#x27;])
plt.bar(x, y, color=[&#x27;#ff0000&#x27;, &#x27;#00ff00&#x27;, &#x27;#0000ff&#x27;])
plt.show()
</code></pre>
Or you can even put a single scalar value, to apply it to all bars:
<pre><code class="hljs">plt.bar(x, y, color=&#x27;green&#x27;)
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-4.png" alt="change bar plot color in matplotlib">
<h2 id="barplotwitherrorbarsinmatplotlib">Bar Plot with Error Bars in Matplotlib</h2>
When you're plotting mean values of lists, which is a common application for Bar Plots, you'll have some error space. It's very useful to plot error bars to let other observers, and yourself, know how truthful these means are and which deviation is expected.
For this, let's make a dataset with some values, <a target="_blank" href="/calculating-mean-median-and-mode-in-python/">calculate their means</a> and <a target="_blank" href="/calculating-variance-and-standard-deviation-in-python/">standard deviations</a> with NumPy and plot them with error bars:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.array([4, 5, 6, 3, 6, 5, 7, 3, 4, 5])
y = np.array([3, 4, 1, 3, 2, 3, 3, 1, 2, 3])
z = np.array([6, 9, 8, 7, 9, 8, 9, 6, 8, 7])

x_mean = np.mean(x)
y_mean = np.mean(y)
z_mean = np.mean(z)

x_deviation = np.std(x)
y_deviation = np.std(y)
z_deviation = np.std(z)

bars = [x_mean, y_mean, z_mean]
bar_categories = [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;]
error_bars = [x_deviation, y_deviation, z_deviation]

plt.bar(bar_categories, bars, yerr=error_bars)
plt.show()
</code></pre>
Here, we've created three fake datasets with several values each. We'll visualize the mean values of each of these lists. However, since means, as well as averages can give the false sense of accuracy, we'll also calculate the standard deviation of these datasets so that we can add those as error bars.
Using NumPy's <code>mean()</code> and <code>std()</code> functions, this is a breeze. Then, we've packed the bar values into a <code>bars</code> list, the bar names for a nice user experience into <code>bar_categories</code> and finally - the standard deviation values into an <code>error_bars</code> list.
To visualize this, we call the regular <code>bar()</code> function, passing in the <code>bar_categories</code> (categorical values) and <code>bars</code> (continuous values), alongside the <code>yerr</code> argument.
Since we're plotting vertically, we're using the <code>yerr</code> argument. If we were plotting horizontally, we'd use the <code>xerr</code> argument. Here, we've provided the information about the error bars.
This ultimately results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-bar-plot-tutorial-and-examples-5.png" alt="bar plot with error bars in matplotlib">
<h2 id="plotstackedbarplotinmatplotlib">Plot Stacked Bar Plot in Matplotlib</h2>
Finally, let's plot a Stacked Bar Plot. Stacked Bar Plots are really useful if you have groups of variables, but instead of plotting them one next to the other, you'd like to plot them one on top of the other.
For this, we'll again have groups of data. Then, we'll calculate their standard deviation for error bars.
Finally, we'll need an index range to plot these variables on top of each other, while maintaining their relative order. This index will essentially be a range of numbers the length of all the groups we've got.
To stack a bar on another one, you use the <code>bottom</code> argument. You specify what's on the <code>bottom</code> of that bar. To plot <code>x</code> beneath <code>y</code>, you'd set <code>x</code> as the <code>bottom</code> of <code>y</code>.
For more than one group, you'll want to add the values together before plotting, otherwise, the Bar Plot won't add up. We'll use NumPy's <code>np.add().tolist()</code> to add the elements of two lists and produce a list back:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

# Groups of data, first values are plotted on top of each other
# Second values are plotted on top of each other, etc
x = [1, 3, 2]
y = [2, 3, 3]
z = [7, 6, 8]

# Standard deviation rates for error bars
x_deviation = np.std(x)
y_deviation = np.std(y)
z_deviation = np.std(z)

bars = [x, y, z]
ind = np.arange(len(bars))
bar_categories = [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;];
bar_width = 0.5
bar_padding = np.add(x, y).tolist()

plt.bar(ind, x, yerr=x_deviation, width=bar_width)
plt.bar(ind, y, yerr=y_deviation, bottom=x, width=bar_width)
plt.bar(ind, z, yerr=z_deviation, bottom=bar_padding, width=bar_width)

plt.xticks(ind, bar_categories)
plt.xlabel(&quot;Stacked Bar Plot&quot;)

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

In this tutorial, we'll go over how to plot a bar plot in Matplotlib and Python. We'll go over basic bar plots, as well as customize them and advanced stacked bar plots with examples.