David Landup

Asaolu Elijah

Jovana Ninkovic

In this guide, we'll take a look at Vuex - the centralized state management library for Vue applications. Learn how to use getters, actions and mutations to alter the Vuex store state through code.

Guide to Vuex - Centralized State Management for Vue Applications

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
<blockquote>
In this guide, we'll take a look at how to collect Stream elements to a map in Java 8.
</blockquote>
<h2 id="collectorsandstreamcollect">Collectors and Stream.collect()</h2>
Collectors represent implementations of the <code>Collector</code> interface, which implements various useful reduction operations, such as accumulating elements into collections, summarizing elements based on a specific parameter, etc.
<blockquote>
All predefined implementations can be found within the <code>Collectors</code> class.
</blockquote>
You can also very easily implement your own collector and use it instead of the predefined ones, though - you can get pretty far with the built-in collectors, as they cover the vast majority of cases in which you might want to use them.
To be able to use the class in our code we need to import it:
<pre><code class="hljs">import static java.util.stream.Collectors.*;
</code></pre>
<code>Stream.collect()</code> performs a mutable reduction operation on the elements of the stream.

 <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">
 A mutable reduction operation collects input elements into a mutable container, such as a <code>Collection</code>, as it processes the elements of the stream.

 </div>
 </div>
 </div>
 <h2 id="guidetocollectorstoset">Guide to Collectors.toSet()</h2>
The <code>toSet()</code> method is used to collect a stream into a set. It works in a similar fashion to the <code>toList()</code> method, but ultimately collects into a different underlying data structure, by returning a <code>Collector</code> that accumulates the input elements into a new <code>Set</code>.
It's worth noting that there are no guarantees on the type, mutability, serializability, or thread-safety of the <code>Set</code> returned:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Set&lt;T&gt;&gt; toSet()
</code></pre>
<blockquote>
A <code>Set</code> doesn't allow duplicate elements or in more formal terms - sets contain no pair of elements <code>a</code> and <code>b</code> such that <code>a.equals(b)</code>, and it can contain at most one <code>null</code> element.
</blockquote>
If you collect a stream with duplicate elements into a <code>Set</code> - it's a quick way to prune away duplicates:
<pre><code class="hljs">Stream&lt;String&gt; stream = 
 Stream.of(&quot;This&quot;, &quot;forms&quot;, &quot;forms&quot;, &quot;a&quot;, &quot;short&quot;, &quot;a&quot;, &quot;sentence&quot;, &quot;sentence&quot;);
Set&lt;String&gt; sentenceSet = stream.collect(Collectors.toSet());
</code></pre>
However, this example highlights an important characteristic of how Sets are populated - the elements don't retain their relative order when collected, like they do in, say, the <code>toList()</code> collector. This is because the default implementation of a <code>Set</code> is a <code>HashSet</code>, which orders elements based on their hashes and doesn't even guarantee the consistency of this order over time.
<blockquote>
We'll take a look at how we can provide a custom implementation of a <code>Set</code> in a later section.
</blockquote>
Running this piece of code results in:
<pre><code class="hljs">[sentence, a, This, short, forms]
</code></pre>
Since we rarely work with just Strings or primitive objects - let's define a simple class to represent a <code>Book</code>:
<pre><code class="hljs">public class Book {
 private String title;
 private String author;
 private int releaseYear;
 private int soldCopies;

 // Constructor, getters and setters
}
</code></pre>
And with that, let's create a simple list of a few books (with a duplicate entry):
<pre><code class="hljs">List&lt;Book&gt; books = Arrays.asList(
 new Book(&quot;The Fellowship of the Ring&quot;, &quot;J.R.R. Tolkien&quot;, 1954, 30),
 new Book(&quot;The Hobbit&quot;, &quot;J.R.R. Tolkien&quot;, 1937, 40),
 new Book(&quot;Animal Farm&quot;, &quot;George Orwell&quot;, 1945, 32),
 new Book(&quot;Nineteen Eighty-Four&quot;, &quot;George Orwell&quot;, 1949, 50),
 new Book(&quot;Nineteen Eighty-Four&quot;, &quot;George Orwell&quot;, 1949, 38)
);
</code></pre>
A pretty typical pipeline consists of a <code>filter()</code> based on some <code>Predicate</code> before collecting back to a collection:
<pre><code class="hljs">Set&lt;String&gt; booksGeorgeOrwell = books.stream()
 .filter(book-&gt;book.getAuthor()
 .equals(&quot;George Orwell&quot;) &amp;&amp; book.getCopiesSold() &gt;= 30)
 .map(Book::getTitle).collect(Collectors.toSet());

System.out.println(booksGeorgeOrwell);
</code></pre>
<blockquote>
If you'd like to read more about filtering and predicates - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-the-filter-method/">Java 8 Streams: Definitive Guide to the filter() Method</a> and <a target="_blank" href="https://stackabuse.com/complete-guide-to-java-8-predicates/">Functional Programming in Java 8: Definitive Guide to Predicates</a>!
</blockquote>
As we discussed earlier, <code>Set</code>s don't allow for duplicates. After we've inspected the clause we've given and which of the books in our <code>List</code> meet the criteria, we should have the following result:
<pre><code class="hljs">[Animal Farm, Nineteen Eighty-Four]
</code></pre>
Works great! The duplicate entry was pruned away, without explicit logic to prune away duplicates.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to collect and convert a stream into a Set - using Java 8's Streams API, with the <code>Collectors</code> class.

Branko Ilic

In this guide, learn how to collect and convert a stream into a Set in Java 8, with practical code examples.

Guide to Java 8 Collectors: toSet()

<h2 id="introduction">Introduction</h2>
Pages on modern websites, and especially Single-Page Applications (SPAs) do not follow the traditional method of loading new pages completely whenever something changes on them. Client-Side Routing is used instead - to route towards resources to load another part of the program or structurally change the application's entire view if needed, when an action (such as clicking a button or link) is performed.
React is a massively popular library for front-end development used to create highly responsive user interfaces, and naturally, it has its own Router, which performs Client-Side Routing - the <code>react-router-dom</code>.
<blockquote>
In this guide, we'll take a look at how to create routes in a React application, programmatically navigate between routes, as well as send and retrieve data between them, using React Router.
</blockquote>
<h2 id="creatingareactapplication">Creating a React Application</h2>
Let's start out by creating a simple React application via the command line:
<pre><code class="hljs">$ npx create-react-app router-sample
</code></pre>
Once created, let's move into the project's directory, and start the application:
<pre><code class="hljs">$ cd router-sample
$ npm start
</code></pre>
This will start up a server on <code>localhost:3000</code> and your default browser will fire up to serve the application. Before creating any new files to serve on this endpoint, let's install <code>react-router-dom</code>, since it doesn't come prepackaged.
<h3 id="installingreactrouter">Installing React Router</h3>
As usual, installing a package using <code>npm</code> is as simple as running a single command:
<pre><code class="hljs">$ npm install react-router-dom
</code></pre>
<h3 id="creatingnewrouteswithreactrouter">Creating New Routes with React Router</h3>
The <code>react-router-dom</code> package makes it simple to create new routes. To begin, you wrap the entire application with the <code>&lt;BrowserRouter&gt;</code> tag. We do this to gain access to the browser's <code>history</code> object. Then you define your router links, as well as the components that will be used for each route.
To demonstrate this, let's create a new file called <code>About.js</code> in the <code>/src</code> folder:
<pre><code class="hljs">const About = () =&gt; {
 return (
 &lt;div&gt;
 &lt;h1&gt;About page here!&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Fugit, modi!
 &lt;/p&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
Now, let's update the <code>src/index.js</code> page and import <code>About</code> from the file we've just created. Within the <code>&lt;BrowserRouter&gt;</code> tag, we'll define our routes and components associated with them:
<pre><code class="hljs">import { render } from &quot;react-dom&quot;;
import { BrowserRouter, Routes, Route } from &quot;react-router-dom&quot;;
import App from &quot;./App&quot;;
import About from &quot;./About&quot;;

render(
 &lt;BrowserRouter&gt;
 &lt;Routes&gt;
 &lt;Route path=&quot;/&quot; element={&lt;App /&gt;} /&gt;
 &lt;Route path=&quot;about&quot; element={&lt;About /&gt;} /&gt;
 &lt;/Routes&gt;
 &lt;/BrowserRouter&gt;,
 document.getElementById(&quot;root&quot;)
);
</code></pre>
We've imported the <code>&lt;BrowserRouter&gt;</code> here, and we've wrapped our entire application around it. We'd also selected <code>App.js</code> as the component for our home page (under the <code>/</code> endpoint), and <code>About.js</code> as the component for the <code>/about</code> page.
Finally, let's adapt the <code>App.js</code> file, which will, again, be the main entry point for the application and serve our home page:
<pre><code class="hljs">import { Link } from &quot;react-router-dom&quot;;

function App() {
 return (
 &lt;div className=&quot;App&quot;&gt;
 &lt;h1&gt;Welcome to my react app!&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Accusamus,
 pariatur?
 &lt;/p&gt;
 &lt;br /&gt;
 &lt;Link to=&quot;/about&quot;&gt;About Page&lt;/Link&gt;
 &lt;/div&gt;
 );
}

export default App;
</code></pre>
At this stage, we've created two routes: the entry route (<code>/</code>) and the <code>/about</code> route, and we should be able to easily navigate from the home page to the about page when we visit our application:
<img src="https://s3.stackabuse.com/media/articles/programmatically-navigate-using-react-router-1.gif" alt="navigating between pages with react">
<h2 id="reactrouterhooksnavigationmethods">React Router Hooks (Navigation Methods)</h2>
Hooks were added to React recently, which are functions that allow you to &quot;hook&quot; into the application's state, without having to write new classes. The React Router comes with a few hooks that allow us to programmatically access the Router State and navigate between components. Among these are the following hooks:
<ul>
<li><code>useHistory()</code></li>
<li><code>userNavigate()</code></li>
<li><code>useLocation()</code></li>
<li><code>useParams()</code></li>
</ul>
To use any of these hooks, we must first import them from the <code>react-router-dom</code> package and then specify a variable that invokes the hook; we'll go through this in more detail in the sections that follow.
<h3 id="usehistory">useHistory()</h3>

 <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: The <code>useHistory()</code> hook has been deprecated in the latest version of React Router. If you're using React Router V6, you'll want to use the <code>useNavigate()</code> hook instead. It's covered right after <code>useHistory()</code>.

 </div>
 </div>
 </div>
 The <code>useHistory()</code> hook provides direct access to React Router's history instances, enabling us to perform actions like retrieving the number of entries in the history stack, adding, altering, or removing an entry from the stack, and so on.
Some of the most useful methods here include:
<ul>
<li><code>goBack()</code> - Go backward in history.</li>
<li><code>goForward()</code> - Go forward in history.</li>
<li><code>push()</code> - Add a new entry to the history stack, i.e., navigate to a new URL.</li>
<li><code>replace()</code> - Similar to <code>push()</code> in that it replaces the current stack in the history, but unlike <code>push()</code>, the user cannot travel back in history, i.e. clicking the browser back button will not return to the previous state.</li>
</ul>
With just this, we can navigate from our <code>About</code> page to the home page programmatically, by <code>push()</code>-ing a new entry into the history, effectively navigating the user to the new entry:
<pre><code class="hljs">import React from &quot;react&quot;;
import { useHistory } from &quot;react-router-dom&quot;;

const About = () =&gt; {
 let history = useHistory();

 const goHome = () =&gt; {
 history.push(&quot;/&quot;);
 };

 return (
 &lt;div&gt;
 &lt;h1&gt;About page here!&lt;/h1
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Fugit, modi!
 &lt;/p&gt;
 &lt;button onClick={goHome}&gt;Go to home page&lt;/button&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
Here, we just import the <code>useHistory()</code> hook and create a new <code>goHome()</code> function that executes on a button click. It's just a wrapper for a <code>push()</code> call.
We can also transfer the state or send arbitrary data to the route we are navigating to. We can do this by sending an object to the push methods instead of the pathname as a string, and adding our state to a distinct object:
<pre><code class="hljs">history.push({
 pathname: &#x27;/blog,
 search: &#x27;?blogId=12, // Query string
 state: { // Location state
 author_name: &quot;John Doe&quot;, 
 },
}); 
</code></pre>
After covering <code>useNavigate()</code>, we'll take a look at how to access this data using the <code>useLocation()</code> and <code>useParams()</code> hooks.
<h3 id="usenavigate">useNavigate()</h3>
If you're using the most recent version of React Router, the <code>useHistory()</code> hook has been deprecated in favor of <code>useNavigate()</code>. The approach is nearly identical; the main difference is that the <code>useNavigate()</code> hook does not accept methods like <code>.push()</code> or <code>.replace()</code>. You just <code>navigate()</code> to a certain entry:
<pre><code class="hljs">import React from &quot;react&quot;;
import { useNavigate } from &quot;react-router-dom&quot;;

const About = () =&gt; {
 let navigate = useNavigate();

 const goHome = () =&gt; {
 navigate(&quot;/&quot;);
 };

 return (
 &lt;div&gt;
 &lt;h1&gt;About page here!&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor sit amet consectetur adipisicing elit. Fugit, modi!
 &lt;/p&gt;
 &lt;button onClick={goHome}&gt;Go to home page&lt;/button&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
And, of course, this method also allows us to transfer states between routes:
<pre><code class="hljs">navigate(&quot;/blog&quot;, { state: { author_name: &quot;John Doe&quot; } });
</code></pre>
<h3 id="retrievingdatabetweenrouteswithuselocationanduseparams">Retrieving Data Between Routes with useLocation() and useParams()</h3>
The <code>useLocation()</code> hook provides us access to the browser's <code>location</code> object. Consider it the hook in charge of obtaining the necessary information about the current route:
<pre><code class="hljs">import { useNavigate, useLocation } from &quot;react-router-dom&quot;;
/*...*/
let location = useLocation();
console.log(location);
</code></pre>
Running the code above should return all of the information about the current route, as shown below:
<pre><code class="hljs">{
 &quot;pathname&quot;: &quot;/about&quot;,
 &quot;search&quot;: &quot;&quot;,
 &quot;hash&quot;: &quot;&quot;,
 &quot;state&quot;: null,
 &quot;key&quot;: &quot;default&quot;
}
</code></pre>
It's reasonable to think of the <code>useLocation()</code> hook as a <code>useState()</code> hook that updates the state to a new location whenever the URL changes. On the other hand, the <code>userParams()</code> hook can be used to get the value of URL parameters. When called, <code>useParams()</code> provides an object that maps the names of URL parameters to their values in the current URL.
For example, in our router configuration, say we've had a dynamic route:
<pre><code class="hljs">&lt;Route path=&quot;/about/:user_id&quot;&gt;
 &lt;About /&gt;
&lt;/Route&gt;
</code></pre>
And on another page, we have a link component that points to some information pertaining to User 2:
<pre><code class="hljs">&lt;Link to=&quot;/about/2&quot;&gt;About User 2&lt;/Link&gt;
</code></pre>
When parameters are passed, like we've seen before - we can access the parameters via the <code>userParams()</code> hook:
<pre><code class="hljs">import { useParams } from &quot;react-router-dom&quot;;

const About = () =&gt; {
 const { user_id } = useParams();

 return (
 &lt;div&gt;
 &lt;h1&gt;About user {user_id}&lt;/h1&gt;
 &lt;p&gt;
 Lorem ipsum dolor...
 &lt;/p&gt;
 &lt;/div&gt;
 );
};

export default About;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
React Router is used for Client-Side Routing of resources. In this guide, we've taken a quick look at how you can programmatically navigate an application using React Router as well as how to transfer states between routes when you do.

In this guide, learn how to create routes, programmatically navigate, send and receive data using React Router in JavaScript, with practical examples.

Programmatically Navigate Using React Router

Marcus Sanatan

Mohammad Waseem

In this practical guide, learn how to perform object detection on images, real-time videos and video streams in Python with OpenCV and Haar-Cascade Classifiers!

Object Detection with OpenCV-Python Using a Haar-Cascade Classifier

<h2 id="introduction">Introduction</h2>
Counting the word frequency in a list element in Python is a relatively common task - especially when creating distribution data for <a target="_blank" href="https://stackabuse.com/matplotlib-histogram-plot-tutorial-and-examples/">histograms</a>.
Say we have a list <code>['b', 'b', 'a']</code> - we have two occurrences of &quot;b&quot; and one of &quot;a&quot;. This guide will show you three different ways to count the number of word occurrences in a Python list:
<ul>
<li>Using Pandas and NumPy</li>
<li>Using the <code>count()</code> Function</li>
<li>Using the Collection Module's <code>Counter</code></li>
<li>Using a Loop and a Counter Variable</li>
</ul>
In practice, you'll use Pandas/NumPy, the <code>count()</code> function or a <code>Counter</code> as they're pretty convenient to use.
<h2 id="usingpandasandnumpy">Using Pandas and NumPy</h2>
The shortest and easiest way to get value counts in an easily-manipulable format (<code>DataFrame</code>) is via NumPy and Pandas. We can wrap the list into a NumPy array, and then call the <code>value_counts()</code> method of the <code>pd</code> instance (which is also available for all <code>DataFrame</code> instances):
<pre><code class="hljs">import numpy as np
import pandas as pd

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

pd.value_counts(np.array(words))
</code></pre>
This results in a <code>DataFrame</code> that contains:
<pre><code class="hljs">hello 3
goodbye 1
bye 1
howdy 1
hi 1
dtype: int64
</code></pre>
You can access its <code>values</code> field to get the counts themselves, or <code>index</code> to get the words themselves:
<pre><code class="hljs">df = pd.value_counts(np.array(words))

print(&#x27;Index:&#x27;, df.index)
print(&#x27;Values:&#x27;, df.values)
</code></pre>
This results in:
<pre><code class="hljs">Index: Index([&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;bye&#x27;, &#x27;howdy&#x27;, &#x27;hi&#x27;], dtype=&#x27;object&#x27;)

Values: [3 1 1 1 1]
</code></pre>
<h2 id="usingthecountfunction">Using the count() Function</h2>
The &quot;standard&quot; way (no external libraries) to get the count of word occurrences in a list is by using the list object's <code>count()</code> function.
The <code>count()</code> method is a built-in function that takes an element as its only argument and returns the number of times that element appears in the list.
<blockquote>
The complexity of the <code>count()</code> function is O(n), where <code>n</code> is the number of factors present in the list.
</blockquote>
The code below uses <code>count()</code> to get the number of occurrences for a word in a list:
<pre><code class="hljs">words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

print(f&#x27;&quot;hello&quot; appears {words.count(&quot;hello&quot;)} time(s)&#x27;)
print(f&#x27;&quot;howdy&quot; appears {words.count(&quot;howdy&quot;)} time(s)&#x27;)
</code></pre>
This should give us the same output as before using loops:
<pre><code class="hljs">&quot;hello&quot; appears 3 time(s)
&quot;howdy&quot; appears 1 time(s)
</code></pre>
The <code>count()</code> method offers us an easy way to get the number of word occurrences in a list for each individual word.
<h2 id="usingthecollectionmodulescounter">Using the Collection Module's Counter</h2>
The <code>Counter</code> class instance can be used to, well, count instances of other objects. By passing a list into its constructor, we instantiate a <code>Counter</code> which returns a dictionary of all the elements and their occurrences in a list.
From there, to get a single word's occurrence you can just use the word as a key for the dictionary:
<pre><code class="hljs">from collections import Counter

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

word_counts = Counter(words)

print(f&#x27;&quot;hello&quot; appears {word_counts[&quot;hello&quot;]} time(s)&#x27;)
print(f&#x27;&quot;howdy&quot; appears {word_counts[&quot;howdy&quot;]} time(s)&#x27;)
</code></pre>
This results in:
<pre><code class="hljs">&quot;hello&quot; appears 3 time(s)
&quot;howdy&quot; appears 1 time(s)
</code></pre>
<h2 id="usingaloopandacountervariable">Using a Loop and a Counter Variable</h2>
Ultimately, a brute force approach that loops through every word in the list, incrementing a counter by one when the word is found, and returning the total word count will work!
Of course, this method gets more inefficient as the list size grows, it's just conceptually easy to understand and implement.
The code below uses this approach in the <code>count_occurrence()</code> method:
<pre><code class="hljs">def count_occurrence(words, word_to_count):
 count = 0
 for word in words:
 if word == word_to_count:
 # update counter variable
 count = count + 1
 return count


words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]
print(f&#x27;&quot;hello&quot; appears {count_occurrence(words, &quot;hello&quot;)} time(s)&#x27;)
print(f&#x27;&quot;howdy&quot; appears {count_occurrence(words, &quot;howdy&quot;)} time(s)&#x27;)
</code></pre>
If you run this code you should see this output:
<pre><code class="hljs">&quot;hello&quot; appears 3 time(s)
&quot;howdy&quot; appears 1 time(s)
</code></pre>
Nice and easy!
<h2 id="mostefficientsolution">Most Efficient Solution?</h2>
Naturally - you'll be searching for the most efficient solution if you're dealing with a large corpora of words. Let's benchmark all of these to see how they perform.
The task can be broken down into finding occurrences for all words or a single word, and we'll be doing benchmarks for both, starting with all words:
<pre><code class="hljs">import numpy as np
import pandas as pd
import collections

def pdNumpy(words):
 def _pdNumpy():
 return pd.value_counts(np.array(words))
 return _pdNumpy

def countFunction(words):
 def _countFunction():
 counts = []
 for word in words:
 counts.append(words.count(word))
 return counts
 return _countFunction

def counterObject(words):
 def _counterObject():
 return collections.Counter(words)
 return _counterObject
 
import timeit

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

print(&quot;Time to execute:\n&quot;)
print(&quot;Pandas/NumPy: %ss&quot; % timeit.Timer(pdNumpy(words)).timeit(1000))
print(&quot;count(): %ss&quot; % timeit.Timer(countFunction(words)).timeit(1000))
print(&quot;Counter: %ss&quot; % timeit.Timer(counterObject(words)).timeit(1000))
</code></pre>
Which results in:
<pre><code class="hljs">Time to execute:

Pandas/NumPy: 0.33886080000047514s
count(): 0.0009540999999444466s
Counter: 0.0019409999995332328s
</code></pre>
The <code>count()</code> method is extremely fast compared to the other variants, however, it doesn't give us the labels associated with the counts like the other two do.
If you need the labels - the <code>Counter</code> outperforms the inefficient process of wrapping the list in a NumPy array and then counting.
On the other hand, you can make use of DataFrame's methods for sorting or other manipulation that you can't do otherwise. <code>Counter</code> has some unique methods as well.
Ultimately, you can use the <code>Counter</code> to create a dictionary and turn the dictionary into a <code>DataFrame</code> as as well, to leverage the speed of <code>Counter</code> and the versatility of <code>DataFrame</code>s:
<pre><code class="hljs">df = pd.DataFrame.from_dict([Counter(words)]).T
</code></pre>
If you don't need the labels - <code>count()</code> is the way to go.
Alternatively, if you're looking for a single word:
<pre><code class="hljs">import numpy as np
import pandas as pd
import collections

def countFunction(words, word_to_search):
 def _countFunction():
 return words.count(word_to_search)
 return _countFunction

def counterObject(words, word_to_search):
 def _counterObject():
 return collections.Counter(words)[word_to_search]
 return _counterObject

def bruteForce(words, word_to_search):
 def _bruteForce():
 counts = []
 count = 0
 for word in words:
 if word == word_to_search:
 # update counter variable
 count = count + 1
 counts.append(count)
 return counts
 return _bruteForce
 
import timeit

words = [&#x27;hello&#x27;, &#x27;goodbye&#x27;, &#x27;howdy&#x27;, &#x27;hello&#x27;, &#x27;hello&#x27;, &#x27;hi&#x27;, &#x27;bye&#x27;]

print(&quot;Time to execute:\n&quot;)
print(&quot;count(): %ss&quot; % timeit.Timer(countFunction(words, &#x27;hello&#x27;)).timeit(1000))
print(&quot;Counter: %ss&quot; % timeit.Timer(counterObject(words, &#x27;hello&#x27;)).timeit(1000))
print(&quot;Brute Force: %ss&quot; % timeit.Timer(bruteForce(words, &#x27;hello&#x27;)).timeit(1000))
</code></pre>
Which results in:
<pre><code class="hljs">Time to execute:

count(): 0.0001573999998072395s
Counter: 0.0019498999999996158s
Brute Force: 0.0005682000000888365s
</code></pre>
The brute force search and <code>count()</code> methods outperform the <code>Counter</code>, mainly because the <code>Counter</code> inherently counts all words instead of one.
<h2 id="conclusion">Conclusion</h2>
In this guide, we explored finding the occurrence of the word in a Python list, assessing the efficiency of each solution and weighing when each is more suitable.

Guest Contributor

In this tutorial, we'll learn how to count the number of times a word occurred in a list in Python using Pandas/Numpy, the count() function, a for loop, and the Counter() function of the collections module and benchmark them.

Count Number of Word Occurrences in List Python

Joseph Eshiett

In this guide, we’ll take a look at extracting and parsing data from XML files with BeautifulSoup and lxml. Let's practice by parsing an RSS feed and saving it to a CSV file.

Parsing XML with BeautifulSoup in Python

<h2 id="introduction">Introduction</h2>
In this short guide, we'll cover all necessary aspects of sorting an array by date in JavaScript.
The array data structure in JavaScript has a built-in <code>sort()</code> method, but it is not designed to be used to sort an array by date. There are a lot of different date formats and we need to make the sorting work no matter the format used to represent a date.
Firstly, let's go into some basic concepts and constraints that we need to understand to be able to alter the <code>sort()</code> method so that it can sort the elements of an array by date, and then we'll show some practical examples that explain how sorting by dates works.

 <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: In this guide, we'll be sorting an array of dates, but the same rules apply in the case of sorting an array of objects containing a date property

 </div>
 </div>
 </div>
 <h2 id="javascriptssortmethod">JavaScript's sort() method</h2>
As previously mentioned, the <code>Array</code> data structure in JavaScript has a built-in <code>sort()</code> method used to sort the elements of an array. The <code>sort()</code> method works by converting the elements into strings and sorting those string representations of elements lexicographically in ascending order.
Another important fact to keep in mind is that the <code>sort()</code> method sorts elements in-place, meaning that it alters the original array:
<pre><code class="hljs">const exampleArray = [&#x27;bbb&#x27;, &#x27;aa&#x27;, &#x27;ddd&#x27;, &#x27;c&#x27;];
exampleArray.sort();
console.log(exampleArray);
// Outputs: [&#x27;aa&#x27;, &#x27;bbb&#x27;, &#x27;c&#x27;, &#x27;ddd&#x27;]
</code></pre>
Obviously, the <code>sort()</code> method is designed to work with strings, but it is not designed to work with dates. For example, let's assume that we want to sort the following array of dates:
<pre><code class="hljs">const dates = [&#x27;Mar 16 2017&#x27;, &#x27;Jan 22 2021&#x27;, &#x27;Dec 31 2000&#x27;];
dates.sort();
console.log(dates);
</code></pre>
The desired output will be an array sorted by dates in ascending order:
<pre><code class="hljs">[&#x27;Dec 31 2000&#x27;, &#x27;Mar 16 2017&#x27;, &#x27;Jan 22 2021&#x27;]
</code></pre>
But the actual output will be:
<pre><code class="hljs">[&#x27;Dec 31 2000&#x27;, &#x27;Jan 22 2021&#x27;, &#x27;Mar 16 2017&#x27;]
</code></pre>
This happens because the <code>sort()</code> method works by sorting the string representations of elements, not the actual elements.
For instance, <code>D</code> from <code>'Dec 31 2000'</code> is lexicographically lesser than <code>J</code> from <code>'Jan 22 2021'</code> and so on. This undesired behavior is the same no matter the date format, therefore, we need to find a way to alter the <code>sort()</code> method to make it suitable for sorting dates.
<h2 id="primerondatesinjavascript">Primer on Dates in JavaScript</h2>
In order to know how to sort an array by date in JavaScript, firstly, we need to understand how JavaScript represents dates.
In short, the structure used to represent dates in JavaScript is a <code>Date</code> object, it does so by storing a <code>Number</code> that represents the number of milliseconds since 1 January 1970.
There are four ways of creating a <code>Date</code> object, but, in essence, all of them store the date as the <code>Number</code>, as previously described:
<pre><code class="hljs">// Blank constructor - the current date and time
const now = new Date();

// Date string as the argument
const exampleDate1 = new Date(dateString);

// Number of milliseconds since 1 Jan 1970 as the argument
const exampleDate2 = new Date(milliseconds);

// Year, month, ... as the argument
const exampleDate3 = new Date(year, month, day, hour, minute, second, millisecond);
</code></pre>
Due to the nature of the problem of sorting an array by date, we'll use the second way, passing the string representation of the date in the <code>Date</code> constructor. Generally speaking, there are 3 formats of strings that are used to represent dates:
<table class="table table-striped">
 <thead>
 <td>Name</td>
 <td>Format</td>
 <td>Example</td>
 <td>Browser Independent</td>
 </thead>
 <tr>
 <td>ISO Date</td>
 <td>YYYY-MM-DD</td>
 <td>"2017-09-24"</td>
 <td>**Yes** (strictly defined by ISO standard)</td>
 </tr>
 <tr>
 <td>Short Date</td>
 <td>MM/DD/YYYY</td>
 <td>"09/24/2017"</td>
 <td>**No** (may vary on different browsers)</td>
 </tr>
 <tr>
 <td>Long Date</td>
 <td>DD Month YYYY</td>
 <td>"24 September 2017"</td>
 <td>**No** (may vary on different browsers)</td>
 </tr>
</table>
So, if we want to create a <code>Date</code> object for the 24th of September 2017, we'll do so in one of the following ways:
<pre><code class="hljs">const date = new Date(&quot;2017-09-24&quot;);
// Or
const date = new Date(&quot;09/24/2017&quot;);
// Or
const date = new Date(&quot;24 September 2017&quot;);
</code></pre>
All of these will represent the exact same date (the same number of milliseconds since 1 January 1970).
<h2 id="howtosortanarraybydateinjavascriptstringrepresentation">How to Sort an Array by Date in JavaScript (String Representation)</h2>
Now that we know how does the <code>Date</code> object and <code>sort()</code> method work, we can explain how to use the <code>sort()</code> method to sort an array by a date.
Firstly, let's assume that we need to sort an array of dates:
<pre><code class="hljs">// [&#x27;16 March 2017&#x27;, &#x27;22 January 2021&#x27;, &#x27;31 December 2000&#x27;]
const dates = [&#x27;16 March 2017&#x27;, &#x27;01/22/2021&#x27;, &#x27;2000-12-31&#x27;];
</code></pre>
As we can see, elements of the <code>dates</code> array are string representations of some dates. As we've discussed before, simply using the <code>sort()</code> method on <code>dates</code> won't produce the desired output, so we need to alter it to make it suitable for sorting dates. We'll do so by creating an appropriate custom comparison function and passing it to the <code>sort()</code> method.

 <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">
 A comparison function, in simple terms, is a function that accepts two arguments (numbers) and returns positive, negative, or zero values. It is used to define the sorting order in a <code>sort()</code> method.

 </div>
 </div>
 </div>
 For example, the following comparison function will be used for sorting elements in ascending order:
<pre><code class="hljs">function(a, b){
 return a - b;
}
</code></pre>
The following rules apply to the sorting order based on the return value of a compare function:
<table class="table table-striped">
 <thead>
 <td>Return value</td>
 <td>Sorting order</td>
 </thead>
 <tr>
 <td>Positive</td>
 <td>b before a</td>
 </tr>
 <tr>
 <td>Zero</td>
 <td>same</td>
 </tr>
 <tr>
 <td>Negative</td>
 <td>a before b</td>
 </tr>
</table>
The comparison function that will be able to sort dates must firstly convert string representations of dates into <code>Date</code> objects and then compare two dates in the desired way. Thankfully, the <code>Date</code> constructor accepts a wide variety of formats, and can translate them to an easily comparable format:
<pre><code class="hljs">function(a, b){
 // Convert string dates into `Date` objects
 const date1 = new Date(a);
 const date2 = new Date(b);
 
 return date1 - date2;
}
</code></pre>
For sorting in descending order, the only change we need to make is to swap places of <code>date1</code> and <code>date2</code> in the return statement:
<pre><code class="hljs">return date2 - date1;
</code></pre>
When we've created the appropriate comparison function, the only thing left to do is to pass it to the <code>sort()</code> method in order for it to be able to sort dates:
<pre><code class="hljs">dates.sort(function(a, b){
 const date1 = new Date(a)
 const date2 = new Date(b)
 
 return date1 - date2;
})
</code></pre>
Alternatively, you can define the function as a non-anonymous function and pass it that way:
<pre><code class="hljs">function dateComparison(a, b) {
 const date1 = new Date(a)
 const date2 = new Date(b)
 
 return date1 - date2;
}

dates.sort(dateComparison);
console.log(dates);
</code></pre>
Now, the <code>dates</code> array is sorted in the ascending order:
<pre><code class="hljs">[&#x27;2000-12-31&#x27;, &#x27;16 March 2017&#x27;, &#x27;01/22/2021&#x27;]
</code></pre>
<h2 id="howtosortanarraybydateinjavascriptdateobjects">How to Sort an Array by Date in JavaScript (Date Objects)</h2>
The simpler version of this problem is the case where the <code>dates</code> array is already an array of <code>Date</code> objects. In that case, the simplest compare function will do the job:
<pre><code class="hljs">const date1 = new Date(&#x27;16 March 2017&#x27;);
const date2 = new Date(&#x27;01/22/2021&#x27;);
const date3 = new Date(&#x27;2000-12-31&#x27;);
const dates = [date1, date2, date3];

dates.sort(function(a, b){
 return a - b 
});

console.log(dates);
</code></pre>
The output will be:
<pre><code class="hljs">[&#x27;2000-12-31&#x27;, &#x27;16 March 2017&#x27;, &#x27;01/22/2021&#x27;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've discussed the important facts about sorting an array by date. Finishing it, you should have the knowledge of sorting arrays, <code>Date</code> objects, and you are able to combine what you have learned to sort an array of dates in the desired order.

Dimitrije Stamenic

In this short guide, learn how to sort an array in JavaScript for both string representations and date objects with a custom comparator function and practical code examples.

How to Sort an Array by Date in JavaScript

<h2 id="introduction">Introduction</h2>
Whether you are creating a registration form for your website or you just need to delete all invalid email addresses from your mailing list, you can't help but perform the process of email validation.
<blockquote>
You need to validate if an email address is real by checking whether it meets the required form and can receive email messages. That must be performed efficiently and safely.
</blockquote>
That is where <code>email-validator</code> comes in. It is an easy to use, yet robust, Python library used to validate email addresses.
In this guide, we'll go over the basics of this library, discover when and why you could use it, as well as when not to. We'll go over these with practical examples that will help you understand how to use <code>email-validator</code>.
<h2 id="whatisemailvalidator">What is email-validator?</h2>
As we've previously stated, <code>email-validator</code> is a robust Python library that validates email addresses. It performs two types of validation - syntax validation and deliverability validation. That is important because the email address must meet the required form and have a resolvable domain name at the same time to be considered valid.

 <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">
 Syntax validation ensures that a string representation of an email address is of the form , such as <code>example@stackabuse.com</code>. 
Deliverability validation ensures that the syntactically correct email address has the domain name (the string after the <code>@</code> sign - <code>stackabuse.com</code>) that can be resolved.

 </div>
 </div>
 </div>
 In simple terms, it ensures that the validated email address can send and receive email messages.
On top of that, <code>email-validator</code> has a small bonus for us, if the email address is valid, <code>email-validator</code> can return its normalized form, so that we can store it in a database in a proper way. On the other hand, if an email address is invalid, <code>email-validator</code> will give us a clear and human-readable error message to help us understand why the passed email address is not valid.

 <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">
 In its simplest form, the normalization of an email address implies lowercasing the domain of an email address (the sequence after the <code>@</code> sign), because it is case-insensitive.

 </div>
 </div>
 </div>
 In more complex cases of normalization, where the domain part includes some Unicode characters, normalization covers a variety of conversions between Unicode and ASCII characters. The problem lies in the fact that different Unicode strings can look and mean the same to the end-user, so the normalization should ensure that those strings will be recorded in the same way because they actually represent the same domain.
It is important to mention that this library is not designed to work with an email address that doesn't meet the form of <code>example@domainname.com</code>.
<blockquote>
For example, it won't properly validate the <code>To:</code> line in an email message (for example, <code>To: Example Name &lt;example@domainname.com&gt;</code>).
</blockquote>
<h2 id="emailvalidatorvsregexforemailvalidation">email-validator vs RegEx for Email Validation</h2>
We usually use some kind of Regular Expression (RegEx) to validate the correct form of email addresses and it is a great choice if you only need to make sure that some email address meets the required form. It is a well-known technique, easy to write and maintain, and doesn't consume too much computing power to execute.
<blockquote>
If you'd like to read more about validating email addresses with RegEx - read our <a target="_blank" href="https://stackabuse.com/python-validate-email-address-with-regular-expressions-regex/">Python: Validate Email Address with Regular Expressions</a>!
</blockquote>
On the other hand, email address validation sometimes can be a lot more complex. A string containing an email address may meet the specified form of an email address, but still cannot be considered a proper email address, because the domain doesn't resolve.
<blockquote>
For instance, <code>example@ssstackabuse.com</code> meets the specified form of an email address, but isn't valid because the domain name (<code>ssstackabuse.com</code>) doesn't exist, therefore doesn't resolve and the example email address can't send and receive email messages.
</blockquote>
On the other hand, <code>example@stackabuse.com</code>, meets both requirements for a valid email address. It meets the desired form and the domain name resolves. Therefore, it can be considered a valid email address.
In that case, the <code>email-validator</code> provides a superior solution - it performs both syntax and deliverability validation with one simple function call, so there is no need to bother with making sure that the email address can actually send and receive emails. It would be impossible to code both of those verifications using just Regular Expressions.

 <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: It's factually impossible to guarantee whether an email will be received, or not, without sending an email and observing the result. You can, however, check if it could receive an email as a categorical possibility.

 </div>
 </div>
 </div>
 Those two things make a strong case in favor of <code>email-validator</code> against Regular Expressions. It is easier to use and still can perform more tasks more efficiently.
<h2 id="howtoinstallemailvalidator">How to Install email-validator?</h2>
The <code>email-validator</code> library is available on PyPI, so the installation is pretty straightforward via <code>pip</code> or <code>pip3</code>:
<pre><code class="hljs">$ pip install email-validator
$ pip3 install email-validator
</code></pre>
And now you have the <code>email-validator</code> ready to use in a Python script.
<h2 id="validateemailaddresswithemailvalidator">Validate Email Address with email-validator?</h2>
The core of the <code>email-validator</code> library is its <code>validate_email()</code> method. It takes a string representation of an email address as the argument and performs validation on that address. If the passed email address is valid, the <code>validate_email()</code> method will return an object containing a normalized form of the passed email address, but in the case of an invalid email address, it will raise the <code>EmailNotValidError</code> with a clear and human-readable error message that will help us understand why the passed email address is not valid.
<code>EmailNotValidError</code> is actually just an abstract class, which is used to detect that an error in a validation process occurred, hence, it is not used to represent and describe actual errors.
For that purpose, <code>EmailNotValidError</code> class has two subclasses describing actual errors that occurred. The first one is <code>EmailSynaxError</code> which is raised when a syntax validation fails, meaning that the passed email doesn't meet the required form of an email address. The second one is <code>EmailUndeliverableError</code> which is raised when a deliverability validation fails, meaning that the domain name of the passed email address doesn't exist.
Now we can finally take a look at how to use the <code>validate_email()</code> method. Of course, the first step is to import it to our script, and then we are ready to use it:
<pre><code class="hljs">from email_validator import validate_email

testEmail = &quot;example@stackabuse.com&quot;

emailObject = validate_email(testEmail)
print(emailObject.email)
</code></pre>
Since the passed <code>testEmail</code> is a valid email address, the previous code will output the normalized form of the email address stored in <code>testEmail</code> variable:
<pre><code class="hljs">example@stackabuse.com
</code></pre>

 <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: In the previous example, the output is the same as the original address from the <code>testEmail</code> because it was originally normalized. If you pass the unnormalized form of an email to the <code>validate_email()</code> method, the returned email address will be normalized, as expected.

 </div>
 </div>
 </div>
 If we change the original <code>testEmail</code> to <code>&quot;example@STACKabuse.com&quot;</code>, the previous code will still have the same output, because it's normalized:
<pre><code class="hljs">example@stackabuse.com
</code></pre>
On the other hand, if we pass the invalid email address to the <code>validate_email()</code> method, the previous code will prompt us with the corresponding error message. The following example of <code>testEmail</code> will pass the syntax validation, but fail the deliverability validation because the domain <code>ssstackabuse.com</code> doesn't exist:
<pre><code class="hljs">testEmail = &quot;example@ssstackabuse.com&quot;
</code></pre>
In this case, the previous code will prompt a long error amongst which is:
<pre><code class="hljs">&gt;&gt; ...
&gt;&gt; raise EmailUndeliverableError(&quot;The domain name %s does not exist.&quot; % domain_i18n)
email_validator.EmailUndeliverableError: The domain name ssstackabuse.com does not exist.
</code></pre>
Based on this prompt, we can conclude that the passed email is invalid because its domain name does not exist. The corresponding messages will also be prompted in the case of syntactically invalid emails so that we can easily conclude that the passed email address doesn't meet the required form of an email address.
You could extract a more user-friendly and human-readable error message from this as well, automatically. To extract just the error message from the previous prompt, we need to rewrite the previous code as follows:
<pre><code class="hljs">from email_validator import validate_email, EmailNotValidError

testEmail = &quot;examplestackabuse.com&quot;

try:
 # Validating the `testEmail`
 emailObject = validate_email(testEmail)

 # If the `testEmail` is valid
 # it is updated with its normalized form
 testEmail = emailObject.email
 print(testEmail)
except EmailNotValidError as errorMsg:
 # If `testEmail` is not valid
 # we print a human readable error message
 print(str(errorMsg))
</code></pre>
This code will output just a simple error message extracted from the previous prompt:
<pre><code class="hljs">The domain name ssstackabuse.com does not exist.
</code></pre>

 <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: We've taken advantage of the <code>EmailNotValidError</code> class. We've tried to execute the email validation in the <code>try</code> block and ensured that the error will be caught in the <code>except</code> block in case of failing the validation. There is no need to catch <code>EmailSyntaxError</code> or <code>EmailUndeliverableError</code> individually, because both of them are subclasses of the caught <code>EmailNotValidError</code> class, and the type of error can be easily determined by the printed error message.

 </div>
 </div>
 </div>
 <h3 id="validate_emailoptionalarguments">validate_email() - Optional Arguments</h3>
By default, the <code>validate_email()</code> method accepts only one argument - the string representation of the email address that needs to be validated, but can accept a few other keyword arguments:
<ul>
<li>allow_smtputf8 - the default value is <code>True</code>, if set to <code>False</code> the <code>validate_email()</code> won't validate internationalized email addresses, just ones that have a domain name consisting of ASCII characters only (no UTF-8 characters are allowed in a domain name in that case).</li>
<li>check_deliverability - the default value is <code>True</code>, if set to <code>False</code>, no deliverability validation is performed .</li>
<li>allow_empty_local - the default value is <code>False</code>, if set to <code>True</code>, the empty local part of an email address will be allowed (i.e. <code>@stackabuse.com</code> will be considered as the valid email address).</li>
</ul>
<h3 id="thevalidatedemailobject">The ValidatedEmail Object</h3>
You've probably noticed that we've been accessing the normalized form of an email address by <code>emailObject.email</code>. That is because the <code>validate_email()</code> method returns the <code>ValidatedEmail</code> object (in previous examples, it was stored in the <code>emailObject</code> variable) when a valid email address is passed as the argument.
The <code>ValidatedEmail</code> object contains multiple attributes which describe different parts of the normalized email address. The <code>email</code> attribute contains the normalized form of the validated email address, therefore, we need to access it using the <code>.</code> notation - <code>emailObject.email</code>.
<blockquote>
Generally, we can access any attribute of the <code>ValidatedEmail</code> object by using <code>variableName.attributeName</code> (where <code>variableName</code> is the variable used to store the <code>ValidatedEmail</code> object).
</blockquote>
For example, let's say that we've validated the <code>example@sTaCkABUSE.cOm</code> with the <code>validate_email()</code> method. The resulting <code>ValidatedEmail</code> object will contain some interesting and useful attributes as described in the following table:
<table class='table table-striped'>
<thead>
<tr>
<th align="center">Attribute Name</th>
<th>Example Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td align="center">email</td>
<td>example@stackabuse.com</td>
<td>Normalized form of an email address.</td>
</tr>
<tr>
<td align="center">ascii_email</td>
<td>example@stackabuse.com</td>
<td>ASCII only form of <code>email</code> attribute. If the <code>local_part</code> contains any kind of internationalized characters, this attribute will be set to <code>None</code>.</td>
</tr>
<tr>
<td align="center">local_part</td>
<td>example</td>
<td>The string before the <code>@</code> sign in the normalized form of the email address.</td>
</tr>
<tr>
<td align="center">ascii_local_part</td>
<td>example</td>
<td>If there are no internationalized characters, this attribute is set to ASCII only form of <code>local_part</code> attribute. Otherwise, it is set to <code>None</code>.</td>
</tr>
<tr>
<td align="center">domain</td>
<td>stackabuse.com</td>
<td>The string after the <code>@</code> sign in the normalized form of the email address. If it contains non-ASCII characters, the <code>smptutf8</code> attribute must be <code>True</code>.</td>
</tr>
<tr>
<td align="center">ascii_domain</td>
<td>stackabuse.com</td>
<td>ASCII only form of <code>domain</code> attribute.</td>
</tr>
<tr>
<td align="center">smtputf8</td>
<td>True</td>
<td>A boolean value. If the <code>allow_smtputf8=False</code> argument is passed to the <code>validate_email()</code> method, this argument is <code>False</code> and <code>True</code> otherwise.</td>
</tr>
</tbody>
</table>

 <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: ASCII variants of mentioned attributes are generated using the Punycode encoding syntax. It is an encoding syntax used to transform a Unicode string into an ASCII string for use with Internationalized Domain Names in Applications (IDNA).

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
All in all, the <code>email-validator</code> is a great tool for validating email addresses in Python.
In this guide, we've covered all the important aspects of using this library, so that you have a comprehensive view of it. You should be able to understand when and how to use the <code>email-validator</code>, as well as when to pick some alternative tool.

In this guide, learn how to validate email addresses in Python with email-validator - checking their syntax and deliverability in one method, as well as how to handle errors and extract meaningful messages through practical examples.

Validate Email Addresses in Python with email-validator

<h2 id="introduction">Introduction</h2>
Reversing a string isn't uncommon in development, and fairly popular for entry-level interview questions. With JavaScript, we have many ways to reverse a string, which is somewhat similar to <a target="_blank" href="https://stackabuse.com/reverse-an-array-or-list-in-javascript/">reversing an array</a>. We can use a combination of string's <code>split()</code> method as well as array's <code>reverse()</code> and <code>join()</code> methods (since strings are ultimately arrays of characters).
We can also reverse a string with our own iterative (loop) or recursive functions.
<blockquote>
In this guide, we'll take a look at several ways to reverse a string in JavaScript.
</blockquote>
<h2 id="usingbuiltinmethodstoreversethestringsplitreverseandjoin">Using Built-in Methods to Reverse the String - split(), reverse() and join()</h2>
The simplest way to reverse a string in JavaScript is to split a string into an array, <code>reverse()</code> it and <code>join()</code> it back into a string. With ES6, this can be shortened and simplified down to:
<pre><code class="hljs">let string = &quot;!onaiP&quot;
string = [...string].reverse().join(&quot;&quot;);

console.log(string); // &quot;Piano!&quot;
</code></pre>
Here, the <a target="_blank" href="https://stackabuse.com/spread-operator-in-javascript/">Spread Syntax</a> is used to split the string into an array and is functionally equivalent to the <code>split()</code> method, which you could also use instead.
To understand why they all work together, let's overview what each function does.
<h3 id="split">split()</h3>
The <code>split()</code> method returns a new array of strings after splitting a string with the provided separator:
<pre><code class="hljs">string.split(separator, limit)
</code></pre>
The <code>separator</code> defines where the string splits into an element in the resulting array. We can define the number of the array element with the <code>limit</code> parameter. When we use the <code>split()</code> method with an empty string, <code>''</code>, the string will be split on every character. It will come in handy when we convert our string into an array of individual characters.
Again, you can use the spread operator to achieve the same result. The spread operator is a JavaScript operator that works on the iterables like an array, string, and objects. We can copy and concatenate objects and arrays using the spread operator:
<pre><code class="hljs">[...myVar, 4, 5, 6] // combines myVar array with the given elements
myFunc(...myVar) // Use the myVar&#x27;s elements as argument to the function
</code></pre>
When the spread operator is used with a string, the string is converted into a sequence of characters:
<pre><code class="hljs">let str = &#x27;hello&#x27;;
console.log([...str]); // [&quot;h&quot;,&quot;e&quot;,&quot;l&quot;,&quot;l&quot;,&quot;o&quot;]
console.log(str.split(&#x27;&#x27;)); // [&quot;h&quot;,&quot;e&quot;,&quot;l&quot;,&quot;l&quot;,&quot;o&quot;]
</code></pre>

 <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: While splitting UTF-16 characters, use the spread operator instead of the <code>split()</code> method.

 </div>
 </div>
 </div>
 <h3 id="reverse">reverse()</h3>
The <code>reverse()</code> returns a reversed array, in-place. That's to say - the original array is reversed instead of a copy that's returned as the result:
<pre><code class="hljs">let str = [&#x27;a&#x27;,&#x27;b&#x27;,&#x27;c&#x27;,&#x27;d&#x27;];
let reversedStr = str.reverse();
console.log(str); // [&quot;d&quot;,&quot;c&quot;,&quot;b&quot;,&quot;a&quot;]
console.log(reversedStr); // [&quot;d&quot;,&quot;c&quot;,&quot;b&quot;,&quot;a&quot;]
</code></pre>
You don't need to assign the result to a new variable, though, we commonly do in order to change the variable name to a more indicative one.
<h3 id="join">join()</h3>
The <code>join()</code> method concatenates the elements of an array and returns a string. We can also specify a <code>separator</code>, which is optional, to join the elements. When we use the default separator, the elements will be separated by a comma in the string. Using an empty string as the separator will concatenate the array elements and return as a string as usual:
<pre><code class="hljs">let str = [&#x27;a&#x27;,&#x27;b&#x27;,&#x27;c&#x27;,&#x27;d&#x27;];
console.log(str.join(&#x27;&#x27;)); // &quot;abcd&quot;
console.log(str.join()); // &quot;a,b,c,d&quot;
console.log(str.join(&#x27; - &#x27;)); // &quot;a - b - c - d&quot;
</code></pre>
<h3 id="combiningthebuiltinmethodstoreversethestring">Combining the Built-in Methods to Reverse the String</h3>
With all of that in mind - the way these work together becomes intuitive:
<pre><code class="hljs">let str = &#x27;guitar&#x27;;
console.log(&#x27;The original string is: &#x27; + str);
let splitStr = str.split(&#x27;&#x27;); // [&quot;g&quot;,&quot;u&quot;,&quot;i&quot;,&quot;t&quot;,&quot;a&quot;,&quot;r&quot;]
let reversedArr = splitStr.reverse();
let reversedStr = reversedArr.join(&#x27;&#x27;);
console.log(&quot;The reversed string is: &quot; + reversedStr);
</code></pre>
Or, you can shorten it down to:
<pre><code class="hljs">let reversedStr = [...str].reverse().join(&#x27;&#x27;);
// Or
let reversedStr = str.split(&#x27;&#x27;).reverse().join(&#x27;&#x27;);
</code></pre>
The code above results in:
<pre><code class="hljs">The original string is: guitar
The reversed string is: ratiug
</code></pre>
<h2 id="usingaforlooptoreversethestring">Using a for Loop to Reverse the String</h2>
With a for loop, we can iterate over each character from the string. Starting from the end of the string to the beginning of the string - we can continuously append the characters to a new string and thus form a reversed string:
<pre><code class="hljs">const str = &#x27;guitar&#x27;;
console.log(&#x27;The original string is: &#x27; + str);
let reversedStr = &#x27;&#x27;;

for (let i = str.length - 1; i &gt;= 0; i--) {
 reversedStr += str[i];
}

console.log(&#x27;The reversed string is: &#x27; + reversedStr);
</code></pre>
Here, we created an empty string, <code>reversedStr</code>, to hold the reversed string. String indices are like array indices, they start at 0. Therefore, we started the loop from one less than the length of the string (picking up the letter <code>r</code>) and loop till our counter goes to 0 (with the letter <code>g</code>).
The <code>reversedStr</code> variable concatenates the elements of the string.
Running the code gives us this output:
<pre><code class="hljs">The original string is: guitar
The reversed string is: ratiug
</code></pre>
<h2 id="usingrecursiontoreversethestring">Using Recursion to Reverse the String</h2>
Recursion is a process where a function calls itself. However, a function that calls itself may end up calling itself infinitely, and the process will never end without an exit condition. Therefore, we provide a condition, namely the base condition, to end the recursive behavior of the function.

 <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">
 We can use recursion to solve problems by writing very few lines of code without the hassle of iterating. However, this process can be slow if the recursion depth is high.

 </div>
 </div>
 </div>
 The syntax of a generic recursive function looks like this:
<pre><code class="hljs">function recursion(){
 .......
 base condition
 recursion()
 .......
}

recursion()
</code></pre>
When the <code>recursion()</code> function is called, it first checks some condition, and if evaluated to <code>true</code> - the function calls itself. This process is then repeated, again, and again. When the condition fails, the recursion is stopped, and the function returns a value.
<blockquote>
We can use recursion to reverse a string in JavaScript using some string methods like <code>substring()</code> and <code>charAt()</code>.
</blockquote>
The <code>substring()</code> method extracts a part of the string. We can pass the start and end indices in the method as the parameters. If only the start index is supplied to the method - it will extract the string from that index until the last one.
But, when we supply both the start and the end index, it will extract the string from the start index but does not include the end index:
<pre><code class="hljs">let str = &#x27;hello&#x27;
console.log(str.substring(1)) //&quot;ello&quot;
console.log(str.substring(1,3)) //&quot;el&quot;
</code></pre>
The <code>charAt()</code> method extracts the indexed character from a string. It returns a new string consisting of the character. An example of the method is shown below.
<pre><code class="hljs">let str = &#x27;hello&#x27;
console.log(str.charAt(2)) // &quot;l&quot;
</code></pre>
For our recursive function - we first check whether the string is empty as the base condition. After a series of recursive calls, the string will become empty, and the recursion will end. Inside the <code>reverse()</code> function, the recursive <code>reverse()</code> function is given <code>substring(1)</code> as its parameter.
The <code>charAt()</code> method is concatenated with the <code>reverse()</code> function in the return statement:
<pre><code class="hljs">function reverse(str) {
 if (str === &#x27;&#x27;)
 return &#x27;&#x27;;
 else
 return reverse(str.substring(1)) + str.charAt(0);
}

let str = &#x27;guitar&#x27;
console.log(&#x27;The original string is: &#x27; + str);
const output = reverse(str);
console.log(&#x27;The reversed string is: &#x27; + output);
</code></pre>
In the first recursive call, <code>reverse(&quot;guitar&quot;)</code> will result <code>reverse(&quot;uitar&quot;) + &quot;g&quot;</code>. In the second call, <code>reverse(&quot;uitar&quot;)</code> will result <code>reverse(&quot;itar&quot;) + &quot;u&quot;</code>. Likewise, the final recursive call, <code>reverse(&quot;o&quot;)</code> will return an <code>reverse(&quot;&quot;)+ &quot;r&quot;</code>.
Now the execution of the <code>else</code> part is terminated, and the recursion will travel back its depth. At the final call, the string <code>r</code> is added to <code>reverse('')</code>, which results in the string <code>r</code>.
Next, the function call moves one step above where the string <code>a</code> is added to <code>reverse(&quot;r&quot;)</code>. It makes the string <code>ra</code>. Likewise, <code>t</code> is added with <code>ra</code>, and it becomes <code>rat</code>. Similarly, the recursion depth is traversed upwards, and it finally returns the string <code>ratiug</code>:
<pre><code class="hljs">The original string is: guitar
The reversed string is: ratiug
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article we discussed how to reverse a string. We used the built-in <code>split()</code>, <code>reverse()</code> and <code>join()</code> methods, the spread operator, created a <code>for</code> loops that creates a new reversed string, and a recursive function using <code>substring()</code> and <code>charAt()</code> which all produced the same results.

In this article we reverse strings using the spread operator, built-in split(), reverse() and join() methods, creating for loops that creates a new reversed string, and a recursive function using substring() and charAt().