DEV Community: Vinay Khatri

What is Network Scanning

Vinay Khatri — Thu, 22 Feb 2024 15:07:01 +0000

Gathering information about the target machine or server is one of the crucial steps toward compromising or identifying any vulnerabilities on the machine. There are various methods to gather information on a target, but one of the most effective and commonly used is called Network Scanning. Network scanning itself is divided into multiple types. In this particular blog section, I will walk you through what network scanning is, its objectives, how it aids in reconnaissance, and how we can use the popular tool Nmap to perform network scanning with ease.

What is Network Scanning?

Network scanning is an active process to gather information on a target machine by identifying active hosts, their open ports, and the services running on those ports. In the field of ethical hacking, network scanning allows us to scan a particular target for its open ports or scan an entire network to identify active hosts. With the information gathered through network scanning, one can identify present vulnerabilities and exploit them to gain unauthorized access to the system or inject a payload into the network.

Types of Network Scanning:
There are mainly three types of network scanning:

Host Discovery
Port Scanning
Vulnerability Scanning

1.Host Discovery Scanning:

In Host discovery scanning, we aim to identify active hosts over a network. By utilizing this scanning method, we can determine which IPs are active and operational within a network, along with the number of devices connected to the router or network. The primary objective of host discovery is to map out the network and determine which IPs are reachable.

The simplest technique for Host discovery is known as ping sweep, wherein an ICMP ping request is sent to individual IP addresses, and those that reply without packet loss confirm their operational status. This can be easily done using the ping command in the terminal or command prompt.

ping 192.168.29.98                                                                                                                                        
Pinging 192.168.29.98 with 32 bytes of data:          
Reply from 192.168.29.98: bytes=32 time=272ms TTL=64
Reply from 192.168.29.98: bytes=32 time=200ms TTL=64
Reply from 192.168.29.98: bytes=32 time=112ms TTL=64  
Reply from 192.168.29.98: bytes=32 time=25ms TTL=64                                                                                                                           
Ping statistics for 192.168.29.98:zz
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),                                                                
Approximate round trip times in milli-seconds:                                                                              
Minimum = 25ms, Maximum = 272ms, Average = 152ms

To perform the ping sweep we can use the nmap -sn command, that can ping the entire network specified using the CIDR notaion.

┌──(crow㉿kali)-[~]
└─$ nmap -sn 192.168.29.1/24
Starting Nmap 7.93 ( https://nmap.org ) at 2024-02-21 21:20 IST
Nmap scan report for (192.168.29.1)
Host is up (0.010s latency).
Nmap scan report for 192.168.29.12
Host is up (0.0047s latency).
Nmap scan report for 192.168.29.98
Host is up (0.0045s latency).
Nmap scan report for 192.168.29.202
Host is up (0.000081s latency).
Nmap scan report for 192.168.29.212
Host is up (0.048s latency).
Nmap done: 256 IP addresses (5 hosts up) scanned in 2.85 seconds

In this command, Nmap sends an ICMP request to every IP address in the network range specified.

2.Port Scanning

Port scanning involves targeting an individual active machine or server and scanning for its open ports. Ports are essential for communication between machines to send and receive data. Ports are associated with specific protocols and services, and through port scanning, we aim to identify open ports that may be using outdated services vulnerable to exploitation.

Various techniques can be used for port scanning, such as TCP connect scanning, SYN scanning, UDP scanning, and ACK scanning, all of which can be performed using the Nmap tool. For example, a TCP connect scan, which is a reliable and straightforward port scanning technique, can be performed with the following command

nmap -sT 192.168.29.12  
Starting Nmap 7.93 ( https://nmap.org ) at 2024-02-21 21:40 IST
Nmap scan report for 192.168.29.12
Host is up (0.0049s latency).
Not shown: 977 closed tcp ports (conn-refused)
PORT     STATE SERVICE
21/tcp   open  ftp
22/tcp   open  ssh
23/tcp   open  telnet
25/tcp   open  smtp
53/tcp   open  domain
80/tcp   open  http
111/tcp  open  rpcbind
139/tcp  open  netbios-ssn
445/tcp  open  microsoft-ds
512/tcp  open  exec
513/tcp  open  login
514/tcp  open  shell
1099/tcp open  rmiregistry
1524/tcp open  ingreslock
2049/tcp open  nfs
2121/tcp open  ccproxy-ftp
3306/tcp open  mysql
5432/tcp open  postgresql
5900/tcp open  vnc
6000/tcp open  X11
6667/tcp open  irc
8009/tcp open  ajp13
8180/tcp open  unknown

In this command, the nmap performs the TCP connect scan on the first 10000 port.

3.Vulnerability Scanning:

In vulnerability scanning, we take a more active approach to identify available vulnerabilities on the network or system. This involves scanning for known vulnerabilities in software, configurations, or missing patches. The main objective is to discover weaknesses by identifying services or applications that can be easily exploited. And there various tools such as OpenVAS, Nessus, etc., provide powerful utilities for vulnerability scanning

Compress Images size with Python

Vinay Khatri — Sat, 27 Aug 2022 07:41:29 +0000

A high quality image comprise of many pixels which increase the image overall memory size. But sometime when we want to save the image in less quality for better loading, in that case we use the image compression. Image compression is a process where we minimize the size of the image without degrading the image quality.

To compress the Image in Python we can use the pillow library which is an open source third party library.
To use this library first we need to install for our Python environment using the pip install command.

pip install pillow

After installing this library we can start compressing the image we want.

import PIL
from PIL import Image

#open the image
with  Image.open('original.jpg') as my_image:

    # the original width and height of the image
    image_height = my_image.height
    image_width = my_image.width

    print("The original size of Image is: ", round(len(my_image.fp.read())/1024,2), "KB")

    #compressed the image
    my_image = my_image.resize((image_width,image_height),PIL.Image.NEAREST)

    #save the image
    my_image.save('compressed.jpg')

    #open the compressed image
    with Image.open('compressed.jpg') as compresed_image:
        print("The size of compressed image is: ", round(len(compresed_image.fp.read())/1024,2), "KB")

Output

The original size of Image is:  1953.24 KB
The size of compressed image is:  1547.01 KB

Break the code

First load the original image that we want to comrpess using the Image.open() method.
Find the width and the height of the original image, using the width and height properties.
compress the image copy using the resize method, keep the daimension size of the compressed image as same as the original image and apply the PIL.Image.NEAREST filter to compressed the image in the my_image.resize((image_width,image_height),PIL.Image.NEAREST) statement. Note: There are multiple compression filter available for the resize mehtod you can check all the filters here.
At last save the compressed image using the save() method.

Note: I used the
print("The original size of Image is: ", round(len(my_image.fp.read())/1024,2), "KB")
print("The size of compressed image is: ", round(len(compresed_image.fp.read())/1024,2), "KB")
statements to show the difference between the size of the original image and compressed image.

Resize the size

In the above code snippet we keep remain the dimension of the compressed image as same as the original image, which result in not that much of size difference. We can also resize the dimension size of the original image by specifying the specific width and height for the compressed image.

from turtle import width
import PIL
from PIL import Image

#open the image
with  Image.open('original.jpg') as my_image:

    #new widht and height in px
    width = 400
    height = 700

    print("The original size of Image is: ", round(len(my_image.fp.read())/1024,2), "KB")

    #compressed the image
    my_image = my_image.resize((width,height),PIL.Image.NEAREST)

    #save the image
    my_image.save('compressedResized.jpg')

    #open the compressed image
    with Image.open('compressedResized.jpg') as compresed_image:
        print("The size of compressed image is: ", round(len(compresed_image.fp.read())/1024,2), "KB")

Output

The original size of Image is:  1953.24 KB
The size of compressed image is:  56.89 KB

Download from the web and compress the image

We can also download an image from the web and compresses it using the Python pillow library.
To download the image from the web we first need to install the Python requests library.

pip install requests

import PIL
from PIL import Image
import requests

img_url = "https://images.pexels.com/photos/60597/dahlia-red-blossom-bloom-60597.jpeg"

response = requests.get(img_url)


#download image 
with open("downloaded.jpg", 'wb') as save_image:
    save_image.write(response.content)

#open the image
with  Image.open('downloaded.jpg') as my_image:

    # the original width and height of the image
    image_height = my_image.height
    image_width = my_image.width

    print("The original size of Image is: ", round(len(my_image.fp.read())/1024,2), "KB")

    #compressed the image
    my_image = my_image.resize((image_width,image_height),PIL.Image.NEAREST)

    #save the image
    my_image.save('compressed.jpg')

    #open the compressed image
    with Image.open('compressed.jpg') as compresed_image:
        print("The size of compressed image is: ", round(len(compresed_image.fp.read())/1024,2), "KB")

Output

The original size of Image is:  706.43 KB
The size of compressed image is:  401.19 KB

Compress the uploaded images in Django.

This compress feature of Python with pillow comes very handy with Django when the user upload a high quality image and you wish to compress it.

class UserProfile(models.Model):
    profile_picture = models.ImageField(upload_to='profile_pictures', blank=True, verbose_name='Profile Picture')

def save(self, * args, **kwargs):
        super().save( * args, **kwargs)
        if self.profile_picture:
            img= Image.open(self.profile_picture.path)

            if img.height>1000 or img.width >1000:
                output_size= (500,500)
                img.resize((output_size), PIL.Image.NEAREST)
                img.save(self.profile_picture.path)

How to shutdown a window using python? one-liner Python code

Vinay Khatri — Mon, 25 Jul 2022 07:05:00 +0000

Although windows provide a graphical user interface to showdown, restart, logoff, and hibernate our computer. But we can also write a Python script to showdown or restart our window with specified time intervals.
Shutting down the computer is an operating system functionality, so to achieve this in Python, we can use the Python inbuilt os module to interact with the operating system.

Shut Down the Window using Python

Windows provide the shutdown /s terminal command to shut down the wind. And it will immediately shut down the computer.

Command

shutdown /s

Shutdown program

import os
os.system("shutdown /s")

Note: The system() method will execute the shutdown /s command for the window.

Shut Down the Window after a specific period in Python

The shutdown command also accepts the /t flag for the period shutdown. It comes very handy when we want to set the time-out period before shutdown.

Command

shutdown \s \t xxx

Note: xxx are the number of seconds for the shutdown.

Shutdown program

import os

os.system("shutdown /s /t 10")

print("Your Pc will shut down in 10 seconds")

Restart the window using Python

To restart the window immediately, we can raise the /r flag witht the shutdown command.

Command

shutdown /r

Restart program

import os

os.system("shutdown /r ")

Restart the Window after xxx seconds

We can also specify the xxx number of seconds to set a restart process. To set the time period we can use the /t flag and specify the xxx seconds.

Command

shutdown /r /t 10

Restart Program

import os

os.system("shutdown /r /t 10")

print("Your Pc will restart in 10 seconds")

Restart and shut down with a comment

We can also specify the reason, message, or comment for the shutdown or restart processes, so we can know why we initiated the shutdown or restart.

Command

shutdown /s /c message

Example

import os

comment ="Time for work out"

os.system(f"shutdown /s /t 10 /c {comment}")

How to Check Internal and External links on a Webpage using Python

Vinay Khatri — Fri, 15 Jul 2022 20:07:53 +0000

Python is one of the most popular programming languages for extracting, processing, and analyzing data. The inbuilt and third-party libraries of Python make it very easy for a developer to get specific data from a web page and make results around those data sets.
In this article, I have covered a simple Python script that can extract links from a given url of a web page and create a CSV file containing all the links present on that web page with extra information telling whether the link is external or internal.

Prerequisite

As it is a python article with the program, so it goes without saying that you need to have basic knowledge of Python and Python installed on your system to test the program for yourself.
If you are on a new system, you can easily install the latest version of Python with this quick download link.

To make the program, I will use 4 Python libraries, among which two libraries are third-party libraries, and the other two are built-in.

Libraries

1. requests:
requests is the popular python HTTP library. We will use this library to make an HTTP request for the url which links we want to check.
As requests is a third-party library, we need to install it for our Python environment using the pip command.
pip install requests
2. Beautiful soup:
Beautiful soup is a third-party Python library that can extract data from HTML and XML files. Generally, a web page is an HTML document, and we can use the Python beautiful soup to extract links from that web page.

Use the following command to install beautiful soup
pip install beautifulsoup4
3. csv
csv modules come with Python, and we can write, read and append between .csv files using this module.

4. datetime
datetime is also an inbuilt Python module that can deal with date and time.

Program

Now let’s use all these 4 Python modules and write a Program that can tell all the internal and external links of a web page and export that data into a .csv file.

I have divided this program into three functions to make it modular.

Function 1: requestMaker(url)

The requestMake(url) function accepts the url as a string and sends a get request to the url using the .get() method.
After making the request, inside the requestMaker() function, I collected the response web page HTML content and the url using the .text and .url properties.
And called the parseLinks(pageHtml, pageUrl) function.

#to make the HTTP request to the give url
def requestMaker(url):
    try:
        #make the get request to the url
        response = requests.get(url)

        #if the request is successful
        if response.status_code in range(200, 300):
            #extract the page html content for parsing the links
            pageHtml = response.text
            pageUrl = response.url

            #call the parseLink function
            parseLinks(pageHtml, pageUrl)

        else:
            print("Sorry Could not fetch the result status code {response.status_code}!")

    except:
        print(f"Could Not Connect to url {url}")

Function 2: parseLinks(pageHtml, pageUrl)

The parseLinks() function accept the pageHtml and pageUrl as string, and parse the pageHTML string using the BeautiulSoup module with HTML parser as a soup object. And with the soup object we collected a list of all the <a> tags present in the HTML page using the .find_all('a') method.
Then inside the parseLinks() function I have called the extIntLinks(allLinks, pageUrl) function.

#parse all the links from the web page
def parseLinks(pageHtml, pageUrl):
    soup = BeautifulSoup(pageHtml, 'html.parser')

    #get all the <a> elements from the HTML page
    allLinks = soup.find_all('a')

    extIntLinks(allLinks, pageUrl)

Function 3: extIntLinks(allLinks, pageUrl)

The extIntLinks(allLinks, pageUrl) function does the following things.

Create a unique .csv file name using the datetime module.
Create the unique .csv file in write mode.
Loop through all the extracted <a> links
Check for the internal and external links.
Write the data into the csv file.

def extIntLinks(allLinks, pageUrl):
    #filename 
    currentTime = datetime.datetime.now()
    #create a unique .csv file name using the datetime module
    filename =  f"Links-{currentTime.day}-{currentTime.month}-{currentTime.year} {currentTime.hour}{currentTime.minute}{currentTime.second}.csv"

    with open(filename, 'w', newline='') as csvfile:
        fieldnames = ['Tested Url','Link', 'Type']

        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()

        internalLinks = 0
        externalLinks = 0 

        #go through all the <a> elements list 
        for anchor in allLinks:
            link = anchor.get("href")   #get the link from the <a> element

            #check if the link is internal
            if link.startswith(pageUrl) or link.startswith("/") or link.startswith("#") :
                writer.writerow({'Tested Url':pageUrl,'Link': link, 'Type': 'Internal'})
                internalLinks+=1
            #if the link is external
            else:
                writer.writerow({'Tested Url':pageUrl,'Link': link, 'Type': 'External'})
                externalLinks+=1
        writer = csv.writer(csvfile)
        writer.writerow(["Total Internal Links", f"{internalLinks}", "Total External Links", f"{externalLinks}"])

        print(f"The page {url} has {internalLinks} Internal Link(s) and {externalLinks} External Link(s)")
        print(f"And data has been saved in the {filename}")

The complete Program:

Now we can put the complete program altogether and run it.

import requests
from bs4 import BeautifulSoup
import csv
import datetime 


def extIntLinks(allLinks, pageUrl):
    #filename 
    currentTime = datetime.datetime.now()
    #create a unique .csv file name using the datetime module
    filename =  f"Links-{currentTime.day}-{currentTime.month}-{currentTime.year} {currentTime.hour}{currentTime.minute}{currentTime.second}.csv"

    with open(filename, 'w', newline='') as csvfile:
        fieldnames = ['Tested Url','Link', 'Type']

        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()

        internalLinks = 0
        externalLinks = 0 

        #go through all the <a> elements list 
        for anchor in allLinks:
            link = anchor.get("href")   #get the link from the <a> element

            #check if the link is internal
            if link.startswith(pageUrl) or link.startswith("/") or link.startswith("#") :
                writer.writerow({'Tested Url':pageUrl,'Link': link, 'Type': 'Internal'})
                internalLinks+=1
            #if the link is external
            else:
                writer.writerow({'Tested Url':pageUrl,'Link': link, 'Type': 'External'})
                externalLinks+=1
        writer = csv.writer(csvfile)
        writer.writerow(["Total Internal Links", f"{internalLinks}", "Total External Links", f"{externalLinks}"])

        print(f"The page {url} has {internalLinks} Internal Link(s) and {externalLinks} External Link(s)")
        print(f"And data has been saved in the {filename}")


#parse all the links from the web page
def parseLinks(pageHtml, pageUrl):
    soup = BeautifulSoup(pageHtml, 'html.parser')

    #get all the <a> elements from the HTML page
    allLinks = soup.find_all('a')

    extIntLinks(allLinks, pageUrl)

#to make the HTTP request to the give url
def requestMaker(url):
    try:
        #make the get request to the url
        response = requests.get(url)

        #if the request is successful
        if response.status_code in range(200, 300):
            #extract the page html content for parsing the links
            pageHtml = response.text
            pageUrl = response.url

            #call the parseLink function
            parseLinks(pageHtml, pageUrl)

        else:
            print("Sorry Could not fetch the result status code {response.status_code}!")

    except:
        print(f"Could Not Connect to url {url}")



if __name__ == "__main__":
    url = input("Enter the URL eg. https://example.com:  ")
    requestMaker(url)

Output

Enter the URL eg. https://example.com:  https://techgeekbuzz.com
The page https://techgeekbuzz.com has 126 Internal Link(s) and 7 External Link(s)
And data has been saved in the Links-16-7-2022 11644.csv

The CSV File

You can also download the this code from my github

HAPPY CODING!!

Best Python Libraries for Beginners and Intermediate Developers(2022)

Vinay Khatri — Fri, 04 Mar 2022 08:35:00 +0000

With the rapid growth in artificial intelligence and machine learning, Python has gained widespread popularity in the past few years. Its simple syntax helps developers to implement complex algorithms with ease. Python is not only suitable for machine learning and data science, but its huge number of libraries allows you to use Python seamlessly for web development, scripting, game development, and much more. Here in this article, we have mentioned the top 10 Python libraries which are trending among the developer community.

But before discussing the best Python libraries, let's try to understand what a library is all about.

What is a Library?

A library is a collection of pre-written code that you can easily import for adding certain functionality to your project. We use libraries so that we do not have to write code from the scratch. A library allows us to leverage the pre-written code, functions, or classes to enhance the functionality implemented by our code.

Top Python Libraries

Python offers a large number of libraries for different types of development, ranging from web development to machine learning. Here, we have curated a list of the most popular Python libraries used in different areas of development. Also, all the libraries listed ahead are fully compatible with Python 3. We haven't included any library that is exclusively compatible with Python 2 as it is not in use anymore.

Now, let's get familiar with the top Python libraries.

1. Request

Request library is among the most useful Python libraries. Almost every Python web framework uses this library to send HTTP requests to servers. The request library helps us to send organic HTTP requests without any manual intervention.
Request Features

International Domains and URLs.
Comes with Keep-Alive & connection pooling.
Enables sessions with cookie persistence.
Supports browser-style SSL verification.

2. Beautiful Soup

Beautiful Soup library is an ideal choice for developers to scrape information from a web page, make HTTP requests using Beautiful Soup library and Request library, and retrieve data from a web page in the form of HTML or XML.
It can also retrieve API data if API data is present on the web page. This library is easy to use and you can go through its documentation to explore all its capabilities.
Beautiful Soup Features

It can use the API of a website.
It can access the HTML of a web page to extract useful information.

3. Pillow

Developed by Alex Clark and the team, Pillow is a Python Image Library (PIL). This library helps to add support for opening, manipulating, and saving different image file formats. Many Python libraries and frameworks use this library if they need to handle image files
Pillow Features

It is an open-source library.
It can handle any image format.
Allows you to filter images, create thumbnails, and blur images.

4. Pygame

If you want to use Python to develop games, you can use the Pygame library. This library allows you to develop games for the Windows and Linux platforms.
Though this library doesn't support the creation of 3D games, it is a great option for intermediate-level Python developers looking to level up their game development skills.
PyGame Features

It has good documentation.
You can create 2D games.
It is easy to learn and implement.

5. NumPy

NumPy is also one of the most famous Python libraries. If you are an intermediate-level Python developer, you must have heard of this library because it provides one of the most basic Data Structures that every high-level programming language should have.
Python does not have a built-in array Data Structure. NumPy has a Data Structure called list, which looks similar to an array but does not perform all the operations that an array is supposed to do. Apart from the array, it also provides many mathematical functionalities, such as matrix (which is also a part of the array).
NumPy Features

This library has good documentation.
It provides many mathematical functionalities to Python.
It is easy to learn and use.
Comes in handy if you are using Python for Data Science.

6. Pandas

Pandas is a data analysis library used extensively for data science applications. It is an open-source library and is among the most famous Python libraries. Its large global community provides extensive help to individuals who are using this library to create new projects.
This Library is also used to create machine learning models because of its data handling features. Also, it uses high-level structure and many algorithms to analyze the data. Even many developers use Pandas library to sort complex data.
Pandas Features

Offers high performance.
Easy to learn and use.
It has many built-in methods.
Comes with a graphical interface.

7. SciPy

SciPy is similar to NumPy with some distinction. Though NumPy and SciPy both support many common features, we use SciPy when we deal with a large number of data and stats.
Developers highly rely on SciPy if they want to use Python for Data Science. It is an open-source library with huge community support. Basically, SciPy is a collection of many mathematical algorithms that are ideal for solving statistics problems. There are many other libraries available for data science, but SciPy is the simplest amongst them.
SciPy Features

Large community support.
Rapid development.
Simple data science tools.
Easy to get started.

8. Keras

It is an open-source and high-level neural network Python library that is commonly used for developing deep learning algorithms and performing experiments. This library is written in Python itself, which makes it capable of running on top of other machine learning libraries for Python.
Keras also use Theano and TensorFlow at the backend to perform many tasks. The main drawback of Keras is that its speed is a little slow as compared to other machine learning libraries.
Keras Features

It offers many features like compiling models, processing data-sets, visualization of graphs, and much more.
It provides a modular approach for creating artificial neural networks.
Being created using Python itself, it is easy to debug.

9. Theano

It is another powerful Python library for machine learning, deep learning, and data analysis. It offers many mathematical algorithms and also comes with multi-dimensional array support that can be used for handling complex data.
Theano Features

Supports integration with NumPy.
It can perform many complex mathematical functions.
It can evaluate expression faster as compared to other Python machine learning libraries.

10. Scikit-Learn

Scikit-Learn is among the widely used Python library for machine learning and data science. When it comes to managing and processing huge amounts of complex data, many developers consider this library as the ideal option.
This Python library comes with many built-in algorithms and training methods, including regression. Scikit-Learn is built using NumPy, SciPy, and matplotlib libraries and is known for its exceptional data handling power.
Scikit-Learn Features

It has many inbuilt methods for cross-validation.
Allows development of unsupervised learning models.
It also provides a graphical interface to it easier for developers to work with it.

11. Matplotlib

This Python library is used to provide a graphical interface to represent the data. Matplotlib is used with NumPy and SciPy libraries because the main job of this library is to plot 2D graphs for various filtered data.
First, we use the NumPy and SciPy or any other data analysis library to sort the data, and then we use matplotlib to get a proper graphical view of that data. This library helps to analyze the data in a fun way so even non-programmers can also read and interpret the data easily.
Matplotlib Features

It helps to plot a graphical interface for the generated data.
This library is fun to use.
It can plot various kinds of graphs like a bar graph, a pie graph, and more.
This library is very easy to learn.

12. TensorFlow

Machine Learning is not hype anymore, it has become a reality. Also, the future is all about artificial intelligence and machine learning. TensorFlow is the most popular library that is used to build machine learning models.
It is an end-to-end open-source library supported by many programming languages, including Python. It is developed by Google and Google itself use TensorFlow to build their AI models.
TensorFlow can store an algorithm in a cube and array-like structure and perform a tensor operation on them. Even in neural computation, developers use TensorFlow because it is very good with the new algorithms.

TensorFlow Features

It is an open-source library.
With TensorFlow, we can develop ML models easily because it uses high-level APIs.
It can create ML models for different platforms.
TensorFlow comes with a simple and flexible architecture.
It has a large expert community.

Conclusion

In this article, we have mentioned the top Python libraries that are mostly used for data science, artificial intelligence, machine learning, and deep learning. While working on projects, it is essential to choose libraries that not only allow you to add the desired functionalities but also speed up the development process. So, make sure to choose Python libraries having detailed documentation and extensive community support.

Python 3.10 Structural Pattern Matching (Match Case)

Vinay Khatri — Mon, 06 Dec 2021 18:35:59 +0000

After a wait of so many updates, Python has finally introduced a switch-case like structure in its latest 3.10 version. If we talk about other programming languages like, C++, Java, and JavaScript all these three popular programming languages support switch case statement, which is an alternative to write efficient and cleaner conditional statement.
Let's see an example of Switch Case statement in C++

Switch Case Statement in C++

#include <iostream>
using namespace std;

int main() {
    int http = 200;

    switch (http) {
        case  200:
            cout<<"OK";
            break;
        case 201:
            cout<<"CREATED";
            break;
        case 202:
            cout<<"ACCEPTED";
            break;
        case 400:
            cout<<"BAD REQUEST";
            break;
        case 404:
            cout<<"NOT FOUND";
            break;
        case 503:
            cout<<"SERVICE UNAVAILABLE";
            break;
        default:
            cout << "Error! HTTP Code is not valid";
            break;
    }

    return 0;
}

OUTPUT
ok

The above code is very clean example of conditional statement. The switch case comes very handy when we have a conditional operation based on a single data object.

Python Structural Pattern Matching

In Python 3.10, the core developer team of Python introduced a new conditional statement syntax Structural Pattern Matching, which is a similar syntax to the switch case statement present in the other programming languages.

Although Python contain if..else and if...elif...else statements to write conditional statements, but the all new Python Structural Pattern Matching provides a more elegant and legible way to write some conditional statement.

Syntax

match subject:
    case pattern1:
        #case 1 code block
    .....
    ....
    ...
    case patternN:
        #case N code block

Keywords

match is the keyword here.
subject is the value that need to be match.
case is also a keyword
pattern is the value that will be match with subject if any case pattern matches the match subject that case code block will be executed.

Example

http = 200

match http:
    case 200:
        print("OK")
    case 201:
        print("CREATED")
    case 202:
        print("ACCEPTED")
    case 400:
        print("BAD REQUEST")
    case 404:
        print("NOT FOUND")
    case 503:
        print("SERVICE UNAVAILABLE")
    case _:
        print("Error! HTTP Code is not valid")

Output

OK

Conclusion

The new Python match case statement is an alternative of the switch case statement present in the other programming languages. Although the switch case statement provide an elegant way to write conditional statement, still for complex and multilayer conditional statement it is not a good option. It can only be used when the condition expression is a single value.

Python Conditional Statements

Vinay Khatri — Sun, 21 Nov 2021 08:04:49 +0000

Decision-making in any programming language is as significant as it is in our lives. In a programming language, decision-making is determining the order of statements to be executed depending on a specific condition or repeating the execution of statements until a specified condition is met.
Conditional statements are a crucial part of decision-making in programming, and they are also referred to as decision-making statements. They are simple programming language commands that control a program’s execution flow and decide which part of the program should get executed. More precisely, they carry out different actions depending on whether the given condition is true or false.
In this article, we shall discuss different types of Python conditional statements with their syntaxes, flowcharts, and examples. So, without further ado, let us begin.

Python Conditional Statements

Python has five different conditional statements, namely if, if-else, else-if (elif), nested-if, and elif ladder. Let us discuss each of these statements in detail.

1. If Statement

Python ‘if’ statement decides whether to execute certain statements or not. If a condition specified in the ‘if’ statement is true, it executes the code present inside the ‘if’ block; otherwise, it will not. The rest of the code outside the ‘if’ block will be executed, regardless of whether the condition in ‘if’ is true or false.

Syntax:

if (expression):
    statement(s)

Flow chart:

Example:

x, y = 34, 98
If (y>x):
     result = "x is less than y."
      print(result)
print("Welcome to TechGeekBuzz!")

Output:

In the above example, we have taken two variables, x, and y, with values 34 and 98, respectively. We have specified a condition in the ‘if’ statement (y>x).
The statements in the ‘if’ block will be executed only if the given condition evaluates to true. Otherwise, the final print statement will be printed.
As the value of y is greater than x, i.e., 98 > 34, the statements inside the ‘if’ block will be executed, and the result will be:

x is less than y.
Welcome to TechGeekBuzz!

2. If-else Statement

The Python ‘if-else’ statement implies that if the condition specified in ‘if’ evaluates true, then execute the set of code present in the ‘if’ block. Otherwise, execute the set of code present in the ‘else’ block. The rest of the statements outside the ‘if’ and ‘else’ block will be executed.

Syntax:

if (expression):
    statement(s)
else: 
    statement(s)

Flowchart:

Example:

a = 23
if (a > 20):
    print("a is greater than 20.")
else:
    print("a is less than 20.")
print("Welcome to TechGeekBuzz!")

Output:

In the above example, we have taken a variable ‘a’ whose value is 23 and specified a condition (a>20) in the ‘if’ statement.
If the condition in ‘if’ evaluates to true, the statement inside the ‘if’ block will be executed; otherwise, the statement in the ‘else’ block will be executed.
The condition in the ‘if’ statement evaluates to true as 23 is greater than 20. Therefore, the statement in the ‘if’ block will be executed, and the result will be:

a is greater than 20.
Welcome to TechGeekBuzz!

3. Else-If (elif) Statement

We generally use the Python ‘elif’ statement when we need to justify more than two results. This statement enables us to check for multiple conditions. It implies that if the condition in the ‘if’ statement evaluates to false, move to the ‘elif’ statement, evaluate its condition and if it results in false, execute the ‘else’ block.

Syntax:

if (expression):
    statement(s)
elif (expression):
    statement(s)
else:
    statements(s)
```

`

####Flowchart:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rfi6kzk39arb07xs8b0v.png)

####Example:
`

```
n = 5
if (n<0):
    print("n is a negative number")
elif (n==0):
    print("n is zero")
else:
    print("n is a positive number")
print("Welcome to TeckGeekBuzz!")
```

`

####Output:
In this example, we have assigned a value of 5 to a variable ‘n’, and we have to check whether ‘n’ is a negative number, zero, or a positive number.
If the condition in the ‘if’ statement results in true, the statement inside the ‘if’ block will be executed. Otherwise, the condition in the ‘elif’ statement will be checked. If it evaluates to true, the statement inside the ‘elif’ block will be executed. Otherwise, the statement in the ‘else’ block will be executed.
We have specified the condition (n<0) in the ‘if block’, which evaluates to false as n is not less than 0. Therefore, the control flow moves to the ‘elif’ block, having the condition ‘n==0’. This condition also results in false. Finally, the statement in the ‘else’ block is true and thus the last print statement will be executed. The output will be:
`

```
n is a positive number. 
Welcome to TechGeekBuzz!
```

`

###4. Nested if-else Statement
The Python nested if-else statement implies that ‘if’ or ‘else’ statements can have another ‘if’ or ‘if-else’ statement within it. We can check multiple conditions using the nested if-else statement.
####Syntax:
`

```
if (expression):
    if (expression):
        statement(s)
     else:
           statement(s)
else:
     statement(s)
```

`

####Flowchart:
![Nested If else flow chart](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3xn0vuvf6itq3zu71svj.png)

####Example:
`

```
p = 20
if (p>0):
     #First if
    if (p<30):
        print("p is smaller than 30.")

     #Nested if
     #The below 'if' statement gets executed only 
     #if the above one holds true

    if (p<15):
        print("p is smaller than 15 too.")
    else:
        print("p is greater than 15.")
else:
    print("p is a negative number.")
print("Welcome to TechGeekBuzz!")
```

`

####Output:
In this example, we have a variable whose value is 20. The ‘if’ statement has the condition ‘p>0’. If this condition evaluates to true, then the set of code inside the ‘if’ block will be executed. Otherwise, the statement in the ‘else’ block will be executed.
The condition ‘p>0’ holds true, and the set of code inside the ‘if’ block gets executed. This ‘if’ block has ‘nested if’. The control flow moves to the second ‘if’ only in case the condition of the first ‘if’ evaluates to true.
We have the condition ‘p<30’ in the first ‘if’, which holds true, and the statement inside this ‘if’ block gets executed. Now the control flow moves to the second ‘if’ with the condition ‘p<15’, which does not hold true. Finally, the statement in the ‘else’ block gets executed, followed by the last print statement of the program.
The output will be:
`

```
p is smaller than 30. 
p is greater than 15. 
Welcome to TechGeekBuzz!
```

`
###5. Else-if (elif) Ladder
As its name suggests, an elif ladder is a sequence of ‘elif’ statements in a program. It helps us to check multiple conditions. As soon as the condition in any of the ‘elif’ statements evaluates to true, it executes a set of code present in that ‘elif’ block. 
####Syntax:
`

```
if (expression):
    statement(s)
elif (expression): 
    statements(s)
elif (expression):
    statement(s)
.
.
.
else: 
    statement(s)
```

`

####Flowchart:
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gs6eym4y5jbjvy2ivs0p.png)

####Example:
`

```
marks = 95
if (marks<35): 
    print("Fail")
elif (marks>35 and marks<60):
    print("Second Class")
elif (marks>60 and marks<80):
    print("First Class")
else:
    print("Distinction")
```

`
####Output:
Here, we have a variable ‘marks’ with a value of 95. The ‘if’ statement has the condition ‘marks<35’, which does not hold true, therefore, the control flow moves to the first ‘elif’ statement, having the condition ‘marks>35 and marks<60’. As the value of marks is 95, the condition of the first elif statement evaluates to false.
Now, the condition of the second ‘elif’ statement, ‘marks>60 and marks<80’, is checked, which does not hold true. Finally, the statement in the ‘else’ block gets executed, and the result will be:
`

```
Distinction
```

`

###6. Shorthand if and if-else Statements
We can use shorthand if and if-else statements when there is a single line of code to execute in ‘if’ or ‘else’ blocks.
####Syntax of Shorthand if:
`

```
If condition: statement
```

`

####Example of Shorthand if:
`

```
i = 10
If i<20:
    print("i is less than 20.")

```

`
####Output:
`

```
i is less than 20. 
```

`

####Syntax of Shorthand if-else:
`

```
statement_when_True if condition else statement_when_False
```

`

####Example of Shorthand if-else:
`

```
i = 20
print(True) if i<15 else print(False)
```

`

####Output:
`

```
False
```

`

###Conclusion
This is all about Python conditional statements. We have covered five different types of Python conditional statements. These statements control the execution of a program. The only thing to remember while using Python conditional statements is to use indentation properly.
We use the ‘if’ statement to execute a block of code when the condition evaluates to true. If the condition in ‘if’ fails, we execute the code specified in the ‘else’ block. When there are multiple possibilities as an outcome, or we need to check for multiple conditions, we use the ‘elif’ statement. We can add as many ‘elif’ statements depending upon the number of conditions, and hence it forms an elif ladder.