Marcus Sanatan

Sathiya Sarathi Gunasekaran

This article will give you a crash course on web scraping in Python with Beautiful Soup - a popular Python library for parsing HTML and XML.

Parsing HTML with BeautifulSoup in Python

Guide to Parsing HTML with BeautifulSoup in Python

<h2 id="introduction">Introduction</h2>
The main purpose of writing code is so that a computer can interpret it as commands. However, it's also important that the code we write is also easily interpretable by fellow developers.
Have you ever gone back to a project and had difficulty understanding the internal logic? Well that's probably because said project hasn't been commented properly.
Comments are notes written in the code that are ignored by the JavaScript engine, which means they don't affect the output in any way. Their sole purpose is describing how and why code works to other developers, and yourself.
In this article, we will look at how to comment JavaScript code, as which types of comments exist, and some best practices.
<h2 id="singlelinecomments">Single-Line Comments</h2>
Single-line comments are generally used to comment a part of the line or full line of code. Single-line comments in JavaScript start with <code>//</code>. The interpreter will ignore everything to the right of this control sequence until the end of the line.
Let's see an example of a single-line comment in action:
<pre><code class="hljs">// Print &quot;Hello World&quot; in the console
console.log(&quot;Hello World&quot;);
</code></pre>
Here, we are using a single-line comment to describe what the next line of code is doing. 
If a single-line comment appears at the end of a line of code, it's called an inline comment.
These are generally used to add quick annotations:
<pre><code class="hljs">let c = a + b; // Assign sum of a, b to c
</code></pre>
<h2 id="multilinecommentsandjavascriptdocstrings">Multi-Line Comments and JavaScript DocStrings</h2>
If we'd like to add a note that is spread across multiple lines, we can opt for multi-line comments or block-level comments.
Multi-line comments start with <code>/*</code> and end with <code>*/</code>:
<pre><code class="hljs">/* The following program contains source code for a game called Tic-tac-toe.
It is a paper-and-pencil game for two players, X and O, who take turns marking the spaces in a 3×3 grid. 
The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row is the winner
*/
</code></pre>
Here, a multi-line comment is used to describe tic-tac-toe. Generally, multi-line comments are used to introduce and explain a section of code, where a single line/sentence isn't enough.
Another type of multi-line comment can oftentimes be seen as well:
<pre><code class="hljs">/**
* The following program contains source code for a game called Tic-tac-toe.
* It is a paper-and-pencil game for two players, X and O, who take turns marking the
* spaces in a 3×3 grid. 
* The player who succeeds in placing three of their marks in a horizontal, vertical, or 
* diagonal row is the winner
*/
</code></pre>
Oftentimes, these comments can include information about the proceeding code, such as the parameters of a function or even the author of the code:
<pre><code class="hljs">/**
* Function that greets a user
* @author John
* @param {String} name Name of the user
* @return {String} Greeting message
*/
function greetUser(name) {
 return `Greetings, ${name}!`;
}
</code></pre>
These comments are referred to as DocStrings, as they're essentially strings (comments) that constitute the documentation of your code.
These types of comments are really useful for other developers in your team, as you can clarify what the expected input is, what the output is, as well as who to contact if need be.
An added benefit is that you can generate documentation based on these DocStrings.
<h2 id="usingcommentsfordebugging">Using Comments for Debugging</h2>
Besides making notes, comments can also be used to quickly prevent code execution for debugging purposes. This is possible because JavaScript Engines do not interpret commented code. This is called as commenting out code.
If there's an erroneous line, that's causing problems, we can simply &quot;comment it out&quot; to disable it, without deleting the line. This can be paired with actual debuggers to help you assess what's going on.
Consider the following code:
<pre><code class="hljs">console.log(&quot;Working code&quot;);
console.log(&quot;Erroneous code);
</code></pre>
If we'd like to remove the second statement, but don't wish to delete it forever, we can simply comment it out:
<pre><code class="hljs">console.log(&quot;Working code&quot;);
//console.log(&quot;Erroneous code);
</code></pre>
Pro Tip: In most of the code editors, we can use the keyboard shortcut <code>Ctrl + /</code> for Windows and <code>Cmd + /</code> for Mac to comment out a single line of code.
Additionally, you can also comment out entire sections if you're unsure whether you'll delete them or not:
<pre><code class="hljs">/*console.log(&quot;Entering for loop&quot;);
for (let i = 0; i &lt; 100; i++) {
 console.log(i);
}*/
</code></pre>
<h2 id="goodcommentingpractices">Good Commenting Practices</h2>
First of all, commenting is not an excuse to write unreadable code, and then just patch it up with five paragraphs of comments explaining it. We first have to focus on writing clean, self-explanatory code, which can later be improved with constructive comments.
Use comments to explain why you did something, not how you did it. If you find yourself explaining how you did something, then it's time to take a step back and refactor your code into something self-explanatory.
Another piece of advice would be to not write comments which are obvious and are redundant by nature. For example, the following comment is completely unnecessary:
<pre><code class="hljs">// Prints out the result
console.log(result)
</code></pre>
There are useful tools, such as <a rel="nofollow noopener" target="_blank" href="https://github.com/jsdoc/jsdoc">JSDOC 3</a> that can generate documentation, based just on the comments within your code, which are formatted as DocStrings outlined above.
<h2 id="conclusion">Conclusion</h2>
In this article, we have gone over what comments are and how to create them in JavaScript. We have looked at different types of comments - single-line and multi-line comments, as well as mentioned JavaScript Docstrings.
We've also seen how to debug our code using a technique called &quot;commenting out&quot;, and finally summed up some good commenting practices.

Abhilash Kakumanu

In this tutorial, we'll go over how to comment code in JavaScript. We'll go over the types of comments, including DocStrings, and some best practices for writing comments in JavaScript.

Commenting Code in JavaScript - Types and Best Practices

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to declare and initialize arrays in Java.
We declare an array in Java as we do other variables, by providing a type and name:
<pre><code class="hljs">int[] myArray;
</code></pre>
To initialize or instantiate an array as we declare it, meaning we assign values as when we create the array, we can use the following shorthand syntax:
<pre><code class="hljs">int[] myArray = {13, 14, 15};
</code></pre>
Or, you could generate a stream of values and assign it back to the array:
<pre><code class="hljs">int[] intArray = IntStream.range(1, 11).toArray();
int[] intArray = IntStream.rangeClosed(1, 10).toArray();
int[] intArray = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).toArray();
</code></pre>
To understand how this works, read more to learn the ins and outs of array declaration and instantiation!
<ul>
<li><a href="#arraydeclarationinjava">Array Declaration in Java</a></li>
<li><a href="#arrayinitializationinjava">Array Initialization in Java</a></li>
<li><a href="#intstreamrange">IntStream.range()</a></li>
<li><a href="#intstreamrangeclosed">IntStream.rangeClosed()</a></li>
<li><a href="#intstreamof">IntStream.of()</a></li>
<li><a href="#javaarrayloopinitialization">Java Array Loop Initialization</a></li>
</ul>
<h2 id="arraydeclarationinjava">Array Declaration in Java</h2>
The declaration of an array object in Java follows the same logic as declaring a Java variable. We identify the data type of the array elements, and the name of the variable, while adding rectangular brackets <code>[]</code> to denote its an array.
Here are two valid ways to declare an array:
<pre><code class="hljs">int intArray[];
int[] intArray;
</code></pre>
The second option is oftentimes preferred, as it more clearly denotes of which type <code>intArray</code> is.
Note that we've only created an array reference. No memory has been allocated to the array as the size is unknown, and we can't do much with it.
<h2 id="arrayinitializationinjava">Array Initialization in Java</h2>
To use the array, we can initialize it with the <code>new</code> keyword, followed by the data type of our array, and rectangular brackets containing its size:
<pre><code class="hljs">int[] intArray = new int[10];
</code></pre>
This allocates the memory for an array of size <code>10</code>. This size is immutable.
Java populates our array with default values depending on the element type - <code>0</code> for integers, <code>false</code> for booleans, <code>null</code> for objects, etc. Let's see more of how we can instantiate an array with values we want.
The slow way to initialize your array with non-default values is to assign values one by one:
<pre><code class="hljs">int[] intArray = new int[10];
intArray[0] = 22;
</code></pre>
In this case, you declared an integer array object containing 10 elements, so you can initialize each element using its index value.
The most common and convenient strategy is to declare and initialize the array simultaneously with curly brackets <code>{}</code> containing the elements of our array.
The following code initializes an integer array with three elements - 13, 14, and 15:
<pre><code class="hljs">int intArray[] = {13, 14, 15};
</code></pre>
Keep in mind that the size of your array object will be the number of elements you specify inside the curly brackets. Therefore, that array object is of size three.
This method work for objects as well. If we wanted to initialize an array of three Strings, we would do it like this:
<pre><code class="hljs">int[] stringArray = {&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;};
</code></pre>
Java allows us to initialize the array using the <code>new</code> keyword as well:
<pre><code class="hljs">int[] intArray = new int[]{13, 14, 15};
String[] stringArray = new String[]{&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;};
</code></pre>
It works the same way.
Note: If you're creating a method that returns an initialized array, you will have to use the <code>new</code> keyword with the curly braces. When returning an array in a method, curly braces alone won't work:
<pre><code class="hljs">public String[] getNames() {
 return new String[]{&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;}; // Works
}

public String[] getNames() {
 return {&quot;zelda&quot;, &quot;link&quot;, &quot;ganon&quot;}; // Doesn&#x27;t work
}
</code></pre>
<h2 id="intstreamrange">IntStream.range()</h2>
If you're declaring and initializing an array of integers, you may opt to use the <code>IntStream</code> Java interface:
<pre><code class="hljs">int[] intArray = IntStream.range(1, 11).toArray();
</code></pre>
The above code creates an array of ten integers, containing the numbers 1 to 10:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
The <code>IntStream</code> interface has a <code>range()</code> method that takes the beginning and the end of our sequence as parameters. Keep in mind that the second parameter is not included, while the first is.
We then use the method <code>toArray()</code> method to convert it to an array.
Note: <code>IntStream</code> is just one of few classes that can be used to create ranges. You can also use a <code>DoubleStream</code> or <code>LongStream</code> in any of these examples instead.
<h2 id="intstreamrangeclosed">IntStream.rangeClosed()</h2>
If you'd like to override that characteristic, and include the last element as well, you can use <code>IntStream.rangeClosed()</code> instead:
<pre><code class="hljs">int[] intArray = IntStream.rangeClosed(1, 10).toArray();
</code></pre>
This produces an array of ten integers, from 1 to 10:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h2 id="intstreamof">IntStream.of()</h2>
The <code>IntStream.of()</code> method functions very similarly to declaring an array with some set number of values, such as:
<pre><code class="hljs">int[] intArray = new int[]{6, 2, 4, 5, 7};
</code></pre>
Here, we specify the elements in the <code>of()</code> call:
<pre><code class="hljs">int[] intArray = IntStream.of(6, 2, 4, 5, 7).toArray();
</code></pre>
This produces an array with the order of elements preserved:
<pre><code class="hljs">[6, 2, 4, 5, 7]
</code></pre>
Or, you could even call the <code>sorted()</code> method on this, to sort the array as it's being initialized:
<pre><code class="hljs">int[] intArray = IntStream.of(6, 2, 4, 5, 7).sorted().toArray();
</code></pre>
Which results in an array with this order of elements:
<pre><code class="hljs">[2, 4, 5, 6, 7]
</code></pre>
<h2 id="javaarrayloopinitialization">Java Array Loop Initialization</h2>
One of the most powerful techniques that you can use to initialize your array involves using a <code>for</code> loop to initialize it with some values.
Let's use a loop to initialize an integer array with values 0 to 9:
<pre><code class="hljs">int[] intAray = new int[10];	

for (int i = 0; i &lt; intArray.length; i++) {
 int_array[i] = i;
}
</code></pre>
This is identical to any of the following, shorter options:
<pre><code class="hljs">int[] intArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] intArray = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] intArray = IntStream.rangeClosed(0, 9).toArray();
</code></pre>
A loop is more ideal than the other methods when you have more complex logic to determine the value of the array element.
For example, with a <code>for</code> loop we can do things like making elements at even indices twice as large:
<pre><code class="hljs">int[] intArray = new int[10];	

for (int i = 0; i &lt; intArray.length; i++) {
 if (i % 2 == 0) {
 int_array[i] = i * 2;
 } else {
 int_array[i] = i;
 }
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we discovered the different ways and methods you can follow to declare and initialize an array in Java. We've used curly braces <code>{}</code>, the <code>new</code> keyword and <code>for</code> loops to initialize arrays in Java, so that you have many options for different situations!
We've also covered a few ways to use the <code>IntStream</code> class to populate arrays with ranges of elements.

Mohamed Echout

In this article, we'll go over how to declare and initialize an array in Java, with examples and best practices. We'll cover traditional array declaration and initialization, as well as IntStreams.

How to Declare and Initialize an Array in Java

<h2 id="introduction">Introduction</h2>
List concatenation the act of creating a single list from multiple smaller lists by daisy chaining them together.
There are many ways of concatenating lists in Python. Specifically, in this article, we'll be going over how to concatenate two lists in Python using the plus operator, unpack operator, multiply operator, manual for loop concatenation, the <code>itertools.chain()</code> function and the inbuilt list method <code>extend()</code>.
In all the code snippets below, we'll make use of the following lists:
<pre><code class="hljs">list_a = [1, 2, 3, 4]
list_b = [5, 6, 7, 8]
</code></pre>
<h2 id="plusoperatorlistconcatenation">Plus Operator List Concatenation</h2>
The simplest and most straightforward way to concatenate two lists in Python is the plus (<code>+</code>) operator:
<pre><code class="hljs">list_c = list_a + list_b
print (list_c)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="unpackoperatorlistconcatenation">Unpack Operator List Concatenation</h2>
This method allows you to join multiple lists. It is a fairly new feature and only available from Python 3.6+. The unpacking operator, as the name implies, unpacks an <code>iterable</code> object into its elements. Unpacking is useful when we want to generate a plethora of arguments from a single list. For example:
<pre><code class="hljs">def foo(a, b, c, d):
 return a + b + c + d

# We want to use the arguments of the following list with the foo function.
# However, foo doesn&#x27;t take a list, it takes 4 numbers, which is why we need to
# unpack the list.
foo(*list_a)
# This is the same as if we were to call foo(1,2,3,4)
</code></pre>
<pre><code class="hljs">10
</code></pre>
In a nutshell, we use the list constructor (<code>[a,b..]</code>) and generate the elements of the new list in order by unpacking multiple lists one after another:
<pre><code class="hljs">list_c = [*list_a, *list_b, *list_a]
# This is the same as:
# list_c = [1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4]
print (list_c)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4]
</code></pre>
<h2 id="multiplyoperatorlistconcatenation">Multiply Operator List Concatenation</h2>
The multiply (<code>*</code>) operator is special case of list concatenation in Python. It is used to repeat a whole list multiple times (which is why it's denoted with a multiplication operator):
<pre><code class="hljs">print(list_a * 2)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 1, 2, 3, 4]
</code></pre>
<h2 id="forlooplistconcatenation">for loop List Concatenation</h2>
In this method we will go through one list while appending each of its elements to another list one by one. When the loop is over you will have a single list with all the desired elements:
<pre><code class="hljs">for i in list_b:
 list_a.append(i)
print (list_a)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="itertoolschainlistconcatenation">itertools.chain() List Concatenation</h2>
This method works with <code>iterables</code>. It constructs and returns an iterator that can later be used to construct the chained list (think of it as an arrow which just memorizes the order of elements in the resulting list):
<pre><code class="hljs"># If we were to call itertools.chain() like so
iterator = itertools.chain([1, 2], [3, 4])

# Basically the iterator is an arrow which can give us the next() element in a sequence, so if we call a list() constructor with said iterable, it works like this:
list(iterator)
</code></pre>
Under the hood, something along these lines is what happens:
<pre><code class="hljs"># Iterator: The next element in this list is 1 
[1, 2], [3, 4]
 ^
# Iterator: The next element in this list is 2
[1, 2], [3, 4]
 ^
# Iterator: The next element in this list is 3 
[1, 2], [3, 4]
 ^
# Iterator: The next element in this list is 4 
[1, 2], [3, 4]
 ^
# So the list() call looks something like:
list([1,2,3,4])

# Keep in mind this is all pseudocode, Python doesn&#x27;t give the developer direct control over the iterator
</code></pre>
For this method, you will need to import <code>itertools</code>:
<pre><code class="hljs">import itertools

list_c = list(itertools.chain(list_a, list_b))
print (list_c)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="extendlistconcatenation">extend() List Concatenation</h2>
This is aa built-it function that can be used to expand a list. Here we are expanding the first list by adding elements of the second list to it:
<pre><code class="hljs">list_a.extend(list_b)

print (list_a)
</code></pre>
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over five ways to concatenate two lists in Python - using the plus operator, the unpack operator, the multiply operator, a for loop, <code>itertools.chain()</code> and <code>extend()</code>.

Guest Contributor

In this tutorial, we'll go over multiple ways on how to concatenate multiple lists in Python. We'll go over the plus operator, multiply operator, for loop, itertools.chain() and extend().

How to Concatenate Two Lists in Python

<h2 id="introduction">Introduction</h2>
There are a number of different data visualization libraries for Python. Out of all of the libraries, however, Matplotlib is easily the most popular and widely used one. With Matplotlib you can create both simple and complex visualizations.
Jupyter notebooks are one of the most popular methods of sharing data science and data analysis projects, code, and visualization. Although you may know how to visualize data with Matplotlib, you may not know how to use Matplotlib in a Jupyter notebook.
In this article, we'll be covering how to use an IPython notebook to plot Matplotlib plots inline.
It will also cover the purpose of the Matplotlib “inline” and &quot;notebook&quot; magic methods, which are used to set Matplotlib backends.
<h2 id="settingupipython">Setting Up IPython</h2>
Jupyter notebooks are Interactive, and if they let you share your work with other programmers and analysts in a reproducible format. Yet before you can work with a Jupyter notebook <a rel="nofollow noopener" target="_blank" href="https://Jupyter.org/install">you need to install it</a>.
The simplest and easiest way to install a Jupyter notebook is with the use of a package manager. If you are using Conda you can install the Jupyter file system with the following command:
<pre><code class="hljs">$ conda install -c conda-forge notebook
</code></pre>
If you are using pip, you can install Jupyter with this command instead:
<pre><code class="hljs">$ pip install notebook
</code></pre>
After the Jupyter lab has been installed, you can launch an instance of a Jupyter notebook by opening up the command line and using the following intuitively named command prompt:
<pre><code class="hljs">Jupyter Notebook
</code></pre>
You can then access your Jupyter notebook by pointing your browser to the following URL:
<pre><code class="hljs">http://localhost:8888/tree?
</code></pre>
<h2 id="importingdataandvisualizingdata">Importing Data and Visualizing Data</h2>
We'll be making use of the famous <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/jsphyg/tipping">Tips dataset</a>.
We'll import Pandas for reading the <code>.csv</code> file, as well as <code>matplotlib.pyplot</code> for visualization. After that, we can construct a <a target="_blank" href="/matplotlib-scatterplot-tutorial-and-examples/">simple scatter plot</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-1.png" alt="jupyter notebook matplotlib visualization">
This is how you'd usually visualize data in a Jupyter notebook. However, if you shared this notebook with someone in its current form - they'd have to run the code themselves to see the visualizations.
If you would like the visualizations themselves to be included in the notebook body, you make use of the <code>inline</code> command, which refers to a Matplotlib backend.
<h2 id="matplotlibbackends">Matplotlib Backends</h2>
Usually, displaying plots involves using the <code>show()</code> function from PyPlot. With Jupyter notebooks, this isn't necessary as the plots are displayed after running the cells containing the code that generates them. These plots are by default, displayed inline, which means, they're displayed in the notebook itself.
However, you can also display the plot outside of the notebook, which can be done by changing the Matplotlib backend. Jupyter automatically sets a Matplotlib backend, though, this can be overridden using magic functions, which are called with the <code>%</code> character.
<h3 id="matplotlibplotonexternalwindowusingipythonjupyter">Matplotlib Plot On External Window using IPython/Jupyter</h3>
Let's start off with trying to plot on an external window from the notebook:
<pre><code class="hljs">%matplotlib qt
</code></pre>
Here, we've told the Jupyter notebook to use Qt to generate the frame on our local machine instead. This function call is situated before the Matplotlib import:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-2.png" alt="jupyter notebook qt plot externally matplotlib">
<h3 id="matplotlibplotinlineusingipythonjupyterinline">Matplotlib Plot Inline using IPython/Jupyter (inline)</h3>
Certain versions of Jupyter may not correctly set the backend for Matplotlib and fail to render graphs inline. In that case, the inline plotting can be forced in one of two ways.
You can set the <code>inline</code> function, instead of <code>qt</code> to force Jupyter to display the plots inline:
<pre><code class="hljs">%matplotlib inline
</code></pre>
This helps make sure that anyone who opens the notebook can see the visualizations, without needing to rerun the code cells:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-3.png" alt="jupyter notebook plot inline matplotlib">
<h3 id="matplotlibplotinlineusingipythonjupyternotebook">Matplotlib Plot Inline using IPython/Jupyter (notebook)</h3>
The second method of rendering a Matplotlib plot within a notebook is to use the <code>notebook</code> backend:
<pre><code class="hljs">%matplotlib notebook
</code></pre>
Using <code>%matplotlib notebook</code> creates interactive plots that are embedded within the notebook itself, allowing those viewing the notebook to do things like resize the figure or zoom in on the figure:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-plot-inline-and-with-qt-matplotlib-with-ipython-and-jupyter-notebooks-4.png" alt="jupyter notebook plot inline matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to plot externally (using Qt) and inline (using <code>inline</code> and <code>notebook</code> magic functions) in IPython/Jupyter notebooks.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

Dan Nelson

In this tutorial, we'll go over how to plot inline plots using IPyhon/Jupyter notebooks, with Matplotlib in Python.
We'll cover how to plot externally using Qt, as well as inline.

How to Plot Inline and With Qt - Matplotlib with IPython/Jupyter Notebooks

<h2 id="introduction">Introduction</h2>
Almost every website involves collecting user input through html forms. Whenever we collect user data, we have to validate it. In Computer Science, data validation is the process of checking whether the data entered is sensible and reasonable.
Consider developing a form for email subscriptions. In this case, we want to check whether the submitted email follows a generic email format like <code>username@randomMail.com</code>. Without validation, malicious users can enter useless values or even perform SQL injections.
In this article, we'll be performing form data validation using <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/validator">Validator.js</a> - a lightweight NPM package built exactly for this purpose.
<h2 id="installingvalidatorjs">Installing Validator.js</h2>
Let's create a directory for our project, named <code>string-validator</code>, move into it, create an <code>index.js</code> entry point and initialize a Node project with the default settings using <code>npm</code>:
<pre><code class="hljs">$ mkdir string-validator
$ cd string-validator
$ npm init -y
</code></pre>
Then, let's:
<pre><code class="hljs">$ touch index.js
</code></pre>
After initializing the project, we can install the <code>Validator.js</code> package using:
<pre><code class="hljs">$ npm install validator
</code></pre>
<h2 id="formdatavalidationusingvalidatorjs">Form Data Validation Using Validator.js</h2>
Consider an application for selling books where user input is first gathered using an HTML form. This data is then sent, in JSON format, to a server for further processing. Let's see how string validation can be done for this.
Let's say that this is the data that is being sent from the front-end. Let's save this data in the <code>index.js</code> file. Also, let's require <code>Validator.js</code> in our file:
<pre><code class="hljs">const validator = require(&quot;validator&quot;)

const data = {
 &quot;gender&quot;: &quot;male&quot;,
 &quot;name&quot;: {
 &quot;title&quot;: &quot;mr&quot;,
 &quot;first&quot;: &quot;brad&quot;,
 &quot;last&quot;: &quot;gibson&quot;
 },
 &quot;countryCode&quot;: &quot;IE&quot;,
 &quot;postalCode&quot;: &quot;93027&quot;,
 &quot;email&quot;: &quot;brad.gibson@example.com&quot;,
 &quot;cell&quot;: &quot;081-454-0666&quot;,
 &quot;dob&quot;: &quot;1993-07-20T09:44:18.674Z&quot;,
 &quot;creditCardNumber&quot;: &quot;4539415755005206&quot;,
 &quot;book&quot;: {
 &quot;title&quot;: &quot;Harry Potter and the Deathly Hallows&quot;,
 &quot;author&quot;: &quot;Rowling, J. K.&quot;,
 &quot;isbn&quot;: &quot;9780545010221&quot;,
 &quot;isbnVersion&quot;: &quot;13&quot;
 }
}
</code></pre>
Validator.js has a lot of pre-set functions to check for validity of different inputs, such as credit cards, mobile phones, emails, postal codes, etc.
First of all, let's check whether the user is giving us valid credit card details. This can be done using:
<pre><code class="hljs">console.log(validator.isCreditCard(data.creditCardNumber)); // true
</code></pre>
In order to deliver the book, the postal code has to be valid. So, let's check that using:
<pre><code class="hljs">console.log(validator.isPostalCode(data.postalCode, data.countryCode)) // false
</code></pre>
Phone number validation can be done using:
<pre><code class="hljs">console.log(validator.isMobilePhone(data.cell, `en-${data.countryCode}`)); // false
</code></pre>
Email validation can be done using:
<pre><code class="hljs">console.log(validator.isEmail(data.email)) // true
</code></pre>
Also, we can do ISBN validation by using:
<pre><code class="hljs">console.log(validator.isISBN(data.book.isbn, data.book.isbnVersion)) // true
</code></pre>
Then, we can prompt the user to re-enter any invalid information to make sure we have clean, workable data.
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over the Validator.js NPM package - which is a lightweight package used for data and string validation.

In this tutorial, we'll go over how to perform form data validation in Node.js, using Validator.js. We'll be validating emails, strings, credit cards, postal codes and phone numbers.

Form Data Validation in Node.js with Validator.js

Form Data Validation in Node.js With Validator.js

<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://www.heroku.com/">Heroku</a> is a cloud platform that provides hosting services. It supports several programming languages including PHP, Node.js, and Python. It is Platform-as-a-Service (PaaS) which allows you to manage website applications while it takes care of your servers, networks, storage and other cloud components.
In this article, we'll take a look at how to deploy a Django application to Heroku, using Git.
You can follow the same steps, and deploy the application <a target="_blank" href="/deploying-django-apps-to-heroku-from-github/">from GitHub</a>, if it's hosted there.
<h2 id="prerequisites">Prerequisites</h2>
Below is a list of things that need to be done before we getting started with the deployment:
<ul>
<li>Git</li>
<li>Heroku Account and CLI</li>
<li>Django Application</li>
</ul>
The Heroku Command Line Interface (CLI) makes it easy to create and manage your Heroku applications directly from the terminal. It’s an essential part of using Heroku.
To install the Heroku CLI (aka Heroku Toolbelt), please follow the instructions on the <a rel="nofollow noopener" target="_blank" href="https://devcenter.heroku.com/articles/heroku-cli">official website</a>.
Make sure your Django application is running on <a rel="nofollow noopener" target="_blank" href="https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/">virtual environment</a> which you need to keep active throughout the deployment process.
<h3 id="aherokuaccount">A Heroku Account</h3>
Once all these things have been installed, the next step is to create a free Heroku account <a rel="nofollow noopener" target="_blank" href="https://signup.heroku.com/">here</a>, if you don't have an account already.
After writing the following in a terminal:
<pre><code class="hljs">$ heroku login
</code></pre>
The terminal should display a message like:
<pre><code class="hljs">heroku: Press any key to open up the browser to login or q to exit:
</code></pre>
Press any key and log in using your browser. The terminal will then display a message along the lines of:
<pre><code class="hljs">Logged in as email@domain.com
</code></pre>
<h2 id="configuredjangoapplicationforheroku">Configure Django Application for Heroku</h2>
Now that we are done with the prerequisites, let's prepare our Django application for Heroku.
<h3 id="procfile">Procfile</h3>
A Procfile is a file named <code>Procfile</code> without any file extension placed in the root of your application. It lists the process types in an application and each process type is a declaration of a command that is executed when a container/dyno of that process type is started.
Before creating a <code>Procfile</code>, you'll want to install <code>django gunicorn</code> in your project directory:
<pre><code class="hljs">$ pip install django gunicorn
</code></pre>
While Django ships with its own WSGI server, our <code>Procfile</code> will tell Heroku to use <code>gunicorn</code> to serve our application, which is also recommended by Heroku.
Now, create a <code>Procfile</code> in the parent directory and add the following line:
<pre><code class="hljs">web: gunicorn yourdjangoweb.wsgi --log-file -
</code></pre>
Replace <code>yourdjangoweb</code> with the actual name of your project.
<h3 id="runtimetxt">Runtime.txt</h3>
Create a text file called <code>runtime.txt</code> in the same directory as the <code>Procfile</code>. It tells Heroku what version of Python your application is using. If you are not sure of the version, enter <code>python --version</code> in the terminal with your Django virtual environment activated.
Then add the version in <code>runtime.txt</code>:
<pre><code class="hljs">python-x.x.x
</code></pre>
See the supported versions of Python on Heroku <a rel="nofollow noopener" target="_blank" href="https://devcenter.heroku.com/articles/python-support">here</a>.
<h3 id="allowedhosts">Allowed Hosts</h3>
This is an extra security measure in Django to prevent HTTP host header attacks by only allowing the site to be served at host/domains which are added in the <code>ALLOWED_HOSTS</code> list. If <code>Debug = True</code> and <code>ALLOWED_HOSTS</code> is <code>[]</code> then only <code>localhost</code> is allowed by default. To deploy and serve your web application on Heroku, add it to the list:
<pre><code class="hljs">ALLOWED_HOSTS = [&#x27;herokuappname.herokuapp.com&#x27;]
</code></pre>
Alternatively, you can allow all apps from Heroku by omitting the app name like this:
<pre><code class="hljs">ALLOWED_HOSTS = [&#x27;.herokuapp.com&#x27;]
</code></pre>
You can also use <code>['*']</code> to allow all hosts. You can find more details in <a rel="nofollow noopener" target="_blank" href="https://docs.djangoproject.com/en/3.1/ref/settings/#allowed-hosts">the documentation</a>.
<h3 id="installpackages">Install Packages</h3>
Below are the extra packages which need to be installed in our virtual environment.
To connect our Django database with Heroku, install <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/dj-database-url/"><code>dj-database-url</code></a> by calling:
<pre><code class="hljs">$ pip install dj-database-url
</code></pre>
As Heroku uses Postgres databases, we need its adapter for Python as well:
<pre><code class="hljs">$ pip install psycog2
</code></pre>
And finally, we will use <a rel="nofollow noopener" target="_blank" href="http://whitenoise.evans.io/en/stable/">WhiteNoise</a> to serve static files in the production server. Which we can install by calling:
<pre><code class="hljs">$ pip install whitenoise
</code></pre>
We have already configured <code>gunicorn</code>, let's add a configuration for <code>whitenoise</code> and <code>dj-database-url</code>.
<h3 id="configuringstaticfiles">Configuring Static Files</h3>
First add basic settings to serve static files in any Django project. You can copy-paste the following settings in your <code>settings.py</code>:
<pre><code class="hljs"># Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
PROJECT_ROOT = os.path.join(os.path.abspath(__file__))
STATIC_ROOT = os.path.join(PROJECT_ROOT, &#x27;staticfiles&#x27;)
STATIC_URL = &#x27;/static/&#x27;

# Extra lookup directories for collectstatic to find static files
STATICFILES_DIRS = (
 os.path.join(PROJECT_ROOT, &#x27;static&#x27;),
)
</code></pre>
<ul>
<li>
Add WhiteNoise to the <code>MIDDLEWARE</code> list immediately after <code>SecurityMiddleware</code> which should be on the top:
<pre><code class="hljs">MIDDLEWARE = [
 &#x27;django.middleware.security.SecurityMiddleware&#x27;,
 &#x27;whitenoise.middleware.WhiteNoiseMiddleware&#x27;,
 
 &#x27;django.contrib.sessions.middleware.SessionMiddleware&#x27;,
 &#x27;django.middleware.common.CommonMiddleware&#x27;,
 &#x27;django.middleware.csrf.CsrfViewMiddleware&#x27;,
 &#x27;django.contrib.auth.middleware.AuthenticationMiddleware&#x27;,
 &#x27;django.contrib.messages.middleware.MessageMiddleware&#x27;,
 ]
</code></pre>
</li>
<li>
Add <code>STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'</code> in your <code>settings.py</code>.0
</li>
</ul>
<h3 id="configuringthedatabase">Configuring the Database</h3>
We are using <code>dj-database-url</code> to configure our database. Add these lines at the bottom of your <code>settings.py</code>:
<pre><code class="hljs">import dj_database_url 
prod_db = dj_database_url.config(conn_max_age=500)
DATABASES[&#x27;default&#x27;].update(prod_db)
</code></pre>
<h3 id="requirementstxt">Requirements.txt</h3>
Heroku will recognize a deployed application as a Python application only if it has a <code>requirements.txt</code> file in the root directory. It tells Heroku what packages are required to run your application.
We can use <code>pip freeze</code> and pipe the output into a <code>requirements.txt</code> file for this:
<pre><code class="hljs">$ pip freeze &gt; requirements.txt
</code></pre>
Your <code>requirements.txt</code> should include these:
<pre><code class="hljs">whitenoise==5.2.0
dj-database-url==0.5.0
Django==3.0.9
gunicorn==20.0.4
psycopg2==2.8.5
pytz==2020.1
</code></pre>
Note: The above versions are used by our Django application and they can differ for yours.
<h2 id="connectherokuapplicationwithgit">Connect Heroku Application With Git</h2>
Now we need to create a Heroku application:
<pre><code class="hljs">$ heroku create herokuappname
</code></pre>
It will display a &quot;done&quot; message with two URLs along this lines:
<pre><code class="hljs">Creating ⬢ herokuappname... done
https://herokuappname.herokuapp.com/ | https://git.heroku.com/herokuappname.git
</code></pre>
This means a Git repository has been created on Heroku cloud for your application. The URL <code>https://herokuappname.herokuapp.com/</code> will be used to access your application anywhere but we still need to do one more step before running our application i.e. we need to push our code to the repository.
Initialize an empty repository in your project directory:
<pre><code class="hljs">$ git init
&gt; Initialized empty Git repository in /herokuappname/.git/
</code></pre>
Connect your Heroku app with the empty <code>git</code> repository:
<pre><code class="hljs">$ heroku git:remote -a herokuappname
&gt; set git remote heroku to https://git.heroku.com/herokuappname.git
</code></pre>
Add files to the staging area:
<pre><code class="hljs">$ git add .
</code></pre>
Commit the changes/files:
<pre><code class="hljs">$ git commit -m &quot;first commit for all files&quot;
</code></pre>
Finally, push the project to <code>git</code> repo hosted on Heroku:
<pre><code class="hljs">$ git push master heroku
</code></pre>
If everything goes fine, you will see an output like this:
<pre><code class="hljs">Counting objects: 26, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (20/20), done.
Writing objects: 100% (26/26), 32.13 KiB | 0 bytes/s, done.
Total 26 (delta 1), reused 0 (delta 0)
remote: Compressing source files... done.
remote: Building source:
.....
.....
remote: -----&gt; Launching...
remote: Released v1
remote: https://herokuappname.herokuapp.com/ deployed to Heroku
remote: 
remote: Verifying deploy... done.
To https://git.heroku.com/herokuappname.git
[new branch] master -&gt; master
</code></pre>
<h3 id="collectstaticerror">collectstatic Error</h3>
You might get an error related to <code>collectstatic</code> when you run the <code>git push heroku master</code> command. This is related the to static files directory and you can bypass it with the following command:
<pre><code class="hljs">$ heroku config:set DISABLE_COLLECTSTATIC=1 
Setting DISABLE_COLLECTSTATIC and restarting ⬢ herokuappname... done, v2 
DISABLE_COLLECSTATIC: 1
</code></pre>
It will tell Heroku not to run <code>collectstatic</code> command during application deployment. You can run it later using <code>bower</code>:
<pre><code class="hljs">$ heroku run &#x27;bower install --config.interactive=false;grunt prep;python manage.py collectstatic --noinput&#x27;
</code></pre>
It can occur for many reasons including but not limited to:
<ul>
<li>Your <code>STATICFILES_DIRS</code> list is empty in <code>settings.py</code> or not configured properly.</li>
<li>Your <code>static</code> directory contains no files for <code>git</code> to track. You can add any temporary file into your <code>static</code> directory to make it work.</li>
</ul>
<h3 id="migratethedatabase">Migrate the Database</h3>
Final step is to reflect your <code>models</code> to Heroku database by running migrations:
<pre><code class="hljs">$ heroku run python manage.py migrate
</code></pre>
That's it, your application is up and running on heroku! You can access it at <code>[appname].herokuapp.com</code>. The URL in our case would be <code>http://herokuappname.herokuapp.com/</code>.
<h2 id="addingacustomdomainname">Adding a Custom Domain Name</h2>
Every app on Heroku is hosted on <code>.herokuapp.com</code> but you can change it to your domain name if you own one. The process is simple:
<ul>
<li>Login to <a rel="nofollow noopener" target="_blank" href="https://www.heroku.com/">Heroku Dashboard</a></li>
<li>Select your current app from the list:</li>
</ul>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-deploy-a-django-application-to-heroku-with-git-cli-1.png" alt="heroku application list">
<ul>
<li>Select Settings from navbar and scroll down to find the Domain section:</li>
</ul>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-deploy-a-django-application-to-heroku-with-git-cli-2.png" alt="heroku domain settings">
<ul>
<li>Click on Add domain where you will be able to add your domain name.</li>
</ul>
This option is for verified accounts only. You will be asked to enter credit card details on Heroku to verify your account. You can find more details about adding domains and sub-domains on <a rel="nofollow noopener" target="_blank" href="https://devcenter.heroku.com/articles/custom-domains">this page</a>.
<h2 id="conclusion">Conclusion</h2>
In this article, we deployed a Django application on Heroku with a custom domain name, using Git.
Besides various cloud services, Heroku also offers one of the best server up times and 24/7 operation and security team support.

Muhammad Hashir Hassan

In this tutorial, we'll go over how to deploy a Python Django application to Heroku with the Git CLI. We'll also connect a database and add a custom domain.

How to Deploy a Django Application to Heroku with Git CLI

<h2 id="introduction">Introduction</h2>
We as software developers often stumble into situations where we need to insert a dose of randomness into our code.
In this article, we will look at how to generate random numbers in JavaScript. We will also touch upon a few built-in methods to deal with random numbers. By the end, we will put this knowledge to good use by writing a function to simulate a six-sided die.
<h2 id="generatingrandomnumbersinjavascript">Generating Random Numbers in JavaScript</h2>
<code>Math.random()</code> in JavaScript generates a floating-point (decimal) random number between <code>0</code> and <code>1</code> (inclusive of 0, but not 1). Let's check this out by calling:
<pre><code class="hljs">console.log(Math.random())
</code></pre>
This will output a floating-point number similar to:
<pre><code class="hljs">0.9261766792243478
</code></pre>
This is useful if you're dealing with percentages, as any value between <code>0</code> and <code>1</code>, rounded to two decimal places, can be thought of as a percentile.
<h2 id="generatingrandomwholenumbersinrange">Generating Random Whole Numbers in Range</h2>
We generally don't deal with floating-point numbers in the 0 to 1 range, though. So, let's look at a way to round floating-point numbers.
We can round down a floating-point number using <code>Math.floor()</code>. Similarly, we can round up a number via the <code>Math.ceil()</code> function:
<pre><code class="hljs">console.log(Math.floor(3.6))
console.log(Math.ceil(3.6))
</code></pre>
This will give us the output:
<pre><code class="hljs">3
4
</code></pre>
Let's generate a random number between <code>min</code> and <code>max</code>, not including <code>max</code>:
<pre><code class="hljs">function randomNumber(min, max){
 const r = Math.random()*(max-min) + min
 return Math.floor(r)
}
</code></pre>
Alternatively, we could've included <code>max</code> with the <code>Math.ceil()</code> function instead.
We are multiplying with <code>(max-min)</code> to transform the range [0,1) into [0, <code>max-min</code>). Next, to get a random number in the required range, we are adding <code>min</code>. Finally, we are rounding this to an integer using <code>Math.floor()</code>.
Let's call this method a few times and observe the results:
<pre><code class="hljs">for (var i = 0; i &lt; 10; i++) {
 console.log(randomNumber(0, 10))
}
</code></pre>
This will output something similar to:
<pre><code class="hljs">8
3
3
0
1
1
8
2
8
8
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Generating pseudo-random numbers in a program can be used to simulate unpredictability of an enemy in-game, or for randomization of forests in a block-like game we all know and love. It can also be used to simulate random inputs while testing another program you wrote.
Either way, generating a random number is an important tool in any engineer's toolkit, and should be expanded as much as possible with different generation methods and algorithms. This article was just the first step of learning random number generation.

In this tutorial, we'll go over how to generate a random number in range using JavaScript with examples.

JavaScript: Generate Random Number in Range

<h2 id="introduction">Introduction</h2>
A <a target="_blank" rel="nofollow noopener" href="https://en.wikipedia.org/wiki/Command-line_interface">Command-line interface (CLI)</a> is a way to interact with computers using textual commands.
A lot of tools that don't require GUIs are written as CLI tools/utilities. Although Python has the <a target="_blank" href="/creating-command-line-utilities-with-pythons-argparse/">built-in <code>argparse</code> module</a>, other libraries with similar functionality do exist.
These libraries can help us in writing CLI scripts, providing services like parsing options and flags to much more advanced CLI functionality.
This article discusses the <a target="_blank" rel="nofollow noopener" href="https://google.github.io/python-fire/">Python Fire</a> library, written by Google Inc., a useful tool to create CLI with minimal code.
<h2 id="generalformofcliapplications">General Form of CLI Applications</h2>
Before we start with the <code>Fire</code> library let's try to understand the basics of command-line interface programs in general. Depending on the program and command, the general pattern of a CLI can be summed up as follows:
<pre><code class="hljs">prompt command parameter1 parameter2 ... parameterN
</code></pre>
<ul>
<li>prompt is a sequence of characters that prompts the user to input a command</li>
<li>command is the name of the program that the user is executing (e.g. <code>ls</code>)</li>
<li>parameters are optional tokens that augment or modify the command output</li>
</ul>
A CLI program is executed by typing the name of the program after the <code>prompt</code> appears, in this case the $ symbol.
Here we are using the <code>ls</code> command that returns a list of file names in a directory, the current directory being the default:
<pre><code class="hljs">$ ls
README.md
python
</code></pre>
You can modify the behavior or output of a command-line program by providing it with a list of tokens or parameters better known as flags. Let's try out a flag of the <code>ls</code> command:
<pre><code class="hljs">$ ls -l
-rwxrwxrwx 1 pandeytapan pandeytapan 10 Sep 23 18:29 README.md
drwxrwxrwx 1 pandeytapan pandeytapan 512 Sep 23 18:29 python
</code></pre>
As you can see, after passing the <code>-l</code> flag, we get additional information for each entry like the owner, group, and file size.
Flags which have a single hyphen (<code>-</code>) are called short options, while those with two hyphens (<code>--</code>) are called long options. Both kinds can be used together in a single command, like in the following example:
<pre><code class="hljs">$ ls -l --time-style=full-iso
-rwxrwxrwx 1 pandeytapan pandeytapan 10 2020-09-23 18:29:25.501149000 +0530 README.md
drwxrwxrwx 1 pandeytapan pandeytapan 512 2020-09-23 18:29:25.506148600 +0530 python
</code></pre>
<blockquote>
The difference between short and long options:
<ol>
<li>Short options can be chained together
<ul>
<li>If we want to use both the <code>-l</code> and <code>-a</code> short options we just type <code>-al</code></li>
</ul>
</li>
<li>Short options are denoted by a single character while long options have a full hyphen-separated name and cannot be chained together.</li>
</ol>
</blockquote>
The <code>--time-style</code> flag works with the <code>-l</code> flag and controls the display time format for a directory listing.
A CLI provides an easy way for the user to configure and run an application from the command line. Google's Python Fire library makes it easy to add a CLI processing component to any existing Python script.
Let's see how to make a command line application using Python Fire.
<h2 id="installation">Installation</h2>
Let's go ahead and install the library using <code>pip</code>:
<pre><code class="hljs">$ pip install fire
</code></pre>
<code>Python Fire</code> works on any Python object i.e. functions, classes, dictionaries, lists etc. Let's try to understand the usage of the <code>Python Fire</code> library through some examples.
<h2 id="generatingcliapplicationwithpythonfire">Generating CLI Application with Python Fire</h2>
Let's make a script, say, <code>fire_cli.py</code> and put a function within it:
<pre><code class="hljs">def greet_mankind():
 &quot;&quot;&quot;Greets you with Hello World&quot;&quot;&quot;
 return &#x27;Hello World&#x27;
</code></pre>
On running this program on Python shell the output is:
<pre><code class="hljs">&gt;&gt;&gt; from fire_cli import greet_mankind
&gt;&gt;&gt; greet_mankind()
&#x27;Hello World&#x27;
&gt;&gt;&gt;
</code></pre>
We can easily turn this script into a CLI application using Python Fire:
<pre><code class="hljs">import fire

def greet_mankind():
 &quot;&quot;&quot;
 Returns a textual message
 &quot;&quot;&quot;
 return &#x27;Hello World&#x27;

if __name__ == &#x27;__main__&#x27;:
 fire.Fire()
</code></pre>
The <code>fire.Fire()</code> call turns the module i.e. <code>fire_cli.py</code> into a Fire CLI application. Moreover it has exposed the <code>greet_mankind()</code> function as a command, automatically.
Now we can save and run the above script as CLI as follows:
<pre><code class="hljs">$ python fire_greet_mk_cli.py greet_mankind
Hello World
</code></pre>
As a refresher, let's break down the call:
<ul>
<li>$ is the prompt</li>
<li>python is the command interpreter</li>
<li>fire_cli.py is the module that contains the CLI command</li>
<li>greet_mankind is the command</li>
</ul>
<h2 id="passingargumentstoacommand">Passing Arguments to a Command</h2>
Let us make another CLI application that takes a name as a parameter and displays a custom greeting message:
<pre><code class="hljs">import fire

def greetings(name):
 &#x27;&#x27;&#x27;
 Returns a greeting message
 Parameters
 ----------
 name : string
 String that represents the addresses name 

 Returns
 -------
 string
 greeting message concatenated with name
 &#x27;&#x27;&#x27;
 return &#x27;Hello %s&#x27; % name

if __name__ == &#x27;__main__&#x27;:
 fire.Fire()
</code></pre>
Here, we've now got a function that accepts a string - <code>name</code>. Python Fire automatically picks this up and if we supply an argument after the <code>greetings</code> call, it'll bind that input to the <code>name</code> parameter. We've also added a comment as a sort of documentation for the <code>--help</code> command.
Here's how we can run this command from the command line:
<pre><code class="hljs">$ python fire_greet_cli.py greetings Robin
Hello Robin
</code></pre>
A Fire CLI application can use <code>--help</code> flags to check the command description generated from Python docs:
<pre><code class="hljs">python fire_greet_cli.py greetings --help
NAME
 fire_greet_cli.py greetings - Returns a greeting message

SYNOPSIS
 fire_greet_cli.py greetings NAME

DESCRIPTION
 Returns a greetings message

POSITIONAL ARGUMENTS
 NAME
 String that represents the addresses name

NOTES
 You can also use flags syntax for POSITIONAL ARGUMENTS
</code></pre>
<h2 id="settingafunctionasentrypoint">Setting a Function as Entry Point</h2>
With slight modification we can control the exposure of the <code>greetings()</code> function to the command-line and set it as the default entry-point:
<pre><code class="hljs">import fire

def greetings(name):
 &#x27;&#x27;&#x27;
 Returns a greeting message 
 :param name: string argument
 :return: greeting message appended with name
 &#x27;&#x27;&#x27;
 return &#x27;Hello %s&#x27; % name

if __name__ == &#x27;__main__&#x27;:
 fire.Fire(greetings)
</code></pre>
This is how we will run the command now:
<pre><code class="hljs">$ python fire_greet_cli.py Robin
Hello Robin
</code></pre>
So this time we no longer need to call the command as we have defined <code>greetings</code> implicitly as an entry point using <code>Fire()</code>. One thing to be noted here is that with this version, we can only pass a single argument :
<pre><code class="hljs">$ python fire_greet_cli.py Robin Hood
ERROR: Could not consume arg: Hood
...
$ python fire_greet_cli.py Robin
Hello Robin
</code></pre>
<h2 id="argumentsparsing">Arguments Parsing</h2>
The Fire library also works with classes. Let's define a class <code>CustomSequence</code> that generates and returns a list of numbers between <code>start</code> and <code>end</code>:
<pre><code class="hljs">import fire

class CustomSequence:
 &#x27;&#x27;&#x27;Class that generates a sequence of numbers&#x27;&#x27;&#x27;
 def __init__(self, offset=1):
 &#x27;&#x27;&#x27;
 Parameters
 ----------
 offset : int, optional
 Number controlling the difference between two generated values
 &#x27;&#x27;&#x27;
 self.offset = offset

 def generate(self, start, stop):
 &#x27;&#x27;&#x27;
 Generates the sequence of numbers

 Parameters
 ----------
 start : int
 Number that represents the elements lower bound
 stop : int
 Number that represents the elements upper bound

 Returns
 -------
 string
 a string that represents the generated sequence
 &#x27;&#x27;&#x27;
 return &#x27; &#x27;.join(str(item) for item in range(start, stop, self.offset))

if __name__ == &#x27;__main__&#x27;:
 fire.Fire(CustomSequence)
</code></pre>
This is how we generate a sequence using this command-line utility:
<pre><code class="hljs">$ python fire_gen_cli.py generate 1 10
1 2 3 4 5 6 7 8 9
</code></pre>
We used a class instead of a function because unlike functions if we want to pass an argument to the constructor, it always has to be represented as a command line flag with double hyphens (e.g. <code>--offset=2</code>).
Therefore, our CLI application supports an optional argument <code>--offset</code> that will be passed on to the class constructor. This modifies the output by controlling the difference between two consecutive generated values:
Here's the output with offset value of 2:
<pre><code class="hljs">$ python fire_gen_cli.py generate 1 10 --offset=2
1 3 5 7 9
</code></pre>
The constructor's arguments are always passed using the flag syntax whereas arguments to other methods or functions are passed positionally or by name :
<pre><code class="hljs">$ python fire_gen_cli.py generate --start=10 --stop=20
10 11 12 13 14 15 16 17 18 19
$ python fire_gen_cli.py generate 10 20
10 11 12 13 14 15 16 17 18 19
$ python fire_gen_cli.py generate --start=10 --stop=20 --offset=2
10 12 14 16 18
</code></pre>
We can check the usage of the<code>generate</code> command using the <code>--help</code> flag. This will give the usage information for the CLI :
<pre><code class="hljs">$ python fire_gen_cli.py generate --help
INFO: Showing help with the command &#x27;fire_gen_cli.py generate -- --help&#x27;.

NAME
 fire_gen_cli.py generate - Generates the sequence of numbers

SYNOPSIS
 fire_gen_cli.py generate START STOP

DESCRIPTION
 Generates the sequence of numbers

POSITIONAL ARGUMENTS
 START
 Number that represents the first value for the sequence
 STOP
 Number that represents the ending value for the sequence

NOTES
 You can also use flags syntax for POSITIONAL ARGUMENTS
</code></pre>
Using <code>--help</code> with the module gives us its usage information:
<pre><code class="hljs">$ python fire_gen_cli.py --help
INFO: Showing help with the command &#x27;fire_gen_cli.py -- --help&#x27;.

NAME
 fire_gen_cli.py - Class that generates a sequence of numbers

SYNOPSIS
 fire_gen_cli.py &lt;flags&gt;

DESCRIPTION
 Class that generates a sequence of numbers

FLAGS
 --offset=OFFSET
</code></pre>
<h2 id="fireflags">Fire Flags</h2>
Fire CLIs come with many built-in flags. We have already seen <code>--help</code>, though, another useful flag is <code>--interactive</code>. Using this flag puts us in Python REPL mode, with the module already defined.
This is quite useful for testing commands:
<pre><code class="hljs">$ python fire_greet_cli.py -- --interactive
Fire is starting a Python REPL with the following objects:
Modules: fire
Objects: component, fire_greet_cli.py, greetings, result, trace

Python 3.7.8 (tags/v3.7.8:4b47a5b6ba, Jun 28 2020, 08:53:46) [MSC v.1916 64 bit (AMD64)]
Type &#x27;copyright&#x27;, &#x27;credits&#x27; or &#x27;license&#x27; for more information
IPython 7.16.1 -- An enhanced Interactive Python. Type &#x27;?&#x27; for help.


In [1]: greetings(&quot;Robin&quot;)
Out[1]: &#x27;Hello Robin&#x27;
</code></pre>
<blockquote>
Note that Fire flags should be separated from other options with two hyphens (<code>--</code>), so if we want to use both <code>--help</code> and <code>--interactive</code> flags in a command, it would look something like this:
</blockquote>
<pre><code class="hljs">$ python fire_greet_cli.py -- --help --interactive
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Google's Python Fire library is a quick and easy way to generate command line interfaces (CLIs) for nearly any Python object.
In this article, we've gone over how to install Python Fire, as well as generate simple command-line interfaces.

Tapan Pandey

In this tutorial, we'll go over how to make a command-line interface application using Python Fire.