Olivera Popović

Dimitrije Stamenic

Merge Sort is one of the most famous sorting algorithms due to its efficient, general-purpose usage. It's a classic example of a divide-and-conquer algorithm. We'll be implementing it in Python on multiple data types.

Merge Sort in Python

<h2 id="introduction">Introduction</h2>
Have you ever received a PDF or an image file from someone via email, only to see strange characters when you open it? This can happen if your email server was only designed to handle text data. Files with binary data, bytes that represent non-text information like images, can be easily corrupted when being transferred and processed to text-only systems.
Base64 encoding allows us to convert bytes containing binary or text data to ASCII characters. By encoding our data, we improve the chances of it being processed correctly by various systems.
In this tutorial, we would learn how Base64 encoding and decoding works, and how it can be used. We will then use Python to Base64 encode and decode both text and binary data.
<h2 id="whatisbase64encoding">What is Base64 Encoding?</h2>
Base64 encoding is a type of conversion of bytes into ASCII characters. In mathematics, the base of a number system refers to how many different characters represent numbers. The name of this encoding comes directly from the mathematical definition of bases - we have 64 characters that represent numbers.
The Base64 character set contains:
<ul>
<li>26 uppercase letters</li>
<li>26 lowercase letters</li>
<li>10 numbers</li>
<li><code>+</code> and <code>/</code> for new lines (some implementations may use different characters)</li>
</ul>
When the computer converts Base64 characters to binary, each Base64 character represents 6 bits of information.
Note: This is not an encryption algorithm, and should not be used for security purposes.
Now that we know what Base64 encoding is and how it is represented on a computer, let's look deeper into how it works.
<h2 id="howdoesbase64encodingwork">How Does Base64 Encoding Work?</h2>
We will illustrate how Base64 encoding works by converting text data, as it's more standard than the various binary formats to choose from. If we were to Base64 encode a string we would follow these steps:
<ol>
<li>Take the ASCII value of each character in the string</li>
<li>Calculate the 8-bit binary equivalent of the ASCII values</li>
<li>Convert the 8-bit chunks into chunks of 6 bits by simply re-grouping the digits</li>
<li>Convert the 6-bit binary groups to their respective decimal values.</li>
<li>Using a base64 encoding table, assign the respective base64 character for each decimal value.</li>
</ol>
Let's see how it works by converting the string &quot;Python&quot; to a Base64 string.
The ASCII values of the characters <code>P, y, t, h, o, n</code> are <code>15, 50, 45, 33, 40, 39</code> respectively. We can represent these ASCII values in 8-bit binary as follows:
<pre><code class="hljs">01010000 01111001 01110100 01101000 01101111 01101110
</code></pre>
Recall that Base64 characters only represent 6 bits of data. We now re-group the 8-bit binary sequences into chunks of 6 bits. The resultant binary will look like this:
<pre><code class="hljs">010100 000111 100101 110100 011010 000110 111101 101110
</code></pre>
Note: Sometimes we are not able to group the data into sequences of 6 bits. If that occurs, we have to pad the sequence.
With our data in groups of 6 bits, we can obtain the decimal value for each group. Using our last result, we get the following decimal values:
<pre><code class="hljs">20 7 37 52 26 6 61 46
</code></pre>
Finally, we will convert these decimals into the appropriate Base64 character using the Base64 conversion table:
<img src="https://stackabuse.s3.amazonaws.com/media/encoding-and-decoding-base64-strings-python-1.png" alt="Base64 Encoding Table">
As you can see, the value <code>20</code> corresponds to the letter <code>U</code>. Then we look at <code>7</code> and observe it's mapped to <code>H</code>. Continuing this lookup for all decimal values, we can determine that &quot;Python&quot; is represented as <code>UHl0aG9u</code> when Base64 encoded. You can verify this result with an online converter.
To Base64 encode a string, we convert it to binary sequences, then to decimal sequences, and finally, use a lookup table to get a string of ASCII characters. With that deeper understanding of how it works, let's look at why would we Base64 encode our data.
<h2 id="whyusebase64encoding">Why use Base64 Encoding?</h2>
In computers, all data of different types are transmitted as 1s and 0s. However, some communication channels and applications are not able to understand all the bits it receives. This is because the meaning of a sequence of 1s and 0s is dependent on the type of data it represents. For example, <code>10110001</code> must be processed differently if it represents a letter or an image.
To work around this limitation, you can encode your data to text, improving the chances of it being transmitted and processed correctly. Base64 is a popular method to get binary data into ASCII characters, which is widely understood by the majority of networks and applications.
A common real-world scenario where Base64 encoding is heavily used are in mail servers. They were originally built to handle text data, but we also expect them to send images and other media with a message. In those cases, your media data would be Base64 encoded when it is being sent. It will then be Base64 decoded when it is received so an application can use it. So, for example, the image in the HTML might look like this:
<pre><code class="hljs">&lt;img src=&quot;data:image/png;base64,aVRBOw0AKg1mL9...&quot;&gt;
</code></pre>
Understanding that data sometimes needs to be sent as text so it won't be corrupted, let's look at how we can use Python to Base64 encoded and decode data.
<h2 id="encodingstringswithpython">Encoding Strings with Python</h2>
Python 3 provides a <code>base64</code> module that allows us to easily encode and decode information. We first convert the string into a bytes-like object. Once converted, we can use the <code>base64</code> module to encode it.
In a new file <code>encoding_text.py</code>, enter the following:
<pre><code class="hljs">import base64

message = &quot;Python is fun&quot;
message_bytes = message.encode(&#x27;ascii&#x27;)
base64_bytes = base64.b64encode(message_bytes)
base64_message = base64_bytes.decode(&#x27;ascii&#x27;)

print(base64_message)
</code></pre>
In the code above, we first imported the <code>base64</code> module. The <code>message</code> variable stores our input string to be encoded. We convert that to a bytes-like object using the string's <code>encode</code> method and store it in <code>message_bytes</code>. We then Base64 encode <code>message_bytes</code> and store the result in <code>base64_bytes</code> using the <code>base64.b64encode</code> method. We finally get the string representation of the Base64 conversion by decoding the <code>base64_bytes</code> as ASCII.
Note: Be sure to use the same encoding format when converting from string to bytes, and from bytes to string. This prevents data corruption.
Running this file would provide the following output:
<pre><code class="hljs">$ python3 encoding_text.py
UHl0aG9uIGlzIGZ1bg==
</code></pre>
Now let's see how we can decode a Base64 string to its raw representation.
<h2 id="decodingstringswithpython">Decoding Strings with Python</h2>
Decoding a Base64 string is essentially a reverse of the encoding process. We decode the Base64 string into bytes of un-encoded data. We then convert the bytes-like object into a string.
In a new file called <code>decoding_text.py</code>, write the following code:
<pre><code class="hljs">import base64

base64_message = &#x27;UHl0aG9uIGlzIGZ1bg==&#x27;
base64_bytes = base64_message.encode(&#x27;ascii&#x27;)
message_bytes = base64.b64decode(base64_bytes)
message = message_bytes.decode(&#x27;ascii&#x27;)

print(message)
</code></pre>
Once again, we need the <code>base64</code> module imported. We then encode our message into a bytes-like object with <code>encode('ASCII')</code>. We continue by calling the <code>base64.b64decode</code> method to decode the <code>base64_bytes</code> into our <code>message_bytes</code> variable. Finally, we decode <code>message_bytes</code> into a string object <code>message</code>, so it becomes human readable.
Run this file to see the following output:
<pre><code class="hljs">$ python3 decoding_text.py
Python is fun
</code></pre>
Now that we can encode and decode string data, let's try to encode binary data.
<h2 id="encodingbinarydatawithpython">Encoding Binary Data with Python</h2>
As we mentioned previously, Base64 encoding is primarily used to represent binary data as text. In Python, we need to read the binary file, and Base64 encodes its bytes so we can generate its encoded string.
Let's see how we can encode this image:
<img src="https://stackabuse.s3.amazonaws.com/media/encoding-and-decoding-base64-strings-python-2.png" alt="Python logo">
Create a new file <code>encoding_binary.py</code> and add the following:
<pre><code class="hljs">import base64

with open(&#x27;logo.png&#x27;, &#x27;rb&#x27;) as binary_file:
 binary_file_data = binary_file.read()
 base64_encoded_data = base64.b64encode(binary_file_data)
 base64_message = base64_encoded_data.decode(&#x27;utf-8&#x27;)

 print(base64_message)
</code></pre>
Let's go over the code snippet above. We open the file using <code>open('my_image.png', 'rb')</code>. Note how we passed the <code>'rb'</code> argument along with the file path - this tells Python that we are reading a binary file. Without using <code>'rb'</code>, Python would assume we are reading a text file.
We then use the <code>read()</code> method to get all the data in the file into the <code>binary_file_data</code> variable. Similar to how we treated strings, we Base64 encoded the bytes with <code>base64.b64encode</code> and then used the <code>decode('utf-8')</code> on <code>base64_encoded_data</code> to get the Base64 encoded data using human-readable characters.
Executing the code will produce similar output to:
<pre><code class="hljs">$ python3 encoding_binary.py
iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAAsTAAALEwEAmpwYAAAB1klEQVQ4jY2TTUhUURTHf+fy/HrjhNEX2KRGiyIXg8xgSURuokXLxFW0qDTaSQupkHirthK0qF0WQQQR0UCbwCQyw8KCiDbShEYLJQdmpsk3895p4aSv92ass7pcfv/zP+fcc4U6kXKe2pTY3tjSUHjtnFgB0VqchC/SY8/293S23f+6VEj9KKwCoPDNIJdmr598GOZNJKNWTic7tqb27WwNuuwGvVWrAit84fsmMzE1P1+1TiKMVKvYUjdBvzPZXCwXzyhyWNBgVYkgrIow09VJMznpyebWE+Tdn9cEroBSc1JVPS+6moh5Xyjj65vEgBxafGzWetTh+rr1eE/c/TMYg8hlAOvI6JP4KmwLgJ4qD0TIbliTB+sunjkbeLekKsZ6Zc8V027aBRoBRHVoduDiSypmGFG7CrcBEyDHA0ZNfNphC0D6amYa6ANw3YbWD4Pn3oIc+EdL36V3od0A+MaMAXmA8x2Zyn+IQeQeBDfRcUw3B+2PxwZ/EdtTDpCPQLMh9TKx0k3pXipEVlknsf5KoNzGyOe1sz8nvYtTQT6yyvTjIaxsmHGB9pFx4n3jIEfDePQvCIrnn0J4B/gA5J4XcRfu4JZuRAw3C51OtOjM3l2bMb8Br5eXCsT/w/EAAAAASUVORK5CYII=
</code></pre>
Your output may vary depending on the image you've chosen to encode.
Now that we know how to Bas64 encode binary data in Python, let's move on to Base64 decoding binary data.
<h2 id="decodingbinarydatawithpython">Decoding Binary Data with Python</h2>
Base64 decoding binary is similar to Base64 decoding text data. The key difference is that after we Base64 decode the string, we save the data as a binary file instead of a string.
Let's see how to Base64 decode binary data in practice by creating a new file called <code>decoding_binary.py</code>. Type the following code into the Python file:
<pre><code class="hljs">import base64

base64_img = &#x27;iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAAsTAAA&#x27; \
 &#x27;LEwEAmpwYAAAB1klEQVQ4jY2TTUhUURTHf+fy/HrjhNEX2KRGiyIXg8xgSURuokX&#x27; \
 &#x27;LxFW0qDTaSQupkHirthK0qF0WQQQR0UCbwCQyw8KCiDbShEYLJQdmpsk3895p4aS&#x27; \
 &#x27;v92ass7pcfv/zP+fcc4U6kXKe2pTY3tjSUHjtnFgB0VqchC/SY8/293S23f+6VEj&#x27; \
 &#x27;9KKwCoPDNIJdmr598GOZNJKNWTic7tqb27WwNuuwGvVWrAit84fsmMzE1P1+1TiK&#x27; \
 &#x27;MVKvYUjdBvzPZXCwXzyhyWNBgVYkgrIow09VJMznpyebWE+Tdn9cEroBSc1JVPS+&#x27; \
 &#x27;6moh5Xyjj65vEgBxafGzWetTh+rr1eE/c/TMYg8hlAOvI6JP4KmwLgJ4qD0TIbli&#x27; \
 &#x27;TB+sunjkbeLekKsZ6Zc8V027aBRoBRHVoduDiSypmGFG7CrcBEyDHA0ZNfNphC0D&#x27; \
 &#x27;6amYa6ANw3YbWD4Pn3oIc+EdL36V3od0A+MaMAXmA8x2Zyn+IQeQeBDfRcUw3B+2&#x27; \
 &#x27;PxwZ/EdtTDpCPQLMh9TKx0k3pXipEVlknsf5KoNzGyOe1sz8nvYtTQT6yyvTjIax&#x27; \
 &#x27;smHGB9pFx4n3jIEfDePQvCIrnn0J4B/gA5J4XcRfu4JZuRAw3C51OtOjM3l2bMb8&#x27; \
 &#x27;Br5eXCsT/w/EAAAAASUVORK5CYII=&#x27;

base64_img_bytes = base64_img.encode(&#x27;utf-8&#x27;)
with open(&#x27;decoded_image.png&#x27;, &#x27;wb&#x27;) as file_to_save:
 decoded_image_data = base64.decodebytes(base64_img_bytes)
 file_to_save.write(decoded_image_data)
</code></pre>
In the above code, we first convert our Base64 string data into a bytes-like object that can be decoded. When you are base64 decoding a binary file, you must know the type of data that is being decoded. For example, this data is only valid as a PNG file and not a MP3 file as it encodes an image.
Once the destination file is open, we Base64 decode the data with <code>base64.decodebytes</code>, a different method from <code>base64.b64decode</code> that was used with strings. This method should be used to decode binary data. Finally, we write the decoded data to a file.
In the same directory that you executed <code>decoding_binary.py</code>, you would now see a new <code>decoded_image.png</code> file that contains the original image that was encoded earlier.
<h2 id="conclusion">Conclusion</h2>
Base64 encoding is a popular technique to convert data in different binary formats to a string of ASCII characters. This is useful when transmitting data to networks or applications that cannot process raw binary data but would readily handle text.
With Python, we can use the <code>base64</code> module to Base64 encode and decode text and binary data.
What applications would you use to encode and decode Base64 data?

Marcus Sanatan

Abhishek Amin

Base64 encoding allows us to convert bytes containing binary or text data to ASCII characters. In this tutorial, we'll be encoding and decoding Base64 Strings in Python.

Encoding and Decoding Base64 Strings in Python

<h2 id="introduction">Introduction</h2>
Most of the user-facing software comes with a visually pleasing interface or via a decorated webpage. At other times, a program can be so small that it does not warrant an entire graphical user interface or web application to expose its functionality to the end-user.
In these cases, we can build programs that are accessible via a Command Line Interface, or CLI.
In this post, we will explore Python's <code>argparse</code> module and use it to build a simple command-line tool to help us shorten URLs swiftly.
<h2 id="commandlineinterface">Command Line Interface</h2>
A Command Line Interface is a text-based user interface that provides a means of interacting with a computer through textual commands. The program that facilitates this interaction by exposing the interface is known as a command-line interpreter or a shell.
It takes in commands in the form of text input, executes programs based on the input provided, then displays the output on the interface. There are many shells available, with the first popular ones being the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bourne_shell">Bourne shell</a> and <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/C_shell">C shell</a> for Unix-based systems. The <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bash_(Unix_shell)">Bourne Again Shell</a> (aka bash) is a hugely popular extension of the Bourne Shell, alongside the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/KornShell">KornShell</a> (<code>ksh</code>).
It is also worth noting that CLIs, like other software, require user accounts to work with them. The system enforces permissions on these users to help control the level of access and limit of what a user can achieve with the system. This distinction is required since the shell is an interface between the user and the operating system kernel that controls all computer operations. Access to this functionality needs to be restricted to prevent malicious use of the command-line interface.
CLIs offer a prompt, which is usually a dollar sign (<code>$</code>) that indicates that you can enter your command. However, this prompt also indicates that the command entered will be performed without root access.
When root access is granted to the current user interacting with the CLI, the prompt changes to a hash sign (<code>#</code>).
While Graphical User Interfaces (GUIs) are easier to learn and more visually intuitive, CLIs allow users to interact with software using only a keyboard, which can result in faster performance. CLIs also use up fewer computer resources as compared to GUIs, making them lighter and faster.
<h2 id="scripting">Scripting</h2>
Most command-line interpreters ship with some basic commands that can all be invoked through the command-line interface to perform specific tasks. Some common ones include:
<ul>
<li><code>uptime</code>: Indicates how long the computer has been on</li>
<li><code>date</code>: Returns the current date and time</li>
<li><code>ls</code>: Returns a list of all the files and folders in a directory</li>
<li><code>cd</code>: Used to move from one directory to another</li>
<li><code>pwd</code>: Used to show the current working directory</li>
<li><code>man</code>: Used to show the manual or instructions of any command</li>
<li><code>touch</code>: Used to create new, empty files</li>
<li><code>mkdir</code>: Used to create new directories</li>
</ul>
A shell script is a program designed to be executed by a command-line interpreter. It contains a series of commands, like the ones listed above, coupled with variables and conditions instructing the shell on what task or tasks to undertake.
Through shell scripts, a user can perform multiple commands in quick succession without the need to remember them all. They are mostly used to achieve repetitive operations without the repetitive entry of commands, therefore, reducing the effort required by the end-user.
We can write shell scripts that consist of the shell commands to be executed, but also, we can execute other high-level languages, such as Python and JavaScript.
<h2 id="whatisargparse">What is argparse?</h2>
A Python shell script is just a normal Python program that is executed by the command-line interpreter. When executing a shell script, arguments are passed into our script through <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/sys.html#sys.argv">sys.argv</a>. This variable is a list of the arguments passed to our program, including the script name, which is also the first argument.
Normally, we can write a simple script that does not require any extra arguments, like a simple script to display the current date. This will, however, limit the functionality we can offer. To make our scripts more versatile and widen the scope of their usage, we have to facilitate customization through arguments that give the user more control and options in terms of functionality.
The <code>argparse</code> module helps us parse the arguments passed with our script and process them in a more convenient way. It also adds customization features such as naming our program and adding descriptions in a simpler way.
<code>argparse</code> also provides a means for us to customize the usage instructions for our script and indicate which arguments are required and which are optional. To explore all these features and more, we'll build our own Python CLI utility in the next section.
<h2 id="demoapplication">Demo Application</h2>
Currently if we want to shorten a URL, we will need to fire up a browser and navigate to a URL shortening site in order to do the task. Our goal is to accelerate and enhance this URL shortening process through a script that we can fire up anytime on our terminal. We will only have to pass the URLs we need to shorten as arguments and receive the shortened URLs in response.
For this demo, we'll use <a rel="nofollow" target="_blank" href="https://shorte.st/">Shorte.st</a> as our provider since its API is simple and straightforward.
After creating an account, we can head over to the Link Tools section and select Developers API. Here we will find our access token and the URL which our script will use to shorten our URLs.
Once the user provides a URL to our command line utility to be shortened, we will send the URL to the Shorte.st API endpoint along with our access token. The response will be our shortened URL and a status message.
Let us start by creating a virtual environment and installing the <a target="_blank" href="/the-python-requests-module/">requests module</a>, which we'll use to send HTTP requests to the API:
<pre><code class="hljs">$ mkdir pyshortener &amp;&amp; cd pyshortener
$ virtualenv --python=python3 env --no-site-packages
$ source env/bin/activate
$ pip install requests
</code></pre>
In the first line above we have actually combined two commands in one using the double ampersand (<code>&amp;&amp;</code>). This allows us to execute the commands in sequence, unless the first command fails, which then prevents the second command from being executed.
After creating our virtual environment and activating it, we then install our Python dependency.
For this demo we will first build our shortening function and then wrap its functionality using <code>argparse</code> into the final script:
<pre><code class="hljs">import requests
from requests.exceptions import ConnectionError
import json

def shorten_url(url):
 try:
 response = requests.put(&quot;https://api.shorte.st/v1/data/url&quot;,
 {&quot;urlToShorten&quot;: url},
 headers={&quot;public-api-token&quot;: &quot;[MY-API-TOKEN]&quot;})

 api_response = json.loads(response.content)

 return {&quot;status&quot;: api_response[&#x27;status&#x27;],
 &quot;shortenedUrl&quot;: api_response[&#x27;shortenedUrl&#x27;],
 &quot;message&quot;: &quot;URL shortened successfully&quot;}

 except ConnectionError:
 return {&quot;status&quot;: &quot;error&quot;,
 &quot;shortenedUrl&quot;: None,
 &quot;message&quot;: &quot;Please ensure you are connected to the internet and try again.&quot;}

shorten_url(www.stackabuse.com)
</code></pre>
Our function takes in a URL and sends it to the Shorte.st API and returns the shortened URL. Let's shorten <code>www.stackabuse.com</code> by executing our script:
<pre><code class="hljs">$ python pyshortener.py
{&#x27;status&#x27;: &#x27;ok&#x27;, &#x27;shortenedUrl&#x27;: &#x27;http://gestyy.com/w6ph2J&#x27;, &#x27;message&#x27;: &#x27;URL shortened successfully&#x27;}
</code></pre>
As we can see, our function works but the output is less than ideal. We also have to hardcode the URL in the script itself, which gives us a fixed input and output.
We are going to take this a step further and allow users to pass in the URL as an argument when they execute the script. In order to do this we will now introduce <code>argparse</code> to help us parse the arguments provided by the user:
<pre><code class="hljs">import requests
from requests.exceptions import ConnectionError
import json
import argparse # Add the argparse import

def shorten_url(url):
 # Code stays the same...

# Create a parser
parser = argparse.ArgumentParser(description=&#x27;Shorten URLs on the terminal&#x27;)

# Add argument
parser.add_argument(&#x27;--url&#x27;, default=&quot;google.com&quot;, help=&quot;The URL to be shortened&quot;)
args = vars(parser.parse_args())
print(args)
</code></pre>
In this version of the script, we don't call <code>shorten_url</code>, but instead just print out the arguments captured and parsed by <code>argparse</code>.
We start by creating an <code>ArgumentParser</code> object using <code>argparse</code>, which will hold all the info required to transform the arguments passed into Python data types we can work with.
After creating the parser, we can now add arguments using <code>parser.add_argument()</code>. This function allows to specify the following information about our arguments:
<ul>
<li>The first argument is a name or a flag used to identify our arguments. Optional arguments are identified by the <code>-</code> prefix, in our case <code>--url</code> is an optional argument.</li>
<li>The <code>default</code> option allows specifying a default value when the user has not provided the argument.</li>
<li>The <code>help</code> option briefly describes what the argument is.</li>
<li>We can also use the <code>choice</code> option to specify allowable values for an argument, such as yes and no.</li>
<li>Through a <code>type</code> option we can also specify the type to which our command will be converted to, for instance converting arguments into integers.</li>
</ul>
When we run our script without providing any arguments, the URL defaults to &quot;google.com&quot;, just like we've set in the <code>add_argument</code> method:
<pre><code class="hljs">$ python pyshortener.py
{&#x27;url&#x27;: &#x27;google.com&#x27;}
</code></pre>
Now when we pass <code>www.stackabuse.com</code> using the <code>--url</code> flag, it is set as the value to the <code>url</code> key:
<pre><code class="hljs">$ python pyshortener.py --url www.stackabuse.com
{&#x27;url&#x27;: &#x27;www.stackabuse.com&#x27;}
</code></pre>
We can now receive a user's URL via the command line and shorten it by modifying our script:
<pre><code class="hljs">if args.get(&#x27;url&#x27;):
 print(shorten_url(args[&#x27;url&#x27;]))
</code></pre>
When we run it and pass a URL we should then receive the output from the Shorte.st API:
<pre><code class="hljs">$ python pyshortener.py --url stackabuse.com
{&#x27;status&#x27;: &#x27;ok&#x27;, &#x27;shortenedUrl&#x27;: &#x27;http://gestyy.com/w6pk2R&#x27;, &#x27;message&#x27;: &#x27;URL shortened successfully&#x27;}
</code></pre>
Although our output is not as friendly as we'd want it too, so let us create a function to format our output in a more desirable manner:
<pre><code class="hljs">def handle_output(result):
 &quot;&quot;&quot; Function to format and print the output
 &quot;&quot;&quot;
 if result[&quot;status&quot;] == &quot;ok&quot;:
 print(f&quot;{result[&#x27;message&#x27;]}. Your shortened URL is:\n&quot;
 f&quot;\t{result[&#x27;shortenedUrl&#x27;]}&quot;)
 elif result[&quot;status&quot;] == &quot;error&quot;:
 print(f&quot;{result[&#x27;message&#x27;]}&quot;)

# Receive and process the argument
args = vars(parser.parse_args())

if args.get(&#x27;url&#x27;):
 result = shorten_url(args[&#x27;url&#x27;])
 handle_output(result)
</code></pre>
When we run our script one more time:
<pre><code class="hljs">$ python pyshortener.py --url www.stackabuse.com
URL shortened successfully. Your shortened URL is:
 http://gestyy.com/w6pk2R
</code></pre>
Our output is now more user-friendly due to the addition of the <code>handle_output()</code> function. To see how <code>argparse</code> has generated the help text for our script, we can execute our script with the <code>-h</code> flag to display the help text as follows:
<pre><code class="hljs">$ python pyshortener.py -h
usage: pyshortener.py [-h] [--url URL]

Shorten URLs on the terminal

optional arguments:
 -h, --help show this help message and exit
 --url URL The URL to be shortened
</code></pre>
<h2 id="conclusion">Conclusion</h2>
We have built a shell script using Python to help us shorten URLs quickly on the terminal. We have used the <code>argparse</code> module to parse the arguments that are passed into our script and even defined a default value in case the argument is provided.
Our script now also has a beautiful help message that can be displayed using the <code>-h</code> flag which was generated by the <code>argparse</code> module meaning we did not have to write it down manually.
The next step would be to enhance our script to accept a list of URLs or read URLs from a text file to facilitate batch shortening of URLs.
The source code for the script in this project can be found <a rel="nofollow" target="_blank" href="https://github.com/ro6ley/PyShortener">here on GitHub</a>.

Robley Gori

At times, apps are small enough that they really don't need a GUI. In such cases, a Command Line Interface is sufficient. In this article, we'll be using the argparse module to create some CLI apps in Python.

Creating Command Line Utilities with Python's argparse

<h2 id="introduction">Introduction</h2>
Servers are computer software or hardware that processes requests and delivers data to a client over a network. Various types of servers exist, with the most common ones being web servers, database servers, application servers, and transaction servers.
Widely used web servers such as <a rel="nofollow" target="_blank" href="https://www.apache.org/">Apache</a>, <a rel="nofollow" target="_blank" href="http://monkey-project.com/">Monkey</a>, and <a rel="nofollow" target="_blank" href="https://jigsaw.w3.org/">Jigsaw</a> are quite time-consuming to set up when testing out simple projects and a developer's focus is shifted from producing application logic to setting up a server.
Python's <code>SimpleHTTPServer</code> module is a useful and straightforward tool that developers can use for a number of use-cases, with the main one being that it is a quick way to serve files from a directory.
It eliminates the laborious process associated with installing and implementing the available cross-platform web servers.
Note: While <code>SimpleHTTPServer</code> is a great way to easily serve files from a directory, it shouldn't be used in a production environment. According to the official Python docs, it &quot;only implements basic security checks.&quot;
<h2 id="whatisanhttpserver">What is an HTTP Server</h2>
HTTP stands for HyperText Transfer Protocol. Let us think of a protocol as a spoken language like English. English has a set of rules and vocabulary. Thus, if we both understand the rules and vocabulary defining the English Language, then we can communicate in the language effectively.
Just like human beings, electronic devices communicate with each other as well. They, therefore, need a 'set of rules and vocabulary' to actively pass and receive information from each other.
A protocol is a standard set of rules that facilitates successful communication between electronic devices. These sets of mutually accepted and implemented rules include the commands used to initiate the sending and reception of data, the data types to be transmitted between devices, how to detect errors in data, how successful data transfers are confirmed, and much more.
For example, when you perform a simple search using a browser, there were two essential systems involved - the HTTP Client and HTTP Server.
The client, commonly referred to as the browser, can be an elaborate program such as Google Chrome, or Firefox, but it can also be as simple as a CLI application. The client sends your request to the server, which the processes the HTTP requests and provides a response to the client. In the case of browsers, the response is typically an HTML page.
<h2 id="pythonssimplehttpservermodule">Python's SimpleHTTPServer Module</h2>
When you need a quick web server running, setting up a production-level server is a massive overkill.
Python's <code>SimpleHTTPServer</code> module is a labor-saving tool that you can leverage for turning any directory in your system into an uncomplicated web server. It comes packaged with a simple HTTP server that delivers standard <code>GET</code> and <code>HEAD</code> request handlers.
With a built-in HTTP server, you are not required to install or configure anything to have your web server up and running.
Note: The Python <code>SimpleHTTPServer</code> module was merged into the <code>http.server</code> module in Python 3. Throughout this article we'll be using the Python 3 version, but if you're using Python 2 you can swap out <code>http.server</code> for <code>SimpleHTTPServer</code> and it should work in most cases.
<h2 id="commandlineusage">Command Line Usage</h2>
The simplest way to start up a web server that serves the directory in which the command is ran is to simply navigate to your project's directory using the terminal and run:
Python 2
<pre><code class="hljs">$ python -m SimpleHTTPServer 8000
</code></pre>
Python 3
<pre><code class="hljs">$ python3 -m http.server 8000
</code></pre>
By running this command, you'll be able to access the files in your directory through your browser at <code>localhost:8000</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-1.png" alt="application directory listing">
As you can see, the server provides a simple directory UI in which you can access any of the files. This is the simplest way to directly serve files locally over HTTP.
<h2 id="defaultpythonusage">Default Python Usage</h2>
For one reason or another, running this server via the command line might not suit our use-case. At times like this we can instead use the server directly in our code using the <code>SimpleHTTPRequestHandler</code> object. But first, we need to set it up with a socket server.
Beneath the HTTP protocol are UDP (User Datagram Protocol) or TCP (Transmission Control Protocol), which are transport protocols that handle the transportation of data from one network location to another. Since we're running an HTTP server, our application will use the TCP protocol, through a TCP Socket Address which contains an IP address and a port number. This can be set up with Python's <code>socketserver.TCPServer</code>, which we've implemented below:
<pre><code class="hljs">import http.server
import socketserver

PORT = 8000

handler = http.server.SimpleHTTPRequestHandler

with socketserver.TCPServer((&quot;&quot;, PORT), handler) as httpd:
 print(&quot;Server started at localhost:&quot; + str(PORT))
 httpd.serve_forever()
</code></pre>
Note: The code will fail with the error <code>AttributeError: __exit__</code> for Python versions &lt; 3.6. This is because in previous versions <code>socketserver.TCPServer</code> does not support use with <a target="_blank" href="/python-context-managers/">context managers</a> (the <code>with</code> keyword). In these cases you need to call <code>server_close()</code> to stop the server.
By default, the <code>SimpleHTTPRequestHandler</code> serves files from the current directory and related subdirectories. As the name suggests, it is a simple HTTP request handler. Being the simple server that it is, it only allows you to retrieve data and not post it to the server. And because of this, it only implements the HTTP <code>GET</code> and <code>HEAD</code> methods via <code>do_GET()</code> and <code>do_HEAD()</code>.
The parameters passed to the <code>TCPServer</code> represent the IP address and port number. By leaving the IP address empty, the server listens to all available IP addresses, while we've set the port to <code>8000</code>. This means that it would then be accessible on <code>localhost:8000</code>.
Finally, <code>httpd.server_forever()</code> starts the server, listens, and responds to incoming requests from the client.
The server can be started by simply executing the file:
<pre><code class="hljs">$ python3 simple-server.py
</code></pre>
And just like with the command line usage, we can now access the directory through our web browser:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-1.png" alt="application directory listing">
<h2 id="customizingpaths">Customizing Paths</h2>
Another approach we can take is to make a custom class that extends <code>SimpleHTTPRequestHandler</code> and handles our requests with some custom functionality. To do this, we implement our own <code>do_GET()</code> function.
But before we get to that, let's say we have an HTML file that we want to serve, <code>mywebpage.html</code>:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;head&gt;
 &lt;title&gt;Using Python&#x27;s SimpleHTTPServer Module&lt;/title&gt;
 &lt;style&gt;
 #rectangle {
 height: 50px;
 width: 100px;
 background-color: #00f28f;
 }
 &lt;/style&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;h2&gt;Rectangle served by SimpleHTTPServer&lt;/h2&gt;
 &lt;div id=&quot;rectangle&quot;&gt;&lt;/div&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
In order to serve this HTML from a path that isn't <code>/mywebpage.html</code>, we can use our custom handler to serve it on any path we want. In this example we'll just serve it on the root path, <code>/</code>:
<pre><code class="hljs">import http.server
import socketserver

class MyHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
 def do_GET(self):
 if self.path == &#x27;/&#x27;:
 self.path = &#x27;mywebpage.html&#x27;
 return http.server.SimpleHTTPRequestHandler.do_GET(self)

# Create an object of the above class
handler_object = MyHttpRequestHandler

PORT = 8000
my_server = socketserver.TCPServer((&quot;&quot;, PORT), handler_object)

# Star the server
my_server.serve_forever()
</code></pre>
Again, running this script will allow us to access it through the browser:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-2.png" alt="rectangle served on the browser">
Though, there are a lot more customizations we can do with the response via the <code>self</code> reference, which we'll see in the next section.
<h2 id="returningdynamichtml">Returning Dynamic HTML</h2>
A common usage of web servers is to serve dynamically generated HTML. Although this is only a very simple server, it can perform this task as well. In addition to sending dynamic HTML, we can also set different status codes, headers, etc. In the following example we set some headers and return dynamic HTML that is generated using the query parameter <code>name</code>:
<pre><code class="hljs">import http.server
import socketserver
from urllib.parse import urlparse
from urllib.parse import parse_qs

class MyHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
 def do_GET(self):
 # Sending an &#x27;200 OK&#x27; response
 self.send_response(200)

 # Setting the header
 self.send_header(&quot;Content-type&quot;, &quot;text/html&quot;)

 # Whenever using &#x27;send_header&#x27;, you also have to call &#x27;end_headers&#x27;
 self.end_headers()

 # Extract query param
 name = &#x27;World&#x27;
 query_components = parse_qs(urlparse(self.path).query)
 if &#x27;name&#x27; in query_components:
 name = query_components[&quot;name&quot;][0]

 # Some custom HTML code, possibly generated by another function
 html = f&quot;&lt;html&gt;&lt;head&gt;&lt;/head&gt;&lt;body&gt;&lt;h1&gt;Hello {name}!&lt;/h1&gt;&lt;/body&gt;&lt;/html&gt;&quot;

 # Writing the HTML contents with UTF-8
 self.wfile.write(bytes(html, &quot;utf8&quot;))

 return

# Create an object of the above class
handler_object = MyHttpRequestHandler

PORT = 8000
my_server = socketserver.TCPServer((&quot;&quot;, PORT), handler_object)

# Star the server
my_server.serve_forever()
</code></pre>
And running this code with the URL <code>http://localhost:8000?name=Billy</code> will yield:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-3.png" alt="serving dynamic html">
Any value you set for the <code>name</code> query parameter will then show up on the screen! You can even omit the <code>name</code> query parameter and see what happens.
As you can see, creating a custom request handler allows us to manipulate the responses as much as we'd like by changing the implementation of the <code>do_GET</code> method and we don't have such control over our responses with the default implementation.
The same can be done with the HTTP HEAD method (via the <code>do_HEAD()</code> function), but since it is very similar to that of GET method we'll leave that as an exercise to the reader.
<h2 id="conclusion">Conclusion</h2>
Python provides us with the <code>SimpleHTTPServer</code> module (or <code>http.server</code> in Python 3) that can be used to quickly and easily serve files from a local directory via HTTP. This can be used for many development or other internal tasks, but is not meant for production.
This is a great solution for local use since web servers such as <a rel="nofollow" target="_blank" href="https://www.apache.org/">Apache</a>, <a rel="nofollow" target="_blank" href="http://monkey-project.com/">Monkey</a>, and <a rel="nofollow" target="_blank" href="https://jigsaw.w3.org/">Jigsaw</a> are much more difficult to get set up and are often overkill for development activities.

Guest Contributor

For quick testing, setting up a server is more of a hassle than making the application itself. In this article, we'll use the SimpleHTTPServer module to quickly run a Python app and access it through the browser.

Serving Files with Python's SimpleHTTPServer Module

<h2 id="introduction">Introduction</h2>
A list is one of the fundamental data types in Python. Every time you come across a variable name that's followed by a square bracket <code>[]</code>, or a <code>list</code> constructor, it is a list capable of containing multiple items, making it a compound data type. Similarly, it is also a breeze to declare a new list and subsequently, add one or more items to it.
<h2 id="shortoverviewoflistsinpython">Short Overview of Lists in Python</h2>
Let us create a new populated list:
<pre><code class="hljs">new_list = [1, 2, 3, 4, 5]
print(new_list) # [1, 2, 3, 4, 5]
</code></pre>
Or we can simply use the <code>append()</code> method to add anything you want to the list:
<pre><code class="hljs">new_list.append(6)
print(new_list) # [1, 2, 3, 4, 5, 6]
</code></pre>
If you need to append multiple items to the same list, the <code>extend()</code> method will come in handy. You simply need to pass the list of items to append to the <code>extend</code> method, as shown below:
<pre><code class="hljs">new_list.extend([7, 8, 9])
print(new_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
As you can see, creating a list and appending it with other items is just a piece of cake. You can accomplish this task without having to make multiple calls to the <code>.append()</code> method.
Similarly, you can use a <code>for</code> loop to append multiple items to a list. For example, we will have to write the following piece of code for creating a list of squares for the integers 1-20.
<pre><code class="hljs">list_a = []
for i in range(1, 20):
 list_a.append(i**2)
</code></pre>
<h2 id="whatarelistcomprehensionsinpython">What are List Comprehensions in Python?</h2>
In the simplest of words, list comprehension is the process of creating a new list from an existing list. Or, you can say that it is Python's unique way of appending a <code>for</code> loop to a list. But, it is already pretty simple to declare a list and append anything you like to it. Isn't it? So, why bother comprehending our lists?
List comprehension, in fact, offers many benefits over traditional lists. To begin with, the code spans over only a single line, making it even easier to declare and read. It is also less cumbersome to comprehend lists than using <code>for</code> loops to declare a new one. Finally, it is also a convenient, quicker, and intuitive way of generating a new, populated list.
Going back to the squares of the integers 1-20, we can obtain the same result using the list comprehension method. Here is what our code will look like now:
<pre><code class="hljs">list_b = [i**2 for i in range(1, 20)]
</code></pre>
Notice how the logic for generating the list items is all wrapped in brackets. We'll cover more about the syntax in the next section.
<h2 id="listcomprehensionssyntax">List Comprehensions Syntax</h2>
Before we move forward, it is imperative to explain the syntax of list comprehension. Here is the basic syntax of list comprehension that contains a condition:
<pre><code class="hljs">[expression for item in list if conditional]
</code></pre>
It may seem a bit backward with the <code>expression</code> being before the loop, but this is how it's done! The order is this way, presumably, because it would be difficult to put the <code>expression</code> after the <code>conditional</code> without some type of semicolon, which Python doesn't have.
As you might have already guessed, <code>expression</code> is actually the output we get when we execute the rest of the code in a list comprehension. The code itself is just a for loop iterating over a collection of data. In our example, we are using the <code>expression</code>, or the output, to generate the list of squares.
Note that the conditional is optional, so like in our example above we don't need to include it.
It is also worth mentioning that we have a list to be looped over, the item or items to be iterated, and of course a conditional statement in both the list comprehension and traditional for loops. So each method has the same general constructs, but the difference is how you format and organize them.
We are also going to look at another, more complex example to further understand the concept behind list comprehension.
<pre><code class="hljs">list_a = [1, 3, 6, 9, 12, 15]
list_b = []
for number in list_a:
 if number % 4 == 0:
 list_b.append(number)

print(list_b)
</code></pre>
We are actually looping over the <code>list_a</code> in the above example. Subsequently, we will append an item to <code>list_b</code> if its value is divisible by 4, which is checked using the modulus operator (<code>%</code>). In this example we'd see the following printed to the console:
<pre><code class="hljs">[12]
</code></pre>
This is because 12 is the only number in that array that is divisible by 4.
Once again, we can just use list comprehension to reduce the total lines of code we have to write to attain the same goal.
As mentioned above, the <code>for</code> loop in the above statement is iterating over the list called <code>list_a</code>. Then it executes the conditional statement that checks if the current value is divisible by 4. Finally, it executes the <code>.append()</code> method when it ascertains that the value is actually divisible by 4.
Now, if you want to write the above piece of code with list comprehension, it would look something like this:
<pre><code class="hljs">list_a = [1, 3, 6, 9, 12, 15]
list_b = [number for number in list_a if number % 4 == 0]

print(list_b)
</code></pre>
As you can see, we have reduced the <code>for</code> loop, which spanned over three lines, to only one line. That is actually the real beauty of list comprehension.
<h2 id="whentouselistcomprehensions">When to Use List Comprehensions</h2>
You can use list comprehension in many cases in which you need to generate a list from an iterable. However, the best time to use this method is when you need to add or extract items to a list consistently according to a set pattern. Python developers mostly use them to extract data from an often big collection of items.
Let us suppose you have a list of thousands of current and previous students with their names, their father's names, and addresses. The data of each of the students is further stored in a respective dictionary. But, what if you only want to print their names?
<pre><code class="hljs">students = [
 {
 &quot;name&quot; : &quot;Jacob Martin&quot;,
 &quot;father name&quot; : &quot;Ros Martin&quot;,
 &quot;Address&quot; : &quot;123 Hill Street&quot;,
 }, {
 &quot;name&quot; : &quot;Angela Stevens&quot;,
 &quot;father name&quot; : &quot;Robert Stevens&quot;,
 &quot;Address&quot; : &quot;3 Upper Street London&quot;,
 }, {
 &quot;name&quot; : &quot;Ricky Smart&quot;,
 &quot;father name&quot; : &quot;William Smart&quot;,
 &quot;Address&quot; : &quot;Unknown&quot;,
 }
]
</code></pre>
We do have the option to iterate over the list using the traditional <code>for</code> loop:
<pre><code class="hljs">names_list = []

for student in students:
 names_list.append(student[&#x27;name&#x27;])

print(names_list)
</code></pre>
Although in this example it's only two lines of code for the <code>for</code> loop, we don't even need to write this many lines. We can accomplish the same task by writing only one line of code through the list comprehension method:
<pre><code class="hljs">names_list = [student[&#x27;name&#x27;] for student in students]

print(names_list)
</code></pre>
<pre><code class="hljs">['Jacob Martin', 'Angela Stevens', 'Ricky Smart']
</code></pre>
<h2 id="conclusion">Conclusion</h2>
It is really amazing how list comprehensions actually reduces your workload as well. However, it may seem confusing in the beginning. It is particularly baffling for beginners who have never ventured into this territory before, mostly due to the syntax. You may also find it hard to grasp the concept if you have been programming in other languages because list comprehension does not exist in any of them. The only way to get your head around list comprehension is to practice hard.

List Comprehensions is the process of creating a new list from an existing one. They offer many benefits to traditional lists. In this article, we'll dive into the theory and practice of using list comprehensions.

List Comprehensions in Python

Usman Malik

Tensorflow 2.0 introduced some hefty new features. Amongst them, it now uses the Keras API by default for classification and regression. In this article, we'll take on these classic ML tasks using Tensorflow 2.0.

Tensorflow 2.0: Solving Classification and Regression Problems

Josh Simpson

AWS SNS is a scalable service that allows us to implement the publish/subscribe model with ease. In this tutorial, we'll build a Node.js application, subscribe to an SNS topic and push messages to the subscibers.

Publishing and Subscribing to AWS SNS Messages with Node.js

<h2 id="introduction">Introduction</h2>
Stochastic Optimization refers to a category of optimization algorithms that generate and utilize random points of data to find an approximate solution.
While brute-force algorithms do provide us with the best solution, they're terribly inefficient. This isn't an issue with smaller datasets, but most real-life problems and search-spaces require such a huge computational capability to be solved in a reasonable time-frame that such computers will likely exist beyond a predictable future.
In such cases, a new approach has to be used, and instead of searching for the actual best solution, we settle for an approximate solution that'll work good enough for us.
Many optimization methods exist, and each method can be implemented through many different algorithms. We'll start out by implementing the least efficient and most intuitive Stochastic Search algorithm - Random Search.
In pursuit of efficiency over absolute correctness, many random algorithms have been developed, culminating with evolutionary algorithms such as <a target="_blank" href="/introduction-to-genetic-algorithms-in-java/">Genetic Algorithms</a>.
<h2 id="randomsearch">Random Search</h2>
Random Search is the simplest stochastic search algorithm and it's very intuitive. For example, say we're searching for the maximum of a function. Instead of brute-forcing the solution, it generates random points on a dimension of the search space.
Then, it proceeds to check each of those points by comparing the current fmax against the value of the point it's on, assigning it a new value if necessary. After going through all the generated points, it returns us the fmax as the approximate solution.
The downside with all stochastic search algorithms, and especially Random Search, is that they can be as inefficient as brute-force algorithms if you don't balance it.
<blockquote>
The more random points you use, the closer the approximation will be to the absolute best solution, but the slower the algorithm will be. With an infinite amount of random points, it's just a regular brute-force algorithm.
</blockquote>
Here's a function generated by <a rel="nofollow" target="_blank" href="http://fooplot.com/">FooPlot</a> as an example of how Random Search searches for the maximum/minimum of a function:
<img src="https://stackabuse.s3.amazonaws.com/media/stochastic-optimization-random-search-in-java-1.PNG" alt="function">
There are 7 randomly generated points here, where coincidentally the point 7 is located at the x value that will return the lowest y value and 5 is close to the value that will return the highest y value, for an example.
We'll limit the domain of the function to range from <code>-1</code> to <code>2</code> and in that range, using simple high school calculus, it's easy to deduce that:
$$ 
f_{max} = (0.73947, 0.23098) \wedge f_{min} = (1.71548, -2.79090) 
$$
That being said, depending on the specific accuracy you're looking for (95% for example), if Random Search approximates anything between <code>(0.7, 0.2)</code> and <code>(0.75, 0.25)</code> for the fmax and <code>(1.65, -2.65)</code> and <code>(1.8, -2.9)</code> for the fmin should be an approximately good solution.
<h3 id="implementation">Implementation</h3>
Let's go ahead and implement Random Search in Java. First, let's bound the domain of our function to <code>{-1...2}</code>:
<pre><code class="hljs">private static final double START_DOMAIN = -1;
private static final double END_DOMAIN = 2;
</code></pre>
Then, let's replicate the function from FooPlot, which of course, returns <code>y</code> based on <code>x</code>:
<pre><code class="hljs">private double function(double x) {
 return ((Math.pow(x, 2)-1)*((x-2)*Math.pow(x, 3)));
}
</code></pre>
Finally, let's implement the algorithm itself:
<pre><code class="hljs">public void randomSearch() {
 double startPosition = START_DOMAIN;
 double maxY = function(startPosition);
 double maxX = START_DOMAIN;

 for (int i = 0; i &lt; 10; i++) {
 double random = ThreadLocalRandom.current().nextDouble(START_DOMAIN, END_DOMAIN);

 if (function(random) &gt; maxY) {
 maxY = function(random);
 maxX = random;
 }
 }

 System.out.println(&quot;The maximum of the function f(x) is (&quot; + maxX + &quot;, &quot; + maxY + &quot;)&quot;);
}
</code></pre>
The starting position for the iteration is obviously at the start of the domain. The <code>maxY</code> is calculated using the <code>function()</code> method we've defined and the <code>maxX</code> is set as the value at the start of the domain as well.
These are the current max values as we haven't evaluated anything else yet. As soon as we assign them the default values, through a <code>for</code> loop, we generate a random point between the start and the end of the domain. We then evaluate if the random point, passed through the <code>function()</code>, is by any change larger than the current <code>maxY</code>.
Note: We're using a <code>ThreadLocalRandom</code> instead of a regular <code>Random</code> since <code>ThreadLocalRandom</code> can work way faster than <code>Random</code> in a multi-threaded environment. In our case, it doesn't make much of a difference, but it can make a significant one. Also, it's easier to define a range of <code>double</code>s using <code>ThreadLocalRandom</code>.
If it is, the <code>maxY</code> is set to the <code>function(random)</code> as it returns the <code>y</code> value and the <code>maxX</code> is set to the <code>random</code> as that's the one that produced the largest <code>y</code> value through the <code>function()</code> method.
After the <code>for</code> loop terminates, we're left with <code>maxX</code> and <code>maxY</code> with certain values, which are essentially an approximation of what the actual maximum x and y are.
Running this piece of code will yield:
<pre><code class="hljs">The maximum of the function f(x) is (0.7461978805972576, 0.2308765022939988)
</code></pre>
And comparing this to the actual results, it's pretty accurate, with a measly 10 random points. If we increase the number of random points from 10 to 100, we get the following result:
<pre><code class="hljs">The maximum of the function f(x) is (0.735592753214972, 0.2309513390409203)
</code></pre>
There's not a lot of improvement between the two, which just goes to show that 100 iterations is completely unneeded. If we take the liberty of reducing it from 10 to 5, we'll see that's it's off:
<pre><code class="hljs">The maximum of the function f(x) is (0.6756978982704229, 0.22201906058201992)
</code></pre>
Again, depending on your accuracy needs, this might just be an acceptable solution.
Changing the algorithm to search for a minimum instead of the maximum is as easy as changing the <code>&gt;</code> operator to a <code>&lt;</code> operator in the <code>if</code> clause.
<h2 id="conclusion">Conclusion</h2>
Sometimes, an approximation of the solution is good enough for your needs and you don't need to force your machine to find the best possible solution.
This approach is extremely useful when you're dealing with problems of huge computational complexity and can improve the performance of your program by orders of magnitude.
Of course, if you don't balance the algorithm right, you'll end up with an inefficient solution, so play around with the number of random points in order to get an efficient one.!

David Landup

Stochastic Optimization refers to a category of optimization algorithms that generate and utilize random points of data for approximating a solution. In this article, we'll be exploring the simplest one - Random Search, in Java.

Stochastic Optimization: Random Search in Java

Aleksandar Bursac

Amongst many tools, Postman stands out as one of the more beginner-friendly tools. It makes automated testing easy and quick for those who are just starting out and offers a hassle-free experience, encouraging you to properly test your applications.