Guest Contributor

The Builder Design pattern takes care of object construction and allows us to build complex objects with less human-induced errors and improves maintainability and scalability.

The Builder Design Pattern in Java

<h2 id="introduction">Introduction</h2>
If you wanted to select elements from an array or object before the ES2015 update to JavaScript, you would have to individually select them or use a loop.
The ES2015 specification introduced the destructuring assignment, a quicker way to retrieve array elements or object properties into variables.
In this article, we'll use the destructuring assignment to get values from arrays and objects into variables. We'll then see some advanced usage of the destructuring assignment that allows us to set default values for variables, capture unassigned entries, and swap variables in one line.
<h2 id="arraydestructuring">Array Destructuring</h2>
When we want to take items from an array and use them in separate variables, we usually write code like this:
<pre><code class="hljs">let myArray = [1, 2, 3];
let first = myArray[0];
let second = myArray[1];
let third = myArray[2];
</code></pre>
Since the major ES2015 update to JavaScript, we can now do that same task like this:
<pre><code class="hljs">let myArray = [1, 2, 3];
let [first, second, third] = myArray;
</code></pre>
The second, shorter example used JavaScript's destructuring syntax on <code>myArray</code>. When we destructure an array, we are copying the values of its elements to variables. Array destructuring syntax is just like regular variable assignment syntax (<code>let x = y;</code>). The difference is that the left side consists of one or more variables in an array.
The above code created three new variables: <code>first</code>, <code>second</code>, and <code>third</code>. It also assigned values to those variables: <code>first</code> is equal to 1, <code>second</code> is equal to 2, and <code>third</code> is equal to 3.
With this syntax, JavaScript sees that <code>first</code> and 1 have the same index in their respective arrays, 0. The variables are assigned values corresponding to their order. As long as the location matches between the left and right side, the destructuring assignment will be done accordingly.
The destructuring syntax also works with objects, let's see how.
<h2 id="objectdestructuring">Object Destructuring</h2>
Before the destructuring syntax was available, if we wanted to store an object's properties into different variables we would write code like this:
<pre><code class="hljs">const foobar = {
 foo: &quot;hello&quot;,
 bar: &quot;world&quot;
};

const foo = foobar.foo;
const bar = foobar.bar;
</code></pre>
With the destructuring syntax, we can now quickly do the same thing with fewer lines of code:
<pre><code class="hljs">const foobar = {
 foo: &quot;hello&quot;,
 bar: &quot;world&quot;
};

const { foo, bar } = foobar;
</code></pre>
While array items are destructured via their position, object properties are destructured by their key name. In the above example, after declaring the object <code>foobar</code> we then create two variables: <code>foo</code> and <code>bar</code>. Each variable is assigned the value of the object property with the same name. Therefore <code>foo</code> is &quot;hello&quot; and <code>bar</code> is &quot;world&quot;.
Note: The destructuring assignment works whether you declare a variable with <code>var</code>, <code>let</code>, or <code>const</code>.
If you prefer to give a different variable name while destructuring an object, we can make a minor adjustment to our code:
<pre><code class="hljs">const foobar = {
 foo: &quot;hello&quot;,
 bar: &quot;world&quot;
};

const { foo: baz, bar } = foobar;
console.log(baz, bar); // hello world
</code></pre>
With a colon, we can match an object property and give the created variable a new name. The above code does not create a variable <code>foo</code>. If you try to use <code>foo</code> you will get a <code>ReferenceError</code>, indicating that it was not defined.
Now that we've got the basics of destructuring arrays and objects, let's look at some neat tricks with this new syntax. We'll start with our option to select default values.
<h2 id="defaultvaluesindestructuredvariables">Default Values in Destructured Variables</h2>
What happens if we try to destructure more variables than the number of array elements or object properties? Let's see with a quick example:
<pre><code class="hljs">let [alpha1, alpha2, alpha3] = [&#x27;a&#x27;, &#x27;b&#x27;];

console.log(alpha1, alpha2, alpha3);
</code></pre>
Our output will be:
<pre><code class="hljs">a b undefined
</code></pre>
Unassigned variables are set to <code>undefined</code>. If we want to avoid our destructured variables from being <code>undefined</code>, we can give them a default value. Let's reuse the previous example, and default <code>alpha3</code> to 'c':
<pre><code class="hljs">let [alpha1, alpha2, alpha3 = &#x27;c&#x27;] = [&#x27;a&#x27;, &#x27;b&#x27;];

console.log(alpha1, alpha2, alpha3);
</code></pre>
If we run this in <code>node</code> or the browser, we will see the following output in the console:
<pre><code class="hljs">a b c
</code></pre>
Default values are created by using the <code>=</code> operator when we create a variable. When we create variables with a default value, if there's a match in the destructuring environment it will be overwritten.
Let's confirm that's the case with the following example, which sets a default value on an object:
<pre><code class="hljs">const { prime1 = 1, prime2 } = { prime1: 2, prime2: 3 };

console.log(prime1, prime2);
</code></pre>
In the above example, we default <code>prime1</code> to 1. It should be overwritten to be 2 as there is a <code>prime1</code> property on the object in the right-hand side of the assignment. Running this produces:
<pre><code class="hljs">2 3
</code></pre>
Great! We've confirmed that default values are overwritten when there's a match. This is also good because the first prime number is indeed 2 and not 1.
Default values are helpful when we have too little values in the array or object. Let's see how to handle cases when there are a lot more values that don't need to be variables.
<h2 id="capturingunassignedentriesinadestructuredassignment">Capturing Unassigned Entries in a Destructured Assignment</h2>
Sometimes we want to select a few entries from an array or object and capture the remaining values we did not put into individual variables. We can do just that with the <code>...</code> operator.
Let's place the first element of an array into a new variable, but keep the other elements in a new array:
<pre><code class="hljs">const [favoriteSnack, ...fruits] = [&#x27;chocolate&#x27;, &#x27;apple&#x27;, &#x27;banana&#x27;, &#x27;mango&#x27;];
</code></pre>
In the above code, we set <code>favoriteSnack</code> to 'chocolate'. Because we used the <code>...</code> operator, <code>fruits</code> is equal to the remaining array items, which is <code>['apple', 'banana', 'mango']</code>.
We refer to variables created with <code>...</code> in the destructuring assignment as the rest element. The rest element must be the last element of the destructuring assignment.
As you may have suspected, we can use the rest element in objects as well:
<pre><code class="hljs">const { id, ...person } = {
 name: &#x27;Tracy&#x27;,
 age: 24,
 id: 1020212,
};
</code></pre>
We extract the <code>id</code> property of the object on the right-hand side of the destructuring assignment into its own variable. We then put the remaining properties of the object into a <code>person</code> variable. In this case, <code>id</code> would be equal to <code>1020212</code> and <code>person</code> would be equal to <code>{ name: 'Tracy', age: 24 }</code>.
Now that we've seen how to keep all the data, let's see how flexible the destructuring assignment is when we want to omit data.
<h2 id="selectivevaluesinadestructuringassignment">Selective Values in a Destructuring Assignment</h2>
We don't have to assign every entry to a variable. For instance, if we only want to assign one variable from many options we can write:
<pre><code class="hljs">const [name] = [&#x27;Katrin&#x27;, &#x27;Judy&#x27;, &#x27;Eva&#x27;];
const { nyc: city } = { nyc: &#x27;New York City&#x27;, ldn: &#x27;London&#x27; };
</code></pre>
We assigned <code>name</code> to 'Katrin' from the array and <code>city</code> to 'New York City' from the object. With objects, because we match by key names it's trivial to select particular properties we want in variables. In the above example, how could we capture 'Katrin' and 'Eva' without having to take 'Judy' as well?
The destructuring syntax allows us to put holes for values we aren't interested in. Let's use a hole to capture 'Katrin' and 'Eva' in one go:
<pre><code class="hljs">const [name1, , name2] = [&#x27;Katrin&#x27;, &#x27;Judy&#x27;, &#x27;Eva&#x27;];
</code></pre>
Note the gap in the variable assignment between <code>name1</code> and <code>name2</code>.
So far we have seen how flexible the destructuring assignment can be, albeit only with flat values. In JavaScript, arrays can contain arrays and objects can be nested with objects. We can also have arrays with objects and objects with arrays. Let's see how the destructuring assignment handles nested values.
<h2 id="destructuringnestedvalues">Destructuring Nested Values</h2>
We can nest destructuring variables to match nested entries of an array and object, giving us fine-grained control of what we select. Consider having an array of arrays. Let's copy the first element of each inner array into their own variable:
<pre><code class="hljs">let [[part1], [part2], [part3], [part4]] = [[&#x27;fee&#x27;, &#x27;mee&#x27;], [&#x27;fi&#x27;, &#x27;li&#x27;], [&#x27;fo&#x27;, &#x27;ko&#x27;], [&#x27;fum&#x27;, &#x27;plum&#x27;]];

console.log(part1, part2, part3, part4);
</code></pre>
Running this code will display the following output:
<pre><code class="hljs">fee fi fo fum
</code></pre>
By simply wrapping each variable in the left-hand side with <code>[]</code>, JavaScript knows that we want the value within an array and not the array itself.
When we destructure nested objects, we have to match the key of the nested object to retrieve it. For example, let's try to capture some details of a prisoner in JavaScript:
<pre><code class="hljs">const {
 name,
 crimes: {
 yearsToServe
 }
} = {
 name: &#x27;John Doe&#x27;,
 crimes: {
 charged: [&#x27;grand theft auto&#x27;, &#x27;stealing candy from a baby&#x27;],
 yearsToServe: 25
 }
};

console.log(yearsToServe);
</code></pre>
To get the <code>yearsToServe</code> property, we first need to match the nested <code>crimes</code> object. In this case, the right-hand side has a <code>yearsToServe</code> property of the <code>crimes</code> object set to 25. Therefore, our <code>yearsToServe</code> variable will be assigned a value of 25.
Note that we did not create a <code>crimes</code> object in the above example. We created two variables: <code>name</code> and <code>yearsToServe</code>. Even though we must match the nested structure, JavaScript does not create intermediate objects.
You've done great so far in covering a lot of the destructured syntax capabilities. Let's have a look at some practical uses for it!
<h2 id="usecasesfordestructuringarraysandobjects">Use Cases for Destructuring Arrays and Objects</h2>
There are many uses for destructuring arrays and object, in addition to the lines of code benefits. Here are a couple of common cases where destructuring improves the readability of our code:
<h3 id="forloops">For Loops</h3>
Developers use the destructuring assignment to quickly pull values of interest from an item in a <code>for</code> loop. For example, if you wanted to print all the keys and values of an object, you can write the following:
<pre><code class="hljs">const greetings = { en: &#x27;hi&#x27;, es: &#x27;hola&#x27;, fr: &#x27;bonjour&#x27; };

for (const [key, value] of Object.entries(greetings)) {
 console.log(`${key}: ${value}`);
}
</code></pre>
First, we create a <code>greetings</code> variable that stores how to say &quot;hello&quot; in different languages. Then we loop through the values of the object using the <code>Object.entries()</code> method which creates a nested array. Each object property is represented by 2 dimensional array with the first item being the key and the second item being its value. In this case, <code>Object.entries()</code> creates the following array <code>[['en', 'hi'], ['es', 'hola'], ['fr', 'bonjour']]</code>.
In our <code>for</code> loop, we destructure the individual arrays into <code>key</code> and <code>value</code> variables. We then log them to the console. Executing this program gives the following output:
<pre><code class="hljs">en: hi
es: hola
fr: bonjour
</code></pre>
<h3 id="swappingvariables">Swapping Variables</h3>
We can use the destructuring syntax to swap variables without a temporary variable. Let's say you're at work and taking a break. You wanted some tea, while your coworker wanted some coffee. Unfortunately, the drinks got mixed up. If this were in JavaScript, you can easily swap the drinks using the destructuring syntax:
<pre><code class="hljs">let myCup = &#x27;coffee&#x27;;
let coworkerCup = &#x27;tea&#x27;;
[myCup, coworkerCup] = [coworkerCup, myCup];
</code></pre>
Now <code>myCup</code> has 'tea' and <code>coworkerCup</code> has 'coffee'. Note how we did not have <code>let</code>, <code>const</code>, or <code>var</code> when using the destructuring assignment. As we aren't declaring new variables, we need to omit those keywords.
<h2 id="conclusion">Conclusion</h2>
With the destructuring assignment, we can quickly extract values from arrays or objects and put them into their own variables. JavaScript does this by matching the variable's array position, or the name of the variable with the name of the object property.
We've seen that we can assign default values to variables we are creating. We can also capture the remaining properties of arrays and objects using the <code>...</code> operator. We can skip entries by having holes, which are indicated by commas with nothing in between them. This syntax is also flexible enough to destructure nested arrays and objects.
We provided a couple of nifty places to use the destructuring assignment. Where will you use them next?

JavaScript's Destructuring Assignment provides a quick and flexible way to take values from array elements and object properties and put them into variables.

JavaScript's Destructuring Assignment

Robley Gori

MongoDB is a document-based non-relational database that allows great and easy horizontal scalability. In this article, we'll use PyMongo to connect to a MongoDB database and perform CRUD operations using Python.

Integrating MongoDB with Python Using PyMongo

<h2 id="introduction">Introduction</h2>
Checking if a file or directory exists is a simple and important operation in many tasks. Before accessing a file, we should check if it exists to avoid a <code>NullPointerException</code>. The same goes for directories.
While some functions may create a new file/directory if the requested one doesn't exist, this may be the opposite of what we want. If we wish to append more information to an existing file and the method goes through without a warning, since it creates the new file it needs - we may have lost some information without realizing it.
Here, we've got a simple structure:
<pre><code class="hljs">02/13/2020 11:53 AM &lt;DIR&gt; directory
02/13/2020 11:55 AM &lt;SYMLINKD&gt; directory_link [directory]
02/13/2020 11:53 AM 0 file.txt
02/13/2020 11:55 AM &lt;SYMLINK&gt; symlink.txt [file.txt]
</code></pre>
There's a <code>file.txt</code> file and a <code>symlink.txt</code> file. The <code>symlink.txt</code> file is a symbolic link to the <code>file.txt</code>.
Similarly, we've got a <code>directory</code> and a symbolic link to it - <code>directory_link</code>.
<h2 id="checkifafileexists">Check if a File Exists</h2>
To work with the <code>Files</code> class, you need to be acquainted with the <code>Path</code> class. <code>Files</code> only accepts <code>Path</code>, and not <code>File</code> objects.
For the purposes of the tutorial, we'll define a <code>File</code> and <code>Path</code> instance for the <code>file.txt</code> in our directory:
<pre><code class="hljs">final static String location = &quot;C:\\file.txt&quot;;

Path path = Paths.get(location);
File file = new File(location);
</code></pre>
<h3 id="filesexists">Files.exists()</h3>
That being said, the first way we can check if a file exists is through the <code>Files</code> class:
<pre><code class="hljs">// Check if file exists through a Path
System.out.println(Files.exists(path));

// Check if a file exists by converting File object to Path
System.out.println(Files.exists(file.toPath()));
</code></pre>
Running this code will yield us:
<pre><code class="hljs">true
true
</code></pre>
<h3 id="filesnotexists">Files.notExists()</h3>
You might be wondering why the <code>notExists()</code> method exists at all:
<blockquote>
If <code>exists()</code> returns <code>true</code>, that means that <code>notExists()</code> should return <code>false</code>. They're logical complements and <code>A = !B</code>, right?
</blockquote>
Well, that's where many get it wrong. If <code>Files.exists()</code> returns <code>false</code>, it doesn't have to mean that the file doesn't exist.
It can also mean that the file's existence cannot be verified. In that case, both <code>Files.exists()</code> and <code>Files.notExists()</code> would return <code>false</code>, as Java cannot determine if the file does or doesn't exist.
This typically happens if you have a file that's locked in a way that Java can't access it. Imagine we had a file that's locked in our directory - <code>lockedFile.txt</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/java-check-if-file-or-directory-exists-1.PNG" alt="file with denied permissions">
And if we tried verifying its existence with:
<pre><code class="hljs">System.out.println(Files.exists(path));
System.out.println(Files.notExists(path));
</code></pre>
We'd be greeted with:
<pre><code class="hljs">false
false
</code></pre>
It exists, obviously, but Java doesn't have permission to confirm that on our system - thus giving conflicting results.
<h3 id="filesisregularfile">Files.isRegularFile()</h3>
Additionally, we can check if the file is a regular file (<code>false</code> if it's a directory) through the <code>isRegularFile()</code> method:
<pre><code class="hljs">System.out.println(Files.isRegularFile(path));
</code></pre>
The output is:
<pre><code class="hljs">true
</code></pre>
<h3 id="fileisfile">File.isFile()</h3>
Instead of using the <code>Files</code> class, we can also perform methods on the file objects themselves:
<pre><code class="hljs">System.out.println(file.isFile());
</code></pre>
This returns:
<pre><code class="hljs">true
</code></pre>
<h3 id="fileexists">File.exists()</h3>
Similar to the previous option, we can run the <code>exists()</code> method:
<pre><code class="hljs">System.out.println(file.exists());
</code></pre>
And this also returns:
<pre><code class="hljs">true
</code></pre>
The difference between these two is that the first one checks if it's a file, and the other one checks if it exists. In different circumstances, they'd return different results.
<h3 id="lockedfiles">Locked Files</h3>
A fun thing to note is that if you're using a <code>File</code> to check for existence, Java can determine if the locked file from before exists or not:
<pre><code class="hljs">System.out.println(file.isFile());
System.out.println(file.exists());
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">true
true
</code></pre>
With this, it's evident that the locked file can be read by using the <code>File</code> class instead of the <code>Files</code> helper class.
<h2 id="checkifadirectoryexists">Check if a Directory Exists</h2>
Directories are essentially files, that can contain other files. This is why checking if a directory is a file will return <code>true</code>. Though, if you're checking if a directory is a directory (a special type of file), you'll get a more accurate result.
This time around, we're switching our location to:
<pre><code class="hljs">final static String location = &quot;C:\\directory&quot;;
</code></pre>
<h3 id="filesexists">Files.exists()</h3>
Again, just like in the first example, we can check if it exists via:
<pre><code class="hljs">System.out.println(Files.exists(path));
</code></pre>
The output is:
<pre><code class="hljs">true
</code></pre>
<h3 id="filesisdirectory">Files.isDirectory()</h3>
If we'd like to check if it's specifically a directory, we'd use:
<pre><code class="hljs">System.out.println(Files.isDirectory(path));
</code></pre>
And the output is:
<pre><code class="hljs">true
</code></pre>
Note: If the directory doesn't exist, the <code>isDirectory()</code> method will return <code>false</code>. It's due to the way the method is named. What it does is - it checks if the file exists and if it's a directory, not only the latter. A file can't be a directory if it doesn't exist - hence, <code>false</code> is returned.
<h2 id="checkiffileissymboliclink">Check if File is Symbolic Link</h2>
You might also want to check if a file is just a symbolic link. In that case, you'd use the <code>Files</code> class.
Let's switch our location to:
<pre><code class="hljs">final static String location = &quot;C:\\symlink.txt&quot;;
</code></pre>
<h3 id="filesissymboliclink">Files.isSymbolicLink()</h3>
As usual, the <code>Files</code> class accepts a <code>Path</code> to the file:
<pre><code class="hljs">System.out.println(Files.isSymbolicLink(path));
</code></pre>
Running this would yield:
<pre><code class="hljs">true
</code></pre>
<h3 id="filegetcanonicalpathvsfilegetabsolutepath">File.getCanonicalPath() vs File.getAbsolutePath()</h3>
Another way to check for a symbolic link is to compare the results of the file's canonical path and absolute path. If they're different, it's most probably a symbolic link:
<pre><code class="hljs">System.out.println(file.getCanonicalPath());
System.out.println(file.getAbsolutePath());
</code></pre>
Since we're checking for a symbolic link, and we know it is, these should return a different result - a <code>symlink.txt</code> and <code>file.txt</code> path:
<pre><code class="hljs">C:\symlink.txt
C:\symlink.txt
</code></pre>
However, this isn't the case here. This is due to the fact that the symlink was created on Windows with NTFS (New Technology File System). The symlink was created using the <code>mklink</code> command in the CMD.
<h2 id="checkifeitherexist">Check if Either Exist</h2>
From the previous examples, it's evident that the <code>Files.exists()</code> method will return <code>true</code> for both existing files and directories. Though, it doesn't work best when it comes to locked files.
On the other hand, the <code>exists()</code> method from the <code>File</code> class will also return <code>true</code> for both files and directories and can read the locked file that the <code>Files</code> class can't.
<h2 id="conclusion">Conclusion</h2>
Checking for the existence of files and directories is the first line of defense against missing files and directories. Different approaches have different setbacks and you might assume that a method will return an accurate result, but it won't due to how it works in the background.
Being aware of which methods return which results in which circumstances will allow you to avoid nasty exceptions when handling files.
After checking if your file exists or not, you'll likely want to do some <a target="_blank" href="/reading-and-writing-files-in-java/">Reading and Writing Files in Java</a>.

David Landup

Checking if a file or directory exists is a simple and important operation in many tasks. In this article, we'll explore the many different ways that you can employ to check if a file or directory exists if it's a symlink and the setbacks of these approaches.

Java: Check if a File or Directory Exists

<h3 id="introduction">Introduction</h3>
Sorting, although a basic operation, is one of the most important operations a computer should perform. It is a building block in many other algorithms and procedures, such as searching and merging. Knowing different sorting algorithms could help you better understand the ideas behind the different algorithms, as well as help you come up with better algorithms.
The Selection Sort algorithm sorts an array by finding the minimum value of the unsorted part and then swapping it with the first unsorted element. It is an in-place algorithm, meaning you won't need to allocate additional lists. While slow, it is still used as the main sorting algorithm in systems where memory is limited.
<blockquote>
In this article, we will explain how the Selection Sort works and implement it in Python. We will then break down the actions of the algorithm to learn its <a target="_blank" href="/big-o-notation-and-algorithm-analysis-with-python-examples/">time complexity</a>.
</blockquote>
<h3 id="theideabehindtheselectionsort">The Idea Behind the Selection Sort</h3>
So how does the selection sort work? Selection sort breaks the input list into two parts, the sorted part which initially is empty, and the unsorted part, which initially contains the list of all elements. The algorithm then selects the minimum value of all the unsorted elements and swaps it with the first unsorted value, and then increases the sorted part by one.
A high-level implementation of this sort would look something like this:
<pre><code class="hljs">def selection_sort(L):
 for i in range(len(L) - 1):
 min_index = argmin(L[i:])
 L[i], L[min_index] = L[min_index], L[i]
</code></pre>
In the above pseudocode, <code>argmin()</code> is a function that returns the index of the minimum value. The algorithm uses a variable <code>i</code> to keep track of where the sorted list ends and where the unsorted one begins. Since we start with no sorted items and take the minimum value, it will always be the case that every member of the unsorted part is greater than any member of the sorted part.
The first line increments the value of <code>i</code>, the second line finds the minimum value's index, and the third line swaps those values. Swapping works because Python calculated the right-hand side before assigning anything to the left-hand side, so we don't need any temporary variables.
Let's see how it works in action with a list that contains the following elements: <code>[3, 5, 1, 2, 4]</code>.
We begin with the unsorted list:
<ul>
<li>3 5 1 2 4</li>
</ul>
The unsorted section has all the elements. We look through each item and determine that <code>1</code> is the smallest element. So, we swap <code>1</code> with <code>3</code>:
<ul>
<li>1 5 3 2 4</li>
</ul>
Of the remaining unsorted elements, <code>[5, 3, 2, 4]</code>, <code>2</code> is the lowest number. We now swap <code>2</code> with <code>5</code>:
<ul>
<li>1 2 3 5 4</li>
</ul>
This process continues until the list is sorted:
<ul>
<li>1 2 3 5 4</li>
<li>1 2 3 4 5</li>
<li>1 2 3 4 5</li>
</ul>
Let's see how we can implement this in Python!
<h3 id="howtoimplementbubblesortinpython">How to Implement Bubble Sort in Python</h3>
The trick to implementing this algorithm is keeping track of the minimum value and swapping two elements of the list:
<pre><code class="hljs">def selection_sort(L):
 # i indicates how many items were sorted
 for i in range(len(L)-1):
 # To find the minimum value of the unsorted segment
 # We first assume that the first element is the lowest
 min_index = i
 # We then use j to loop through the remaining elements
 for j in range(i+1, len(L)-1):
 # Update the min_index if the element at j is lower than it
 if L[j] &lt; L[min_index]:
 min_index = j
 # After finding the lowest item of the unsorted regions, swap with the first unsorted item
 L[i], L[min_index] = L[min_index], L[i]
</code></pre>
Now let's add some code to the file to test the algorithm:
<pre><code class="hljs">L = [3, 1, 41, 59, 26, 53, 59]
print(L)
selection_sort(L)

# Let&#x27;s see the list after we run the Selection Sort
print(L)
</code></pre>
This will give us:
<pre><code class="hljs">[3, 1, 41, 59, 26, 53, 59]
[1, 3, 26, 41, 53, 59, 59]
</code></pre>
The list was correctly sorted! We know how it works and we can implement the Selection Sort in Python. Let's get into some theory and look at its performance with regard to time.
<h3 id="timecomplexitycalculation">Time Complexity Calculation</h3>
So how long does it take for selection sort to sort our list? We are going to take an approach and calculate exactly how much time the selection sort algorithm takes, given an array of size <code>n</code>. The first line of the code is:
<pre><code class="hljs">def selection_sort(L):
</code></pre>
This line shouldn't take that much since it's only setting the function stack. We say that this is a constant - the size of our input does not change how long it takes for this code to run. Let's say it takes <code>c1</code> operations to perform this line of code. Next, we have:
<pre><code class="hljs">for i in range(len(L)-1):
</code></pre>
This one is a little trickier. First of all, we have two function invocations, <code>len()</code> and <code>range()</code>, which are performed before the <code>for</code> loop begins. The cost of <code>len()</code> is also independent of size in CPython, which is the default Python implementation on Windows, Linux, and Mac. This is also true for the initialization of <code>range()</code>. Let's call these two together <code>c2</code>.
Next, we have the <code>for</code>, which is running <code>n - 1</code> times. This is not a constant, the size of the input does make an impact on how long this is executed. So we have to multiply whatever time it takes for one loop to complete by <code>n - 1</code>.
There is a constant cost for evaluating the <code>in</code> operator, let's say <code>c3</code>. That covers the outer <code>for</code> loop.
The variable assignment is also done in constant time. We'll call this one <code>c4</code>:
<pre><code class="hljs">min_index = i
</code></pre>
We now encounter the inner <code>for</code> loop. It has two constant function invocations. Let's say they take <code>c5</code> operations.

 <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>c5</code> is different from <code>c2</code>, because the <code>range()</code> here has two arguments, and there is an addition operation being performed here.

 </div>
 </div>
 </div>
 So far we have <code>c1 + c2 + (n - 1) * (c3 + c4 + c5)</code> operations, and then our inner loop begins, multiplying everything by...? Well, it's tricky, but if you look closely, it takes <code>n - 2</code> times in the first loop, <code>n - 3</code> in the second one, and 1 in the last time.
We need to multiply everything by the sum of all numbers between 1 and <code>n - 2</code>. Mathematicians have told us that the sum would be <code>(n - 2) * (n - 1) / 2</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">
 Advice: Feel free to read more about the sum of integers between 1 and any positive number <code>x</code> <a target="_blank" rel="nofollow noopener" href="https://www.wikihow.com/Sum-the-Integers-from-1-to-N">here</a>.

 </div>
 </div>
 </div>
 The contents of the inner loop are completed in constant time as well. Let's assign the time it takes Python to do the <code>in</code>, <code>if</code>, assignment statement and the variable swap take up an arbitrary constant time of <code>c6</code>.
<pre><code class="hljs">for j in range(i+1, len(L)-1):
 if L[j] &lt; L[min_index]:
 min_index = j
L[i], L[min_index] = L[min_index], L[i]
</code></pre>
All-together we get <code>c1 + c2 + (n - 1) * (c3 + c4 + c5) + (n - 2) * (n - 3) * c6 / 2</code>.
We can simplify this to <code>a * n * n + b * n + c</code>, where <code>a</code>, <code>b</code>, and <code>c</code> represent the values of the evaluated constants.
This is known as O(n2). What does that mean? In summary, our algorithm's performance is based on the squared size of our input list. Therefore, if we double the size of our list, the time it takes to sort it would be multiplied by 4! If we divide the size of our input by 3, the time would shrink by 9!
<h3 id="conclusion">Conclusion</h3>
In this article, we looked at how Selection Sort works and implemented it in Python. We then broke the code down line by line to analyze the algorithm's time complexity.
Learning sorting algorithms will help you get a better understanding of algorithms in general. So, in case you haven't already, you can check out our <a target="_blank" href="/sorting-algorithms-in-python/">sorting algorithms overview</a>!

Marcus Sanatan

Sajjad Heydari

Dimitrije Stamenic

While not the quickest sorting algorithm, Selection Sort is still is still relevant because of how space-efficient it is. In this article, we will explain how Selection Sort works, how to implement it in Python and analyze its time complexity.

Selection Sort in Python

<h2 id="introduction">Introduction</h2>
Test &quot;mocks&quot; are objects that replace real objects while simulating their functions. A mock also has expectations about how the functions being tested will be used.
In some unit test cases we may want to combine the functionality of spies, to observe a method's behavior under call, and that of stubs, to replace a method's functionality, in ensuring that we do not make an actual function call but are still able to monitor the behavior of our target function accordingly. In such a case, we can use mocks.
In this article, we will seek to understand what mocks are and how to use them in unit tests. We'll then get hands-on experience with <a rel="nofollow noopener" target="_blank" href="https://sinonjs.org/">Sinon.js</a> to mock an HTTP request.
This article is the third of our series on unit testing techniques with Sinon.js. We recommend that you read our previous articles on this topic as well:
<ul>
<li><a target="_blank" href="/using-stubs-for-testing-in-javascript-with-sinon-js">Using Stubs for Testing in JavaScript with Sinon.js</a></li>
<li><a target="_blank" href="/using-spies-for-testing-in-javascript-with-sinon">Using Spies for Testing in JavaScript with Sinon.js</a></li>
<li>Using Mocks for Testing in JavaScript with Sinon.js (you are here)</li>
</ul>
<h2 id="whataremocks">What are Mocks?</h2>
Mocks combine the functionality of both spies and stubs, which means that they replace the target function but at the same time provide us with the ability to observe how the function was called.
Furthermore, mocks have built-in assertions called expectations. You define the expectations of how your mocked function will be used upfront. If your mock did not satisfy its expectations, your test will fail.
For example, let's consider a function that communicates with a database to save a contact's details. With a mock, instead of a real database, our function will hit a fake database object. We can determine what kind of response it will give. We'll also state how many times the database should be called and the arguments it should be called with.
Finally, as part of the test, we verify that our database mock was called the exact amount of times we expected. We also check that it got called with only the arguments our function supposed to provide it.
Having seen what mocks are, let us now look at situations where we can employ them.
<h2 id="whyusemocks">Why Use Mocks?</h2>
Mocks are useful when validating how an external dependency is used within a function. Use mocks when you are in interested in:
<ul>
<li>Confirming that your external dependency is used at all</li>
<li>Verifying that your external dependency is used correctly</li>
<li>Ensuring that your function can handle different responses from external dependencies.</li>
</ul>
Imagine that you are testing a function that speaks with a third party API to get some user data. To make requests to the external API, you'll need to make a few calls to authenticate first. It's already becoming inconvenient to use the real API in tests. Additionally, you might not always have an internet connection to access the API while running your tests.
With a mock, we will return fake responses. We can now quickly test that our function behaves correctly when given the fake data in a particular format. We'll also know that our function made requests to the API with the right parameters.
Let's now look at how we can use Sinon.js to create mocks.
<h2 id="usingsinonjstocreateamock">Using Sinon.js to Create a Mock</h2>
We'll use Sinon.js to mock a response from a JSON API that retrieves a list of photos in an album. In addition to Sinon.js, we will be using <a rel="nofollow noopener" target="_blank" href="https://mochajs.org/">Mocha</a> and <a rel="nofollow noopener" target="_blank" href="https://www.chaijs.com/">Chai</a> to setup and run the tests. You can read our guide <a target="_blank" href="/testing-node-js-code-with-mocha-and-chai/">our guide</a> to learn more about them before continuing.
<h3 id="setup">Setup</h3>
Create a directory called <code>SinonMock</code> and move into it:
<pre><code class="hljs">$ mkdir SinonMock
$ cd SinonMock
</code></pre>
We will then use NPM to initialize a project to track the project files we create:
<pre><code class="hljs">$ npm init -y
</code></pre>
Next, we'll install Mocha and Chai as testing dependencies to run our tests, along with Sinon.js:
<pre><code class="hljs">$ npm i mocha chai sinon --save-dev
</code></pre>
Having completed our setup, let's mock an HTTP request.
<h3 id="mockinganhttpcallwithsinonjs">Mocking an HTTP Call with Sinon.js</h3>
In our <a target="_blank" href="/using-spies-for-testing-in-javascript-with-sinon">previous article on test spies</a>, we spied on an HTTP request to the photo album API. We'll continue with that example for this article.
Create a file in the root of the <code>SinonMock</code> directory and call it <code>index.js</code>:
<pre><code class="hljs">$ touch index.js
</code></pre>
In the file created, enter the following code:
<pre><code class="hljs">const request = require(&#x27;request&#x27;);

module.exports = {
 getAlbumById: async function(id) {
 const requestUrl = `https://jsonplaceholder.typicode.com/albums/${id}/photos?_limit=3`;
 return new Promise((resolve, reject) =&gt; {
 request.get(requestUrl, (err, res, body) =&gt; {
 if (err) {
 return reject(err);
 }
 resolve(JSON.parse(body));
 });
 });
 }
};
</code></pre>
To recap, <code>getAlbumById()</code> is a function which calls a JSON API that returns a list of photos. We provide an album ID as the function argument. We have previously explored stubbing and spying on the <code>request.get()</code> method.
Now, we will mock the <code>request</code> object and check if the <code>get()</code> method is called once, as required, and verify if it received the correct arguments. We'll then verify that our function has the correct properties based on what was returned from our mock.
Create another file at the root of the <code>SinonMock</code> directory and call it <code>index.test.js</code>:
<pre><code class="hljs">$ touch index.test.js
</code></pre>
Open the <code>index.test.js</code> file with an editor and enter the following code:
<pre><code class="hljs">const expect = require(&#x27;chai&#x27;).expect;
const request = require(&#x27;request&#x27;);
const sinon = require(&#x27;sinon&#x27;);
const index = require(&#x27;./index&#x27;);

describe(&#x27;with mock: getPhotosByAlbumId&#x27;, () =&gt; {
 it(&#x27;should getPhotosByAlbumId&#x27;, (done) =&gt; {
 let requestMock = sinon.mock(request);
 const myPhotos = [{
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 1,
 &quot;title&quot;: &quot;accusamus beatae ad facilis cum similique qui sunt&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/92c952&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/92c952&quot;
 },
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 2,
 &quot;title&quot;: &quot;reprehenderit est deserunt velit ipsam&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/771796&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/771796&quot;
 },
 {
 &quot;albumId&quot;: 1,
 &quot;id&quot;: 3,
 &quot;title&quot;: &quot;officia porro iure quia iusto qui ipsa ut modi&quot;,
 &quot;url&quot;: &quot;https://via.placeholder.com/600/24f355&quot;,
 &quot;thumbnailUrl&quot;: &quot;https://via.placeholder.com/150/24f355&quot;
 }];

 requestMock.expects(&quot;get&quot;)
 .once()
 .withArgs(&#x27;https://jsonplaceholder.typicode.com/albums/2/photos?_limit=3&#x27;)
 .yields(null, null, JSON.stringify(myPhotos));

 index.getAlbumById(2).then((photos) =&gt; {
 expect(photos.length).to.equal(3);
 photos.forEach((photo) =&gt; {
 expect(photo).to.have.property(&#x27;id&#x27;);
 expect(photo).to.have.property(&#x27;title&#x27;);
 expect(photo).to.have.property(&#x27;url&#x27;);
 });

 requestMock.verify();
 requestMock.restore();
 done();
 });
 });
});
</code></pre>
In our test case above, we first create a mock of the <code>request</code> object using <code>sinon.mock()</code> and name it <code>requestMock</code>. The <code>requestMock</code> object has the functions of the <code>request</code> object but the functions do nothing by default.
After supplying some fixed photo data, we override the original <code>get()</code> method of the request object by using Sinon.js' mock API's <code>expect()</code> method.
The <code>expect()</code> method takes in a single argument, which is the method of the mocked object we anticipate will be used.
The <code>once()</code> method asserts that our expectation is called once. In this case the <code>get()</code> method of the request object will be called exactly one time.
The <code>withArgs()</code> method asserts that we expect the <code>get()</code> method to be called with the array of arguments we supply to it. In our case the URL of the API.
The <code>yields()</code> method puts data into the callback that our mock object accepts. In this case, our error and response are both <code>null</code> but our body has a JSON response.
After this setup, we then call our <code>getAlbumById()</code> method and check if the photos returned to have the correct properties.
Notice the <code>verify()</code> call of the <code>requestMock</code> object to confirm that our expectations were met. If expectations fail, the test will throw an exception. We then call the <code>restore()</code> method to discard the mock created by our test and restore the original request object.
When you run this test, you should get the following result:
<pre><code class="hljs">$ mocha index.test.js

with mock: getPhotosByAlbumId
 ✓ should getPhotosByAlbumId


 1 passing (13ms)

✨ Done in 0.72s.
</code></pre>
To confirm the behavior of our mock, let's see if the expectations fail if we change the URL we communicate with. In your <code>index.js</code> file, change:
<pre><code class="hljs">const requestUrl = `https://jsonplaceholder.typicode.com/albums/${id}/photos?_limit=3`;
</code></pre>
To:
<pre><code class="hljs">const requestUrl = `https://example.com`;
</code></pre>
Now run the tests once more:
<pre><code class="hljs">$ mocha index.test.js
</code></pre>
Since we changed the input to the <code>get()</code> method, the URL argument no longer matches what's in our test. We'll get this output when we run the test:
<pre><code class="hljs">&gt; mocha index.test.js



 with mock: getPhotosByAlbumId
(node:85434) UnhandledPromiseRejectionWarning: ExpectationError: Unexpected call: get(https://example.com, function () {})
 Expected get(https://jsonplaceholder.typicode.com/albums/2/photos?_limit=3[, ...]) once (never called)
</code></pre>
Great! We're pretty certain that our mocks will guarantee that our function behaves as we expect!
By using a mock, we have been able to get the benefits of both spies and stubs. We were able to check that our function was called exactly once, and with the correct arguments, a benefit provided us by spies. We were also able to stub the request so that we were not making an actual HTTP call to the API, which ensured that our test ran quickly.
<h2 id="conclusion">Conclusion</h2>
Mocks in unit testing combine the functionality of both spies and stubs by replacing functions like stubs and at the same time providing us with means of observing the functions to check how they were called, the functionality provided us by spies. Mocks then give us the benefit of verifying how our function was used in a test.
In this article, we introduced the concept of mocking in unit testing, and saw how we could mock an HTTP call. To learn more about Sinon.js mocks, you can review the <a rel="nofollow noopener" target="_blank" href="https://sinonjs.org/releases/latest/mocks/">official documentation</a> of the mocks API.

Allan Mogusu

Sinon.js is a popular framework used in standalone test spies, stubs and mocks for JavaScript. In this article, we'll mock an HTTP request in a unit test.

Using Mocks for Testing in JavaScript with Sinon.js

<h2 id="introduction">Introduction</h2>
The main focus of this article is to help you understand how Spring's <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/annotation/Value.html">@Value</a> annotation works.
<code>@Value</code> is a Java annotation that is used at the field or method/constructor parameter level and it indicates a default value for the affected argument. It is commonly used for injecting values into configuration variables - which we will show and explain in the next part of the article.
<h2 id="basicassignment">Basic Assignment</h2>
For the easiest examples, we will assign values to three different fields using the <code>@Value</code> annotation by giving them explicit values:
<pre><code class="hljs">@Value(&quot;John&quot;)
private String trainee;

@Value(&quot;100&quot;)
private int hoursOfCode;

@Value(&quot;true&quot;)
private boolean passedAssesmentTest;
</code></pre>
It's very important to note that the argument passed to the <code>@Value</code> annotation can only be a <code>String</code>. Spring will convert the value to the specified type and the assignment will be done without any problems - even if we are passing <code>String</code> values to <code>int</code> or <code>boolean</code> variables.
<h2 id="springenvironment">Spring Environment</h2>
Injecting values from properties files with the help of <code>@Value</code> annotation is probably the most used use-case in real-life applications.
We will use the default property file for Spring Boot - <code>application.properties</code>, where we can define variables that we can access afterwards:
<pre><code class="hljs">car.brand=Audi
car.color=Red
car.power=150
</code></pre>
<pre><code class="hljs">@Value(&quot;${car.brand&quot;)
private String brand;

@Value(&quot;${car.color}&quot;)
private String color;

@Value(&quot;${car.power}&quot;)
private int power;
</code></pre>
In this example, the values for the variables are being read from the <code>application.properties</code> file and assigned to them during bean creation.
Most of the time, we'd use this approach to inject configuration values from the <code>application.properties</code> file into beans.
<h2 id="defaultvalue">Default Value</h2>
Default values are used as a &quot;fallback&quot; if the property we wish to inject isn't defined or missing:
<pre><code class="hljs">@Value(&quot;${car.type:Sedan}&quot;)
private String type;
</code></pre>
In the above example, because we don't have any <code>car.type</code> property in <code>application.properties</code>, Spring will assign <code>Sedan</code> to the <code>type</code> variable as the default value.
If the <code>car.type</code> property gets inserted into the properties file, the new value will be used instead.
<h2 id="systemvariables">System Variables</h2>
We can also access system variables which are stored as properties by the Spring application at start:
<pre><code class="hljs">@Value(&quot;${user.name}&quot;)
// Or
@Value(&quot;${username}&quot;)
private String userName;

@Value(&quot;${number.of.processors}&quot;)
// Or
@Value(&quot;${number_of_processors}&quot;)
private int numberOfProcessors;

@Value(&quot;${java.home}&quot;)
private String java;
</code></pre>
The variables can be called with different naming conventions - Spring searches for us and assigns the correct value.
<h2 id="globalmethodvalue">Global Method Value</h2>
Because <code>@Value</code> is processed by the <code>BeanPostProcessor</code> class, it will be invoked when Spring is building the Spring context by instantiating configuration files and beans.
This means that by having <code>@Value</code> on a method, all the arguments will be mapped with the value provided to the annotation:
<pre><code class="hljs">@Value(&quot;${car.brand}&quot;)
public CarData setCarData(String color, String brand) {
 carData.setCarColor(color);
 carData.setCarBrand(brand);
}
</code></pre>
If we are printing <code>carData.getCarColor()</code> and <code>carData.getCarBrand()</code> we will get the <code>car.brand</code> value both times, because like we said, all arguments will be mapped with the value provided.
<h2 id="parametermethodvalue">Parameter Method Value</h2>
We can fix this by using <code>@Value</code> directly on the method parameter:
<pre><code class="hljs">@Value(&quot;${car.brand}&quot;)
public CarData setCarData(@Value(&quot;${car.color}&quot;) String color, String brand) {
 carData.setCarColor(color);
 carData.setCarBrand(brand);
}
</code></pre>
Now, if we are printing the values from the <code>carData</code> object - the color field will have the <code>car.color</code> value, because we provided the value to the parameter of the method itself.
<h2 id="springexpressionlanguagespel">Spring Expression Language (SpEL)</h2>
The Spring Expression Language (SpEL) is an expression language which serves as the foundation for expression evaluation within the Spring portfolio.
Basically, when using SpEL together with the <code>@Value</code> annotation, we are just changing the way we tell Spring what we need. Let's take a closer look:
<pre><code class="hljs">@Value(&quot;#{systemProperties[&#x27;user.name&#x27;]}&quot;)
private String userName;
</code></pre>
This is how you'd inject a specific system property. On the other hand, we could inject all properties by:
<pre><code class="hljs">@Value(&quot;#{systemProperties}&quot;)
private Map&lt;String, String&gt; properties;
</code></pre>
We know now, that we can use the <code>@Value</code> annotation for methods as a global value or as a parameter value.
Since constructors are essentially methods, we can use the annotation in constructors as well:
<pre><code class="hljs">public Driver(@Value(&quot;#{systemProperties[&#x27;user.name&#x27;]}&quot;) String name, String location) {
 this.name = name;
 this.location = location;
}
</code></pre>
<h2 id="injectingintomaps">Injecting into Maps</h2>
With SpEL, we can do some other fairly interesting things when coupled with the <code>@Value</code> annotation. For example, let's make a <code>Map</code> that represents <code>indoor</code> and <code>outdoor</code> hobbies of a student. Each of these can have multiple values:
<pre><code class="hljs">student.hobbies={indoor: &#x27;reading, drawing&#x27;, outdoor: &#x27;fishing, hiking, bushcraft&#x27;}
</code></pre>
Now, to inject this, we'll need a <code>Map&lt;String, List&lt;String&gt;&gt;</code>:
<pre><code class="hljs">@Value(&quot;#{${student.hobbies}}&quot;)
private Map&lt;String, List&lt;String&gt;&gt; hobbies;
</code></pre>
<h2 id="injectingintolists">Injecting into Lists</h2>
If a property has comma-separated-values, such as a simple list of books, we can use SpEL to interpret it and transform it into a list:
<pre><code class="hljs">student.booksRead=Harry Potter,The Hobbit,Game of Thrones
</code></pre>
By using the <code>split()</code> method, and splitting for every comma (<code>,</code>), we can inject these values into a list:
<pre><code class="hljs">@Value(&quot;#{&#x27;${student.booksRead}&#x27;.split(&#x27;,&#x27;)}&quot;)
private List&lt;String&gt; booksRead;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As soon as you end up working on a real application, you realize that configuration is an important topic and if you are using Spring. There's a big chance you already use or you will have to use the <code>@Value</code> annotation extensively.
Understanding this basic functionality is very important because if you don't, you might end up using it totally wrong.
We also need to be aware that not everything that looks simple is also very good for long term solutions. For example, we should only use <code>@Value</code> in encapsulated components/services (we can call them configuration services).
This way, we will have all our configurations in one place, and that component will only have the responsibility of loading and providing them to other components.

@Value is a Java annotation used at the field or method/constructor level. It's commonly used to inject values into configuration variables.

In this article, we'll cover the many ways you can use the @Value annotation.

The @Value Annotation in Spring

Hiram Kamau

With method overriding, inheriting classes may tweak how we expect a class to behave. In this article, we'll explore one of the core concepts of OOP - polymorphism, through method overriding.

Method Overriding in Java

<h3 id="introduction">Introduction</h3>
For most people, Bubble Sort is likely the first sorting algorithm they heard of in their Computer Science course.
It's highly intuitive and easy to &quot;translate&quot; into code, which is important for new software developers so they can ease themselves into turning ideas into a form that can be executed on a computer. However, Bubble Sort is one of the worst-performing sorting algorithms in every case except checking whether the array is already sorted, where it often outperforms more efficient sorting algorithms like <a target="_blank" href="/quicksort-in-python/">Quick Sort</a>.
<h3 id="theideabehindthebubblesort">The Idea Behind the Bubble Sort</h3>
The idea behind Bubble Sort is very simple, we look at pairs of adjacent elements in an array, one pair at a time, and swap their positions if the first element is larger than the second, or simply move on if it isn't. Let's look at an example and sort the array <code>[8, 5, 3, 1, 4, 7, 9]</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/bubble-sort-in-java-1.gif" alt="bubble sort">
If you focus on the first number, the number <code>8</code>, you can see it &quot;bubbling up&quot; the array into the correct place. Then, this process is repeated for the number <code>5</code> and so on.
<h3 id="howtoimplementbubblesortinpython">How to Implement Bubble Sort in Python</h3>
With the visualization out of the way, let's go ahead and implement the algorithm. Again, it's extremely simple:
<pre><code class="hljs">def bubble_sort(our_list):
 # We go through the list as many times as there are elements
 for i in range(len(our_list)):
 # We want the last pair of adjacent elements to be (n-2, n-1)
 for j in range(len(our_list) - 1):
 if our_list[j] &gt; our_list[j+1]:
 # Swap
 our_list[j], our_list[j+1] = our_list[j+1], our_list[j]
</code></pre>
Now, let's populate a list and call the algorithm on it:
<pre><code class="hljs">our_list = [19, 13, 6, 2, 18, 8]
bubble_sort(our_list)
print(our_list)
</code></pre>
This will give us:
<pre><code class="hljs">[2, 6, 8, 13, 18, 19]
</code></pre>
<h4 id="optimization">Optimization</h4>
The simple implementation did its job, but there are two optimizations we can make here.
When no swaps are made, that means that the list is sorted. However, with the previously implemented algorithm, it'll keep evaluating the rest of the list even though it really doesn't need to. To fix this, we'll keep a <code>boolean</code> flag and check if any swaps were made in the previous iteration.
If no swaps are made, the algorithm should stop:
<pre><code class="hljs">def bubble_sort(our_list):
 # We want to stop passing through the list
 # as soon as we pass through without swapping any elements
 has_swapped = True

 while(has_swapped):
 has_swapped = False
 for i in range(len(our_list) - 1):
 if our_list[i] &gt; our_list[i+1]:
 # Swap
 our_list[i], our_list[i+1] = our_list[i+1], our_list[i]
 has_swapped = True
</code></pre>
The other optimization we can make leverages the fact that Bubble Sort works in such a way that the largest elements in a particular iteration end up at the end of the array.
The first time we pass through the list the position n is guaranteed to be the largest element, the second time we pass through the position n-1 is guaranteed to be the second-largest element, and so forth.
This means that with each consecutive iteration we can look at one less element than before. More precisely, in the k-th iteration, only need to look at the first n - k + 1 elements:
<pre><code class="hljs">def bubble_sort(our_list):
 has_swapped = True

 num_of_iterations = 0

 while(has_swapped):
 has_swapped = False
 for i in range(len(our_list) - num_of_iterations - 1):
 if our_list[i] &gt; our_list[i+1]:
 # Swap
 our_list[i], our_list[i+1] = our_list[i+1], our_list[i]
 has_swapped = True
 num_of_iterations += 1
</code></pre>
<h3 id="optimizedvsnonoptimizedbubblesort">Optimized vs Non-Optimized Bubble Sort</h3>
Let's go ahead and compare the time it takes for each of these code snippets to sort the same list a thousand times using the <code>timeit</code> module:
<pre><code class="hljs">Unoptimized Bubble Sort took: 0.0106407
</code></pre>
<pre><code class="hljs">Bubble Sort with a boolean flag took: 0.0078251
</code></pre>
<pre><code class="hljs">Bubble Sort with a boolean flag and shortened list took: 0.0075207
</code></pre>
<blockquote>
There isn't much of a difference between the latter two approaches due to the fact that the list is extremely short, but on larger lists - the second optimization can make a huge difference.
</blockquote>
<h3 id="conclusion">Conclusion</h3>
In the most inefficient approach, Bubble Sort goes through n-1 iterations, looking at n-1 pairs of adjacent elements. This gives it the time complexity of \)O(n^2)\), in both best-case and average-case situations. \)O(n^2)\) is considered pretty horrible for a sorting algorithm.
It does have an O(1) space complexity, but that isn't enough to compensate for its shortcomings in other fields.
However, it's still a big part of the software development community and history, and textbooks almost never fail to mention it when talking about basic sorting algorithms.

Olivera Popović

Although horribly inefficient, Bubble Sort is still a big part of the software development community and history. In this article, we'll be diving into a few approaches to Bubble Sorting lists in Python.