<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.

Abhilash Kakumanu

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.

Generating Command-Line Interfaces (CLI) with Fire in Python

<h2 id="introduction">Introduction</h2>
The term slicing in programming usually refers to obtaining a substring, sub-tuple, or sublist from a string, tuple, or list respectively.
Python offers an array of straightforward ways to slice not only these three but any iterable. An iterable is, as the name suggests, any object that can be iterated over.
In this article, we'll go over everything you need to know about Slicing Numpy Arrays in Python.
<h2 id="numpyarrayslicing">NumPy Array slicing</h2>
The most common way to slice a NumPy array is by using the <code>:</code> operator with the following syntax:
<pre><code class="hljs">array[start:end]
array[start:end:step]
</code></pre>
The <code>start</code> parameter represents the starting index, <code>end</code> is the ending index, and <code>step</code> is the number of items that are &quot;stepped&quot; over.
NumPy is a free Python package that offers, among other things, n-dimensional arrays.
Slicing 1D (one dimensional) arrays in NumPy can be done with the same notation as slicing regular lists in Python:
<pre><code class="hljs">import numpy as np
arr = np.array([1,2,3,4])
print(arr[1:3:2])
print(arr[:3])
print(arr[::2])
</code></pre>
Output:
<pre><code class="hljs">[2]
[1 2 3]
[1 3]
</code></pre>
<h3 id="2dnumpyarrayslicing">2D NumPy Array Slicing</h3>
A 2D array in NumPy is an array of arrays, a 3D array is an array of arrays of arrays and so forth. A 2D array can be represented as a matrix like so:
<pre><code class="hljs">import numpy
arr = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
</code></pre>
Let's print this matrix out:
<pre><code class="hljs">[[ 1 2 3 4]
 [ 5 6 7 8]
 [ 9 10 11 12]]
</code></pre>
Slicing a 2D array can either result in an array or a matrix. The syntax that results in a matrix would be:
<pre><code class="hljs">arr[startx:endx:stepx, starty:endy:stepy]
</code></pre>
The syntax that results in an array:
<pre><code class="hljs">arr[startx:endx:stepx, const]
arr[const, starty:endy:stepy]
</code></pre>
Utilizing this syntax results in a matrix whose elements are the columns in the range from <code>startx</code> to <code>endx</code> on the x-axis, and rows in the range from <code>starty</code> to <code>endy</code> on the y-axis of the original matrix:
Let's take a look at how we can slice this matrix and what the slicing results in:
<pre><code class="hljs">import numpy

arr = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(&quot;The original matrix:&quot;)
print(arr)

print(&quot;A sliced submatrix:&quot;)
print(arr[1:4,2:4])

print(&quot;A sliced subarray:&quot;)
print(arr[1,:])

print(&quot;A sliced submatrix:&quot;)
print(arr[:,3:])

print(&quot;A sliced subarray:&quot;)
print(arr[:,3])
</code></pre>
This code segment prints out:
<pre><code class="hljs">The original matrix:
[[ 1 2 3 4]
 [ 5 6 7 8]
 [ 9 10 11 12]
 [13 14 15 16]]
A sliced submatrix:
[[ 7 8]
 [11 12]
 [15 16]]
A sliced subarray:
[5 6 7 8]
A sliced submatrix:
[[ 4]
 [ 8]
 [12]
 [16]]
A sliced subarray:
[ 4 8 12 16]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Slicing any sequence in Python is easy, simple, and intuitive. Negative indexing offers an easy way to acquire the first or last few elements of a sequence, or reverse its order.
In this article, we've covered how to slice Python's NumPy arrays.

Kristina Popovic

In this tutorial, we'll go over examples of how to slice a NumPy Array in Python. We'll slice 1D and multi-dimensional arrays/matrices into subarray and submatrices.

Python: Slice Notation on NumPy Arrays

Mehreen Saeed

In this tutorial, we'll go over the theory on how does gradient descent work and how to implement it in Python. Then, we'll implement batch and stochastic gradient descent to minimize Mean Squared Error functions.

Gradient Descent in Python: Implementation and Theory

<h2 id="introduction">Introduction</h2>
The term slicing in programming usually refers to obtaining a substring, sub-tuple, or sublist from a string, tuple, or list respectively.
Python offers an array of straightforward ways to slice not only these three but any iterable. An iterable is, as the name suggests, any object that can be iterated over.
In this article, we'll go over everything you need to know about Slicing Tuples in Python.
<h2 id="slicingatupleinpython">Slicing a Tuple in Python</h2>
There are a couple of ways to slice a tuple, most common of which is by using the <code>:</code> operator with the following syntax:
<pre><code class="hljs">tuple[start:end]
tuple[start:end:step]
</code></pre>
The <code>start</code> parameter represents the starting index, <code>end</code> is the ending index, and <code>step</code> is the number of items that are &quot;stepped&quot; over.
If <code>step</code> isn't explicitly given, the default value is <code>1</code>.
Let's go ahead and slice a tuple:
<pre><code class="hljs">a_tuple = (&#x27;You&#x27;, &#x27;can’t&#x27;, &#x27;stop&#x27;, &#x27;the&#x27;, &#x27;change,&#x27;, &#x27;any&#x27;, &#x27;more&#x27;, &#x27;than&#x27;, &#x27;you&#x27;, &#x27;can&#x27;, &#x27;stop&#x27;, &#x27;the&#x27;, &#x27;suns&#x27;, &#x27;from&#x27;, &#x27;setting.&#x27;)
subtuple = a_tuple[1:5]
print(subtuple)
</code></pre>
The resulting tuple will be:
<pre><code class="hljs">(&#x27;can’t&#x27;, &#x27;stop&#x27;, &#x27;the&#x27;, &#x27;change,&#x27;)
</code></pre>
<h3 id="findingthefirstandthelastnelementsofatuple">Finding the First and the Last n Elements of a Tuple</h3>
To find the first and last <code>n</code> elements of a tuple, we'll slice from the first element to <code>n</code> and then from <code>-n</code> to the end of the tuple.
<code>-n</code> will start counting from the end of the tuple, backwards, giving us the last <code>n</code> elements:
<pre><code class="hljs">n = 2
a_tuple = (&#x27;I&#x27;, &#x27;find&#x27;, &#x27;your&#x27;, &#x27;lack&#x27;, &#x27;of&#x27;, &#x27;faith&#x27;, &#x27;disturbing.&#x27;)

first_n_tuple = a_tuple[:n]
print(first_n_tuple)
last_n_tuple = a_tuple[-n:]
print(last_n_tuple)
</code></pre>
The resulting subtuples are:
<pre><code class="hljs">(&#x27;I&#x27;, &#x27;find&#x27;)
(&#x27;faith&#x27;, &#x27;disturbing.&#x27;)
</code></pre>
<h3 id="reversetuplewithslicenotation">Reverse Tuple with Slice Notation</h3>
If we set the <code>step</code> parameter to <code>-1</code>, it'll start stepping backwards. If we include the whole, or even a part of the tuple, and just step backwards, it'll effectively reverse the tuple's contents:
<pre><code class="hljs">a_tuple = (&#x27;Fear&#x27;, &#x27;is&#x27;, &#x27;the&#x27;, &#x27;path&#x27;, &#x27;to&#x27;, &#x27;the&#x27;, &#x27;dark&#x27;, &#x27;side.&#x27;, &#x27;Fear&#x27;, &#x27;leads&#x27;, &#x27;to&#x27;, &#x27;anger;&#x27;, &#x27;anger&#x27;, &#x27;leads&#x27;, &#x27;to&#x27;, &#x27;hate;&#x27;, &#x27;hate&#x27;, &#x27;leads&#x27;, &#x27;to&#x27;, &#x27;suffering.&#x27;, &#x27;I&#x27;, &#x27;sense&#x27;, &#x27;much&#x27;, &#x27;fear&#x27;, &#x27;in&#x27;, &#x27;you.&#x27;, 7)
reverse_tuple = a_tuple[::-1]
print(reverse_tuple)
</code></pre>
The reversed tuple will be:
<pre><code class="hljs">(7, &#x27;you.&#x27;, &#x27;in&#x27;, &#x27;fear&#x27;, &#x27;much&#x27;, &#x27;sense&#x27;, &#x27;I&#x27;, &#x27;suffering.&#x27;, &#x27;to&#x27;, &#x27;leads&#x27;, &#x27;hate&#x27;, &#x27;hate;&#x27;, &#x27;to&#x27;, &#x27;leads&#x27;, &#x27;anger&#x27;, &#x27;anger;&#x27;, &#x27;to&#x27;, &#x27;leads&#x27;, &#x27;Fear&#x27;, &#x27;side.&#x27;, &#x27;dark&#x27;, &#x27;the&#x27;, &#x27;to&#x27;, &#x27;path&#x27;, &#x27;the&#x27;, &#x27;is&#x27;, &#x27;Fear&#x27;)
</code></pre>
<h3 id="findingeverynthelementofatuple">Finding Every n-th Element of a Tuple</h3>
To find every <code>n</code>-th element of a tuple, we'll jump over all non-<code>n</code> elements by setting the step to be <code>n</code>:
<pre><code class="hljs">n = 5
a_tuple = (&#x27;The&#x27;, &#x27;dark&#x27;, &#x27;side&#x27;, &#x27;of&#x27;, &#x27;the&#x27;, &#x27;Force&#x27;, &#x27;is&#x27;, &#x27;a&#x27;, &#x27;pathway&#x27;, &#x27;to&#x27;, &#x27;many&#x27;, &#x27;abilities&#x27;, &#x27;some&#x27;, &#x27;consider&#x27;, &#x27;to&#x27;, &#x27;be&#x27;, &#x27;unnatural.&#x27;)
replaced_tuple = a_tuple[::n]
print(replaced_tuple)
</code></pre>
This will result in a tuple:
<pre><code class="hljs">(&#x27;The&#x27;, &#x27;Force&#x27;, &#x27;many&#x27;, &#x27;be&#x27;)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Slicing any sequence in Python is easy, simple, and intuitive. Negative indexing offers an easy way to acquire the first or last few elements of a sequence, or reverse its order.
In this article, we've covered how to apply the Slice Notation on Tuples in Python.

In this article, we'll cover examples of how to use the slice notation on tuples in Python. We'll slice a tuple, find the first and last n elements, reverse a tuple and skip over n elements.

Python: Slice Notation on Tuple

<h2 id="introduction">Introduction</h2>
A list is the most flexible data structure in Python. Whereas, a 2D list which is commonly known as a list of lists, is a list object where every item is a list itself - for example: <code>[[1,2,3], [4,5,6], [7,8,9]]</code>.
Flattening a list of lists entails converting a 2D list into a 1D list by un-nesting each list item stored in the list of lists - i.e., converting <code>[[1, 2, 3], [4, 5, 6], [7, 8, 9]]</code> into <code>[1, 2, 3, 4, 5, 6, 7, 8, 9] </code>.
The process of flattening can be performed using nested for loops, list comprehensions, recursion, built-in functions or by importing libraries in Python depending on the regularity and depth of the nested lists.
<h2 id="typesofnestedlists">Types of Nested Lists</h2>
Since Python is weakly typed, you can encounter regular and irregular lists of lists.
<h3 id="regularlistoflists">Regular List of Lists</h3>
Every element of this list is a sublist, thereby adhering to the uniformity of the element type. 
Example: <code>[[1, 2, 3], [4, 5, 6], [7, 8, 9]]</code> is a regular list of lists as <code>[1, 2, 3], [4, 5, 6], [7, 8, 9]</code> is of type <code>list</code>.
<h3 id="irregularlistoflists">Irregular List of Lists</h3>
Every element of this list is either a sublist or a non-list item (for example an integer or string). Therefore, there is an irregularity in terms of the element type. Example: <code>[[1, 2, 3], [4, 5], 6] </code> where <code>[1, 2, 3]</code> and <code>[4, 5]</code> are of type <code>list</code> and <code>6</code> is of type <code>int</code>.
<h2 id="flattenlistoflistsusingnestedforloops">Flatten List of Lists Using Nested for Loops</h2>
This is a brute force approach to obtaining a flat list by picking every element from the list of lists and putting it in a 1D list.
The code is intuitive as shown below and works for both regular and irregular lists of lists:
<pre><code class="hljs">def flatten_list(_2d_list):
 flat_list = []
 # Iterate through the outer list
 for element in _2d_list:
 if type(element) is list:
 # If the element is of type list, iterate through the sublist
 for item in element:
 flat_list.append(item)
 else:
 flat_list.append(element)
 return flat_list

nested_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
print(&#x27;Original List&#x27;, nested_list)
print(&#x27;Transformed Flat List&#x27;, flatten_list(nested_list))
</code></pre>
This results in:
<pre><code class="hljs">Original List [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Transformed Flat List [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h2 id="flattenlistoflistsusingalistcomprehension">Flatten List of Lists Using a List Comprehension</h2>
This approach provides an elegant but a less intuitive solution to create a flat list based on an existing 2D list:
<pre><code class="hljs">regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
flat_list = [item for sublist in regular_list for item in sublist]
print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
Which would output the following:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<h2 id="flattenlistoflistsrecursively">Flatten List of Lists Recursively</h2>
The 2D list can be flattened recursively as well. The implementation below works both for regular and irregular list of lists:
<pre><code class="hljs">def flatten(list_of_lists):
 if len(list_of_lists) == 0:
 return list_of_lists
 if isinstance(list_of_lists[0], list):
 return flatten(list_of_lists[0]) + flatten(list_of_lists[1:])
 return list_of_lists[:1] + flatten(list_of_lists[1:])


print(flatten([[1, 2, 3, 4], [5, 6, 7], [8, 9], 10]))
</code></pre>
Which would give us:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h2 id="usinglibraries">Using Libraries</h2>
You can also rely on the help of Python libraries for this task.
<h3 id="flattenlistoflistsusingfunctoolsreduceandiconcat">Flatten List of Lists Using functools (reduce() and iconcat())</h3>
The <code>iconcat()</code> function performs the basic operation of concatenation and is applied cumulatively to the items of a list of lists, from left to right, so as to reduce it to a single list:
<pre><code class="hljs">import functools
import operator
regular_list = []

# Transform an irregular 2D list into a regular one.
def transform(nested_list):
 for ele in nested_list:
 if type(ele) is list:
 regular_list.append(ele)
 else:
 regular_list.append([ele])
 return regular_list


irregular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10], 11]
regular_2D_list = transform(irregular_list)
print(&#x27;Original list&#x27;, irregular_list)
print(&#x27;Transformed list&#x27;, functools.reduce(operator.iconcat, regular_2D_list, []))
</code></pre>
Which would give us the desired result:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10], 11]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
</code></pre>
<h3 id="flattenlistoflistsusingitertoolschain">Flatten List of Lists Using itertools (chain())</h3>
This approach is ideal for transforming a 2-D list into a single flat list as it treats consecutive sequences as a single sequence by iterating through the iterable passed as the argument in a sequential manner.
<pre><code class="hljs">import itertools

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
flat_list = list(itertools.chain(*regular_list))

print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
Again, this would give us a flattened list as the output:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
<h3 id="flattenlistoflistsusingnumpyconcatenateandflat">Flatten List of Lists Using numpy (concatenate() and flat())</h3>
Numpy offers common operations which include concatenating regular 2D arrays row-wise or column-wise. We are also using the <code>flat</code> attribute to get a 1D iterator over the array in order to achieve our goal. However, this approach is relatively slow:
<pre><code class="hljs">import numpy

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]

flat_list = list(numpy.concatenate(regular_list).flat)

print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
Which gives us the desired output:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<h2 id="usingbuiltinfunctions">Using Built-In Functions</h2>
The task of flattening can also be performed by using built-in functions that Python offers.
<h3 id="flattenlistoflistsusingsum">Flatten List of Lists Using sum</h3>
Summing over inner lists is another solution. The function has two parameters: <code>iterable</code> which is a list of lists and <code>start</code> which is an empty list in our case that serves as the initial flat list to which items of the inner sublists are added.
This approach is convenient as you don't have to import anything but it's slower than <code>itertools()</code> and the <code>chain()</code> functions when the number of sublists is large:
<pre><code class="hljs">regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]

flat_list = sum(regular_list, [])

print(&#x27;Original list&#x27;, regular_list)
print(&#x27;Transformed list&#x27;, flat_list)
</code></pre>
With the output:
<pre><code class="hljs">Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<h3 id="flattenlistoflistsusinglambda">Flatten List of Lists Using Lambda</h3>
An anonymous function can be defined using the lambda keyword. The regular/irregular list is passed as the argument to this anonymous function and the evaluation of the expression is done to obtain a flat 1D list:
<pre><code class="hljs">irregular_list = [[1, 2, 3], [3, 6, 7], [7, 5, 4],7]

# Using lambda arguments: expression
flatten_list = lambda irregular_list:[element for item in irregular_list for element in flatten_list(item)] if type(irregular_list) is list else [irregular_list]

print(&quot;Original list &quot;, irregular_list)
print(&quot;Transformed List &quot;, flatten_list(irregular_list))
</code></pre>
We would again get the desired result:
<pre><code class="hljs">Original list [[1, 2, 3], [3, 6, 7], [7, 5, 4], 7]
Transformed List [1, 2, 3, 3, 6, 7, 7, 5, 4, 7]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we provided an extensive list of ways we can complete the task of flattening a list of lists in Python.

Raksha Shenoy

In this tutorial, we'll go over examples of how to flatten a 2D (list of lists) list into one list. We'll use for loops, list comprehensions, recursive algorithms, as well as libraries like Numpy and functools.

Python: How to Flatten List of Lists

Python: How to Flatten a List of Lists

<h2 id="introduction">Introduction</h2>
Searching, in the context of Computer Science, is the process of locating a particular element in the given list/array. If we pay close attention, we can find search algorithms everywhere.
Consider the process of logging into a website. Entered email and password are searched against the existing key-value pairs in the database to validate the user.
In this article, let us look at the most basic algorithm to search through a given list of elements - Linear Search.
<h2 id="understandinglinearsearch">Understanding Linear Search</h2>
The Linear Search algorithm is a set of instructions to traverse the given list and check every element in the list until we find whatever element we are looking for. The technical term for the element we are looking for is - key.
The algorithm goes from the leftmost (or starting) element and continues searching until it either finds the desired element or goes through all the elements in the list.
If the element is found, we will return the position (or <code>index</code>) of the element. If the element we are looking for doesn't exist in the list, we generally return <code>-1</code>.
<h2 id="implementationoflinearsearchinjavascript">Implementation of Linear Search in JavaScript</h2>
We can traverse through the given list using a <code>for</code> loop. Let's look at the implementation of Linear Search:
<pre><code class="hljs">function linearSearch(arr, key){
 for(let i = 0; i &lt; arr.length; i++){
 if(arr[i] === key){
 return i
 }
 }
 return -1
}
</code></pre>
Here we are going through all the elements in an array and comparing each element with the key. If we find a match, we return the index of the element. In our case, the variable <code>i</code> keeps track of where we are in the array, and if we find a match, we return the current value for <code>i</code>.
In case the element doesn't exist in our list, the <code>linearSearch</code> function won't return any <code>i</code> value from the loop. We just <code>return -1</code> after the loop to show that the function didn't find the desired element.
<h2 id="globallinearsearch">Global Linear Search</h2>
In the previous implementation, we return a value after we come across the first occurrence of the element we are looking for (<code>key</code>). But what if we want to the indices of all the occurrences of a given element?
That's where global linear search comes in. It is a variant of linear search where we are looking for multiple occurrences of a given element.
Let's look at the implementation of the global linear search:
<pre><code class="hljs">function globalLinearSearch(arr, key){
 let results = []
 for(let i = 0; i &lt; arr.length; i++){
 if(arr[i] === key){
 results.push(i)
 }
 }
 // If results array is empty, return -1
 if(!results){
 return -1
 }

 return results
}
</code></pre>
In this case, instead of immediately returning the index of the matching element, we are storing it in an array. In the end, we are returning the array of indices.
<h2 id="theefficiencyoflinearsearch">The Efficiency of Linear Search</h2>
Linear Search is a classic example of a brute-force algorithm. This means that the algorithm doesn't use any logic to try and do what it's supposed to quickly, or to somehow reduce the range of elements in which it searches for <code>key</code>. Other search algorithms aim to do this more efficiently by some sort of preprocessing of the list/array, for example sorting it.
The time complexity of Linear Search is O(n), where n is the number of elements in the list we're searching. This is because we always consider the worst-case while calculating the time complexity. In the case of Linear Search (as with most search algorithms) the worst-case occurs when the element doesn't exist in the list. In this situation, we'd need to go through all the n elements to determine that the element isn't there.
<h2 id="conclusion">Conclusion</h2>
In this article, we have seen the logic behind linear search, and then using that knowledge, we implemented the algorithm in JavaScript. We have also looked at the time complexity for the linear search algorithm.
It's by far the simples search algorithm, one that doesn't use any logic to try and discard a particular range for searching or with a focus on speed.

In this article, we'll take a look at one of the simplest search algorithms - Linear Search in JavaScript. We'll implement regular as well as linear search for all occurrences of an element.