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>

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

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.