<h2 id="introduction">Introduction</h2>
Regular Expressions (RegEx) are a powerful tool and help us match patterns in a flexible, dynamic and efficient way, as well as to perform operations based on the results.
<blockquote>
In this short guide, we'll take a look at how to validate email addresses in Java with Regular Expressions.
</blockquote>
<blockquote>
If you'd like to read more about Regular Expressions and the <code>regex</code> package, read out <a target="_blank" href="https://stackabuse.com/guide-to-regular-expressions-in-java/">Guide to Regular Expressions in Java</a>!
</blockquote>
<h2 id="validatingemailaddressesinjava">Validating Email Addresses in Java</h2>
Validating email addresses isn't hard - there's not much diversity in the email world, though, there are a few ways you can go about it.
Regular Expressions are expressive so you can add more and more constraints based on how you want to validate the emails, just by adding more matching rules.
<blockquote>
Typically, you can boil things down to a pretty simple RegEx that will fit most email address patterns.
</blockquote>
You can disregard the organization type (<code>.com</code>, <code>.org</code>, <code>.edu</code>), host (<code>gmail</code>, <code>yahoo</code>, <code>outlook</code>), or other parts of an email address, or even enforce them.
In the proceeding sections, we'll take a look at a few different Regular Expressions, and which email formats they support or reject.
<h3 id="generalpurposeemailregularexpression">General-Purpose Email Regular Expression</h3>
A general purpose email format is:
<pre><code class="hljs">something@host.organizationtype
</code></pre>
The <code>organizationtype</code> is by convention, 3 characters - <code>edu</code>, <code>org</code>, <code>com</code>, etc. There are quite a few hosts, even custom ones, so really, this could be any sequence of characters - even <code>aaa</code>.
That being said, for pretty loose validation (but still a fully valid one) we can check whether the String contains 4 groups:
<ul>
<li>Any sequence of characters - name</li>
<li>The <code>@</code> symbol</li>
<li>Any sequence of characters - host</li>
<li>Any 2-3-character letter sequence - organization type (<code>io</code>, <code>com</code>, <code>etc</code>).</li>
</ul>
This nets us a Regular Expression that looks like:
<pre><code class="hljs">(.*)(@)(.*)(.[a-z]{2,3})
</code></pre>
To additionally make sure they don't contain any whitespaces at all, we can add a few <code>\S</code> checks:
<pre><code class="hljs">(\S.*\S)(@)(\S.*\S)(.\S[a-z]{2,3})
</code></pre>
That being said, to validate an email address in Java, we can simply use the <code>Pattern</code> and <code>Matcher</code> classes:
<pre><code class="hljs">String email = &quot;someone@gmail.com&quot;;

Pattern pattern = Pattern.compile(&quot;(\\S.*\\S)(@)(\\S.*\\S)(.\\S[a-z]{2,3})&quot;);
Matcher matcher = pattern.matcher(email);

if (matcher.matches()) {
 System.out.println(&quot;Full email: &quot; + matcher.group(0));
 System.out.println(&quot;Username: &quot; + matcher.group(1));
 System.out.println(&quot;Hosting Service: &quot; + matcher.group(3));
 System.out.println(&quot;TLD: &quot; + matcher.group(4));
}
</code></pre>
This results in:
<pre><code class="hljs">Full email: someone@gmail.com
Username: someone
Hosting Service: gmail
TLD: com
</code></pre>
Alternatively, you can use the built-in <code>matches()</code> method of the String class (which just uses a <code>Pattern</code> and <code>Matcher</code> anyway):
<pre><code class="hljs">String email = &quot;someone@gmail.com&quot;;

if(email.matches(&quot;(\\S.*\\S)(@)(\\S.*\\S)(.\\S[a-z]{2,3})&quot;)) {
 System.out.println(String.format(&quot;Email &#x27;%s&#x27; is valid!&quot;, email));
}
</code></pre>
Which results in:
<pre><code class="hljs">Email &#x27;someone@gmail.com&#x27; is valid!
</code></pre>
Awesome! This general-purpose RegEx will take care of pretty much all generic input and will check whether an email follows the generic form that all emails follow.
For the most part - this will work quite well, and you won't need much more than this. You won't be able to detect spam emails with this, such as:
<pre><code class="hljs">aaaaa@aaa.aaa
</code></pre>
However, you will enforce a certain form.

 <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: To enforce certain hosts or domains, simply replace the <code>.*</code> and/or <code>.[a-z]{2,3}</code> with actual values, such as <code>gmail</code>, <code>io</code> and <code>.edu</code>.

 </div>
 </div>
 </div>
 <h3 id="robustemailvalidationregex">Robust Email Validation Regex</h3>
What does a robust email RegEx look like? Chances are - you won't like it, unless you enjoy looking at Regular Expressions, which isn't a particularly common hobby.
Long story short, this is what it looks like:
<pre><code class="hljs">(?:[a-z0-9!#$%&amp;&#x27;*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&amp;&#x27;*+/=^_`{|}~-]+)*
|&quot;(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]
|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*&quot;)
@
(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?
|\[(?:(?:(2(5[0-5]|[0-4][0-9])
|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])
|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]
|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])
</code></pre>
<ul>
<li>Adapted RegEx by <a rel="nofollow noopener noreferrer" target="_blank" href="https://stackoverflow.com/users/15625/bortzmeyer">bortzmeyer</a></li>
</ul>
This is the <a rel="nofollow noopener noreferrer" target="_blank" href="https://www.ietf.org/rfc/rfc5322.txt">RFC5322</a>-compliant Regular Expression that covers 99.99% of input email addresses.*
Explaining it with words is typically off the table, but visualizing it helps a lot:
<img src="https://s3.stackabuse.com/media/articles/java-regular-expressions-how-to-validate-emails.png" alt="">
*Image and claim are courtesy of <a target="_blank" rel="nofollow noopener noreferrer" href="http://emailregex.com/">EmailRegex.com</a>.
That being said, to create a truly robust email verification Regular Expression checker in Java, let's substitute the loose one with this:
<pre><code class="hljs">String email = &quot;someone@gmail.com&quot;;

Pattern pattern = Pattern.compile(&quot;(?:[a-z0-9!#$%&amp;&#x27;*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&amp;&#x27;*+/=?^_`{|}~-]+)*|\&quot;(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\&quot;)@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])&quot;);
Matcher matcher = pattern.matcher(email);

if (matcher.matches()) {
 System.out.println(String.format(&quot;Email &#x27;%s&#x27; is valid!&quot;, matcher.group(0)));
}
</code></pre>
Needless to say - this works:
<pre><code class="hljs">Email &#x27;someone@gmail.com&#x27; is valid!
</code></pre>
This doesn't check whether the email exists (can't check that unless you try to send the email to the address) so you're always stuck with that possibility. And of course, even this regex will note that odd email addresses such as:
<pre><code class="hljs">aaaa@aaa.aaa
</code></pre>
... are fully valid.
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to perform email validation in Java with Regular Expressions.
Any sort of validation really typically depends on your specific project, but there are some loose/general-purpose forms you can enforce and match for.
We've built a simple general-purpose form which will work most of the time, followed by a greatly robust Regular Expression as detailed by RFC5322.

David Landup

In this guide, we'll take a look at how to validate email addresses in Java, using the regex package as well as built-in String methods, through a general-purpose email Regular Expression (RegEx).

Java Regular Expressions - How to Validate Emails

Regular Expressions (RegEx) are a powerful tool and help us match patterns in a flexible, dynamic and efficient way, as well as to perform operations based on the results.
<blockquote>
In this short guide, we'll take a look at the built-in RegEx methods, which are a part of the String class and allow us to avoid the hassle of working with the <code>Pattern</code> and <code>Matcher</code> classes.
</blockquote>
<blockquote>
If you'd like to read more about Regular Expressions and the <code>regex</code> package, read out <a target="_blank" href="https://stackabuse.com/guide-to-regular-expressions-in-java/">Guide to Regular Expressions in Java</a>!
</blockquote>
<h2 id="stringregexmethodsinjava">String RegEx Methods in Java</h2>
The <code>regex</code> package in the standard Java API has introduced us to the <code>Pattern</code> and <code>Matcher</code> classes that we can use to represent Regular Expressions and check for matches. Though, this requires the creation and use of two additional objects - which, although works just fine, is a bit verbose and unnecessary.
A cleaner, more elegant solution on the client's end was much needed, for simple matching, and the <code>String</code> class was imbued with a few methods pertaining to Regular Expressions.
<blockquote>
What happens under the hood?
</blockquote>
Well, exactly as you might've imagined - the methods ultimately call the classes from the <code>regex</code> module, and using String RegEx methods is technically the exact same as using the classes themselves - just cleaner and less verbose.

 <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: For most cases, you'll prefer using the built-in methods, because of this.

 </div>
 </div>
 </div>
 <blockquote>
If you'd like to read more about Regular Expressions and the <code>regex</code> package, read out <a target="_blank" href="https://stackabuse.com/guide-to-regular-expressions-in-java/">Guide to Regular Expressions in Java</a>!
</blockquote>
<h3 id="thematchesmethod">The matches() Method</h3>
The <code>matches()</code> method works in much the same way as the <code>matches()</code> method of the <code>Matcher</code> object, returned from a <code>Pattern</code> object, given a certain RegEx. This is because it inherently calls these exact methods.
It accepts a string-represented Regular Expression and returns a <code>boolean</code> based on whether the entirety of the string matches the RegEx - beware that the entire string has to match it, otherwise, <code>false</code> is returned:
<pre><code class="hljs">String string = &quot;Hello there!&quot;;
boolean matches = string.matches(&quot;.*Hello.*&quot;);

if (matches) {
 System.out.println(&quot;General Kenobi.&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: The <code>matches()</code> method, surprisingly enough, doesn't support the addition of <code>Pattern</code> enums, such as <code>CASE_INSENSITIVE</code> and is actually <code>CASE_SENSITIVE</code> by default. For these, you'll have to use the source class itself.

 </div>
 </div>
 </div>
 Our RegEx checks for the sequence <code>&quot;Hello&quot;</code> with any number of characters before and after it, so naturally, it does match and the result is:
<pre><code class="hljs">General Kenobi.
</code></pre>
For those interested, the <code>matches()</code> method looks like this:
<pre><code class="hljs">public boolean matches(String regex) {
 return Pattern.matches(regex, this);
}
</code></pre>
Which just calls:
<pre><code class="hljs">public static boolean matches(String regex, CharSequence input) {
 Pattern p = Pattern.compile(regex);
 Matcher m = p.matcher(input);
 return m.matches();
}
</code></pre>
That being said, the method is case-sensitive by default.
<h3 id="thesplitmethod">The split() Method</h3>
The <code>split()</code> method is a commonly used method. Many are acquainted with the method being told that it splits the string based on the given character/delimiter, however, this isn't fully accurate.
<blockquote>
The <code>split()</code> method splits the given string, on every occurrence of the given Regular Expression.
</blockquote>
If your RegEx is a single character, it'll split on instances of that character - though, you're not limited to single characters. You can split the string on any RegEx:
The most common use-case is splitting an input String, in CSV format:
<pre><code class="hljs">String countries = &quot;England,Japan,Italy,Kenya,Mexico&quot;;
String[] splits = countries.split(&quot;,&quot;);

for (String country: splits){
 System.out.println(country);
}
</code></pre>
This results in:
<pre><code class="hljs">England
Japan
Italy
Kenya
Mexico
</code></pre>
Additionally, sentences are oftentimes broken down into words by splitting on each <code>&quot; &quot;</code> (whitespace)`. Because of this, the common understanding of the method is that it splits on a certain character - but there's the possibility of getting creative here.
<h3 id="thereplacefirstandreplaceallmethods">The replaceFirst() and replaceAll() Methods</h3>
The <code>Matcher</code> class doesn't only match - it can be used to replace certain parts of Strings, found via Regular Expressions.
To that end, you can use the short-hand <code>replaceFirst()</code> and <code>replaceAll()</code> methods of the String class, which calls the <code>Matcher</code> (which in turn calls String methods...) to modify a String, on the first (or all) occurrence of a given sequence is matched.
Both methods accept a RegEx and a replacement String - the <code>replaceFirst()</code> replaces the first occurrence of that sequence of characters with the replacement String, while the <code>replaceAll()</code> method replaces all occurrences:
<pre><code class="hljs">String string = &quot;Python is a general-purpose programming language. With Python, you can opt to create...&quot;;

string = string.replaceAll(&quot;Python&quot;, &quot;Jaffa&quot;);
System.out.println(string);

string = string.replaceFirst(&quot;Jaffa&quot;, &quot;Java&quot;);
System.out.println(string);
</code></pre>
Both methods return a new <code>String</code> object, so make sure to assign it to a new reference variable, or the same one you've already got lying around. In the first <code>println()</code> call, we'll have both <code>&quot;Python&quot;</code> sequences turned into <code>&quot;Jaffa&quot;</code>, and in the second <code>println()</code> call, we'll have turned the first <code>&quot;Jaffa&quot;</code> into <code>&quot;Java&quot;</code>:
<pre><code class="hljs">Jaffa is a general-purpose programming language. With Jaffa, you can opt to create...
Java is a general-purpose programming language. With Jaffa, you can opt to create...
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at the built-in RegEx methods of the String class in Java.
To deal with Regular Expressions, we can use the <code>Pattern</code> and <code>Matcher</code> classes of the <code>regex</code> package - though, for many day-to-day use-cases with Strings, you can avoid the boilerplate by using the built-in methods.
These methods ultimately use the <code>regex</code> package, so the same level of performance and results are to be expected.

In this short guide, we'll dive into the built-in String RegEx methods in Java to avoid the boilerplate of the Pattern and Matcher classes of the regex package.

Java: Built-in String Regular Expression (RegEx) Methods

Regular Expressions (RegEx) are a powerful tool and help us match patterns in a flexible, dynamic and efficient way, as well as to perform operations based on the results.
<blockquote>
In this tutorial, we'll take a look at how to validate an phone number in Java, using Regular Expressions (RegEx).
</blockquote>
<blockquote>
If you'd like to read more about Regular Expressions and the <code>regex</code> package, read out <a target="_blank" href="https://stackabuse.com/guide-to-regular-expressions-in-java/">Guide to Regular Expressions in Java</a>!
</blockquote>
<h2 id="validatingphonenumbersinjavawithregex">Validating Phone Numbers in Java with RegEx</h2>
Phone numbers aren't easy to validate, and they're notoriously flexible. Different countries have different formats, and some countries even use multiple formats and country codes.
To validate a phone number with Regular Expressions, you'll have to make a couple of assertions that generalize well to phone numbers, unless you want to write many different expressions and validate through a list of them.
These assertions will depend on your project, its localization and the countries you wish to apply it to - but keep in mind that with an international project, you might have to be loose on the restrictions lest you end up not allowing a valid phone number through to the system.
For standard US phone number validation, we can use the lengthy, fairly robust expression of:
<pre><code class="hljs">^(\+\d{1,2}\s)?$?\d{3}$?[\s.-]?\d{3}[\s.-]?\d{4}$
</code></pre>
The 4 groups in the expression correspond to the country code, area number, subscriber number and extension. The expressions in-between the groups are there to handle a wide-variety of different formatting you an see:
<pre><code class="hljs">123-456-7890
(123) 456-7890
etc...
</code></pre>
You could also build a different expression by imposing a set of rules for groups (depending on the country) and the formats. you may expect coming in.
You could technically go as simple as checking whether there's 10 numbers in the string (12 if you count the country code as well), and it should be able to validate some of the phone numbers, but such simplicity would require additional validation either on the front-end, or the ability to adapt if an accepted phone number isn't actually valid:
<pre><code class="hljs">Pattern simplePattern = Pattern.compile(&quot;^\\+\\d{10,12}$&quot;);
Pattern robustPattern = Pattern.compile(&quot;^(\\+\\d{1,2}\\s)?\$?\\d{3}\$?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$&quot;);

String phoneNumber = &quot;+12 345 678 9012&quot;;

Matcher simpleMatcher = simplePattern.matcher(phoneNumber);
Matcher robustMatcher = robustPattern.matcher(phoneNumber);

if (simpleMatcher.matches()) {
 System.out.println(String.format(&quot;Simple Pattern matched for string: %s&quot;, phoneNumber));
}
if(robustMatcher.matches()) {
 System.out.println(String.format(&quot;Robust Pattern matched for string: %s&quot;, phoneNumber));
}
</code></pre>
The first matcher, here, will first and foremost have issues with the whitespaces present in the string, and would match otherwise. The robust pattern doesn't have any issues with this, though:
<pre><code class="hljs">Robust Pattern matched for string: +12 345 678 9012
</code></pre>
The robust matcher here would be able to match for several formats:
<pre><code class="hljs">Pattern robustPattern = Pattern.compile(&quot;^(\\+\\d{1,2}\\s)?\$?\\d{3}\$?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$&quot;);

List&lt;String&gt; phoneNumbers = List.of(
 &quot;+12 345 678 9012&quot;,
 &quot;+123456789012&quot;,
 &quot;345.678.9012&quot;,
 &quot;345 678 9012&quot;
);

for (String number : phoneNumbers) {
 Matcher matcher = robustPattern.matcher(number);
 if(matcher.matches()) {
 System.out.println(String.format(&quot;Robust Pattern matched for string: %s&quot;, number));
 }
}
</code></pre>
This would result in:
<pre><code class="hljs">Robust Pattern matched for string: +12 345 678 9012
Robust Pattern matched for string: 345.678.9012
Robust Pattern matched for string: 345 678 9012
</code></pre>
<h2 id="combiningmultipleregularexpressions">Combining Multiple Regular Expressions</h2>
Regular Expressions tend to get messy and long. At a certain point, they become cluttered enough that you can't readily change them or interpret them.
Instead of having a single, universal, robust Regular Expression that encompasses all edge-cases, countries, etc. - you can opt to use several different patterns that will reasonably cover the phone numbers coming in. To make things simpler - you can chain these expressions via the <code>|</code> operator, to check whether the phone number matches any of the patterns:
<pre><code class="hljs">Pattern robustPattern = Pattern
 .compile(
 // Robust expression from before
 &quot;^(\\+\\d{1,2}\\s)?\$?\\d{3}\$?[\\s.-]?\\d{3}[\\s.-]?\\d{4}$&quot;
 // Area code, within or without parentheses,
 // followed by groups of 3-4 numbers with or without hyphens
 + &quot;| ((\$\\d{3}\$ ?)|(\\d{3}-))?\\d{3}-\\d{4}&quot;
 // (+) followed by 10-12 numbers
 + &quot;|^\\+\\d{10,12}&quot;
);

List&lt;String&gt; phoneNumbers = List.of(
 &quot;+12 345 678 9012&quot;,
 &quot;+123456789012&quot;,
 &quot;345.678.9012&quot;,
 &quot;345 678 9012&quot;
);

for (String number : phoneNumbers) {
 Matcher matcher = robustPattern.matcher(number);
 if(matcher.matches()) {
 System.out.println(String.format(&quot;Pattern matched for string: %s&quot;, number));
 }
}
</code></pre>
This results in:
<pre><code class="hljs">Pattern matched for string: +12 345 678 9012
Pattern matched for string: +123456789012
Pattern matched for string: 345.678.9012
Pattern matched for string: 345 678 9012
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Phone numbers are tricky - that's a fact. Regular Expressions are a really versatile and powerful tool and can address the issue of validating phone numbers, but it is admittedly a messy process.
Certain countries follow different standards, while some countries adopt and use multiple formats at the same time, making it hard to write a general-purpose expression to match phone numbers universally.
In this short article, we've taken a look at how to match phone numbers with Regular Expressions in Java, with a few different expressions.

In this short article, we'll take a look at how to validate a phone number in Java, using the regex package and multiple Regular Expressions.

Java Regular Expressions - Validate Phone Number

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to deep and shallow copy the objects in Python.
The short answer is that you can use methods of the <code>copy</code> module, for both operations:
<pre><code class="hljs">import copy

shallow_copy_list = copy.copy(original_list)
deepcopy_list = copy.deepcopy(original_list)
</code></pre>
<blockquote>
Though, what does it mean to copy something in a shallow or deep fashion?
</blockquote>
In the proceeding sections, we'll dive into what these terms mean, how Python treats object references and objects in memory, and why these two methods work the way they do.
<h2 id="shallowcopyanobjectinpython">Shallow Copy an Object in Python</h2>
When we use assignment statements (<code>=</code>) in Python to create copies of compound objects, such as lists or class instances or basically any objects that contain some other objects, Python does not clone the object itself. Instead, it simply binds the reference to the targeted object.
Imagine that we have a list with the following elements in it:
<pre><code class="hljs">original_list =[[1,2,3], [4,5,6], [&quot;X&quot;, &quot;Y&quot;, &quot;Z&quot;]]
</code></pre>
If we try to copy our original list using the assignment statement as follows:
<pre><code class="hljs">shallow_copy_list = original_list
print(shallow_copy_list)
</code></pre>
It may look like that we cloned our object and now have two of them:
<pre><code class="hljs">[[1,2,3], [4,5,6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;]]
</code></pre>
But, do we really have two objects? No, we don't. We have two reference variables pointing to the same object in memory. This can easily be verified by printing the ID of the object in memory for both of these:
<pre><code class="hljs">id(original_list) # 4517445712
id(shallow_copy_list) # 4517445712
</code></pre>
A more tangible proof of this can be observed by attempting to change a value in either of &quot;the two lists&quot; - while in reality, we change the same list, and both pointers point to the same object in memory.
Let's access the last element of the object pointed to by <code>original_list</code>:
<pre><code class="hljs"># Last element of last element
original_list[-1][-1] = &quot;ZZZ&quot;
print(original_list)
</code></pre>
This results in:
<pre><code class="hljs">[[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;ZZZ&#x27;]]
</code></pre>
Knowing that both reference variables point to the same object, printing <code>shallow_copy_list</code> will return the same result:
<pre><code class="hljs">print(shallow_copy_list)
</code></pre>
<pre><code class="hljs">[[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;ZZZ&#x27;]]
</code></pre>
<blockquote>
Shallow Copying is the process of copying a reference to an object and storing it in a new variable. The <code>original_list</code> and <code>shallow_copy_list</code> are merely references that point to the same addresses in memory (RAM), that store the values of <code>[[1, 2, 3], [4, 5, 6], ['X', 'Y', 'ZZZ']]</code>.
</blockquote>
<img src="https://stackabuse.s3.amazonaws.com/media/python-deep-copy-object-01.png" alt="An illustration of the shallow copy ">
It is also possible to create a shallow copy of an object using <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-list/">a slice</a> of the entire list and assignment statement:
<pre><code class="hljs">slice_shallow_copy_list = original_list[:]
</code></pre>
Another way to shallow copy is to use the <code>copy</code> module of Python’s standard library.
To use the <code>copy</code> module, we must first import it:
<pre><code class="hljs">import copy
</code></pre>
Now we can use the <code>copy()</code> method of the <code>copy</code> module:
<pre><code class="hljs">second_shallow_copy_list = copy.copy(original_list)
</code></pre>
Print them both to see that if they reference the same values:
<pre><code class="hljs">print(original_list)
print(second_shallow_copy_list)
</code></pre>
As expected, they do:
<pre><code class="hljs">[[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;ZZZ&#x27;]]
[[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;ZZZ&#x27;]]
</code></pre>
Usually, you would want to copy a compound object, for example at the beginning of a method, then modify the clone, but keep the original object as it was in order to use it again later sometime.
To achieve this, we need to deep copy the object. Now let's learn what is a deep copy and how to deep copy a compound object.
<h2 id="deepcopyanobjectinpython">Deep Copy an Object in Python</h2>
<blockquote>
Deep copying an object means really cloning the object and its values into a new copy (instance) in memory, with those same values.
</blockquote>
Rather than creating a new reference to the same values, with the deep copy, we can actually create a new object that is independent of the original data but contains the same values.
<blockquote>
In a typical deep copy process, first, a new object reference is created, then all the child objects are added to the parent object recursively.
</blockquote>
This way, unlike a shallow copy, making any modification to the original object, does not reflect in the copy object (or vice versa).
Here is a simple illustration of a typical deep copy:
<img src="https://stackabuse.s3.amazonaws.com/media/python-deep-copy-object-02.png" alt="An illustration of the deep copy ">
To deep copy an object in Python, we use the <code>deepcopy()</code> method of the <code>copy</code> module.
Let's import the copy module and create a deep copy of a list:
<pre><code class="hljs">import copy
 
original_list = [[1,2,3], [4,5,6], [&quot;X&quot;, &quot;Y&quot;, &quot;Z&quot;]]
deepcopy_list = copy.deepcopy(original_list)
</code></pre>
Now let's print our lists to make sure the outputs are the same, as well as their IDs as proof of their uniqueness:
<pre><code class="hljs">print(id(original_list), original_list)
print(id(deepcopy_list), deepcopy_list)
</code></pre>
The output confirms that we've created ourselves a genuine copy:
<pre><code class="hljs">4517599280, [[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;]]
4517599424, [[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;]]
</code></pre>
Now let's try to modify our original list by changing the last element of the last list to the &quot;O&quot;, and then print it to see the result:
<pre><code class="hljs">original_list[-1][-1] = &quot;O&quot;
print(original_list)
</code></pre>
We get the results as expected:
<pre><code class="hljs">[[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;O&#x27;]]
</code></pre>
Now if we go ahead and try to print our copy list:
<pre><code class="hljs">print(deepcopy_list)
</code></pre>
The previous modification did not reflect on this list:
<pre><code class="hljs">[[1, 2, 3], [4, 5, 6], [&#x27;X&#x27;, &#x27;Y&#x27;, &#x27;Z&#x27;]]
</code></pre>
Remember that the <code>copy()</code> and <code>deepcopy()</code> methods are applicable on other compound objects. This means that you can use them to create copies of class instances as well.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned what it means to shallow copy and to deep copy an object.
We also learned that we can use the <code>copy()</code> method of the <code>copy</code> module to create a shallow copy, and the <code>deepcopy()</code> method to create a deep copy of the compound objects.

Marcus Sanatan

Ruslan Hasanov

In this article we learn the difference between deep copying and shallow copying objects in Python, and how to do both with the copy library

Python: Deep and Shallow Copy Object

Bilal Hamada

In this guide, we'll take a look at how to use Regular Expressions in Java, as well as practical examples of common tasks and patterns.

Guide to Regular Expressions in Java

Hiram Kamau

In this detailed guide, we'll take a look how to use the findFirst() and findAny() methods from Java 8's Stream API, how they're used as well as some best practices.

Java 8 Streams: Definitive Guide to findFirst() and findAny()

In this piece, the Friendly Overfitting Argument is laid out, as well as when it doesn't hold. Is overfitting in Machine Learning and Artificial Intelligence really as bad as people make it out to be?

Machine Learning: Overfitting Is Your Friend, Not Your Foe

<h2 id="introduction">Introduction</h2>
Python is one of the most suitable languages for automating tasks. Whether it's repeatable (ethical) web scraping after some time period, starting some programs on a computer start up, or automating sending mundane e-mails, Python has a lot of modules that make your life easier.
One of these is a module called <code>keyboard</code>, and it takes full control of your keyboard. With this module, you can type out anything, create hot-keys, create abbreviations, block the keyboard, wait for input, etc.
<blockquote>
In this guide, we'll take a look at how to set up and use the <code>keyboard</code> module in Python.
</blockquote>

 <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: Applications working with automating human-like processes should be developed ethically and responsibly. The <code>keyboard</code> module is made to be very observable, and thus makes it both discouraged and transparent if anyone's using it to create key-loggers or malicious bots.

 </div>
 </div>
 </div>
 <h2 id="installingthekeyboardmodule">Installing the keyboard Module</h2>

 <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 version of Python used in this guide is 3.8. However, the <code>keyboard</code> module can work with both Python 2.x and Python 3.x.

 </div>
 </div>
 </div>
 If you're using Linux, in order to use this library, you must install it as <code>root</code>. If you don't, you'll get an:
<pre><code class="hljs">ImportError: You must be root to use this library on linux.
</code></pre>
Also, when running your script, you should run it with root privileges:
<pre><code class="hljs">$ sudo pip3 install keyboard
$ sudo python3 my_script.py
</code></pre>
On Windows and MacOS, as the privileges work much differently - you can install it simply via <code>pip</code> and run the scripts:
<pre><code class="hljs">$ pip install keyboard
$ python my_script.py
</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: For MacOS, you might have to allow the Terminal or other apps to change the state of your machine, such as by typing. Also keep in mind that as of September 2021, the library is still experimental on MacOS.

 </div>
 </div>
 </div>
 <h2 id="thekeyboardmodulesfunctions">The keyboard Module's Functions</h2>
There are a lot of functions in this module that can be used to simulate keyboard actions.
<ul>
<li><code>keyboard.write(message, [delay])</code> - writes a message, with or without a delay.</li>
<li><code>keyboard.wait(key)</code> - blocks the program until the <code>key</code> is pressed. The <code>key</code> is passed as a string ('space', 'esc', etc.)</li>
<li><code>keyboard.press(key)</code> - presses a key and holds until the <code>release(key)</code> function is called.</li>
<li><code>keyboard.release(key)</code> - releases a key.</li>
<li><code>keyboard.send(key)</code> - presses and releases a key.</li>
<li><code>keyboard.add_hotkey(hotkey, function)</code> - creates a <code>hotkey</code> which when pressed, executes a <code>function</code>.</li>
<li><code>keyboard.record(key)</code> - records keyboard activity until <code>key</code> is pressed.</li>
<li><code>keyboard.play(recorded_events, [speed_factor])</code> - replays events recorded with <code>keyboard.record(key)</code> function, with an optional <code>speed_factor</code>.</li>
</ul>
We'll go through all of these, though, here's a quick example:
<pre><code class="hljs">&gt;&gt;&gt; import keyboard
&gt;&gt;&gt; keyboard.write(&quot;Hello&quot;)
&gt;&gt;&gt; Hello
</code></pre>
The <code>Hello</code> message appears on the screen, in the terminal, as if you've written it. You can automate a command very easily, and create a hotkey alias for it. Here's a (crude) example of exiting the Python REPL, writing a <code>curl</code> command and executing it:
<pre><code class="hljs">&gt;&gt;&gt; import keyboard
&gt;&gt;&gt; keyboard.write(&quot;exit()&quot;); keyboard.send(&quot;enter&quot;); keyboard.write(&quot;curl https://www.google.com&quot;); keyboard.send(&quot;enter&quot;);
&gt;&gt;&gt; exit()
curl https://www.google.com
$ curl https://www.google.com
&lt;!doctype html&gt;&lt;html itemscope=&quot;&quot;...
</code></pre>
<h2 id="keyboardswriteandwaitfunctions">keyboard's write() and wait() Functions</h2>
The <code>write()</code> command writes a message, as we've seen before, with an optional delay in the start. If no delay is set, writing is instant. It's very nicely combined with the <code>wait()</code> function, which awaits a certain key to be pressed.
For instance, we can create a make-shift macro, tied to, say <code>1</code>, which responds to that input with a new message. Note that there's an actual way to create hotkeys instead of this, which we'll cover later.
We'll create an infinite <code>True</code> loop to check for the key being pressed, and you can run the script in the background:
<pre><code class="hljs">import keyboard

while True:
 keyboard.wait(&quot;1&quot;)
 keyboard.write(&quot;\n The key &#x27;1&#x27; was pressed!&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: Special characters are not supported by this function, so if you add, say, <code>!</code> - you'll get hit with a <code>StopIteration</code> exception.

 </div>
 </div>
 </div>
 <h2 id="keyboardspressreleasefunctions">keyboard's press(), release() Functions</h2>
Since it's hard to simulate <code>press()</code> and <code>release()</code> so that the actions are visible, we'll also see <code>record()</code> and <code>play()</code> in action.
The <code>press()</code> function presses a key and releases it when you call <code>release()</code> on the same key. Note that you can't <code>sleep()</code> for some time to simulate holding down a key:
<pre><code class="hljs">&gt;&gt;&gt; import keyboard
&gt;&gt;&gt; from time import sleep
&gt;&gt;&gt; keyboard.press(&quot;a&quot;)
&gt;&gt;&gt; sleep(1)
&gt;&gt;&gt; keyboard.release(&quot;a&quot;)
&gt;&gt;&gt; a
</code></pre>
However, you can hold down some special keys, such as [SHIFT] or [CTRL] this way:
<pre><code class="hljs">&gt;&gt;&gt; keyboard.press(&quot;shift&quot;)
&gt;&gt;&gt; keyboard.write(&quot;lowercase&quot;)
&gt;&gt;&gt; keyboard.release(&quot;shift&quot;)

&gt;&gt;&gt; LOWERCASE
</code></pre>
<h2 id="keyboardsrecordandplayfunctions">keyboard's record() and play() Functions</h2>
It's not always about inputting new keys in - sometimes, you'd like to record what's going on and play it back. Keep in mind that you'll need administrator privileges to record any input like this, as the technology can easily be used to create keyloggers.
The <code>record()</code> function accepts a trigger key, until which it records, and returns a sequence of events of type <code>KeyboardEvent</code>. You can then chuck this sequence of events into the <code>play()</code> function, which faithfully replays them, with an optional <code>speed_factor</code> argument that acts as a multiplier for the speed of the original events:
<pre><code class="hljs">import keyboard
recorded_events = keyboard.record(&quot;esc&quot;)
keyboard.play(recorded_events)
</code></pre>
If we're to print the <code>recorded_events</code>, they'd look something like:
<pre><code class="hljs">KeyboardEvent(w up), KeyboardEvent(o down), ...]
</code></pre>
The effects of these methods are best seen as a GIF or recreated on your machine. For instance, a sequence of writing a message, deleting it and writing a different one instead:
<img src="https://s3.stackabuse.com/media/articles/guide-to-pythons-keyboard-module-1.gif" alt="">
<h2 id="keyboardssendfunction">keyboard's send() function</h2>
The <code>send()</code> function encompasses <code>press()</code> and <code>release()</code> together, and is used for single keys, unlike <code>write()</code> which is used for entire sentences:
<pre><code class="hljs">import keyboard

recorded_events = keyboard.record(&quot;s&quot;)

keyboard.send(&quot;w&quot;)
keyboard.send(&quot;a&quot;)

keyboard.play(recorded_events)
</code></pre>
Once <code>s</code> is pressed, the <code>w</code> and <code>a</code> keys are replayed.
The <code>press()</code> function can also accept combinations of pressed keys. You can send a combination of <code>&quot;ctrl+shift+s&quot;</code> for instance and the dialogue for saving a file should pop up, if you're in an application that supports that operation:
<pre><code class="hljs">import keyboard

while True:
 keyboard.wait(&quot;s&quot;)
 keyboard.press(&quot;ctrl+shift+s&quot;)
 # Or for MacOS
 keyboard.press(&quot;command+shift+s)
</code></pre>
Though, this isn't the right way to add hotkeys. Rather, you can use the <code>add_hotkey()</code> function.
<h2 id="keyboardsadd_abbreviationfunction">keyboard's add_abbreviation() Function</h2>
The <code>add_abbreviation()</code> function is a pretty nifty one, as it allows you to define abbreviations for long inputs, and replaces the abbreviated versions with the saved full versions.
For instance, similar to how services like Google save your email for most input forms, you can create your own abbreviation and trigger it via <code>[SPACE]</code>:
<pre><code class="hljs">&gt;&gt;&gt; import keyboard
&gt;&gt;&gt; keyboard.add_abbreviation(&quot;@&quot;, &quot;john@stackabuse.com&quot;)
</code></pre>
While running, if you type <code>@</code> followed by a <code>[SPACE]</code> - the long-form input will replace the typed <code>@</code>.
<h2 id="keyboardsadd_hotkeyfunction">keyboard's add_hotkey() Function</h2>
The <code>add_hotkey()</code> function accepts a hotkey you'd like to save, or a combination of keys, and a function. It's easy to pass in anonymous lambda functions here, though you can also add named functions.
For instance, let's add a hotkey for <code>CTRL+j</code>, which triggers a lambda function that logs this:
<pre><code class="hljs">import keyboard

keyboard.add_hotkey(&quot;ctrl+alt+j&quot;, lambda: print(&quot;ctrl+alt+j was pressed&quot;))
</code></pre>
The hotkey, <code>ctrl+alt+p</code>, is saved and when you press this combination, you should see the output of the lambda.
<h2 id="conclusion">Conclusion</h2>
The <code>keyboard</code> module is a lightweight and simple library used for simulating keystrokes and simple automation in Python. It's not very feature-rich, but can be used to automate some of the tasks you might be performing in your day-to-day work, or simply for a bit of fun.
A more mature, powerful module that can be used as an alternative is <a rel="nofollow noopener noreferrer" target="_blank" href="https://pypi.org/project/pynput/">pynput</a>.

In this guide, we'll take a look at the experimental keyboard module in Python and how to automate keyboard input and keystrokes easily.

Guide to Python's keyboard Module

In this guide - we'll take a look at how to calculate the Euclidean distance between two points in Python, using Numpy.
<h2 id="whatiseuclideandistance">What is Euclidean Distance?</h2>
Euclidean distance is a fundamental distance metric pertaining to systems in Euclidean space.
<blockquote>
Euclidean space is the classical geometrical space that you get familiar with in the Math class, typically bound to 3 dimensions. Though, it can also be prescribed to any non-negative integer dimension as well.
</blockquote>
<blockquote>
Euclidean distance is the shortest line between two points in Euclidean space.
</blockquote>
The name comes from Euclid, who is widely recognized as &quot;the father of geometry&quot;, as this was the only space people at the time would typically conceive of. Through time, different types of space have been observed in Physics and Mathematics, such as Affine space, and non-Euclidean spaces and geometry are very unintuitive for our cognitive perception.
<blockquote>
In 3-dimensional Euclidean space, the shortest line between two points will always be a straight line between them, though this doesn't hold for higher dimensions.
</blockquote>
Given this fact, Euclidean distance isn't always the most useful metric to keep track of when dealing with many dimensions, and we'll focus on 2D and 3D Euclidean space to calculate the Euclidean distance.
Measuring distance for high-dimensional data is typically done with other distance metrics such as Manhattan distance.
Generally speaking, Euclidean distance has major usage in development of 3D worlds, as well as Machine Learning algorithms that include distance metrics, such as <a target="_blank" href="https://stackabuse.com/k-nearest-neighbors-algorithm-in-python-and-scikit-learn/">K-Nearest Neighbors</a>. Typically, Euclidean distance will represent how similar two data points are - assuming some clustering based on other data has already been performed.
<h3 id="mathematicalformula">Mathematical Formula</h3>
The mathematical formula for calculating the Euclidean distance between 2 points in 2D space: 
$$ 
d(p,q) = \sqrt[2]{(q_1-p_1)^2 + (q_2-p_2)^2 } 
$$ 
The formula is easily adapted to 3D space, as well as any dimension: 
$$ 
d(p,q) = \sqrt[2]{(q_1-p_1)^2 + (q_2-p_2)^2 + (q_3-p_3)^2 } 
$$ 
The general formula can be simplified to: 
$$ 
d(p,q) = \sqrt[2]{(q_1-p_1)^2 + ... + (q_n-p_n)^2 } 
$$ 
A sharp eye may notice the similarity between Euclidean distance and Pythagoras' Theorem: 
$$ 
C^2 = A^2 + B^2 
$$
$$ 
d(p,q)^2 = (q_1-p_1)^2 + (q_2-p_2)^2 
$$
There in fact is a relationship between these - Euclidean distance is calculated via Pythagoras' Theorem, given the Cartesian coordinates of two points.
<blockquote>
Because of this, Euclidean distance is sometimes known as Pythagoras' distance, as well, though, the former name is much more well-known.
</blockquote>

 <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 two points are vectors, but the output should be a scalar (which is the distance).

 </div>
 </div>
 </div>
 We'll be using NumPy to calculate this distance for two points, and the same approach is used for 2D and 3D spaces:
<pre><code class="hljs">import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = fig.add_subplot(111, projection = &#x27;3d&#x27;)

ax.scatter(0, 0, 0)
ax.scatter(3, 3, 3)
plt.show()
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/calculating-euclidean-distance-with-numpy-1.png" alt="two points in euclidean space">
<h2 id="calculatingeuclideandistanceinpythonwithnumpy">Calculating Euclidean Distance in Python with NumPy</h2>
First, we'll need to install the NumPy library:
<pre><code class="hljs">$ pip install numpy
</code></pre>
Now, let's import it and set up our two points, with the Cartesian coordinates as (0, 0, 0) and (3, 3, 3):
<pre><code class="hljs">import numpy as np
# Initializing the points
point_1 = np.array((0, 0, 0))
point_2 = np.array((3, 3, 3))
</code></pre>
Now, instead of performing the calculation manually, let's utilize the helper methods of NumPy to make this even easier!
<h2 id="npsqrtandnpsum">np.sqrt() and np.sum()</h2>
The operations and mathematical functions required to calculate Euclidean Distance are pretty simple: addition, subtraction, as well as the square root function. Multiple additions can be replaced with a sum, as well: 
$$ 
d(p,q) = \sqrt[2]{(q_1-p_1)^2 + (q_2-p_2)^2 + (q_3-p_3)^2 } 
$$
NumPy provides us with a <code>np.sqrt()</code> function, representing the square root function, as well as a <code>np.sum()</code> function, which represents a sum. With these, calculating the Euclidean Distance in Python is simple and intuitive:
<pre><code class="hljs"># Get the square of the difference of the 2 vectors
square = np.square(point_1 - point_2)
# Get the sum of the square
sum_square = np.sum(square)
</code></pre>
This gives us a pretty simple result:
<pre><code class="hljs">(0-3)^2 + (0-3)^2 + (0-3)^2
</code></pre>
Which is equal to 27. All that's left is to get the square root of that number:
<pre><code class="hljs"># The last step is to get the square root and print the Euclidean distance
distance = np.sqrt(sum_square)
print(distance)
</code></pre>
This results in:
<pre><code class="hljs">5.196152422706632
</code></pre>
In true Pythonic spirit, this can be shortened to just a single line:
<pre><code class="hljs">distance = np.sqrt(np.sum(np.square(point_1 - point_2)))
</code></pre>
And you can even use the built-in <code>pow()</code> and <code>sum()</code> methods of the <code>math</code> module of Python instead, though they require you to hack around a bit with the input, which is conveniently abstracted using NumPy, as the <code>pow()</code> function only works with scalars (each element in the array individually), and accepts an argument - to which power you're raising the number.
This approach, though, intuitively looks more like the formula we've used before:
<pre><code class="hljs">from math import *
distance = np.sqrt(sum(pow(a-b, 2) for a, b in zip(point_1, point_2)))
print(distance)
</code></pre>
This also results in:
<pre><code class="hljs">5.196152422706632
</code></pre>
<h2 id="nplinalgnorm">np.linalg.norm()</h2>
The <code>np.linalg.norm()</code> function represents a Mathematical norm. In essence, a norm of a vector is it's length. This length doesn't have to necessarily be the Euclidean distance, and can be other distances as well. Euclidean distance is the L2 norm of a vector (sometimes known as the Euclidean norm) and by default, the <code>norm()</code> function uses L2 - the <code>ord</code> parameter is set to 2.

 <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">
 If you were to set the <code>ord</code> parameter to some other value p, you'd calculate other p-norms. For instance, the L1 norm of a vector is the Manhattan distance!

 </div>
 </div>
 </div>
 With that in mind, we can use the <code>np.linalg.norm() </code> function to calculate the Euclidean distance easily, and much more cleanly than using other functions:
<pre><code class="hljs">distance = np.linalg.norm(point_1-point_2)
print(distance)
</code></pre>
This results in the L2/Euclidean distance being printed:
<pre><code class="hljs">5.196152422706632
</code></pre>
L2 normalization and L1 normalization are heavily used in Machine Learning to normalize input data.
<blockquote>
If you'd like to learn more about feature scaling - read our <a target="_blank" href="https://stackabuse.com/feature-scaling-data-with-scikit-learn-for-machine-learning-in-python/">Guide to Feature Scaling Data with Scikit-Learn</a>!
</blockquote>
<h2 id="npdot">np.dot()</h2>
We can also use a Dot Product to calculate the Euclidean distance. In Mathematics, the Dot Product is the result of multiplying two equal-length vectors and the result is a single number - a scalar value. Because of the return type, it's sometimes also known as a &quot;scalar product&quot;. This operation is often called the inner product for the two vectors.
To calculate the dot product between 2 vectors you can use the following formula: 
$$ 
\vec{p} \cdot \vec{q} = {(q_1-p_1) + (q_2-p_2) + (q_3-p_3) } 
$$
With NumPy, we can use the <code>np.dot()</code> function, passing in two vectors.
If we calculate a Dot Product of the difference between both points, with that same difference - we get a number that's in a relationship with the Euclidean Distance between those two vectors. Extracting the square root of that number nets us the distance we're searching for:
<pre><code class="hljs"># Take the difference between the 2 points
diff = point_1 - point_2
# Perform the dot product on the point with itself to get the sum of the squares
sum_square = np.dot(diff, diff)
# Get the square root of the result
distance = np.sqrt(sum_square)
print(distance)
</code></pre>
Of course, you can shorten this to a one-liner as well:
<pre><code class="hljs">distance = np.sqrt(np.dot(point_1-point_2, point_1-point_2))
print(distance)
</code></pre>
<pre><code class="hljs">5.196152422706632
</code></pre>
<h2 id="usingthebuiltinmathdist">Using the Built-In math.dist()</h2>
Python has its built-in method, in the <code>math</code> module, that calculates the distance between 2 points in 3d space. However, this only works with Python 3.8 or later.
<code>math.dist()</code> takes in two parameters, which are the two points, and returns the Euclidean distance between those points.

 <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 that the two points must have the same dimensions (i.e both in 2d or 3d space).

 </div>
 </div>
 </div>
 Now, to calculate the Euclidean Distance between these two points, we just chuck them into the <code>dist()</code> method:
<pre><code class="hljs">import math
distance = math.dist(point_1, point_2)
print(distance)
</code></pre>
<pre><code class="hljs">5.196152422706632
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Euclidean distance is a fundamental distance metric pertaining to systems in Euclidean space.
<blockquote>
Euclidean space is the classical geometrical space that you get familiar with in the Math class, typically bound to 3 dimensions. Though, it can also be prescribed to any non-negative integer dimension as well.
</blockquote>
<blockquote>
Euclidean distance is the shortest line between two points in Euclidean space.
</blockquote>
The metric is used in many contexts within data mining, machine learning, and several other fields, and is one of the fundamental distance metrics.

In this guide, we'll take a look at how to calculate the Euclidean Distance between two vectors (points) in Python with NumPy and the math module.