<h2 id="introduction">Introduction</h2>
The square root of a number is a very common mathematical function used in all aspects of science - physics, mathematics, computer science, etc. Square roots of numbers and expressions are very frequent in formulas in all matters of science, and especially in the way we represent reality - by modeling what we can observe with calculus.
In this article, we'll take a look at various ways to calculate a square root of a number in Python. Finally, we'll do a <a href="#performancebenchmark">Performance Benchmark</a> with constant and random numbers, as well as lists of random numbers to put all of the approaches to the test.
<h2 id="calculatesquarerootinpythonwithnumpy">Calculate Square Root in Python with NumPy</h2>
NumPy is a scientific computation library, which found itself present in many applications and use cases. Naturally, it has many wrappers of mathematical functions as helper methods.
If not already installed, you can install it via <code>pip</code>:
<pre><code class="hljs">$ pip install numpy
</code></pre>
In terms of NumPy, the <code>sqrt()</code> function calculates the square root of a number, and returns the result:
<pre><code class="hljs">import numpy as np
x = np.sqrt(2)
print(x)
</code></pre>
This results in:
<pre><code class="hljs">1.4142135623730951
</code></pre>
Aside from taking a single variable as an argument, <code>sqrt()</code> is also able to parse through lists and return a list of square roots:
<pre><code class="hljs">arr = [2, 3, 5, 7]
roots = np.sqrt(arr)
print(roots)
</code></pre>
This results in:
<pre><code class="hljs">[1.41421356 1.73205081 2.23606798 2.64575131]
</code></pre>
The <code>sqrt()</code> function has a limitation though - it cannot calculate a square root of a negative number, because the square root operation with real numbers is only defined for positive numbers.
Attempting to insert <code>-4</code> into the <code>sqrt()</code> function will result in an exception:
<pre><code class="hljs">print(np.sqrt(-4))
</code></pre>
Trying to calculate a square root of a negative number will result with a warning and a <code>nan</code> value:
<pre><code class="hljs">RuntimeWarning: invalid value encountered in sqrt
nan
</code></pre>
<h3 id="calculatesquarerootofcomplexnumberwithnumpy">Calculate Square Root of Complex Number with Numpy</h3>
Fortunately, NumPy isn't constrained to only work with real numbers - it can work with complex numbers as well:
<pre><code class="hljs">import numpy as np

complex_number = -1 + 1j
complex_array = [-2, 3, complex_number]

complex_root = np.sqrt(complex_number)
complex_array_roots = np.sqrt(complex_array)

print(f&quot;Square root of &#x27;{complex_number}&#x27;:\n {complex_root}&quot;)
print(f&quot;Square roots of &#x27;{complex_array}&#x27;:\n {complex_array_roots}&quot;)
</code></pre>
If there's at least one complex number in a list, all of the numbers will be cast to and treated as complex, so even negative integers can be added:
<pre><code class="hljs">Square root of &#x27;(-1+1j)&#x27;:
 (0.45508986056222733+1.09868411346781j)
Square roots of &#x27;[-2, 3, (-1+1j)]&#x27;:
 [0. +1.41421356j 1.73205081+0.j 0.45508986+1.09868411j]
</code></pre>
<h2 id="pythonsmathmodule">Python's math Module</h2>
The <code>math</code> module is a standard module packaged with Python. It's always available, but has to be imported, and provides wrappers for some common functions, such as the square root, powers, etc:
<pre><code class="hljs">import math
</code></pre>
<h3 id="mathsqrt">math.sqrt()</h3>
The <code>sqrt()</code> function of the <code>math</code> module is a straightforward function that returns the square root of any positive number:
<pre><code class="hljs">print(math.sqrt(2))
</code></pre>
This results in:
<pre><code class="hljs">1.4142135623730951
</code></pre>
Unlike NumPy's <code>sqrt()</code> function, it can only work on a single element, so if you want to calculate the square root of all elements in a list, you'll have to use a <code>for</code> loop or a list comprehension:
<pre><code class="hljs">import math

arr = [2, 3, 5, 7]
roots = []

for x in arr:
 roots.append(math.sqrt(x))

# OR
roots = [math.sqrt(x) for x in arr]
</code></pre>
In both cases, the <code>roots</code> list will contain:
<pre><code class="hljs">[1.4142135623730951, 1.7320508075688772, 2.23606797749979, 2.6457513110645907]
</code></pre>
<h3 id="mathpow">math.pow()</h3>
A square root of a number can also be calculated by raising a number to a power of ½:
$$ 
\sqrt x = x^{\frac 1 2} 
$$
So really, finding the square root of a number can be expressed as raising the number to a power of ½. <code>math.pow()</code> takes two arguments - the base and the exponent, and rises the base to the power of an exponent:
<pre><code class="hljs">print(math.pow(2, 0.5))
</code></pre>
Naturally, this results in:
<pre><code class="hljs">1.4142135623730951
</code></pre>
<h2 id="theoperator">The ** Operator</h2>
The <code>**</code> operator is a binary operator which means it works with two values, just like regular multiplication with <code>*</code> does. However, as it is an operator used for exponentiation, we raise its left argument to the power of its right argument.
This approach can be used in the same form as the previous one:
<pre><code class="hljs">print(2 ** 0.5)
</code></pre>
And it also results in:
<pre><code class="hljs">1.4142135623730951
</code></pre>
<h2 id="thepowfunction">The pow() Function</h2>
Python has another, built-in <code>pow()</code> method that doesn't require an import of the <code>math</code> module. This method is technically different from the <code>math.pow()</code> method internally.
<code>math.pow()</code> implicitly casts elements to doubles, while <code>pow()</code> uses the object's internal implementation, based around the <code>**</code> operator. While this difference in implementation may warrant the use of one or the other in certain contexts, if you're just calculating the square root of a number, you won't really see the difference:
<pre><code class="hljs">print(pow(2, 0.5))
</code></pre>
This results in:
<pre><code class="hljs">1.4142135623730951
</code></pre>
<h2 id="performancebenchmark">Performance Benchmark</h2>
So which one yields the best performance, and which one should you choose? As usual, there isn't one clear cut winner, and it depends on the usage of the methods. Namely, if you're working with constant numbers, random numbers or an array of random numbers on a larger scale - these methods will perform differently.
Let's test them all out on constant numbers, random numbers and arrays of random numbers:
<pre><code class="hljs">import timeit

print(&quot;Time to execute 100k operations on constant number: \n&quot;)
print(&quot;math.sqrt(): %ss&quot; % timeit.timeit(&quot;math.sqrt(100)&quot;, setup=&quot;import math&quot;, number=100000))
print(&quot;math.pow(): %ss&quot; % timeit.timeit(&quot;math.pow(100, 0.5)&quot;, setup=&quot;import math&quot;, number=100000))
print(&quot;pow(): %ss&quot; % timeit.timeit(&quot;pow(100, 0.5)&quot;, number=100000))
print(&quot;np.sqrt(): %ss&quot; % timeit.timeit(&quot;np.sqrt(100)&quot;, setup=&quot;import numpy as np&quot;, number=100000))
print(&quot;** operator: %ss&quot; % timeit.timeit(&quot;100 ** 0.5&quot;, number=100000))

print(&quot;\nTime to execute 100k operations on random number: \n&quot;)
print(&quot;math.sqrt() %ss&quot; % timeit.timeit(&quot;math.sqrt(random.random())&quot;, setup=&quot;import math; import random;&quot;, number=100000))
print(&quot;math.pow(): %ss&quot; % timeit.timeit(&quot;math.pow(random.random(), 0.5)&quot;, setup=&quot;import math; import random&quot;, number=100000))
print(&quot;pow(): %ss&quot; % timeit.timeit(&quot;pow(random.random(), 0.5)&quot;, setup=&quot;import random&quot;, number=100000))
print(&quot;np.sqrt(): %ss&quot; % timeit.timeit(&quot;np.sqrt(random.random())&quot;, setup=&quot;import numpy as np; import random&quot;, number=100000))
print(&quot;** operator: %ss&quot; % timeit.timeit(&quot;random.random() ** 0.5&quot;, setup=&quot;import random&quot;, number=100000))

print(&quot;\nTime to execute 100k operations on list of random numbers: \n&quot;)
print(&quot;math.sqrt() %ss&quot; % timeit.timeit(&quot;[math.sqrt(x) for x in np.random.rand(100)]&quot;, setup=&quot;import math; import numpy as np;&quot;, number=100000))
print(&quot;math.pow(): %ss&quot; % timeit.timeit(&quot;[math.pow(x, 0.5) for x in np.random.rand(100)]&quot;, setup=&quot;import math; import numpy as np;&quot;, number=100000))
print(&quot;pow(): %ss&quot; % timeit.timeit(&quot;[pow(x, 0.5) for x in np.random.rand(100)]&quot;, setup=&quot;import numpy as np;&quot;, number=100000))
print(&quot;np.sqrt(): %ss&quot; % timeit.timeit(&quot;np.sqrt(np.random.rand(100))&quot;, setup=&quot;import numpy as np; import numpy as np;&quot;, number=100000))
print(&quot;** operator: %ss&quot; % timeit.timeit(&quot;np.random.rand(100) ** 0.5&quot;, setup=&quot;import numpy as np&quot;, number=100000))
</code></pre>
We've passed all of the methods outlined above through the same test - a constant number (which is likely to be cached for optimization), a random number on each of the 100k iterations, and a list of 100 random numbers.

 <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: Only the relative numbers on each test compared to other methods in that test are relevant, since it takes more time to generate 100 random numbers than using the (cached) constant value.

 </div>
 </div>
 </div>
 Running this piece of code results in:
<pre><code class="hljs">Time to execute 100k operations on constant number: 

math.sqrt(): 0.014326499999999999s
math.pow(): 0.0165132s
pow(): 0.018766599999999994s
np.sqrt(): 0.10575379999999998s
** operator: 0.0006493000000000193s

Time to execute 100k operations on random number: 

math.sqrt() 0.019939999999999958s
math.pow(): 0.022284300000000035s
pow(): 0.0231711s
np.sqrt(): 0.09066460000000004s
** operator: 0.018928s

Time to execute 100k operations on list of random numbers: 

math.sqrt() 2.7786073s
math.pow(): 2.9986906s
pow(): 3.5157339999999992s 
np.sqrt(): 0.2291957s
** operator: 0.2376024000000001s
</code></pre>
With constant numbers - the <code>math.pow()</code>, <code>math.sqrt()</code> and <code>pow()</code> functions significantly outperform NumPy's <code>sqrt()</code> function, as they can better utilize caching in the CPU on the language-level.
With random numbers, the caching doesn't work as well and we see smaller discrepancies.
With lists of random numbers, <code>np.sqrt()</code> outperforms all three built-in methods significantly, and the <code>**</code> operator performs in the same ball-park.
To summarize:

 <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">
 <ul>
<li>For constant numbers, the <code>**</code> operator clearly performs the best on the test machine, executing 16 times faster than the built-in methods.</li>
<li>For random numbers, <code>np.sqrt()</code> outperforms the built-in methods, and the <code>**</code> operator, though, there isn't any significant discrepancy in the results.</li>
<li>For random arrays, the <code>np.sqrt()</code> function outperforms the built-in methods, but the <code>**</code> operator is very close.</li>
</ul>

 </div>
 </div>
 </div>
 Depending on the concrete input you're dealing with - you'll choose between these functions. While it may seem like they'll all perform well, and while in most cases, it won't make much of a difference, when dealing with huge datasets, even a 10% decrease in processing time can help in the long-run.
Depending on the data you're processing - test the different approaches on your local machine.
<h2 id="conclusion">Conclusion</h2>
In this short article, we've taken a look at several ways to compute the Square Root of a number in Python.
We've taken a look at the <code>math</code> module's <code>pow()</code> and <code>sqrt()</code> functions, as well as the built-in <code>pow()</code> function, NumPy's <code>sqrt()</code> function and the <code>**</code> operator. Finally, we've benchmarked the methods to compare their performance on different types of input - constant numbers, random numbers and lists of random numbers.

Guest Contributor

David Landup

In this guide, you'll learn how to calculate the square root of a number in Python, using math.sqrt(), np.sqrt(), pow(), math.pow() and the ** operator, with a performance benchmark.

Calculate Square Root of a Number in Python

<h2 id="introduction">Introduction</h2>
A substring is a continuous sequence of characters within a String. For instance, <code>&quot;substring&quot;</code> is a substring of <code>&quot;Find a substring within a string&quot;</code>.
Strings in Python are arrays of bytes representing Unicode characters and one of the most commonly used data types to represent data in a human-readable format.
<blockquote>
In this article we will learn how to count the number of occurrences of a specified substring within a string in Python.
</blockquote>
<h2 id="findalloccurrencesofasubstringinastringusingcount">Find All Occurrences of a Substring in a String Using count()</h2>
The <code>count()</code> method of the string class actually does just this. It returns the number of times a specified value (substring) appears in the string. It also has two optional parameters - <code>start</code> and <code>end</code>, denoting the start and end of the search space:
<pre><code class="hljs">string.count(value, start, end)
</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 default <code>start</code> is <code>0</code>, and the default <code>end</code> is the length of the string.

 </div>
 </div>
 </div>
 Let's take a look at the usage of the method, with a representative sentence:
<pre><code class="hljs"># Define string and substring
str1 = &#x27;John has 1 apple, Sarah has 2 apples, Mike has 5 apples.&#x27;
substr = &#x27;apples&#x27;

# Occurrences of substring &#x27;apples&#x27; in the string
result = str1.count(substr)
print(&quot;Number of substring occurrences:&quot;, result)

# Occurrences of substring &#x27;apples&#x27; from index 0 to index 40
start, end = 0, 40
result2 = str1.count(substr, start, end)
print(&quot;Number of substring occurrences:&quot;, result2)
</code></pre>
This results in:
<pre><code class="hljs">Number of substring occurrences: 2
Number of substring occurrences: 1
</code></pre>
It is a very simple and straightforward method that works well in most cases. It's efficient, and can scale up well to large input sizes. For instance, we could load in a large piece of text and search for a common word or a stopword which is bound to be present.
You can also simply obtain a large search space to get a sense for the efficiency. Let's download 'Romeo and Juliet' by William Shakespeare, from Project Gutenberg, and retrieve the number of times <code>'Romeo'</code> is mentioned:
<pre><code class="hljs">import time
import requests

txt = requests.get(&#x27;https://www.gutenberg.org/cache/epub/1513/pg1513.txt&#x27;).text
print(f&quot;Downloaded {len(txt)} bytes of text...&quot;)

start_time = time.time()
count = txt.count(&#x27;Romeo&#x27;)
end_time = time.time()

print(f&quot;Time to find all occurrences of &#x27;Romeo&#x27;: {end_time - start_time}s with {count} results&quot;)
</code></pre>
This results in:
<pre><code class="hljs">Downloaded 167333 bytes of text...
Time to find all occurrences of &#x27;Romeo&#x27;: 0.0s with 153 results
</code></pre>
Or, even if we find a much more common word, such as <code>'a'</code>:
<pre><code class="hljs">start_time = time.time()
count = txt.count(&#x27;a&#x27;)
end_time = time.time()

print(f&quot;Time to find all occurrences of &#x27;a&#x27;: {end_time - start_time}s with {count} results&quot;)
</code></pre>
The result is the same:
<pre><code class="hljs">Downloaded 167333 bytes of text...
Time to find all occurrences of &#x27;Romeo&#x27;: 0.0s with 8308 results
</code></pre>
The majority of the execution time is taken by the time it takes to download the text.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: This method does not return the position in the string at which the substring occurs.

 </div>
 </div>
 </div>
 If you require this knowledge, either to perform additional transformational operations on the occurrences besides counting them - you'll want to use a Regular Expressions to find their positions or check individual cases with <code>startsWith()</code>.
We'll be taking a look at these two cases in the following sections.
<h2 id="findalloccurrencesandpositionsofasubstringinastringinpython">Find All Occurrences and Positions of a Substring in a String in Python</h2>
The <code>startswith()</code> method returns <code>True</code> if the string starts with the specified <code>value</code> (substring) and <code>False</code> if it does not. Similarly to <code>count()</code> method, this method also has optional parameters start and end that specify the start and end positions of the search space:
<pre><code class="hljs">string.startswith(value, start, end)
</code></pre>
The default <code>start</code> value is <code>0</code> and the default <code>end</code> value is the length of the string.
Using this method is a bit more complex, since it requires us to use list comprehension along with the method itself, or a more traditional <code>for</code> loop. The <code>startswith()</code> method returns the beginning indices of the substring. After that we utilize list comprehension to iterate through the entire search space:
<pre><code class="hljs"># Define string and substring
str1 = &#x27;John has 1 apple, Sarah has 2 apples, Mike has 5 apples.&#x27;
substr = &#x27;apples&#x27;

# Print original string and substring
print(&quot;Original string is:&quot;, str1)
print(&quot;Substring is:&quot;, substr)

# Sse startswith() and list comprehension
# Find all occurrences of a substring within a string
result = [i for i in range(len(str1)) if str1.startswith(substr, i)]

# Print the number of substring occurrences
print(&quot;Number of substring occurrences is:&quot;, len(result))

# We can also find the starting indices of substrings
print(&quot;Starting indices of substrings are: &quot; + str(result))
</code></pre>
This nets us the number of occurrences, like last time, but also the starting positions of the strings themselves. Since we know the string in question, and thus, its length - we can easily deduce the space it occupies in the search string:
<pre><code class="hljs">Original string is: John has 1 apple, Sarah has 2 apples, Mike has 5 apples.
Substring is: apples
Number of substring occurrences is: 2
Starting indices of substrings are: [30, 49]
</code></pre>
<h2 id="findalloccurrencesofasubstringinastringinpythonusingrefinditer">Find All Occurrences of a Substring in a String in Python Using re.finditer()</h2>
The <code>finditer()</code> function is part of Python's RegEx library - <code>re</code>. It is most commonly used to find the occurrence of a particular pattern within a given string.
To enable the usage of this method, along with many other methods that handle RegEx expressions, we first need to import the regex library:
<pre><code class="hljs">re.finditer(pattern, string, flags=0)
</code></pre>
<blockquote>
If you would like to learn more about Regular Expressions, read our <a target="_blank" href="https://stackabuse.com/introduction-to-regular-expressions-in-python/">Guide to Regular Expressions in Python</a>!
</blockquote>
The <code>re.finditer()</code> function returns an iterator yielding matched objects over all non-overlapping matches for the RegEx pattern in a string. The scan is performed from left to right, and matches are returned in the order they are found in. Empty matches are included as well.
Flags can be used to enable various unique features and syntax variations (for example, <code>re.I</code> or <code>re.IGNORECASE</code> flag enables case insensitive matching, <code>re.A</code> or <code>re.ASCII</code> flag enables <code>ASCII</code> only matching instead of the usual full <code>UNICODE</code> matching).
Let's replace the list comprehension from before with a Regular Expression:
<pre><code class="hljs">import re

# Define string and substring
str1 = &#x27;John has 1 apple, Sarah has 2 apples, Mike has 5 apples.&#x27;
substr = &#x27;apples&#x27;

# Print original string and substring
print(&quot;Original string is:&quot;, str1)
print(&quot;Substring is:&quot;, substr)

# Use re.finditer() to find all substring occurrences
# Using list comprehension we find the start and end indices of every substring occurrence
result = [(_.start(), _.end()) for _ in re.finditer(substr, str1)]

# Print number of substrings found
print(&quot;Number of substring occurrences is:&quot;, len(result))

# Print start and end indices of substring occurrences
print(&quot;The start and end indices of the substrings are: &quot; + str(result))
</code></pre>
This results in:
<pre><code class="hljs">Original string is: John has 1 apple, Sarah has 2 apples, Mike has 5 apples.
Substring is: apples
Number of substring occurrences is: 2
The start and end indices of the substrings are: [(30, 36), (49, 55)]
</code></pre>
Now, we don't have to manually add up the length of the strings to the starting indices.
<h2 id="benchmarkingperformance">Benchmarking Performance</h2>
It's worth noting that the performance will vary based on the method you choose. While in all cases, the code will end fairly quickly - it's still worth taking the performance into account on really large search spaces.
Let's use these three methods to find all instances of the character <code>'a'</code> in 'Romeo and Juliet':
<pre><code class="hljs">import re
import time
import requests

txt = requests.get(&#x27;https://www.gutenberg.org/cache/epub/1513/pg1513.txt&#x27;).text
print(f&quot;Downloaded {len(txt)} bytes of text...&quot;)

start_time_1 = time.time()
result_1 = txt.count(&#x27;a&#x27;)
end_time_1 = time.time()

print(f&quot;String.count(): Time to find all occurrences of &#x27;a&#x27;: {end_time_1 - start_time_1}s&quot;)

start_time_2 = time.time()
result_2 = [i for i in range(len(txt)) if txt.startswith(&#x27;a&#x27;, i)]
end_time_2 = time.time()

print(f&quot;List Comprehensions: Time to find all occurrences of &#x27;a&#x27;: {end_time_2 - start_time_2}s&quot;)

start_time_3 = time.time()
result_3 = [(_.start(), _.end()) for _ in re.finditer(&#x27;a&#x27;, txt)]
end_time_3 = time.time()

print(f&quot;Regex: Time to find all occurrences of &#x27;a&#x27;: {end_time_3 - start_time_3}s&quot;)
</code></pre>
This results in:
<pre><code class="hljs">String.count(): Time to find all occurrences of &#x27;a&#x27;: 0.0s
List Comprehensions: Time to find all occurrences of &#x27;a&#x27;: 0.031008481979370117s
Regex: Time to find all occurrences of &#x27;a&#x27;: 0.002000093460083008s
</code></pre>
The <code>count()</code> method is definitely the most efficient one, but it doesn't let us know where the strings are. For the additional knowledge - Regular Expressions are still extremely fast for this task, and more than 10 times as efficient as our manual list comprehension loop.
<h2 id="conclusion">Conclusion</h2>
There are multiple different ways to solve this problem, some used more often than others, depending on the data you'd like to extract in the process.
In the benchmark, the <code>count()</code> method outperformed the other two, but it doesn't give us information on where the substrings are located. On the other hand, Regular Expressions, albeit slower, provide us with this information.
It's worth noting that all three approaches are exceptionally fast and can parse an entire literary masterpiece for a common word in a fraction of a second.

Darko Mladenovski

In this article, we'll take a look at how to count the number of occurrences, as well as the positions of substring occurrences within another string in Python.

Python: Count Number of Substring Occurrences in String

<h2 id="introduction">Introduction</h2>
Regular Expressions, or RegEx for short, are expressions of patterns that can be used for text search and replace actions, validations, string splitting, and much more. These patterns consist of characters, digits and special characters, in such a form that the pattern matches certain segments of text we're searching through.
Regular Expressions are widely used for pattern-matching, and various programming languages have interfaces for representing them, as well as interacting with the matches results.
In this article, we will take a look at how to validate email addresses in Python, using Regular Expressions.
<blockquote>
If you would like to learn more about Python's interface with Regular Expressions, read our <a target="_blank" href="https://stackabuse.com/introduction-to-regular-expressions-in-python/">Guide to Regular Expressions in Python</a>!
</blockquote>
<h2 id="generalpurposeemailregularexpression">General-Purpose Email Regular Expression</h2>
It's worth noting that there is no such regular expression that matches every possible valid email address. Although, there are expressions that can match most valid email addresses.
We need to define what kind of email address format are we looking for. The most common email format is:
<pre><code class="hljs">(username)@(domainname).(top-leveldomain)
</code></pre>
Thus, we can boil it down to a pattern of the <code>@</code> symbol dividing the prefix from the domain segment.
The prefix is the recipient;s name - a string that may contain uppercase and lowercase letters, numbers, and some special characters like the <code>.</code> (dot), <code>-</code>(hyphen), and <code>_</code> (underscore).
The domain consists of its name and a top-level domain divided by a <code>.</code> (dot) symbol. The domain name can have uppercase and lowercase letters, numbers, and <code>-</code> (hyphen) symbols. Additionally, the top-level domain name must be at least 2 characters long (either all uppercase or lowercase letters), but can be longer.

 <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: There are a lot more detailed rules regarding valid emails, such as character count, more specific characters that can be used, etc. We'll be taking a look at an extended, highly fail-proof Regular Expression as defined by RFC5322 after the general-purpose approach.

 </div>
 </div>
 </div>
 In simple terms, our email Regular Expression could look like this:
<pre><code class="hljs">(string1)@(string2).(2+characters)
</code></pre>
This would match correctly for email addresses such as:
<pre><code class="hljs">name.surname@gmail.com
anonymous123@yahoo.co.uk
my_email@outlook.co
</code></pre>
Again, using the same expression, these email addresses would fail:
<pre><code class="hljs">johnsnow@gmail
anonymous123@...uk
myemail@outlook.
</code></pre>
It's worth noting that the strings shouldn't contain certain special characters, lest they break the form again. Additionally, the top-level domain can't be <code>..</code>. Accounting for those cases as well, we can put these rules down into a concrete expression that takes in a few more cases into account than the first representation:
<pre><code class="hljs">([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+
</code></pre>
A special character in the prefix cannot be just before the <code>@</code> symbol, nor can the prefix start with it, so we made sure that there is at least one alphanumeric character before and after every special character.
As for the domain, an email can contain a few top-level domains divided with a dot.
Obviously, this regex is more complicated than the first one, but it covers all of the rules we have defined for the email format. Yet again, it can probably fail to properly validate some edge case that we haven't thought of.
<h2 id="validateemailaddresswithpython">Validate Email Address with Python</h2>
The <code>re</code> module contains classes and methods to represent and work with Regular Expressions in Python, so we'll import it into our script. The method that we will be using is <code>re.fullmatch(pattern, string, flags)</code>. This method returns a match object only if the whole string matches the pattern, in any other case it returns <code>None</code>.

 <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: <code>re.fullmatch()</code> was introduced in Python 3.4, before that, <code>re.match()</code> was used instead. On newer versions, <code>fullmatch()</code> is preferred.

 </div>
 </div>
 </div>
 Let's <code>compile()</code> the Regular Expression from before, and define a simple function that accepts an email address and uses the expression to validate it:
<pre><code class="hljs">import re

regex = re.compile(r&#x27;([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+&#x27;)

def isValid(email):
 if re.fullmatch(regex, email):
 print(&quot;Valid email&quot;)
 else:
 print(&quot;Invalid email&quot;)
</code></pre>
The <code>re.compile()</code> method compiles a regex pattern into a regex object. It's mostly used for efficiency reasons, when we plan on matching the pattern more than once.
Now, let's test the code on some of the examples we took a look at earlier:
<pre><code class="hljs">isValid(&quot;name.surname@gmail.com&quot;)
isValid(&quot;anonymous123@yahoo.co.uk&quot;)
isValid(&quot;anonymous123@...uk&quot;)
isValid(&quot;...@domain.us&quot;)
</code></pre>
This results in:
<pre><code class="hljs">Valid email
Valid email
Invalid email
Invalid email
</code></pre>
Awesome, we've got a functioning system!
<h2 id="robustemailregularexpression">Robust Email Regular Expression</h2>
The expression we've used above works well for the majority of cases and will work well for any reasonable application. However, if security is of higher concern, or if you enjoy writing Regular Expressions, you may opt to tighten the scope of possibilities while still allowing valid email addresses to pass.
Long expressions tend to get a bit convoluted and hard to read, and this expression is no exception:
<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>.
This actually isn't the only expression that satisfies RFC5322. Many of them do, with varying degrees of success. A shorter version which still complies with the specification can be easily imported into Python's <code>re.compile()</code> method to represent an expression:
<pre><code class="hljs">import re

regex = re.compile(r&quot;([-!#-&#x27;*+/-9=?A-Z^-~]+(\.[-!#-&#x27;*+/-9=?A-Z^-~]+)*|\&quot;([]!#-[^-~ \t]|(\\[\t -~]))+\&quot;)@([-!#-&#x27;*+/-9=?A-Z^-~]+(\.[-!#-&#x27;*+/-9=?A-Z^-~]+)*|\[[\t -Z^-~]*])&quot;)

def isValid(email):
 if re.fullmatch(regex, email):
 print(&quot;Valid email&quot;)
 else:
 print(&quot;Invalid email&quot;)

isValid(&quot;name.surname@gmail.com&quot;)
isValid(&quot;anonymous123@yahoo.co.uk&quot;)
isValid(&quot;anonymous123@...uk&quot;)
isValid(&quot;...@domain.us&quot;)
</code></pre>
This also results in:
<pre><code class="hljs">Valid email
Valid email
Invalid email
Invalid email
</code></pre>
<h2 id="conclusion">Conclusion</h2>
To wrap up this guide, let's revise what we've learned. There are many ways to validate emails using Regular Expressions, mostly depending on what certain format we are looking for. In relation to that, there is no one unique pattern that works for all email formats, we simply need to define the rules that we want the format to follow and construct a pattern accordingly.
Each new rule reduces the degree of freedom on the accepted addresses.

Anđela Niketić

In this guide, we'll take a look at how to validate email addresses in Python with Regular Expressions, with a general-purpose simple expression as well as an RFC5322-compliant robust regex.

Python: Validate Email Address with Regular Expressions (RegEx)

Cansın Güler

In this extensive guide, we'll take a look at functional programming and applying Predicates in Java, with Lambda Functions!

Functional Programming in Java 8: Definitive Guide to Predicates

<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>.
Many simple mathematical operations and concepts find their usage in programming, and most often these are just as straightforward in programming as they are in math itself. Summing up elements isn't indifferent to this, and it's usage is often overlooked because there are many ways to utilize this simple task.
<blockquote>
In this guide, we'll take a look at how to sum all elements in a collection in Java, using <code>summingDouble()</code>, <code>summingLong()</code> and <code>summingInt()</code>.
</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: It's worth noting that you can sum the elements themselves, if they're summable, or <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">reduce them</a> to a numerical representation and then sum the reductions, if they aren't.

 </div>
 </div>
 </div>
 <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="definitionofthesumming_collectors">Definition of the summing_() Collectors</h2>
Within the <code>Collectors</code> class itself, we find an abundance of unique methods that deliver on the different needs of a user. One such group is made of summing methods - <code>summingInt()</code>, <code>summingDouble()</code> and <code>summingLong()</code>.
Even though each of these methods work for a distinctive data type listed within their names, they all work fairly similarly, with minor differences:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Integer&gt; summingInt(ToIntFunction&lt;? super T&gt; mapper)

public static &lt;T&gt; Collector&lt;T,?,Double&gt; summingDouble(ToDoubleFunction&lt;? super T&gt; mapper)

public static &lt;T&gt; Collector&lt;T,?,Long&gt; summingLong(ToLongFunction&lt;? super T&gt; mapper)
</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 generic <code>T</code> in the method signatures represents the type of the input elements we're working with.

 </div>
 </div>
 </div>
 Earlier we stated that these methods can only be used for numerical inputs. The predefined <code>ToIntFunction</code>, <code>ToDoubleFunction</code> and <code>ToLongFunction</code> from <code>java.util.function</code> enable us to do exactly such conversions - from object types to their primitive <code>int, double, long</code> types.
Before we begin diving into each of the individual methods, we'll be defining a class that we'll use for our examples alongside a few fields.
This class will be called <code>Product</code>:
<pre><code class="hljs">public class Product {
 private String name;
 private Integer quantity;
 private Double price;
 private Long productNumber;

 // Constructor, getters and setters
}
</code></pre>
The class has four fields of different types:
<ul>
<li><code>String name</code> - we won't end up using this field since this is a non-numeric value, but in order to have meaningful examples we need to name our products.</li>
<li><code>Integer quantity</code> - the number of products in our inventory.</li>
<li><code>Double price</code> - the price of the product.</li>
<li><code>Long productNumber</code> - a six-digit code for every of our products.</li>
</ul>
Alongside these four fields, we also have a simple constructor and getters for everything except the name of the product itself. Let's also instantiate our <code>List</code> of products in the main program:
<pre><code class="hljs">List&lt;Product&gt; products = Arrays.asList(
 new Product(&quot;Milk&quot;, 37, 3.60, 12345600L),
 new Product(&quot;Carton of Eggs&quot;, 50, 1.20, 12378300L),
 new Product(&quot;Olive oil&quot;, 28, 37.0, 13412300L),
 new Product(&quot;Peanut butter&quot;, 33, 4.19, 15121200L),
 new Product(&quot;Bag of rice&quot;, 26, 1.70, 21401265L)
);
</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: Besides this class, which we'll have to reduce to a field in order to sum, we'll also be taking a look at examples of <code>List</code>s consisting only of <code>Integer</code>, <code>Double</code> and <code>Long</code> elements.

 </div>
 </div>
 </div>
 <h3 id="collectorssummingint">Collectors.summingInt()</h3>
The <code>summingInt()</code> method returns a <code>Collector</code> that produces the sum of a integer-valued function applied to the input elements. In other words - it sums the integers in the collection and returns the result. In the case of no input elements, the return value is <code>0</code>.
Let's start off with a basic example with a <code>List</code> of <code>Integers</code>:
<pre><code class="hljs">List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer sum = numbers.stream().collect(Collectors.summingInt(Integer::intValue));
System.out.println(&quot;Sum: &quot; + sum);
</code></pre>
We apply the <code>.stream()</code> method to create a stream of <code>Integer</code> instances, after which we use the previously discussed <code>.collect()</code> method to collect the elements using <code>summingInt()</code>. The method itself, again, accepts the <code>ToIntFunction</code>, which can be used to reduce instances to an integer that can be summed.
Since we're using Integers already, we can simply pass in a method reference denoting their <code>intValue</code>, as no further reduction is needed:
<pre><code class="hljs">Sum: 15
</code></pre>
More often than not - you'll be working with lists of custom objects and would like to sum some of their fields. For instance, we can sum the quantities of each product in the <code>productList</code>, denoting the total inventory we have.
In such a case, the we can use a method reference, such as <code>Product::getQuantity</code> as our <code>ToIntFunction</code>, to reduce the objects into a single integer each, and then sum these integers:
<pre><code class="hljs">Integer sumOfQuantities = products.stream().collect(Collectors.summingInt(Product::getQuantity));
System.out.println(&quot;Total number of products: &quot; + sumOfQuantities);
</code></pre>
This results in:
<pre><code class="hljs">Total number of products: 174
</code></pre>
<blockquote>
If you'd like to read more about reduction and reducing operations, which are typically at the core of summing and averaging operations, amongst other tasks - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">Java 8 Streams: Definitive Guide to reduce()</a>!
</blockquote>
<h3 id="collectorssummingdouble">Collectors.summingDouble()</h3>
In much the same way <code>summingInt()</code> returns the result of summed integer values - <code>summingDouble()</code> returns the result of summed double values.
This method varies from the <code>summingInt()</code> in one regard, however. The sum returned can vary depending on the order in which values are recorded, due to accumulated rounding errors. Values sorted by increasing order tend to produce more accurate results.

 <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: If any value is a <code>NaN</code> or the sum at any point is <code>NaN</code>, the result will also be <code>NaN</code>.

 </div>
 </div>
 </div>
 Let's start off with a list of doubles:
<pre><code class="hljs">List&lt;Double&gt; numbers = Arrays.asList(3.0, 5.5, 11.3, 40.3, 21.1);
Double sum = numbers.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(sum);
</code></pre>
After rounding off our output it prints out:
<pre><code class="hljs">81.2
</code></pre>
Again, we typically work with custom objects and not wrapper/primitive types. Prices of our products are expressed in doubles, so we could sum prices. If we were to buy a single instance of every product in the inventory, what would the price be?
Let's use <code>summingDouble()</code> to get a quote for the price:
<pre><code class="hljs">Double sumOfPrices = products.stream().collect(Collectors.summingDouble(Product::getPrice));
System.out.println(&quot;The total sum of prices: &quot; + sumOfPrices);
</code></pre>
This gives us:
<pre><code class="hljs">The total sum of prices: 47.69
</code></pre>
If we wanted to get a little creative and count the total price of all of our products combined we can do that using this method as well. However, it does require beforehand calculations that makes this significantly easier:
<pre><code class="hljs">List&lt;Double&gt; productPrices = new ArrayList&lt;&gt;();
for(Product product : products){
 productPrices.add(product.getPrice() * product.getQuantity());
}

Double sumOfPrices = productPrices.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(&quot;Sum of all product prices : &quot; + sumOfPrices);
</code></pre>
Running this code gives us the following:
<pre><code class="hljs">Sum of all product prices : 1411.67
</code></pre>
<h3 id="collectorssumminglong">Collectors.summingLong()</h3>
The third and last method from the summing group of methods is <code>summingLong()</code>. This method, as the previous two do, returns a <code>Collector</code> that produces the sum of a long-valued function applied to the input elements. If no elements are present, the result is <code>0</code>:
<pre><code class="hljs">List&lt;Long&gt; numbers = Arrays.asList(23L, 11L, 13L, 49L, 7L);
Long sum = numbers.stream().collect(Collectors.summingLong(Long::longValue));
System.out.println(sum);
</code></pre>
This outputs:
<pre><code class="hljs">103
</code></pre>
Finally, our <code>productNumber</code> field is of type <code>Long</code>. Turns out, the numbers were carefully chosen to encode a secret message once split up and converted from decimal to ASCII. We'll sum the longs and write a custom helper function to decode the message:
<pre><code class="hljs">Long productNumbers = products.stream().collect(Collectors.summingLong(Product::getProductNumber));
System.out.println(productNumbers);
System.out.println(decodeMessage(productNumbers));
</code></pre>
The <code>decodeMessage()</code> method takes in a <code>Long</code>, breaks it up and considers each two characters as a decimal representation of a <code>Character</code>, before adding the characters up and returning the message:
<pre><code class="hljs">public static String decodeMessage(Long encodedMessage) {
 String message = String.valueOf(encodedMessage);
 String[] characters = message.split(&quot;&quot;);
 StringBuilder result = new StringBuilder();

 for (int i = 1; i &lt; characters.length; i+=2) {
 result.append(Character.toString(Integer.parseInt(characters[i-1]+characters[i])));
 }

 return result.toString();
}
</code></pre>
Awesome, let's take a look at the result:
<pre><code class="hljs">74658665
JAVA
</code></pre>
Not an exciting secret message, by all means, but a message nonetheless.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at summing collectors, and explored the <code>summingInt()</code>, <code>summingDouble()</code> and <code>summingLong()</code> methods.
We've explored their usage on primitive wrappers, as well as custom objects, which are typically reduced to a field for summation operations.

Branko Ilic

In this Java 8 Streams guide, we'll take a look at the summing collectors for integers, doubles and longs in Java, with practical examples and tips.

Guide to Java 8 Collectors: summingDouble(), summingLong() and summingInt()

Data takes many shapes and forms - one of the most common data structure being lists/arrays. Strings are, essentially, sequences of alphanumeric characters. The parallel between these is apparent, and we often convert between one and the other.
<blockquote>
In this guide, we'll take a look at how to convert/collect a list to a string in Python.
</blockquote>
<h2 id="convertlisttostringinpythonwithjoin">Convert List to String in Python with join()</h2>
The general approach you'll be using is the <code>join()</code> function, with a couple of options to choose from. The function is invoked on a string denoting a separator - and this separator will be added between all joined items.

 <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: Although you can define a separator upfront, it's typically just instantiated as an empty string, upon which the <code>join()</code> function is called.

 </div>
 </div>
 </div>
 Let's take a look at a list of characters that we'd like to join:
<pre><code class="hljs">base_list = [&#x27;M&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;F&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]
</code></pre>
The simplest way to join these into a single string is to just pass the list into the <code>join()</code> function:
<pre><code class="hljs">string = &quot;&quot;.join(base_list)
print(string)
</code></pre>
This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
We've joined a few characters, denoting the amino-acids present at the start of the sequence of a protein found in the E. coli bacteria!
Each of these elements is of type <code>str</code>, so there's no issue in naturally putting these into a string. Though, sometimes, you might want to convert a certain element into a different type.
Additionally, if you use a different delimiter, you can get a different representation as well:
<pre><code class="hljs">string = &quot;, &quot;.join(base_list)
</code></pre>
This results in:
<pre><code class="hljs">M, K, V, N, L, I, L, F, S, L, L, V
</code></pre>
<h2 id="convertlisttostringinpythonwithlistcomprehension">Convert List to String in Python with List Comprehension</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: Python implicitly converts any data types it can, so you won't need to explicitly convert them in most cases.

 </div>
 </div>
 </div>
 If you do have to convert the elements, you can simply use a list comprehension:
<pre><code class="hljs">string = &quot;&quot;.join(str(element) for element in base_list)
</code></pre>
Each element in the list is now passed through the <code>str()</code> function, which converts them to a string. You can substitute this with any other function, including custom ones. For instance, let's create a function that capitalizes each element in the 'off chance' an element isn't capitalized as it should be:
<pre><code class="hljs">base_list = [&#x27;m&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;f&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]

def capitalize_char(char):
 return char.upper()

string = &quot;&quot;.join(capitalize_char(element) for element in base_list)

print(string)
</code></pre>
<code>m</code> and <code>f</code> have been flipped to lowercase, which shouldn't have happened. We've passed in the <code>capitalize_char()</code> function into the list comprehension, returning the capitalized version of each element we've passed in. This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
<h2 id="convertlisttostringinpythonwithmap">Convert List to String in Python with map()</h2>
Finally, for a more clean and easy way to pass elements through a function - we can use <code>map()</code>. Generally, the <code>map()</code> function is used to map values of one collection to another, typically using a different (or even reduced) format.
For instance, you could map each character to another list of booleans, where each boolean represents if the character is uppercase or not.
Of course, you can also always do a 1-to-1 mapping using the <code>map()</code> function and, well, just map a string to a string, joining them together into a single one:
<pre><code class="hljs">base_list = [&#x27;M&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;F&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]

string = &quot;&quot;.join(map(str, base_list))

print(string)
</code></pre>
This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
<blockquote>
If you'd like to read more about mapping in Python, read our <a target="_blank" href="https://stackabuse.com/map-filter-and-reduce-in-python-with-examples/">Guide to map(), filter() and reduce() in Python</a>!
</blockquote>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to convert a list to a string in Python, collecting the elements into a single piece.
Strings are inherently lists of characters, and they behave in much the same way, but can be treated as individual elements as well.
You've learned how to use the <code>join()</code> function in its plain form, as well as how to use it with list comprehensions, custom methods and the <code>map()</code> function!

In this short practical guide, learn how to join strings into a list with the join() function, list comprehensions, custom methods and the map() function!

Python: Convert List to String with join()

In this guide, learn how to use Collectors.groupingByConcurrent() collector in Java 8 to collect and group elements of streams concurrently, with downstream collectors and suppliers, through examples.

Guide to Java 8 Collectors: groupingByConcurrent()

Data can take many shapes and forms - and it's oftentimes represented as strings.
Be it from a CSV file or input text, we split strings oftentimes to obtain lists of features or elements.
<blockquote>
In this guide, we'll take a look at how to split a string into a list in Python, with the <code>split()</code> method.
</blockquote>
<h2 id="splitstringintolistinpython">Split String into List in Python</h2>
The <code>split()</code> method of the string class is fairly straightforward. It splits the string, given a delimiter, and returns a list consisting of the elements split out from the string.

 <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">
 By default, the delimiter is set to a whitespace - so if you omit the delimiter argument, your string will be split on each whitespace.

 </div>
 </div>
 </div>
 Let's take a look at the behavior of the <code>split()</code> method:
<pre><code class="hljs">string = &quot;Age,University,Name,Grades&quot;

lst = string.split(&#x27;,&#x27;)

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
Our string had elements delimited with a comma, as in a CSV (comma-separated values) file, so we've set the delimiter appropriately.
This results in a list of elements of type <code>str</code>, no matter what other type they can represent:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27;University&#x27;, &#x27;Name&#x27;, &#x27;Grades&#x27;]
Element types: &lt;class &#x27;str&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolisttrimwhitespacesandchangecapitalization">Split String into List, Trim Whitespaces and Change Capitalization</h2>
Not all input strings are clean - so you won't always have a perfectly formatted string to split. Sometimes, strings may contain whitespaces that shouldn't be in the &quot;final product&quot; or have a mismatch of capitalized and non-capitalized letters.
Thankfully, it's pretty easy to process this list and each element in it, after you've split it:
<pre><code class="hljs"># Contains whitespaces after commas, which will stay after splitting
string = &quot;age, uNiVeRsItY, naMe, gRaDeS&quot;
lst = string.split(&#x27;,&#x27;)

print(lst)
</code></pre>
This results in:
<pre><code class="hljs">[&#x27;age&#x27;, &#x27; uNiVeRsItY&#x27;, &#x27; naMe&#x27;, &#x27; gRaDeS&#x27;]
</code></pre>
No good! Each element starts with a whitespace and the elements aren't properly capitalized at all. Applying a function to each element of a list can easily be done through a simple <code>for</code> loop so we'll want to apply a <code>strip()</code>/<code>trim()</code> (to get rid of the whitespaces) and a capitalization function.
Since we're not only looking to capitalize the first letter but also keep the rest lowercase (to enforce conformity), let's define a helper function for that:
<pre><code class="hljs">def capitalize_word(string):
 return string[:1].capitalize() + string[1:].lower()
</code></pre>
The method takes a string, slices it on its first letter and capitalizes it. The rest of the string is converted to lowercase and the two changed strings are then concatenated.
We can now use this method in a loop as well:
<pre><code class="hljs">string = &quot;age, uNiVeRsItY, naMe, gRaDeS&quot;

lst = string.split(&#x27;,&#x27;)
lst = [s.strip() for s in lst]
lst = [capitalize_word(s) for s in lst]

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
This results in a clean:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27;University&#x27;, &#x27;Name&#x27;, &#x27;Grades&#x27;]
Element types: &lt;class &#x27;str&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolistandconverttointeger">Split String into List and Convert to Integer</h2>
What happens if you're working with a string-represented list of integers? After splitting, you won't be able to perform integer operations on these, since they're ostensibly strings.
Thankfully, we can use the same <code>for</code> loop as before to convert the elements into integers:
<pre><code class="hljs">string = &quot;1,2,3,4&quot;

lst = string.split(&#x27;,&#x27;)
lst = [int(s) for s in lst]

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
Which now results in:
<pre><code class="hljs">[1, 2, 3, 4]
Element types: &lt;class &#x27;int&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolistwithlimiter">Split String into List with Limiter</h2>
Besides the delimiter, the <code>split()</code> method accepts a limiter - the number of times a split should occur.
It's an integer and is defined after the delimiter:
<pre><code class="hljs">string = &quot;Age, University, Name, Grades&quot;

lst = string.split(&#x27;,&#x27;, 2)
print(lst)
</code></pre>
Here, two splits occur, on the first and second comma, and no splits happen after that:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27; University&#x27;, &#x27; Name, Grades&#x27;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, you've learned how to split a string into a list in Python.
You've also learned how to trim the whitespaces and fix capitalization as a simple processing step alongside splitting a string into a list.

In this short guide, learn how to split a string into a list in Python. Also, learn how to split a string and then trim the elements, and make the first letters capitalized, through practical examples!

Python: Split String into List with split()

In this detailed guide, learn how to use the groupingBy() collector in Java 8 to collect and group elements of streams, with downstream collectors and suppliers, through examples.