<h3 id="introduction">Introduction</h3>
Counting sort is a sorting algorithm used to sort elements of an array in linear time. We usually use Counting Sort to sort integer arrays.
<blockquote>
Counting Sort is a stable, non-comparative algorithm.
</blockquote>
Non-comparative sorting algorithms perform sorting without any comparison between elements to be sorted.
Stable sorting algorithms preserve the relative order of elements with the same value in the sorted array. That means that the relative order of two same-value elements in the original array will be the same as their relative order in the sorted array.
<img src="https://i.postimg.cc/fwsYpzdf/radix-sort-in-python-01.png" alt="radix-sort-in-python-01.png">
Counting sort is not an in-place algorithm, it uses an auxiliary array to sort elements of an input array.
<h3 id="theideabehindthecountingsort">The Idea Behind the Counting Sort</h3>
Let's first take an intuitive look at how the algorithm works.
Assume that we have the array <code>I = [2, 2, 0, 6, 1, 9, 9, 7]</code> and we want to sort it. We'll call the array <code>I</code> the input array.
<blockquote>
Counting Sort works by counting the number of elements that fit a distinct key value, and then calculates the positions of each key.
</blockquote>
First of all, we need to find the element with the highest value, we'll call it the maximum element - <code>maxElement = 9</code>.
Then, we'll create an auxiliary array with <code>maxElement+1</code> elements, called the count array (C). We'll use it to store the number of occurrences of each individual element in the input array <code>I</code>. Therefore, all counts should be initialized to 0:
<pre><code class="hljs"> C = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # Count array 
 # indices: 0 1 2 3 4 5 6 7 8 9
</code></pre>
Now, we need to go through the following steps:
1. Go over each element of the input array and increase its corresponding count by <code>1</code>
For example, if we come across an element with the value of <code>2</code> in the input array (<code>I</code>), we add 1 to the element with the index <code>2</code> in the count array:
<pre><code class="hljs"> I = [2, 2, 0, 6, 1, 9, 9, 7] # The first element is 2
 ^
 
 C = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0] # We increase count of 2nd element by 1
#indices: 0 1 2 3 4 5 6 7 8 9
</code></pre>
After this step, the count array will store the number of occurrences of each element in the input array:
<pre><code class="hljs"> C = [1, 1, 2, 0, 0, 0, 1, 1, 0, 2] 
#indices: 0 1 2 3 4 5 6 7 8 9
 
# Element 0 has 1 occurrence
# Element 1 has 1 occurrence
# Element 2 has 2 occurrences 
# Element 3 has no occurrences...
</code></pre>
2. For each element in the count array, sum up its value with the value of all its previous elements, and store that value as the value of the current element:
<pre><code class="hljs"> C = [1, 2, 4, 4, 4, 4, 5, 6, 6, 8] 
#indices: 0 1 2 3 4 5 6 7 8 9
# Element 0 = 1
# Element 1 = 1 + 1
# Element 2 = 1 + 1 + 2
# Element 3 = 1 + 1 + 2 + 0
#...
</code></pre>
This way, we are storing the cumulative sum of the elements of the count array, on each step.
3. Calculate element position based on the count array values:
To store this sorted sequence, we'll need to create a new array. Let's call it the output array (<code>O</code>), and initialize it with <code>k</code> zeros, where <code>k</code> is the number of elements in the input array:
<pre><code class="hljs"> O = [0, 0, 0, 0, 0, 0, 0, 0] // Initialized output array
#indices: 0 1 2 3 4 5 6 7 
</code></pre>
For each element <code>I[i]</code> (starting from the end) in the input array:
<ol>
<li>Find the index in the count array that is equal to the value of the current element <code>I[i]</code>
<ul>
<li>That's the element <code>C[j]</code> where <code>j=I[i]</code></li>
</ul>
</li>
<li>Subtract <code>1</code> from the value of the <code>C[i]</code>
<ul>
<li>Now we have <code>newValue = C[i]-1</code></li>
</ul>
</li>
<li>Store the <code>I[i]</code> to the <code>O[newValue]</code></li>
<li>Update the <code>C[i]</code> with the <code>newValue</code></li>
</ol>
<img src="https://i.postimg.cc/C5GGyHXp/radix-sort-in-python-02.png" alt="radix-sort-in-python-02.png">
In the end, the output array contains the sorted elements of the input array!
<h3 id="howtoimplementcountingsortinpython">How to Implement Counting Sort in Python</h3>
Now, with all that out of the way - let's go ahead and implement Counting Sort in Python:
<pre><code class="hljs">def countingSort(inputArray):
 # Find the maximum element in the inputArray
 maxElement= max(inputArray)

 countArrayLength = maxElement+1

 # Initialize the countArray with (max+1) zeros
 countArray = [0] * countArrayLength

 # Step 1 -&gt; Traverse the inputArray and increase 
 # the corresponding count for every element by 1
 for el in inputArray: 
 countArray[el] += 1

 # Step 2 -&gt; For each element in the countArray, 
 # sum up its value with the value of the previous 
 # element, and then store that value 
 # as the value of the current element
 for i in range(1, countArrayLength):
 countArray[i] += countArray[i-1] 

 # Step 3 -&gt; Calculate element position
 # based on the countArray values
 outputArray = [0] * len(inputArray)
 i = len(inputArray) - 1
 while i &gt;= 0:
 currentEl = inputArray[i]
 countArray[currentEl] -= 1
 newPosition = countArray[currentEl]
 outputArray[newPosition] = currentEl
 i -= 1

 return outputArray

inputArray = [2,2,0,6,1,9,9,7]
print(&quot;Input array = &quot;, inputArray)

sortedArray = countingSort(inputArray)
print(&quot;Counting sort result = &quot;, sortedArray)
</code></pre>
Running the code above will produce the following output:
<pre><code class="hljs">Input array = [2, 2, 0, 6, 1, 9, 9, 7]
Counting sort result = [0, 1, 2, 2, 6, 7, 9, 9]
</code></pre>
<h3 id="thecomplexityofthecountingsortalgorithm">The Complexity of the Counting Sort Algorithm</h3>
The Counting sort algorithm uses only simple for and while loops without any complex recursions and subroutine calls, therefore, its complexity analysis is a pretty straightforward process.
Before we dive into the complexity analysis, let's label the length of the input array as <code>n</code> and the value of the maximum element in the input array as <code>k</code>.
<h4 id="timecomplexity">Time Complexity</h4>
The first step of the algorithm iterates over the input array n times in order to initialize the count array, so it has the complexity of O(n).
The second step iterates over the count k times in order to calculate the cumulative sum of each element, so it has the complexity of O(k).
The third step performs the sorting based on the counting array, so it has to iterate in a while loop <code>n</code> times, therefore it has the complexity of O(n).
Collectively, the time complexity of the Counting Sort algorithm is O(n+k).
<h4 id="spacecomplexity">Space Complexity</h4>
Counting sort uses input and output array, both of length <code>n</code> and one count array of length <code>(k+1)</code>.
Therefore, the total space that this algorithm uses is O(n+k).
<h3 id="conclusion">Conclusion</h3>
All in all, Counting Sort is a great and efficient, yet simple sorting algorithm. In ideal circumstances, it is really easy to understand and learn but still manages to maintain linear complexity.
The real problem occurs when the value of the largest element <code>k</code> exceeds the number of elements in the input array <code>n</code>. As the <code>k</code> approaches <code>n²</code>, the time complexity of the counting sort gets closer to O(n²), which is a horrible time complexity for a sorting algorithm. Therefore, it's not recommended to use counting sort if the input array has a large range of values.
Ideally, we will use Counting Sort to sort some integer arrays with a small range of values or as a subroutine for some other sorting algorithm, such as <a target="_blank" href="https://stackabuse.com/radix-sort-in-python">Radix Sort</a>. That way, we will ensure maximizing the full potential of the counting sort, while still avoiding all of the suboptimal use cases.

David Landup

Dimitrije Stamenic

In this guide, we'll take a look at the theory behind Counting Sort and implement it in Python, as well as analyze its time and space complexity.

Counting Sort in Python

<h2 id="introduction">Introduction</h2>
In this article, we will take a look at how to check if an element is hidden with JQuery. Here are the most common ways to check the visibility of an element:
<pre><code class="hljs">console.log($(myElement).is(&quot;:hidden&quot;)) 
console.log($(myElement).is(&quot;:visible&quot;)) 
console.log($(myElement).css(&quot;visibility&quot;) === &quot;hidden&quot;) 
console.log($(myElement).css(&quot;display&quot;) === &quot;none&quot;) 
console.log($(myElement).css(&quot;opacity&quot;) &lt;= &quot;0&quot;) 
</code></pre>
<blockquote>
&quot;Why are there so many ways to check visibility?&quot;
</blockquote>
Multiple factors can play a role in the visibility of an element! We will cover each case and consider when it's wise to use them. Though, first, let's set up our test environment.
<h2 id="environmentsetup">Environment Setup</h2>
For this tutorial, we will use jQuery Core, version 3.6.0. You can get the latest CDN from <a href="https://code.jquery.com/" target="_blank" rel="nofollow noopener">jQuery's official website</a>.
Let's start by creating an <code>index.html</code> file with the boilerplate code most pages have, and add a <code>&lt;p&gt;</code> element with a class named <code>first-element</code> to the <code>&lt;body&gt;</code>:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html lang=&quot;en&quot;&gt;

&lt;head&gt;
 &lt;meta charset=&quot;UTF-8&quot;&gt;
 &lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;
 &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;
 &lt;script src=&quot;https://code.jquery.com/jquery-3.6.0.min.js&quot;
 integrity=&quot;sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=&quot; crossorigin=&quot;anonymous&quot;&gt;&lt;/script&gt;
 &lt;title&gt;Document&lt;/title&gt;
&lt;/head&gt;

&lt;body&gt;
 &lt;p class=&quot;first-element&quot; &gt;This is the first paragraph.&lt;/p&gt;
&lt;/body&gt;

&lt;/html&gt;
</code></pre>
Now let’s hide this paragraph, so that we can test its visibility with <code>.is(&quot;:hidden&quot;)</code>! To hide the <code>first-element</code> we can simply add <code>hidden</code> attribute to it:
<pre><code class="hljs">&lt;p class=&quot;first-element&quot; hidden&gt;This is the first paragraph&lt;/p&gt;
</code></pre>
Note: Reload the page and confirm that the <code>first-element</code> is no longer visible.
<h2 id="checkifelementishiddenwithishidden">Check if Element is Hidden with .is(&quot;:hidden&quot;)</h2>
To use <code>.is(&quot;:hidden&quot;)</code> you can either create <code>&lt;script&gt;&lt;/script&gt;</code> tags and add your JavaScript code within them, or use the Console tool of your browser to execute the code directly. Pick whichever you wish, it will not affect the outcome.
Either way, you can read the output from the Console tab (by pressing <code>F12</code> or <code>Ctrl + Shift + I</code> for most browsers). Alternatively, you can right-click on the page and select &quot;Inspect&quot; from the menu. In Firefox it's &quot;Inspect element&quot;.
<code>.is(&quot;:hidden&quot;)</code> will return <code>true</code> if the selected element is hidden. If it's not hidden, then it will return <code>false</code>.
Let's use this method on our hidden <code>.first-element</code>:
<pre><code class="hljs">var myElement = &quot;.first-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
</code></pre>
If you check the Console tab of your browser, you should see the following output:
<pre><code class="hljs">.first-element is hidden?: true
</code></pre>
Fairly simple, right? We can use the method <code>is(&quot;:visible&quot;)</code> to verify our current result.
<h2 id="checkifelementishiddenwithisvisible">Check if Element is Hidden with is(&quot;:visible&quot;)</h2>
<code>is(&quot;:visible&quot;)</code> will test the visibility of an element and will return <code>true</code> if the selected element is visible, or it will return <code>false</code> if it is hidden.
As you've noticed, it is the direct opposite of the <code>.is(&quot;:hidden&quot;)</code> method. This means that both of them can’t return the same value for the same element. Not at the same time at least.
Let's test it on the <code>first-element</code> and observe the result:
<pre><code class="hljs">var myElement = &quot;.first-element&quot;;
console.log(myElement + &quot; is visible?: &quot; + $(myElement).is(&quot;:visible&quot;));
</code></pre>
As expected, it will output a <code>false</code> value:
<pre><code class="hljs">.first-element is visible?: false
</code></pre>
Note that you would also get the same results when working with the hidden inputs:
<pre><code class="hljs">&lt;input type=&quot;hidden&quot; class=&quot;inp-element&quot; value=&quot;3487&quot;&gt;
</code></pre>
Although the <code>hidden</code> parameter passed into our <code>input</code> element via the <code>type</code> attribute, it still produces the same result.
So far so good. Now let's take our game one step forward and see how to test visibility that has been modified by the CSS.
<h2 id="checkifelementishiddenwithcssvisibility">Check if Element is Hidden with .css(&quot;visibility&quot;)</h2>
Let's add two more items into our DOM:
<pre><code class="hljs">&lt;p class=&quot;second-element&quot;&gt;This is the second paragraph.&lt;/p&gt;
&lt;p class=&quot;third-element&quot;&gt;This is the third paragraph.&lt;/p&gt;
</code></pre>
Refresh/reload your page and confirm that new elements are added.
Now we will change the <code>visibility</code> property of the <code>second-element</code>. To do so, you can create a CSS file and link it to your HTML file or write your CSS code inside the <code>&lt;head&gt;</code> tag of your HTML file, inside the <code>&lt;style&gt;&lt;/style&gt;</code> tags:
<pre><code class="hljs">.second-element{
 visibility: hidden; 
}
</code></pre>
Now this part is a bit tricky. Before reloading the page, take a good look at the current position of the <code>third-element</code>. If you refresh the page, you will notice that the <code>second-element</code> is not visible anymore, but it still takes up the same space. It is not visible, yet the position of the <code>third-element</code> implies that it's still there. In fact, if we go ahead and run our previous functions for this element:
<pre><code class="hljs">var myElement = &quot;.second-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
console.log(myElement + &quot; is visible?: &quot; + $(myElement).is(&quot;:visible&quot;));
</code></pre>
We would get the result that it is not hidden, but it still is visible:
<pre><code class="hljs">.second-element is hidden?: false
.second-element is visible?: true
</code></pre>
The reason is that when you set the <code>visibility</code> property to <code>hidden</code>, it becomes invisible but it is still rendered by the browser, so it takes up its initial space. Most browsers consider elements visible if it has <code>height</code> and/or <code>width</code>. In other words, any element with zero dimensions is considered hidden.
Now that we know what we're dealing with, all we have to do is to check if <code>visibility</code> property of the element is set to <code>hidden</code>, not whether the element itself is <code>hidden</code>:
<pre><code class="hljs">var myElement = &quot;.second-element&quot;;
console.log(myElement + &quot; is visibility === hidden?: &quot; + ($(myElement).css(&quot;visibility&quot;) === &quot;hidden&quot;));
</code></pre>
This will return <code>true</code>:
<pre><code class="hljs">.second-element is visibility === hidden?: true
</code></pre>
While we're at it, let's work out what other CSS properties affect the visibility.
<h2 id="checkifelementishiddenwithcssdisplay">Check if Element is Hidden with .css(&quot;display&quot;)</h2>
Another CSS property that is commonly used to hide elements is <code>display</code>. We already have our <code>third-element</code> ready in our DOM. So all we have to do is set its <code>display</code> to <code>none</code>:
<pre><code class="hljs">.third-element {
 display: none; 
}
</code></pre>
Upon refreshing the page, you can see that it is not visible anymore.
Now, the good thing about <code>display: none;</code> is that we can select it correctly by using our previous <code>is(&quot;:hidden&quot;)</code> and <code>is(&quot;:visible&quot;)</code> methods:
<pre><code class="hljs">var myElement = &quot;.third-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
console.log(myElement + &quot; is visible?: &quot; + $(myElement).is(&quot;:visible&quot;));
</code></pre>
Since the browser doesn't render the <code>third-element</code>, we get the results as expected:
<pre><code class="hljs">.third-element is hidden?: true
.third-element is visible?: false
</code></pre>
We can also select it with using the <code>.css()</code> selector:
<pre><code class="hljs">var myElement = &quot;.third-element&quot;;
console.log(myElement + &quot; is css.display == none?: &quot; + ($(myElement).css(&quot;display&quot;) === &quot;none&quot;));
</code></pre>
And we would get the following output as a result:
<pre><code class="hljs">.third-element is css.display == none?: true
</code></pre>
Another way to make an element invisible is to set its opacity to zero. In the next section, we will create a new element, change its opacity, and check whether it's visible or not.
<h2 id="checkifelementishiddenwithcssopacity">Check if Element is Hidden with .css(&quot;opacity&quot;)</h2>
Making an item invisible via opacity behaves similarly to setting the <code>visibility</code> property to <code>hidden</code>. For this reason, we will add two more elements to observe the change better:
<pre><code class="hljs">&lt;p class=&quot;fourth-element&quot;&gt;This is the fourth paragraph.&lt;/p&gt;
&lt;p class=&quot;visible-element&quot;&gt;Lorem ipsum dolor sit amet consectetur adipisicing elit. Quis corrupti inventore, et beatae accusantium perferendis?&lt;/p&gt;
</code></pre>
Now let's add some padding to emphasize the space taken by the <code>fourth-element</code>, and also set it's opacity to zero:
<pre><code class="hljs">.fourth-element {
 padding: 30px;
 opacity: 0;
}
</code></pre>
Refreshing the page, you will notice the absence of the <code>fourth-element</code>. It has dimensions, thus it's rendered, but it is not opaque, so it is not visible.
So naturally, all the following methods:
<pre><code class="hljs">var myElement = &quot;.fourth-element&quot;;
console.log(myElement + &quot; is hidden?: &quot; + $(myElement).is(&quot;:hidden&quot;));
console.log(myElement + &quot; is visibility === hidden?: &quot; + ($(myElement).css(&quot;visibility&quot;) === &quot;hidden&quot;));
console.log(myElement + &quot; is css.display == none?: &quot; + ($(myElement).css(&quot;display&quot;) === &quot;none&quot;));
</code></pre>
Will return <code>false</code>:
<pre><code class="hljs">.fourth-element is hidden?: false
.fourth-element is visibility === hidden?: false
.fourth-element is css.display == none?: false
</code></pre>
The only way to catch this invisible element, is to use the <code>.css(&quot;opacity&quot;)</code> selector:
<pre><code class="hljs">var myElement = &quot;.fourth-element&quot;;
console.log(myElement + &quot; is opacity lesser than or equal to 0?: &quot; + ($(myElement).css(&quot;opacity&quot;) &lt;= &quot;0&quot;));
</code></pre>
This returns <code>true</code>:
<pre><code class="hljs">.fourth-element is opacity lesser than or equal to 0?: true
</code></pre>
And this concludes our tutorial on how to check if an element is hidden with jQuery!
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned how to check the visibility of an element using jQuery selectors. While the <code>.is(&quot;:hidden&quot;)</code>, <code>is(&quot;:visible&quot;)</code>, and <code>.css(&quot;display&quot;)</code> selectors are good choice to select the non-rendered elements, <code>.css(&quot;visibility&quot;)</code> and <code>.css(&quot;opacity&quot;)</code> are the best fits for the elements that are rendered but not visible to human eyes.

Marcus Sanatan

Ruslan Hasanov

An element in HTML can be hidden through different properties, attributes and CSS configurations. In this article, we'll use jQuery to determine if an element is hidden.

JavaScript: Check if Element is Hidden with jQuery

If you've been working with Git long enough, you've probably had times where you made changes to your codebase, but needed to switch branches or work with the latest working version of your code. However, you don't want to lose the changes you've made already, but they're not yet ready to commit the updates since they're not finished. What should you do?
<h2 id="gitstash">Git Stash</h2>
Luckily, Git provides a mechanism to handle cases like this through the command <code>git stash</code>. The <code>stash</code> command takes the uncommitted changes in your working directory, both the updated tracked files and staged changes, and saves them.
Let's say you're working on a new feature and you made some modifications to your code, and you now have one or more files with uncommitted modifications:
<pre><code class="hljs">$ git status
On branch master
Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)

 modified: index.js

no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
However, the changes aren't finished, and you need to switch to a different branch to quickly fix a bug before continuing on with the current feature. To avoid losing the current updates you've made, you can just stash the changes instead and get them back later without messing up your commit history.
<pre><code class="hljs">$ git stash
Saved working directory and index state WIP on master: bbf6ef9 Initial commit
HEAD is now at bbf6ef9 Initial commit
</code></pre>
As you can see, <code>HEAD</code> is now back to our last commit, which in this case is the initial commit. To verify, look for changes using <code>git status</code>:
<pre><code class="hljs">$ git status
On branch master
nothing to commit, working tree clean
</code></pre>
We're back to where we started as if we never made the changes at all! Now you can go off and fix that bug.
But what about restoring your changes? To get them back, we can simply use the <code>apply</code> sub-command, which takes the last-stashed changes and puts them back into your working directory.
<pre><code class="hljs">$ git stash apply
On branch master
Changes not staged for commit:
 (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
 (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)

 modified: index.js

no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
</code></pre>
And just like that, you have your changes back.
<h2 id="advancedfeatures">Advanced Features</h2>
In the examples above, we used <code>stash</code> in the simplest context. As we tend to find out in our day-to-day programming, real-world use-cases aren't usually that simple. What if, for example, you end up needing to stash changes from your working directory multiple times? Luckily, <code>stash</code> allows you to do just that. Technically, when you stash changes, Git puts the changes on a stack, which can then be pulled off in a LIFO (last in, first out) order. You're able to view this stack using the <code>list</code> subcommand.
<pre><code class="hljs">$ git stash list
stash@{0}: WIP on master: 7513525 Fixed console output
stash@{1}: WIP on master: 91f33cc Fixed output punctuation
stash@{2}: WIP on master: bbf6ef9 Initial commit
stash@{3}: WIP on master: bbf6ef9 Initial commit
</code></pre>
The stashed work at the top of the list is what you'll get when using the <code>apply</code> command without any extra arguments. If there is a different stash you'd like to get instead, you can specify it using the identifier at the beginning of each line. For example, to get the second stash, you would use the following:
<pre><code class="hljs">$ git stash apply stash@{1}
On branch master
nothing to commit, working tree clean
</code></pre>
You may notice that after using the <code>apply</code> subcommand, the stash will still be on the stack. In order to apply it and remove it from the stack, use <code>pop</code> instead.
<pre><code class="hljs">$ git stash pop stash@{0}
On branch master
nothing to commit, working tree clean
Dropped stash@{0} (9079b4ffdf46574701cffcd68eb4feba80ebcf72)
</code></pre>
This stash is now no longer in our stack:
<pre><code class="hljs">$ git stash list
stash@{0}: WIP on master: 91f33cc Fixed output punctuation
stash@{1}: WIP on master: bbf6ef9 Initial commit
stash@{2}: WIP on master: bbf6ef9 Initial commit
</code></pre>
But what if you want to remove a stash without applying it to your current working directory? This can be achieved with <code>drop</code>, which works much like <code>apply</code> and <code>pop</code> syntactically:
<pre><code class="hljs">$ git stash drop stash@{2}
Dropped stash@{2} (5483fdec3496572c8b943504b6029d45a7999453)
</code></pre>
And, as expected, that stash was not applied and it is gone from the stash stack:
<pre><code class="hljs">$ git status
On branch master
nothing to commit, working tree clean
$ git stash list
stash@{0}: WIP on master: 91f33cc Fixed output punctuation
stash@{1}: WIP on master: bbf6ef9 Initial commit
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Unsurprisingly, Git has a solution for most problems that arise in version control since it's been around for such a long time. Here we've seen how to handle the use-case where you have changes in your working directory, but you want to switch branches and not commit the unfinished changes. The <code>stash</code> command can be very powerful, and there are more features to it than what was covered here, like various flags that are available, which we'll save for another article.

Scott Robinson

Git: Stashing Uncommitted Changes

<h2 id="introduction">Introduction</h2>
Elasticsearch initially began as a custom search engine. These days, it has gone above and beyond that singular role as it's part of log aggregation stacks, security monitoring, and even as a datastore for performing exploratory analysis.
Indices in Elasticsearch are where the data is stored, and there are often times when these indices need to be transported from one cluster to another. Perhaps we just need a safe backup before moving data to another cluster or upgrading versions. Elasticdump is a tool that helps in facilitating this backup and restore operation.
<blockquote>
Elasticdump is a tool made to move and save Elasticsearch indices.
</blockquote>
In this guide, we'll take a look at how to use Elasticdump and how to create and move indices between clusters on your local computer.

 <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 follow this tutorial, you need to have <a href="/docker-a-high-level-introduction" target="_blank">docker installed</a>, as well as <a href="/how-to-install-node-js-on-ubuntu" target="_blank">NPM</a>.

 </div>
 </div>
 </div>
 <h2 id="whatiselasticdumpandwhyuseit">What Is Elasticdump, and Why Use It?</h2>
Those familiar with Elasticsearch would know of its &quot;Snapshot and Restore&quot; feature to facilitate these operations. Yes, it is indeed a smart feature that helps back up individual indices or an entire cluster. While exploring that option for a small number of indices or clusters, you may find that using the &quot;Snapshot and Restore&quot; feature could be an overkill. This is even more pronounced when there's no system to incrementally take snapshots.
This is where Elasticdump can help - it's a lightweight tool that can move and save indices with a remote repository required by Elasticsearch's &quot;Snapshot and Restore&quot;.
Here's what Elasticdump can do:
<ul>
<li>Copy the indices from one cluster to the other</li>
<li>Dump indices to flat files</li>
<li>Back up indices &amp; mappings</li>
<li>Restore indices across different versions of Elasticsearch</li>
<li>Multielasticdump that comes along with Elasticdump can export multiple indices in parallel</li>
</ul>
<h2 id="settingupelasticdump">Setting up Elasticdump</h2>
<h3 id="installation">Installation</h3>
Elasticdump is a Node package and it can be directly downloaded from <a href="https://www.npmjs.com/package/elasticdump" target="_blank" rel="noopener nofollow">NPM</a>. We'll need to have Node.js installed, alongside the Node Package Manager (NPM).
Let's go ahead and install them, before downloading Elasticdump:
<pre><code class="hljs">$ sudo apt install nodejs npm # Install Node.js + NPM
$ sudo npm install n -g # Install helper package to get latest Node.js + NPM versions
/usr/local/bin/n -&gt; /usr/local/lib/node_modules/n/bin/n
/usr/local/lib
└── n@7.2.2
$ sudo n latest # Get latest version of NPM

 installing : node-v16.2.0
 mkdir : /usr/local/n/versions/node/16.2.0
 fetch : https://nodejs.org/dist/v16.2.0/node-v16.2.0-linux-x64.tar.xz
 installed : v16.2.0 (with npm 7.13.0)

Note: the node command changed location and the old location may be remembered in your current shell.
 old : /usr/bin/node
 new : /usr/local/bin/node
To reset the command location hash either start a new shell or execute PATH=&quot;$PATH&quot;

$ sudo npm install elasticdump -g # Install Elasticdump globally on your local machine
</code></pre>
This installs Elasticdump globally and the installation can be verified using the following command:
<pre><code class="hljs">$ elasticdump --version
6.71.0
</code></pre>
<h3 id="settingupanelasticsearchclusteroptional">Setting Up an Elasticsearch Cluster (Optional)</h3>
To test Elasticdump out, you will have to have at least one Elasticsearch cluster with a single node setup. If you have an Elasticsearch cluster running already, <a href="#elasticdumpinaction">you may skip this step</a>.
For others, the following commands will spin up an Elasticsearch container for you. Make sure you have Docker or Docker Desktop installed and running on your machine. You can download your suitable installer from <a href="https://www.docker.com/products/docker-desktop" target="_blank" rel="noopener nofollow">here</a>.
Once your Docker server is up and running, let's create a directory, which will contain the volume to hold Elasticsearch's data. If this is not done, Elasticsearch volume would be ephemeral and your data will be lost if the container goes down:
<pre><code class="hljs">$ mkdir -p data/ES9200
$ mkdir -p data/ES9400
$ vol_location=`pwd`
</code></pre>
You can now spin up your Elasticsearch container by keying in the following command:
<pre><code class="hljs">$ docker run -p 9200:9200 -p 9300:9300 -e &quot;discovery.type=single-node&quot; -v ${vol_location}/data/es9200:/usr/share/elasticsearch/data --name=es_source -d docker.elastic.co/elasticsearch/elasticsearch:7.13.0
</code></pre>
Let's break this command down a bit.
We've commanded Docker to publish (<code>-p</code> flag) port <code>9200</code> on your host machine to the <code>9200</code> port on your container, and the same process is then run for <code>9300</code>. We have also assigned an environment variable (<code>-e</code> flag) stating that it is going to be a single node setup.
Then, we attach the volume (<code>-v</code> flag) to the directory created in the previous setup, mapped to the data directory inside the container, in which the data will be stored.
Finally, the <code>--name</code> flag is to give a nice name to the container while the <code>-d</code> flag is to make the container run in the background, and <code>docker.elastic.co/elasticsearch/elasticsearch:7.13.0</code> is the name of the image.
We'll copy data from this Elasticsearch cluster to another cluster, using Elasticdump. To make this happen, you can create another cluster known as <code>es_target</code> by issuing the following command:
<pre><code class="hljs">$ docker run -p 9400:9200 -p 9500:9300 -e &quot;discovery.type=single-node&quot; -v ${vol_location}/data/es9400:/usr/share/elasticsearch/data --name=es_target -d docker.elastic.co/elasticsearch/elasticsearch:7.13.0
</code></pre>
Note: The service won't run on a port that's already being used by another service.
You can check if your Elasticsearch cluster containers are running fine by issuing the following command:
<pre><code class="hljs">$ docker ps
CONTAINER ID IMAGE COMMAND CREATED
STATUS PORTS NAMES
c0aa983abb21 docker.elastic.co/elasticsearch/elasticsearch:7.13.0 &quot;/bin/tini -- /usr/l…&quot; 9 hours ago
Up 2 hours 0.0.0.0:9400-&gt;9200/tcp, :::9400-&gt;9200/tcp, 0.0.0.0:9500-&gt;9300/tcp, :::9500-&gt;9300/tcp es_target
eb30714b5302 docker.elastic.co/elasticsearch/elasticsearch:7.13.0 &quot;/bin/tini -- /usr/l…&quot; 10 hours ago Up 3 hours 0.0.0.0:9200-&gt;9200/tcp, :::9200-&gt;9200/tcp, 0.0.0.0:9300-&gt;9300/tcp, :::9300-&gt;9300/tcp es_source
</code></pre>
The containers that you have created look good! Let's dive into the usage of Elasticdump.
<h2 id="workingwithelasticdump">Working with Elasticdump</h2>
With a container ready, we can start working with Elasticdump.
<h3 id="restoringtheindex">Restoring the Index</h3>
The clusters are ready, but they look empty. Let's create an index and load data to one of the clusters. The <code>es_source</code> cluster runs on port <code>9200</code> and can be accessed via <code>http://localhost:9200</code>. Run the following commands to download the mapping and the data to be loaded:
<pre><code class="hljs">$ wget https://raw.githubusercontent.com/StackAbuse/moving-elasticsearch-indices-with-elasticdump/main/logs_mapping.json
$ wget https://raw.githubusercontent.com/StackAbuse/moving-elasticsearch-indices-with-elasticdump/main/logs_data.json
</code></pre>
Let's try loading these files to the <code>es_source</code> cluster under the index <code>log-2021-06-01</code> using Elasticdump:
<pre><code class="hljs">$ elasticdump --input=logs_mapping.json --output=http://localhost:9200/log-2021-06-01 --type=mapping
$ elasticdump --input=logs_data.json --output=http://localhost:9200/logindex --type=data
</code></pre>
There are three flags here: <code>--input</code> corresponds to the JSON file that we have downloaded, <code>--output</code> corresponds to the cluster endpoint, and <code>--type</code> corresponds to either mapping or data which defines what to export.
Elasticdump takes the input as these files and writes the output to the <code>log-2021-06-01</code> index as:
<pre><code class="hljs">$ elasticdump --input=logs_mapping.json --output=http://localhost:9200/log-2021-06-01 --type=mapping
Sat, 05 Jun 2021 12:30:52 GMT | starting dump
Sat, 05 Jun 2021 12:30:52 GMT | got 1 objects from source file (offset: 0)
Sat, 05 Jun 2021 12:30:59 GMT | sent 1 objects to destination elasticsearch, wrote 1
Sat, 05 Jun 2021 12:30:59 GMT | got 0 objects from source file (offset: 1)
Sat, 05 Jun 2021 12:30:59 GMT | Total Writes: 1
Sat, 05 Jun 2021 12:30:59 GMT | dump complete

$ elasticdump --input=logs_data.json --output=http://localhost:9200/log-2021-06-01 --type=data
Sat, 05 Jun 2021 12:31:23 GMT | starting dump
Sat, 05 Jun 2021 12:31:24 GMT | got 100 objects from source file (offset: 0)
Sat, 05 Jun 2021 12:31:26 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 12:31:26 GMT | got 100 objects from source file (offset: 100)
Sat, 05 Jun 2021 12:31:27 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 12:31:27 GMT | got 100 objects from source file (offset: 200)
Sat, 05 Jun 2021 12:31:28 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 12:31:28 GMT | got 0 objects from source file (offset: 300)
Sat, 05 Jun 2021 12:31:28 GMT | got 0 objects from source file (offset: 300)
Sat, 05 Jun 2021 12:31:28 GMT | Total Writes: 300
Sat, 05 Jun 2021 12:31:28 GMT | dump complete
</code></pre>
Let's check if the restoration is completed successfully:
<pre><code class="hljs">$ curl localhost:9200/_cat/indices
yellow open log-2021-06-01 UD4SRzu-TjCNdVZatdOQsA 1 1 300 0 305.5kb 305.5kb
</code></pre>
There are 300 documents in Elasticsearch constituting a total size of <code>305.5kb</code>.
<h3 id="copyingtheindexacrossclusters">Copying the Index Across Clusters</h3>
The syntax seen above is similar across the usage of Elasticdump for different scenarios. Let's now copy the index created previously into a new index on another cluster:
<pre><code class="hljs">$ elasticdump --input=http://localhost:9200/log-2021-06-01 --output=http://localhost:9400/log-2021-06-01
Sat, 05 Jun 2021 10:05:24 GMT | starting dump
Sat, 05 Jun 2021 10:05:24 GMT | got 100 objects from source elasticsearch (offset: 0)
Sat, 05 Jun 2021 10:05:28 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 10:05:28 GMT | got 100 objects from source elasticsearch (offset: 100)
Sat, 05 Jun 2021 10:05:28 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 10:05:28 GMT | got 100 objects from source elasticsearch (offset: 200)
Sat, 05 Jun 2021 10:05:30 GMT | sent 100 objects to destination elasticsearch, wrote 100
Sat, 05 Jun 2021 10:05:30 GMT | got 0 objects from source elasticsearch (offset: 300)
Sat, 05 Jun 2021 10:05:30 GMT | Total Writes: 300
Sat, 05 Jun 2021 10:05:30 GMT | dump complete
</code></pre>
Elasticdump will create a new index for you if the output index doesn't exist. Let's again verify if the index has been created properly.
<pre><code class="hljs">$ curl localhost:9400/_cat/indices
yellow open log-2021-06-01 UD4SRzu-TjCNdVZatdOQsA 1 1 300 0 305.5kb 305.5kb
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As simple as it sounds, the Elasticdump tool is a must-have tool for anyone dealing with Elasticsearch.

Sathiya Sarathi Gunasekaran

Elasticdump is a lightweight tool that copies data to and from Elasticsearch indices. In this guide, we'll take a look at how to install and use Elasticdump to make your work with Elasticsearch easier.

Guide to Elasticdump - Moving and Saving Elasticsearch Indices

<h2 id="introduction">Introduction</h2>
Measuring code execution time is a vital step in trying to write efficient applications. Temporal awareness of your code on a machine that might be serving a great deal of users lets you plan further, accounting for the execution time.
In multi-threaded systems, it's also useful to measure the execution time of individual <code>Thread</code>s or asynchronous tasks.
Since there's no built-in, convenient way to measure code execution in Java - for Spring-based solutions, we've been introduced to the <code>StopWatch</code> tool.
In this tutorial, we'll take a look at how to measure code execution time in Java with Spring's <code>StopWatch</code>.
<h2 id="springsstopwatchclass">Spring's StopWatch Class</h2>
The <code>StopWatch</code> is a utility class, residing in the <code>util</code> package. It has a very simple API and allows us to time named tasks, groups of tasks and the total running time of a program.
This class is normally used to check the performance of code during the development phase, rather than a part of production applications.
Note: It is worth noting that <code>StopWatch</code> is not thread-safe.
It tracks the time in nanoseconds, relying on <code>System.nanoTime()</code>, which is what people have been doing manually to time the execution of their code.
<h2 id="measuringcodeexecutiontimewithstopwatch">Measuring Code Execution Time with StopWatch</h2>
The <code>StopWatch</code> belongs to the core <code>util</code> package of Spring:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework&lt;/groupId&gt;
 &lt;artifactId&gt;spring-core&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Naturally, it's also present in the <code>spring-boot-starter-web</code> dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
The API of <code>StopWatch</code> boils down to creating an instance and calling <code>start()</code> and <code>stop()</code> - as if timing the code with an actual stopwatch. When starting the timing, you can also provide a <code>String</code> to be used as a name or annotation for the associated task. This helps differentiate them in the results.
<blockquote>
A task is simply the period between a <code>start()</code> and <code>stop()</code> call. For each task, created when a <code>StopWatch</code> starts - its name and execution time are saved in a <code>TaskInfo</code> instance, and added to the task list.
</blockquote>
Let's go ahead and create a task, with a name and measure a piece of code's execution time:
<pre><code class="hljs">StopWatch timeMeasure = new StopWatch();

timeMeasure.start(&quot;Task 1&quot;);
Thread.sleep(1000);
timeMeasure.stop();

System.out.println(&quot;Last task time in Millis: &quot; 
 + timeMeasure.getLastTaskMillis());
</code></pre>
This results in:
<pre><code class="hljs">Last task time in Millis: 1009
</code></pre>
You can access the sum of all tasks through <code>getTotalTimeSeconds()</code>, <code>getTotalTimeMillis()</code> and <code>getTotalTimeNanos()</code>.
You can also access the last task of the <code>StopWatch</code> through <code>getLastTaskInfo()</code>, which returns a <code>TaskInfo</code> instance. This instance contains information on the last task such as the name and how long it took in seconds, milliseconds and nanoseconds:
<pre><code class="hljs">StopWatch stopWatch = new StopWatch();

stopWatch.start(&quot;Task 1&quot;);
Thread.sleep(1000);
stopWatch.stop();

System.out.println(stopWatch.getLastTaskInfo().getTaskName());

System.out.println(stopWatch.getLastTaskInfo().getTimeMillis());
</code></pre>
This now results in:
<pre><code class="hljs">Task 1
1008
</code></pre>
When dealing with multiple tasks, a really handy method is the <code>prettyPrint()</code> method - which prints all of the records in a table-like fashion, with simple formatting:
<pre><code class="hljs">// Naming this StopWatch instance
StopWatch stopWatch = new StopWatch(&quot;Measure Code Execution&quot;);
 
stopWatch.start(&quot;1. Task&quot;);
Thread.sleep(2000);
stopWatch.stop();
 
stopWatch.start(&quot;2. Task&quot;);
Thread.sleep(5000);
stopWatch.stop();
 
stopWatch.start(&quot;3. Task&quot;);
Thread.sleep(3000);
stopWatch.stop();
 
System.out.println(stopWatch.prettyPrint());
</code></pre>
Output:
<pre><code class="hljs">StopWatch &#x27;Measure Code Execution&#x27;: running time = 10012348500 ns
---------------------------------------------
ns % Task name
---------------------------------------------
2002729600 020% 1. Task
5006985700 050% 2. Task
3002633200 030% 3. Task
</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: If we're using <code>StopWatch</code> to measure the code execution time for a large number of intervals (on the order of hundreds of thousands or millions) - the <code>TaskInfo</code> list will consume a significant portion of your working memory. You can turn it off via:
<pre><code class="hljs">stopWatch.setKeepTaskList(false);
</code></pre>

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this tutorial, we took a look at the <code>StopWatch</code> utility class - Spring's answer to the inherent lack of time measurement tools in Java.

Ognjen Jankovic

In this tutorial, we'll take a look at how to measure Java code execution time for Spring-based projects via StopWatch and its simple API.

Measuring Java Code Execution Time with Spring's StopWatch

<h2 id="introduction">Introduction</h2>
Python has a lot of built-in tools that allow us to iterate and transform data. A great example is the <code>itertools</code> module, which offers several convenient iteration functions. Each of these iterator-building functions (they generate iterators) can be used on their own, or combined.
The module was inspired by functional languages such as APL, Haskell, and SPL and the elements within <code>itertools</code> from Python's iterator algebra.
<h2 id="iterablevsiterator">Iterable vs Iterator</h2>
Before we dive into the iteration, let's first define the distinction between two important terms: iterable and iterator.
An iterable is an object which can be iterated over. When using the <code>iter()</code> function, an iterator is being generated. Generally speaking, most sequences are iterable, such as lists, tuples, strings, etc.
An iterator is also an object, which is used to iterate over an iterable and an iterator can also iterate over itself. This is done by using the <code>next()</code> method, passing in the iterator that we're trying to traverse.
The <code>next()</code> method returns the next element of an iterable object. An iterator can be generated from an iterable (using <code>iter()</code>):
<pre><code class="hljs">list = [1,2,3,4,5]
iterator = iter(list)

print(iterator)
</code></pre>
This results in:
<pre><code class="hljs">&lt;list_iterator object at 0x0000018E393A0F28&gt;
</code></pre>
Now, let's access the <code>next()</code> element (starting at the first one) using our <code>iterator</code>:
<pre><code class="hljs">print(next(iterator))
</code></pre>
This results in:
<pre><code class="hljs">1
</code></pre>
This is practically what happens under the hood of the <code>for</code> loop - it calls <code>iter()</code> on the collection you're iterating over, and after that, the <code>next()</code> element is accessed <code>n</code> times.
In this tutorial, we'll be taking a look at a few Python iteration tools:
<ul>
<li><a href="#methodcount">count()</a></li>
<li><a href="#methodcycle">cycle()</a></li>
<li><a href="#methodchain">chain()</a></li>
</ul>
<h2 id="thecountfunction">The count() Function</h2>
The <code>count(start, step)</code> function creates an iterator and is used to generate evenly-spaced values, where the space between them is defined by the <code>step</code> argument. The <code>start</code> argument defines the starting value of the iterator - and these are set to <code>start=0</code> and <code>step=1</code> by default.
Without a braking condition, the <code>count()</code> function will continue counting indefinitely (on a system with indefinite memory):
<pre><code class="hljs">from itertools import count

iterator_count = count(start=0, step=5)

for i in iterator_count:
 if(i == 25):
 break
 print(i)
</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: Using <code>count()</code> like this is unusual. You'd typically chain it with other methods, such as <code>zip()</code>, <code>map()</code>, or <code>imap()</code>.

 </div>
 </div>
 </div>
 The iterator iterates over itself here, printing values in steps of 5:
<pre><code class="hljs">0
5
10
15
20
</code></pre>
Given its generative nature, this function is most commonly used with other functions that expect new or generate sequences.
For example, when using <code>zip()</code> to zip together multiple items of a list, you might want to annotate them via a positional index. While zipping, we'd use <code>count()</code> to generate values for these indices:
<pre><code class="hljs">from itertools import count

list = [&#x27;John&#x27;, &#x27;Marie&#x27;, &#x27;Jack&#x27;, &#x27;Anna&#x27;]
for i in zip(count(), list):
 print(i)
</code></pre>
This results in:
<pre><code class="hljs">(0, &#x27;John&#x27;)
(1, &#x27;Marie&#x27;)
(2, &#x27;Jack&#x27;)
(3, &#x27;Anna&#x27;)
</code></pre>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you'd like to read more about the <code>zip()</code> function, s well as some other commonly used functions alongside it - read our guide on <a rel="nofollow noopener" target="_blank" href="https://stackabuse.com/pythons-iteration-tools-filter-islice-map-and-zip">Python Iteration Tools - filter(), islice(), map() and zip()</a>.

 </div>
 </div>
 </div>
 <h2 id="thecyclefunction">The cycle() Function</h2>
The <code>cycle()</code> function accepts an iterable and generates an iterator, which contains all of the iterable's elements. In addition to these elements, it contains a copy of each element.
Once we iterate through to the end of the elements, we start iterating through the copies. While iterating through the copies, new copies are made. Once the first set of copies runs out - we iterate through the new set.
This process is repeated indefinitely.

 <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: Given this fact, using <code>cycle()</code>, especially for longer sequences is extremely memory-burdening.

 </div>
 </div>
 </div>
 Beware of infinite, recursive creation logic, since you'll easily run out of memory to house it all:
<pre><code class="hljs">from itertools import cycle

list = [1,2,3,4]
iterator = cycle(list)

for i in iterator:
 print(i)
</code></pre>
This results in:
<pre><code class="hljs">1
2
3
4
1
2
3
4
...
</code></pre>
Until we terminate the program or run out of memory. That being said - you should always have an exit/termination condition for the <code>cycle()</code> function.
Given the fact that <code>cycle()</code> can cycle through any iterable, we can easily apply it to strings and tuples as well:
<pre><code class="hljs">from itertools import cycle

string = &quot;This is a random string&quot;
iterator = cycle(string)

for i in iterator:
 print(i)
</code></pre>
This results in an endless sequence of:
<pre><code class="hljs">T
h
i
s
i
s
a
r
a
n
d
o
...
</code></pre>
<h2 id="thechainfunction">The chain() Function</h2>
The <code>chain()</code> function is used to chain multiple iterables together, by generating an iterator that traverses them sequentially, one after the other:
<pre><code class="hljs">result = list(chain([1, 2, 3], 
 [&quot;one&quot;, &quot;two&quot;, &quot;three&quot;], 
 &quot;String&quot;, 
 (&quot;this&quot;, &quot;is&quot;, &quot;a&quot;, &quot;tuple&quot;)))
 
print(result)
</code></pre>
The output will be:
<pre><code class="hljs">[1, 2, 3, &#x27;one&#x27;, &#x27;two&#x27;, &#x27;three&#x27;, &#x27;S&#x27;, &#x27;t&#x27;, &#x27;r&#x27;, &#x27;i&#x27;, &#x27;n&#x27;, &#x27;g&#x27;, &#x27;this&#x27;, &#x27;is&#x27;, &#x27;a&#x27;, &#x27;tuple&#x27;]
</code></pre>
Here, we've got four different types of iterables - each one being chained together.
Even though <code>[&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]</code> is a list of strings, <code>chain()</code> treats this as a list and simply chains its elements without calling a subsequent <code>chain()</code> for each of the strings. On the other hand, <code>&quot;String&quot;</code> is broken down into its constituent characters.
The former can be achieved with another method, derived from the <code>chain()</code> function - <code>chain.from_iterable()</code>:
<pre><code class="hljs">result2 = list(chain([&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]))
result3 = list(chain.from_iterable([&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]))

print(result2)
print(result3)
</code></pre>
The <code>chain()</code> function behaves the same as we've previously observed - it chains the elements as they are. On the other hand, the <code>chain.from_iterable()</code> method treats each element as an iterable and returns its constituent elements alongside other elements broken down in the same fashion:
<pre><code class="hljs">[&#x27;one&#x27;, &#x27;two&#x27;, &#x27;three&#x27;]
[&#x27;o&#x27;, &#x27;n&#x27;, &#x27;e&#x27;, &#x27;t&#x27;, &#x27;w&#x27;, &#x27;o&#x27;, &#x27;t&#x27;, &#x27;h&#x27;, &#x27;r&#x27;, &#x27;e&#x27;, &#x27;e&#x27;]
</code></pre>
Commonly, you'd use <code>chain.from_iterable()</code> to calculate the sum of digits, contained within several collections that you first chain together, and then calculate the <code>sum()</code> for:
<pre><code class="hljs">from itertools import chain

number_list = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
result = list(chain.from_iterable(number_list))
print(sum(result))
</code></pre>
Each element of the <code>number_list</code> collection is another list. Since lists are iterable, the <code>chain.from_iterable()</code> call breaks these down into a single list containing elements from <code>[1..9]</code>, after which we calculate their <code>sum()</code> and print the result:
<pre><code class="hljs">45
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The <code>itertools</code> module introduces us to several useful convenience functions for working with iterables and iteration.
Many of these can be used as standalone convenience functions, but they're most commonly chained with other functions to transform data.

Lazar Ristic

In this tutorial, we'll be taking a look at the `itertools` module in Python - and take a look at examples of count(), cycle() and eval().

Python's itertools – count(), cycle() and chain()

Dragan Bjekic

In this beginner-level guide, we'll get introduced to Jenkins, the CI/CD automation server, and run and automate the build process of a simple project.

Beginner's Introduction to Jenkins - CI/CD

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll explain how to replace words in text sequences, with Python using the FlashText module, which provides one of the most efficient ways of replacing a large set of words in a textual document.
<h2 id="howdoestheflashtextalgorithmwork">How does the FlashText Algorithm Work?</h2>
The FlashText module is based on its proprietary algorithm, the FlashText algorithm. In essence, it is based on a Python implementation of the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm">Aho–Corasick algorithm</a>.
The fundamental takeaway of the algorithm is to reduce the time spent finding a large number of keywords in the text, by minimizing the number of times that the text is scanned.
<blockquote>
A naive algorithm consists of comparing each keyword to every single word in the whole text - akin to Linear Search. That approach is extremely inefficient, because it needs to scan the entire text document <code>n</code> times - where <code>n</code> is the number of keywords.
</blockquote>
<blockquote>
On the other hand, FlashText opts for a different approach, intending to scan the text only once.
</blockquote>
The key to the efficiency of the FlashText algorithm is that it stores all of the keywords, paired with corresponding replacement words in a dictionary. Then, instead of scanning text once for every keyword in the dictionary, it scans the text only once. In that one scan over the text, words are matched to the dictionary keys and if present - replaced with the key's value.
<h2 id="howtoinstallflashtext">How to Install FlashText</h2>
Installing FlashText is fairly straightforward, via <code>pip</code>:
<pre><code class="hljs">$ pip install flashtext
</code></pre>
<h2 id="howtouseflashtext">How to Use FlashText</h2>
Let's first take a look at the <code>FlashText</code> API and some of the key classes within it.
<h3 id="thekeywordprocessorclass">The KeywordProcessor Class</h3>
The main class we'll be working with, which takes care of the processing of keywords, is the <code>KeywordProcessor</code> class. Let's import it directly from <code>FlashText</code> and initialize it:
<pre><code class="hljs">from flashtext import KeywordProcessor
keyword_processor = KeywordProcessor()
</code></pre>
The previous line creates the <code>KeywordProcessor</code> object that will work in the case-insensitive mode.
<blockquote>
Case-insensitive mode will match <code>abc</code> with <code>ABC</code>, as well as with <code>aBc</code>, <code>ABc</code>, etc.
</blockquote>
<blockquote>
Case-sensitive mode will only match <code>aaa</code> with exactly the same string, <code>aaa</code>.
</blockquote>
Alternatively, we can create a <code>KeywordProcessor</code> instance in the case-sensitive mode:
<pre><code class="hljs">keyword_processor= KeywordProcessor(case_sensitive=True)
</code></pre>
<h3 id="definingthekeywordsdictionary">Defining the Keywords Dictionary</h3>
In the FlashText module, we use keywords to define words that need to be replaced. The <code>KeywordProcessor</code> object contains a dictionary containing all of the defined keywords.
There are two ways of adding keywords to the dictionary: in bulk or one-by-one.
Firstly, let's take a look at how to add keywords one-by-one:
<pre><code class="hljs">keyword_processor.add_keyword(&lt;keyword&gt;, &lt;replacementWord&gt;)
</code></pre>
<blockquote>
<code>&lt;replacementWord&gt;</code> is an optional argument. When not specified, just the <code>&lt;keyword&gt;</code> is added to the dictionary and there is no way of replacing it with another replacement word.
So, if you want to use FlashText to replace words in a text, we highly recommend you to specify the <code>&lt;replacementWord&gt;</code> argument.
</blockquote>
If we have more than a couple of keywords, adding them one-by-one can be a little time-consuming. An alternative, much more commonly used even for small lists of keywords is to add keywords in bulk:
<pre><code class="hljs">keyword_dictionary = {
 &#x27;replacementWord1&#x27;: [&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;, &#x27;for&#x27;, &#x27;replacementWord1&#x27;],
 &#x27;replacementWord2&#x27;: [&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;, &#x27;for&#x27;, &#x27;replacementWord2&#x27;],
 ...
 &#x27;replacementWordN&#x27;: [&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;, &#x27;for&#x27;, &#x27;replacementWordN&#x27;]
}

keyword_processor.add_keywords_from_dict(keyword_dictionary )
</code></pre>
Each <code>key</code> in the dictionary is a string keyword. Each <code>value</code> must be a list. Alternatively, you can provide keywords through a <code>List</code>:
<pre><code class="hljs">keyword_processor.add_keywords_from_list([&#x27;list&#x27;, &#x27;of&#x27;, &#x27;keywords&#x27;])
</code></pre>
Though, with this approach - you just add the keywords without replacement words. Or, if a text file contains key-value pairs following a <code>key=&gt;value</code> syntax:
<pre><code class="hljs">keyword1=&gt;value1
keyword2=&gt;value2
</code></pre>
We can import them through the <code>keywords_from_file()</code> function:
<pre><code class="hljs">keyword_processor.add_keywords_from_file(&#x27;keyword_list.txt&#x27;)
</code></pre>
A popular approach, which allows you for the most flexibility and great readability is using a dictionary. It's also the most natural match for the algorithm, given the fact that it all ultimately ends up in a dictionary.
Now, let's take a look at a quick example. Imagine we have a textual document and we want to minimize the usage of synonyms in order to standardize the vocabulary used. In essence, we want to replace all occurrences of words such as awful, terrible and horrible (list of keywords) with the word bad (replacement word), and all occurrences of words such as fine, excellent and great, with the word good.
We would add those <code>keywords</code> and <code>replacement_words</code> to the <code>keyword_dictionary</code>:
<pre><code class="hljs">keyword_dictionary = {
 &quot;bad&quot;: [&quot;awful&quot;, &quot;terrible&quot;, &quot;horrible&quot;],
 &quot;good&quot;: [&quot;fine&quot;, &quot;excellent&quot;, &quot;great&quot;]
}
</code></pre>
And, finally, add the <code>keyword_dictionary</code> to the <code>keyword_processor</code> object:
<pre><code class="hljs">keyword_processor.add_keywords_from_dict(keyword_dictionary)
</code></pre>
<h3 id="replacekeywordswithreplacementwords">Replace Keywords with Replacement Words</h3>
Once we've loaded the keywords and their respective replacement words into the <code>KeywordProcessor</code> instance, we can execute <code>replace_keywords()</code> function, which scans the provided text, and executes the replacement:
<pre><code class="hljs">new_text = keywordProcessor.replace_keywords(&quot;Passed String&quot;)
</code></pre>
It parses through the provided text, replacing all of the keywords within it with their matched values, and returns a new string.
Now, we typically don't work with string literals here - but rather with documents. We'll want to open a document, read the lines within it, and pass those in as a string to the <code>replace_keywords()</code> function.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: For really long files, that might not fit into your local machine's memory - you might want to consider <a target=”_blank” href=”/read-a-file-line-by-line-in-python”>reading a file line-by-line</a>.

 </div>
 </div>
 </div>
 In any case, let's load in a text file and execute the <code>replace_keywords()</code> function on the contents:
<pre><code class="hljs"># Open the long textual document `data.txt`
with open(&#x27;data.txt&#x27;, &#x27;r+&#x27;) as file:
 # Load the content from `data.txt` to a variable as a string
 content = file.read()
 # Replace all desired keywords from `data.txt` and store it in the new variable
 new_content = keyword_processor.replace_keywords(content)
 # Replace the old content
 file.seek(0)
 file.truncate()
 # Write the alternated content to the original file 
 file.write(new_content)
</code></pre>
So if we feed a text file such as, <code>text.txt</code>:
<pre><code class="hljs">The breakfast was terrific! I really loved the eggs, you&#x27;re a great cook.
</code></pre>
With the following keywords and replacement words:
<pre><code class="hljs">from flashtext import KeywordProcessor
keyword_processor = KeywordProcessor()

keyword_dictionary = {
 &quot;good&quot;: [&quot;terrific&quot;, &quot;great&quot;],
 &quot;eggs&quot;: [&quot;hash browns&quot;]
}

keyword_processor.add_keywords_from_dict(keyword_dictionary)

with open(&#x27;data.txt&#x27;, &#x27;r+&#x27;) as file:
 content = file.read()
 new_content = keyword_processor.replace_keywords(content)
 file.seek(0)
 file.truncate()
 file.write(new_content)
</code></pre>
It'd result in an altered <code>text.txt</code> file:
<pre><code class="hljs">The breakfast was good! I really loved the hash browns, you&#x27;re a good cook.
</code></pre>
<h3 id="otherusefulfunctionalitiesoftheflashtextmodule">Other Useful Functionalities of the FlashText Module</h3>
Let's make a dummy <code>keyword_processor</code> and <code>keyword_dictionary</code> to illustrate some of the other useful functionalities of the <code>FlashText</code> module:
<pre><code class="hljs">keywordProcessor = KeywordProcessor()
keywordDictionary = {
 &quot;bad&quot;: [&quot;awful&quot;, &quot;terrible&quot;, &quot;horrible&quot;],
 &quot;good&quot;: [&quot;fine&quot;, &quot;excellent&quot;, &quot;great&quot;]
}
keywordProcessor.add_keywords_from_dict(keywordDictionary)
</code></pre>
To get a list of all keywords in the <code>KeywordProcessor</code> instance, we use the <code>get_all_keywords()</code> function:
<pre><code class="hljs"># List all added keywords
print(keywordProcessor.get_all_keywords())
</code></pre>
Which results in:
<pre><code class="hljs">{&#x27;awful&#x27;: &#x27;bad&#x27;, &#x27;terrible&#x27;: &#x27;bad&#x27;, &#x27;horrible&#x27;: &#x27;bad&#x27;, &#x27;fine&#x27;: &#x27;good&#x27;, &#x27;excellent&#x27;: &#x27;good&#x27;, &#x27;great&#x27;: &#x27;good&#x27;}
</code></pre>
To check if a keyword is present in the <code>KeywordProcessor</code>, we can use the <code>in</code> operator:
<pre><code class="hljs">&#x27;bad&#x27; in keywordProcessor
# Output: true
# keyword `bad` is PRESENT in the keywordProcessor

&#x27;red&#x27; in keywordProcessor
# Output: false
# keyword `red` is NOT PRESENT in the keywordProcessor

&#x27;awful&#x27; in keywordProcessor
# Output: false
# keyword `awful` is NOT THE KEYWORD in the keywordProcessor
# instead, it IS REPLACEMENT WORD
</code></pre>
And to access a <code>replacement_word</code> based on a certain <code>keyword</code>:
<pre><code class="hljs">keywordProcessor[&#x27;fine&#x27;]
# Output: &#x27;good&#x27;

keywordProcessor[&#x27;excellent&#x27;]
# Output: &#x27;good&#x27;

keywordProcessor[&#x27;goood&#x27;]
# Output: None
# There is no keyword `goood` in the keywordProcessor
</code></pre>
And finally, to remove keywords from a <code>KeywordProcessor</code>, we use the <code>remove_keyword()</code> function:
<pre><code class="hljs">keyword_processor.remove_keyword(&#x27;fine&#x27;)
# This will remove `fine` from the keywordProcessor
</code></pre>
​Alternatively, we can specify list or dictionary of keyword-value pairs that we want to remove, and use them to remove specific elements:
<pre><code class="hljs"># Using a dictionary to remove keywords
keywordProcessor.remove_keywords_from_dict({&quot;bad&quot;: [&quot;awful&quot;, &quot;terrible&quot;]})
# This will remove keywords `awful` and `terrible` from the keywordProcessor

# Using a list to remove keywords
keywordProcessor.remove_keywords_from_list([&quot;fine&quot;, &quot;excellent&quot;])
# This will remove keywords `fine` and `excellent` from the keywordProcessor
</code></pre>
<h2 id="flashtextvsregularexpressions">FlashText vs Regular Expressions</h2>
FlashText was primarily created as an alternative to regular expressions, so it would be useful to compare the two of them. In fact, it was created as a response to a <a rel="nofollow noopener" target="_blank" href="https://stackoverflow.com/questions/44178449/regex-replace-is-taking-time-for-millions-of-documents-how-to-make-it-faster/">question on StackOverflow</a>.
When comparing the speed of execution - FlashText is the clear winner. It takes around the same time for the same text, with a small and large number of keywords. On the other hand, with regular expressions - the execution time increases proportionally to the number of keywords to be replaced.
As the <a rel="nofollow noopener" target="_blank" href="https://www.freecodecamp.org/news/regex-was-taking-5-days-flashtext-does-it-in-15-minutes-55f04411025f/">author of FlashText notes</a> - for large queries, it can take regular expressions days to execute, while FlashText does it in 15 minutes:
<img src="https://s3.stackabuse.com/media/articles/search-and-replace-text-with-python-1.png" alt="replace-benchmark">
Credit: Vikash Singh, author of FlashText, at <a rel="nofollow noopener" target="_blank" href="https://www.freecodecamp.org/news/regex-was-taking-5-days-flashtext-does-it-in-15-minutes-55f04411025f/">FreeCodeCamp</a>
<blockquote>
Benchmarks have shown that FlashText takes less time than RegEx to find and replace keywords when the number of keywords exceeds 500.
</blockquote>
Though, when it comes to the special character matching, FlashText has no chance of beating regular expressions. Even more, FlashText doesn't even have the support for that kind of matching - it can only match plain keywords without any special characters.
<blockquote>
Special character matching describes the situations where some characters in the word have a special meaning and can match multiple different characters. 
For example, the character <code>\d</code> describes digits from 0 to 9, meaning that the keyword <code>number\d</code> will match words <code>number0</code>, <code>number1</code>, <code>number2</code>, etc. 
FlashText is not designed with special character matching in mind, so it can only match equal string literals. The word <code>number1</code> can only be matched with the keyword <code>number1</code> and there is no way of using a single keyword to match multiple different words.
</blockquote>
<h2 id="conclusion">Conclusion</h2>
As we've already seen, FlashText is a very simple yet powerful tool. It is pretty lightweight, easy to learn, and very time-efficient no matter the number of keywords to be replaced.
As with any other tool, the key is to know what is the best use-case scenario for it. If you have more than 500 keywords to be replaced and those keywords are simple, without any special character matching, there is no reason not to go with the FlashText over regular expressions.
On the other hand, if you have less than 500 keywords or some kind of special character matching, you should probably ditch FlashText and go with good old regular expressions given their flexibility and syntax.

In this tutorial, we'll take a look at how to find and replace words in a text file, using Python and FlashText, in an extremely efficient manner - without using regular expressions (regex).

Searching and Replacing Words in Python with FlashText

<h2 id="introduction">Introduction</h2>
The software engineering process often reveals to us many redundant elements inside the structure and code of our software. Knowing this, some of the primary responsibilities of a developer are to write easily understandable and maintainable code - not just solutions.
However, projects often get more complex with time, making the initial software structure a critical element that must be well thought-out and implemented from the very beginning.
<blockquote>
Design Patterns are intended to solve this issue.
</blockquote>
Design patterns are a set of standards used to optimize specific tasks related to the <a target="_blank" href="https://stackabuse.com/object-oriented-programming-in-python/">Object Oriented Programming</a> (OOP) paradigm. They aim to reduce the overall count of code lines, optimize structures, and standardize the software architecture.
The Object-Oriented Programming paradigm delivers a structure based on classes, where each class represents a blueprint for an object (instance of that class) that has its own attributes and methods. These classes are related and have their own dependencies, compositions, inheritance, etc. Translating real-life problems and structures to software solutions is the primary motivation for implementing this structure.
In this guide, we’ll explore one of the Behavioral Design Patterns and its implementation in Python: the Template Method.
This design pattern will give us a general method composed of multiple steps. The classes related to our template method class can then call these steps individually or overwrite them.
In addition, we’ll learn how to use the <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/abc.html">ABC Library</a> in Python, which defines an inheritance relationship for abstract base classes (ABCs). We'll use this library to create a simple template method example.
<h2 id="behavioraldesignpatterns">Behavioral Design Patterns</h2>
The Template Method is a Behavioral Design Pattern. What is a Behavioral Design pattern exactly?
<blockquote>
There are three widely recognized software design patterns: Creational, Structural, and Behavioral.
</blockquote>
<ul>
<li>
Creational Design Patterns are intended to enable the creation of objects while abstracting/hiding away the object's creation logic. Creational Design Patterns are used to give programs greater flexibility in selecting the objects they should create for any use case.
</li>
<li>
Structural Design Patterns are intended to handle the composition of objects and classes, relying on inheritance to control how objects are created and given functions.
</li>
<li>
Behavioral Design Patterns are focused on the communication that occurs between objects, controlling how data moves between objects, and distributing behavior between classes.
</li>
</ul>
<blockquote>
The Template Method is focused on the distribution of functions and methods across classes.
</blockquote>
<h2 id="thetemplatemethoddesignpattern">The Template Method Design Pattern</h2>
The template method design pattern allows us to create a base class that contains some number of steps needed to complete a process. When you define these steps with a template, it becomes possible to create one or more concrete classes and overwrite the template steps. This lets you implement some or all of the steps, depending on the concrete class, without overwriting the entire process.
To use the template method, we require an abstract class. The abstract class is essentially one major process broken up into smaller steps or minor processes. To put that another way, the abstract class will make use of the template method (the major process) and within the template we’ll find calls to the minor steps that complete the major process. These minor processes will be methods/functions that the concrete classes can call.
Using an abstract class means we don’t have to instantiate the whole base class to get access to the steps defined with the template method. Instead, we can create subclasses from the abstract class and overwrite just the steps we need in the individual subclasses.
Once we define the abstract class, we can create the concrete classes that will overwrite the steps we need. We’ll use an inheritance relationship to achieve this. Depending on the context of the concrete class, we will overwrite all the steps or just some of them.
We can represent the structure of the template method with a class diagram like this, in accordance with the OOP paradigm:
<img src="https://s3.stackabuse.com/media/articles/template-method-design-pattern-in-python-1.jpg" alt="UML diagram of the template method design pattern">
Here you can see that we begin by creating an abstract class with a template method consisting of multiple steps/functions. From this abstract class, we create two concrete classes that use different steps of the template method.
<h3 id="thetemplatemethodvsthefactorymethod">The Template Method vs the Factory Method</h3>
There's some confusion regarding the differences between the Template method Pattern and the <a target="_blank" href="https://stackabuse.com/the-factory-method-design-pattern-in-python">Factory Method Pattern</a>. This is because their structure is similar, although they aren't the same thing. The Factory Method is a Creational Pattern used to create objects from a superclass. In contrast, the Template Method is a Behavioral Pattern used to define a general method composed of steps that can be modified by subclasses of the abstract class, containing the template method.
<blockquote>
In other words, while the Factory Method creates objects, the Template Method overwrites the functionalities of a major/base process.
</blockquote>
Now that we've clarified the difference between these patterns, we can explore how to implement the Template Method Design Pattern in Python.

 <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 doesn’t support abstract classes without using a specific library. To use abstract class associations, we need to import the <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/abc.html">ABC</a> library.

 </div>
 </div>
 </div>
 <h2 id="theabclibrary">The ABC Library</h2>
The ABC library provides infrastructure for managing abstract base classes in Python. This means we can create class relationships like inheritance or implementations for abstract classes - something required for implementing most design patterns and particularly important in the Template Method's case.
<h2 id="whentousethetemplatemethodpattern">When to Use the Template Method Pattern?</h2>
You'll want to use the Template Method when you need to use or modify some or all of the steps of an algorithm. In these cases, you'll need to differentiate the steps of your algorithm or process, making them individually accessible via inheritance or implementation.
Let's take a look at a practical example:
We have two groups of researchers, one from University A and another from University B. These two groups are studying the effects of quarantine, implemented by governments in response to the SARS‑CoV‑2 pandemic. Both groups have the same base research process. The basic research process is a template that the two research groups can use to proceed with their investigation. Yet the research groups can customize the research process in terms of:
<ul>
<li>Which steps are carried out during the research.</li>
<li>How each research step is carried out.</li>
</ul>
Let's represent this research with a class diagram before creating the model with Python code.
The research guideline is composed of 4 steps:
<ul>
<li>University A decides to apply 2 of the 4 steps (2 and 3)</li>
<li>University B applies the 3 of the steps (1, 3 and 4)</li>
<li>Both groups modified all the chosen steps.</li>
<li>Finally, step number 3 must be applied for both groups as it is mandatory.</li>
</ul>
We already have our diagram class, we just have to change it so it fits with our problem.
Updating the diagram to fit the conditions we specified, we end up with the following model:
<img src="https://s3.stackabuse.com/media/articles/template-method-design-pattern-in-python-2.jpg" alt="UML diagram - Python implementation of template method design pattern">
<h2 id="implementingthetemplatemethoddesignpatterninpython">Implementing the Template Method Design Pattern in Python</h2>
Now that we have the outline for our abstract and concrete classes, let's implement them in Python.
Let's start with our abstract class - <code>researchGuideline.py</code>, which will contain our template methods with the four principal steps for the research.
First, we'll import the ABC library. This library contains a class called <code>ABC</code>, and we'll use it as a superclass for our research template, turning it into an abstract base class.
Next, we'll define our steps as class methods. These methods will be empty for now, but when we define the subclasses - they will overwrite the steps:
<pre><code class="hljs"># Importing the ABC library
from abc import ABC, abstractmethod

# Creating our abstract class:
class ResearchGuideline(ABC):
 
 # Template Method definition:
 def templateMethod(self):
 # Calling all the steps
 self.step1()
 self.step2()
 self.step3()
 self.step4()
 
 # Defining the Template Method Steps
 def step1(self):
 pass

 def step2(self):
 pass
 
 @abstractmethod
 def step3(self):
 pass

 def step4(self):
 pass
</code></pre>
Notice how we added the <code>@abstractmethod</code> decorator to step 3. This shows that an abstract class' subclasses must always overwrite that method. We must include this decorator in the imports, as it’s also part of the ABC library.
Let's define our concrete classes now. We are talking about Universities A and B, with their respective steps. We will create a subclass for both of the universities by using the <code>ResearchGuideline</code> template.
For both classes, we have to import the <code>ResearchGuideline</code> class and create an inheritance between the superclass and the subclass. This allows us to use the steps we defined in the guideline/template and overwrite them. The application of the steps will be a simple log/print in this case.
Let's start with the first subclass:
<pre><code class="hljs">from researchGuideline import ResearchGuideline

class UniversityA(ResearchGuideline):
 def step2(self):
 print(&quot;Step 2 - Applied by University A&quot;)
 
 def step3(self):
 print(&quot;Step 3 - Applied by University A&quot;)
</code></pre>
We'll save this in a Python file called <code>universityA</code>. Now let's set up the second subclass:
<pre><code class="hljs">from researchGuideline import ResearchGuideline

class UniversityB(ResearchGuideline):
 def step1(self):
 print(&quot;Step 1 - Applied by University B&quot;)
 
 def step3(self):
 print(&quot;Step 3 - Applied by University B&quot;)

 def step4(self):
 print(&quot;Step 4 - Applied by University B&quot;)
</code></pre>
We'll save this in a Python file called <code>universityB</code>.
Notice that we've indicated which university is applying which steps. This helps us appreciate the variation between the two concrete classes.
Our model of the template method, including the abstract class and concrete classes, is done! Now let's create our client script, so that we can apply the model.
First, let's import our classes. This involves importing the abstract class and the two concrete classes. Then, we'll create a function that receives a <code>ResearchGuideline</code> object as a parameter, which is our template/abstract class.
Here's the beauty of the inheritance relationship - because the university classes are subclasses from <code>ResearchGuideline </code>they share the same object type.
We can pass either the <code>UniversityA</code> or <code>UniversityB</code> object as the argument into our function that calls template method (this is <code>client_call()</code> below), and the steps overwritten by the concrete class will change how the template method executes.
Here we use both classes, so we can compare the outputs:
<pre><code class="hljs"># Imports
from researchGuideline import *
from universityA import UniversityA
from universityB import UniversityB

# Auxiliary function
def client_call(research_guideline: ResearchGuideline):
 research_guideline.templateMethod();

# Entry point
if __name__ == &#x27;__main__&#x27;:
 # Calling the Template Method using the University A class as parameter
 print(&quot;University A:&quot;)
 client_call(UniversityA())
 
 # Calling the Template Method using the University A class as parameter
 print(&quot;University B:&quot;)
 client_call(UniversityB())
</code></pre>
Running this code, we obtain the following output:
<pre><code class="hljs">University A:
Step 2 - Applied by University A
Step 3 - Applied by University A
University B:
Step 1 - Applied by University B
Step 3 - Applied by University B
Step 4 - Applied by University B
</code></pre>
<h2 id="conclusion">Conclusion</h2>
The template method is an effective way to distribute tasks between classes, redefine processes, and reduce code. Applying this design pattern to an algorithm or solution can help you avoid redundant methods and streamline longer execution processes.
The template method is also an example of the proper use of the OOP paradigm. The model can't be applied in every instance, so be sure to understand your project's needs before using it.

Dan Nelson

Juan Hurtado

In this guide, we'll take a look at the theory and implementation on the Template Method - a Behavioral Design Pattern, in Python.