Difference between labeled and unlabeled break statements in Java with examples for loops, switch blocks, and nested loops.

The break statement in Java is used to terminate the execution of a loop or a switch block. Most developers are familiar with the basic unlabeled form - you hit a condition, you break out. But Java also supports a labeled variant that lets you break out of a specific outer loop in nested structures.

In this article, we will explore both forms with examples and compare when to use each.

Unlabeled Break Statement

An unlabeled break terminates the innermost for, while, do-while, or switch statement that encloses it. Control transfers to the first statement after the terminated block.

Break in a Loop

Example-1:

public class UnlabeledBreakLoop {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};

        for (int num : numbers) {
            if (num == 30) {
                System.out.println("Found 30, breaking out of loop");
                break;
            }
            System.out.println("Current number: " + num);
        }

        System.out.println("Loop ended");
    }
}

Output:
Current number: 10
Current number: 20
Found 30, breaking out of loop
Loop ended

The loop iterates through the array and terminates as soon as it encounters the value 30. The remaining elements ( 40, 50) are never processed.

Break in a Switch Statement

Example-2:

public class UnlabeledBreakSwitch {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            default:
                System.out.println("Other day");
                break;
        }
    }
}

Output:
Wednesday

Without the break statements, execution would "fall through" to subsequent cases. For instance, removing the break after case 3 would print both "Wednesday" and "Thursday".

Labeled Break Statement

A labeled break terminates an outer loop that is marked with a label. The label is an identifier followed by a colon (e.g., outerLoop:), placed before the loop statement.

This is particularly useful in nested loops where an unlabeled break would only exit the inner loop.

Syntax

labelName:
for (...) {
    for (...) {
        if (condition) {
            break labelName;  // exits the outer loop
        }
    }
}

Breaking Out of Nested Loops

Example-1:

public class LabeledBreakNested {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        int target = 5;
        boolean found = false;

        search:
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.println("Checking matrix[" + i + "][" + j + "] = " + matrix[i][j]);
                if (matrix[i][j] == target) {
                    found = true;
                    System.out.println("Found " + target + " at position [" + i + "][" + j + "]");
                    break search;
                }
            }
        }

        if (!found) {
            System.out.println("Target not found");
        }
    }
}

Output:
Checking matrix[0][0] = 1
Checking matrix[0][1] = 2
Checking matrix[0][2] = 3
Checking matrix[1][0] = 4
Checking matrix[1][1] = 5
Found 5 at position [1][1]

The break search statement exits both the inner and outer loops as soon as the target is found. Without the label, only the inner loop would terminate, and the outer loop would continue iterating through the remaining rows unnecessarily.

Labeled Break with While Loops

Labels are not limited to for loops — they work with while and do-while as well.

Example-2:

public class LabeledBreakWhile {
    public static void main(String[] args) {
        int i = 0;

        outer:
        while (i < 3) {
            int j = 0;
            while (j < 3) {
                if (i == 1 && j == 1) {
                    System.out.println("Breaking at i=" + i + ", j=" + j);
                    break outer;
                }
                System.out.println("i=" + i + ", j=" + j);
                j++;
            }
            i++;
        }

        System.out.println("Done");
    }
}

Output:
i=0, j=0
i=0, j=1
i=0, j=2
i=1, j=0
Breaking at i=1, j=1
Done

Without a Labeled Break

To appreciate what labeled breaks give you, consider the same nested-loop search without one. You’d typically use a boolean flag:

boolean found = false;

for (int i = 0; i < matrix.length && !found; i++) {
    for (int j = 0; j < matrix[i].length && !found; j++) {
        if (matrix[i][j] == target) {
            found = true;
            System.out.println("Found " + target + " at [" + i + "][" + j + "]");
        }
    }
}

This works, but the flag check clutters both loop conditions. The labeled break version is more direct and easier to read.

Comparison

When to Use Each

Use an unlabeled break for the common cases — exiting a single loop when a condition is met, or preventing fall-through in switch blocks.

Use a labeled break when you have nested loops and need to exit more than just the innermost one. The classic scenario is searching through a multi-dimensional structure. That said, if the nested logic is complex, extracting it into a separate method and using return is often cleaner than a labeled break.

Conclusion

In this article, we explored the difference between labeled and unlabeled break statements in Java. The unlabeled form handles the majority of cases - terminating a single loop or switch block. The labeled form fills a specific gap: cleanly exiting nested loops without resorting to flag variables. Both are simple tools, but knowing when to reach for each one can make your loop logic noticeably cleaner.

References

• The break Statement — Oracle Java Tutorials
• Java Language Specification — break Statements

Let’s Connect

• LinkedIn: https://www.linkedin.com/in/jimit105/
• GitHub: https://github.com/jimit105
• Substack: https://jimit105.substack.com

Labeled vs Unlabeled Break Statements in Java was originally published in Geek Culture on Medium, where people are continuing the conversation by highlighting and responding to this story.

A guide to integrating Firestore database with Angular applications

In this short article, we will walk through the process of setting up a Remote Firebase Database i.e. Firestore with an Angular Application.

I will divide this guide into 2 sections as follows:

1. Creating a project on Firebase
2. Integrating Firebase with Angular Application

Section 1: Creating a project on Firebase

First, go to Firebase Console

Then, select “Add Project” and give a name to the project.

Once the project is created on Firebase, select “Web” from the options to add Firebase to your Angular Application as shown in the below screenshot, give a nickname for your app, and then click “Register app”.

Section 2: Integrating Firebase with Angular Application

Now, go to your Angular app, open the terminal, and run the following command to install Firebase SDK.

npm install firebase

After installing the SDK, copy the Firebase configuration details (as shown on the console) and paste them into the environment.ts file, as shown below:

export const environment = {
  production: false,
  firebase: {
    apiKey: "xxxxxxxxx",
    authDomain: "angular-demo-1234a.firebaseapp.com",
    projectId: "angular-demo-1234a",
    storageBucket: "angular-demo-1234a.appspot.com",
    messagingSenderId: "xxxxxxxxxx",
    appId: "1:xxxxxxxxxx:web:dexxxxxxyyyxxx"
  }
};

The next step is to install AngularFire using the following command:

ng add @angular/fire

If you receive an Authentication error that asks you to enter an authorization code, then follow the steps given in this post to receive the authorization code.

After running the ng add @angular/fire command, select the features you would like to add to your application. Eg. ng deploy --hosting, Authentication, Firestore, Realtime Database.

Select the account associated with your Firebase application and the project created on Firebase.

The associated configuration and code changes will be automatically made in the Angular application code.

Now, go to app.module.ts and import the following:

import { FIREBASE_OPTIONS } from '@angular/fire/compat';

and make the following changes in the providers:

providers: [
  {provide: FIREBASE_OPTIONS, useValue: environment.firebase}
]

Now, your application is ready to use the Firestore database with Angular Applications.

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

Connect with me

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

How to integrate Firebase with Angular Applications? was originally published in Geek Culture on Medium, where people are continuing the conversation by highlighting and responding to this story.

A guide to monitoring Flask, FastAPI, and Python Applications

What is Elastic APM?

Elastic APM is an application performance monitoring system built on the Elastic Stack. It allows you to monitor software services and applications in real-time, by collecting detailed performance information on response time for incoming requests, database queries, calls to caches, external HTTP requests, and more. This makes it easy to pinpoint and fix performance problems quickly.

Elastic APM also automatically collects unhandled errors and exceptions. Errors are grouped based primarily on the stacktrace, so you can identify new errors as they appear and keep an eye on how many times specific errors happen.

-Elastic

This article consists of three parts:

1. Monitoring Flask / Flask-RESTPlus Applications
2. Monitoring FastAPI Applications
3. Monitoring Python Applications

Monitoring Flask / Flask-RESTPlus Applications

Installation

Elastic APM has built-in support for Flask. Since Flask-RESTPlus and Flask-RESTful are extensions for Flask, the same steps apply for Flask-RESTPlus as well as Flask-RESTful.

Install Elastic APM agent using pip:

pip install elastic-apm[flask]

Implementation

Let’s first import the required packages:

from flask import Flask

from elasticapm.contrib.flask import ElasticAPM
import elasticapm

Now, let's create an instance of Flask, which will be our WSGI application.

app = Flask(__name__)

We can initialize the APM agent by using either environment variables or our application code itself. In this article, we will initialize the APM agent in our code itself.

To create an instance of Elastic APM agent, we need the following parameters:

server_url → The URL of the Elastic APM

service_name → Name of the application

environment → The environment in which the application is running e.g. dev, qa, or prod

server_url = 'http://localhost:8200'
service_name = 'DemoFlask'
environment = 'dev'

Next, we will initialize the APM Agent.
We need to pass the Flask instance app as the first argument for initializing the APM agent, along with the parameters that we defined above.

apm = ElasticAPM(app, server_url=server_url, 
      service_name=service_name, environment=environment)

Our APM agent is now ready.

Now, let’s open Kibana (e.g. http://localhost:5601/) to see the logged data.

Open the Kibana dashboard and go to the APM tab. You can see our service DemoFlask listed there.

Click on the service name and go to Metrics, where you can track the CPU and Memory Usage.

In the transactions tab, you can see the visualization related to each request your application receives, such as Transaction duration and Requests per minute.

You can also view the list of all the endpoints along with their average duration.

Click on a transaction to see more details about the transaction.

You can also add additional information about the transaction by using labels.

elasticapm.label(platform='DemoPlatform')

To add default labels to all transactions, we can use Flask’s app.before_request decorator.

@app.before_request
def apm_log():
    elasticapm.label(platform = 'DemoPlatform',                     
                     application = 'DemoApplication')

The information of the labels will be visible in the metadata tab in the trace sample of the transaction.

Note that, by default, the transaction and error data will be recorded only when the application is not in debug mode.

The sample code can be found in the link mentioned in the Resources section.

Monitoring FastAPI Applications

To monitor FastAPI/Starlette Applications properly using Elastic APM, you need to use Python 3.7+

Installation

Install the Elastic APM agent using pip:

pip install elastic-apm

Implementation

First, let’s import the required packages:

import uvicorn
from fastapi import FastAPI
from elasticapm.contrib.starlette import make_apm_client, ElasticAPM

Next, we will create an APM client using the SERVICE_NAME , SERVER_URL and ENVIRONMENT. Also, we will specify the global labels at the same time using GLOBAL_LABELS.

apm_config = {
 'SERVICE_NAME': 'DemoFastAPI',
 'SERVER_URL': 'http://localhost:8200',
 'ENVIRONMENT': 'dev',
 'GLOBAL_LABELS': 'platform=DemoPlatform, application=DemoApplication'
}
apm = make_apm_client(apm_config)

Now, let’s initialize the Elastic APM agent.

app = FastAPI()
app.add_middleware(ElasticAPM, client=apm)

The FastAPI application is now ready to send the logs to Elastic Server.

The sample code can be found in the link mentioned in the Resources section.

Monitoring Python Applications

We can create an Elastic APM Client to monitor Python applications that do not use a framework (e.g. Flask, Django, or FastAPI). An example of these applications could be schedulable code.

Installation

Install Elastic APM agent using pip:

pip install elastic-apm

Implementation

First, we will create an Elastic APM Client

from elasticapm import Client
import elasticapm
client = Client(
    {'SERVICE_NAME': 'DemoPython',
     'SERVER_URL': 'http://localhost:8200',
     'ENVIRONMENT': 'dev'}
)

For frameworks like Flask and FastAPI, Elastic APM automatically instruments the application and also begins and ends the transactions.

However, for Python applications that do not use such frameworks, we need to manually instrument the application and also begin and end the transactions.

To automatically instrument your application to capture HTTP requests, database queries, etc., add the following line

elasticapm.instrumentation.control.instrument()

To begin a transaction, use begin_transaction method with the appropriate transaction type as the parameter.

For example,

client.begin_transaction('schedule')

To complete a transaction, use the end_transaction method which takes two arguments viz. transaction name and result.

For example,

client.end_transaction('demo-transaction', 'success')

The sample code for monitoring Python applications can be found in the link mentioned in the Resources section.

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

Resources

All the code snippets of this article are available on my GitHub page.

References

• https://www.elastic.co/guide/en/apm/agent/python/current/configuration.html
• https://www.elastic.co/guide/en/apm/agent/python/current/flask-support.html
• https://www.elastic.co/guide/en/apm/get-started/7.4/metadata.html
• https://www.elastic.co/guide/en/apm/agent/python/current/starlette-support.html

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Differ | Twitch
• Check out CoFeed, the smart way to stay up-to-date with the latest in tech 🧪
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

Monitoring Python Applications with Elastic APM was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction to Kafka DLQ and its implementation in Python

Dead Letter Queue is a secondary Kafka topic that receives the messages which the Kafka Consumer failed to process due to certain errors like improper deserialization of messages, improper message format, etc.

Installation

There are various libraries in Python that can be used to connect to Kafka Cluster. Some of them are:

1. kafka-python
2. confluent-kafka
3. PyKafka

I’ll be using kafka-python to connect to Kafka Cluster and to create Kafka Producer and Consumer Clients.

Install kafka-python using pip:

pip install kafka-python

Implementation

We will first import the necessary packages and define the bootstrap servers, primary topic name, and DLQ topic name to create instances of Kafka Producer and Consumer.

from kafka import KafkaProducer, KafkaConsumer
import json
bootstrap_servers = ['localhost:9092']
primary_topic = 'primary-topic-name'
dlq_topic = 'dlq-topic-name'

Now, let's create a Producer for the DLQ Topic, where the malformed messages will be sent.

dlq_producer = KafkaProducer(
    bootstrap_servers=bootstrap_servers,
    value_serializer=lambda x: x.encode('utf-8'),
    acks='all'
)

Next, we will create Kafka Consumer to consume the messages from the primary topic.

consumer = KafkaConsumer(
    primary_topic,
    bootstrap_servers=bootstrap_servers,
    auto_offset_reset='latest',
    enable_auto_commit=True,
    value_deserializer=lambda x: x.decode('utf-8')
)

Now, we will enclose our code in the try-except block. If the message received is not in JSON format or any exception occurs, then the message will be sent to the DLQ topic.

for msg in consumer:
    print(f'\nReceived:\nPartition: {msg.partition} \tOffset: {msg.offset}\tValue: {msg.value}')
    
    try:
        data = json.loads(msg.value)
        print('Data Received:', data)
            
    except:
        print(f'Value {msg.value} not in JSON format')
        dlq_producer.send(dlq_topic, value=msg.value)
        print('Message sent to DLQ Topic')

Conclusion

Creating a DLQ topic helps to identify the malformed messages without disturbing other messages. DLQ topic also helps us to analyze the malformed messages and can be used for reporting purposes.

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

Resources

The code snippets of this article are available on my GitHub page.

Reference

• https://kafka-python.readthedocs.io/en/master/install.html

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

Dead Letter Queue (DLQ) in Kafka was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Different ways to merge Python dictionaries along with the new operators in Python 3.9

In Python, a dictionary is a data structure that contains elements in the form of a key-value pair where keys are used to access the values of the dictionary. Python dictionaries are unordered and mutable i.e. the elements of the dictionaries can be changed.

In this article, we will explore five different ways to merge two or more dictionaries, along with a crude way.

For this article, let us create two dictionaries d1 and d2 which we want to concatenate into a single dictionary:

d1 = {'India': 'Delhi',
      'Canada': 'Ottawa',
      'United States': 'Washington D. C.'}

d2 = {'France': 'Paris',
      'Malaysia': 'Kuala Lumpur'}

The Crude Way

You can merge two dictionaries by iterating over the key-value pairs of the second dictionary with the first one.

d3 = d1.copy()
for key, value in d2.items():
    d3[key] = value
    
print(d3)

Output:

{'India': 'Delhi',
 'Canada': 'Ottawa',
 'United States': 'Washington D. C.',
 'France': 'Paris',
 'Malaysia': 'Kuala Lumpur'}

Now, let us see cleaner and better ways of merging the dictionaries:

Method 1: Using the update method

Dictionary has a method update() which merges the dictionary with the items from the other dictionary in place and overwrites existing keys.

d4 = d1.copy()
d4.update(d2)

print(d4)

Output:
{'India': 'Delhi',
 'Canada': 'Ottawa',
 'United States': 'Washington D. C.',
 'France': 'Paris',
 'Malaysia': 'Kuala Lumpur'}

The update method modifies the current dictionary. So you might want to create a copy of the dictionary before operating on the dictionary.

Method 2: Using the unpacking operator

We can merge dictionaries in one line by simply using the unpacking operator (**).

d5 = {**d1, **d2}

print(d5)

Output:
{'India': 'Delhi',
 'Canada': 'Ottawa',
 'United States': 'Washington D. C.',
 'France': 'Paris',
 'Malaysia': 'Kuala Lumpur'}

We can also merge multiple dictionaries using this method.

{**dict1, **dict2, **dict3}

Method 3: Using collections.ChainMap

This is, perhaps, the least known method to merge dictionaries.
ChainMap class from the Collections module groups multiple dictionaries in a single view.

from collections import ChainMap
d6 = ChainMap(d1, d2)

print(d6)

Output:
ChainMap({'Canada': 'Ottawa',
          'India': 'Delhi',
          'United States': 'Washington D. C.'},
         {'France': 'Paris',
          'Malaysia': 'Kuala Lumpur'})

This method returns an object of the ChainMap class. We can, still, use this object as we would use any other dictionary. e.g. d6[’India’] will return 'Delhi’.

However, in the case of the same keys in two dictionaries, this method will return the value of the first dictionary, unlike the other methods which return the value from the second dictionary.

x = {'A': 1, 'B': 2}
y = {'B': 10, 'C': 20}

z = ChainMap(x, y)
z['B']

# outputs 2

Method 4: Unpacking the second dictionary

We can merge the dictionaries by unpacking the second dictionary.

d7 = dict(d1, **d2)

print(d7)

Output:
{'India': 'Delhi',
 'Canada': 'Ottawa',
 'United States': 'Washington D. C.',
 'France': 'Paris',
 'Malaysia': 'Kuala Lumpur'}

However, this method only works if the keys of the second dictionary are strings.

x = {1: 'A', 2: 'B'}
y = {3: 'C', 4: 'D'}

z = dict(x, **y)

Output:
TypeError: keyword arguments must be strings

Method 5: Using the merge operator

Python 3.9 has introduced the merge operator (|) in the dict class.
Using the merge operator, we can combine dictionaries in a single line of code.

d8 = d1 | d2

print(d8)

Output:
{'India': 'Delhi',
 'Canada': 'Ottawa',
 'United States': 'Washington D. C.',
 'France': 'Paris',
 'Malaysia': 'Kuala Lumpur'}

We can also merge the dictionaries in place by using the update operator (|=).

d1 |= d2

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

Resources

The code snippets used in this article can be found on my GitHub page.

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Differ | Twitch
• Check out CoFeed, the smart way to stay up-to-date with the latest in tech 🧪
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

5 Ways to Merge Dictionaries in Python was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

How to log messages in Python and avoid print statements?

Logging is, perhaps, the most underrated aspect of any software development. Logging helps to develop robust programs by recording the events of the program. Logging is used for various purposes — from debugging to monitoring the application.

Python’s standard library provides a module for logging. In this article, I will show you how to add logging to your programs and develop better applications.

To use logging in your applications, import the logging module

import logging

Logging Levels

The logging module comes predefined with 5 levels of severity which are as follows:

┌──────────┬───────┐
│  Level   │ Value │
├──────────┼───────┤
│ CRITICAL │    50 │
│ ERROR    │    40 │
│ WARNING  │    30 │
│ INFO     │    20 │
│ DEBUG    │    10 │
└──────────┴───────┘

The default level is WARNING, which means only the events of this level and above will be logged.

The logging module provides a set of functions for simple usage. These are shown in the example below:

import logging

logging.debug('Debug message')
logging.info('Info message')
logging.warning('Warning message')
logging.error('Error message')
logging.critical('Critical message')

The output of the above example will be:

WARNING:root:Warning message
ERROR:root:Error message
CRITICAL:root:Critical message

This is because the default logging level is set to WARNING.

Change Logging Level

The logging module provides a function to set the basic configuration for the logger.

To change the level of the logger, pass the level argument for basicConfig() .

Example:

import logging

logging.basicConfig(level=logging.INFO)

logging.debug('Debug message')
logging.info('Info message')
logging.error('Error message')

The output of the above example would be:

INFO:root:Info message
ERROR:root:Error message

In this example, the logging level is set to INFO. So the ‘Info message’ will be logged but the ‘Debug message’ won’t be logged since the level of INFO is greater than DEBUG.

Log to a file

To log the messages to a file, simply pass the name of the file in the filename parameter of the basicConfig()

Example:

import logging

logging.basicConfig(filename='sample.log', level=logging.INFO)

logging.debug('Debug message')
logging.info('Info message')
logging.error('Error message')

The contents of the file would be:

INFO:root:Info message
ERROR:root:Error message

Change logging Format

The default logging format is %(levelname)s:%(name):%(message)s.

To change the default format, we need to specify the format parameter in the basicConfig().

Example:

FORMAT = '%(asctime)s:%(name)s:%(levelname)s - %(message)s'

logging.basicConfig(format=FORMAT, level=logging.INFO)
logging.info('Info message')

The corresponding output would be:

2020-07-03 00:48:00,106:root:INFO - Info message

The complete list of formatting attributes can be found in the official documentation.

Change date format

To change the date format displayed in the logs, we need to change the datefmt parameter.

Example:

FORMAT = '%(asctime)s:%(name)s:%(levelname)s - %(message)s'

logging.basicConfig(format=FORMAT, 
                    level=logging.INFO, 
                    datefmt='%Y-%b-%d %X%z')

logging.info('Info message')

Output:

2020-Jul-03 00:56:31+0530:root:INFO - Info message

The list of available date formats can be found in the documentation.

Logging for exceptions

To log the trace of the exception, you can either use logging.exception or use logging.error with exc_info=True.

Example-1: with logging.error

try:
    5/0

except:
    logging.error('Exception occured')

Output-1:

ERROR:root:Exception occured

Example-2: with logging.error and exc_info=True

try:
    5/0

except:
    logging.error('Exception occured', exc_info=True)

Output-2:

ERROR:root:Exception occured
Traceback (most recent call last):
  File "<ipython-input-2-933e0f6b1879>", line 11, in <module>
    5/0
ZeroDivisionError: division by zero

Example-3: with logging.exception

try:
    5/0

except:
    logging.exception('Exception occured')

Output-3:

ERROR:root:Exception occured
Traceback (most recent call last):
  File "<ipython-input-3-e7d1d57e6056>", line 11, in <module>
    5/0
ZeroDivisionError: division by zero

Conclusion

I hope you were able to understand the basics of Logging in Python. Using this article, you can start using logging for any application for various purposes such as debugging, usage monitoring, and performance monitoring. You can refer to the official documentation for the complete list of available methods.

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

Resources

The code snippets used in this article are available on my GitHub page.

References

• https://docs.python.org/3/library/logging.html
• https://docs.python.org/3/howto/logging.html

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

Introduction to Logging in Python was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Exploring various PyTorch Functions

PyTorch is a Machine Learning library with increasing popularity. In this article, we will explore seven functions available in PyTorch.

First, we will import PyTorch using import torch

Function 1: torch.linspace

torch.linspace is used to create a 1D equally spaced tensor between the values start and end . We can specify the size of the tensor with the steps parameters. The default is steps=100

Example-1:

torch.linspace(1, 10)

Output:
tensor([ 1.0000, 1.0909, 1.1818, 1.2727, 1.3636, 1.4545, 1.5455, 1.6364, 1.7273, 1.8182, 1.9091, 2.0000, 2.0909, 2.1818, 2.2727, 2.3636, 2.4545, 2.5455, 2.6364, 2.7273, 2.8182, 2.9091, 3.0000, 3.0909, 3.1818, 3.2727, 3.3636, 3.4545, 3.5455, 3.6364, 3.7273, 3.8182, 3.9091, 4.0000, 4.0909, 4.1818, 4.2727, 4.3636, 4.4545, 4.5455, 4.6364, 4.7273, 4.8182, 4.9091, 5.0000, 5.0909, 5.1818, 5.2727, 5.3636, 5.4545, 5.5455, 5.6364, 5.7273, 5.8182, 5.9091, 6.0000, 6.0909, 6.1818, 6.2727, 6.3636, 6.4545, 6.5455, 6.6364, 6.7273, 6.8182, 6.9091, 7.0000, 7.0909, 7.1818, 7.2727, 7.3636, 7.4545, 7.5455, 7.6364, 7.7273, 7.8182, 7.9091, 8.0000, 8.0909, 8.1818, 8.2727, 8.3636, 8.4545, 8.5455, 8.6364, 8.7273, 8.8182, 8.9091, 9.0000, 9.0909, 9.1818, 9.2727, 9.3636, 9.4545, 9.5455, 9.6364, 9.7273, 9.8182, 9.9091, 10.0000])

Example-2:

torch.linspace(start=1, end=10, steps=5)

Output:
tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])

Function 2: torch.eye

torch.eye returns a 2D tensor with the values of diagonals as 1 and other values as 0
The function expects two parameters — n and m . If m is not specified, then it returns a 2D tensor of size nxn

Example-1:

torch.eye(n=4, m=5)

Output:
tensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.]])

Example-2:

torch.eye(n=3)

Output:
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])

Function 3: torch.full

torch.full returns a tensor of size size with the values filled with fill_value
The size can be a list or a tuple.

Example-1:

torch.full(size=(3,2), fill_value=10)

Output:
tensor([[10., 10.],
        [10., 10.],
        [10., 10.]])

Example-2:

torch.full(size=[2, 3, 4], fill_value=5)

Output:
tensor([[[5., 5., 5., 5.],
         [5., 5., 5., 5.],
         [5., 5., 5., 5.]],

[[5., 5., 5., 5.],
         [5., 5., 5., 5.],
         [5., 5., 5., 5.]]])

Function 4: torch.cat

torch.cat concatenates a sequence of tensors over the specified dimension dim. All the tensors must be of the same shape

Example-1:

a = torch.ones(3,2)
b = torch.zeros(3,2)
torch.cat((a, b)) # default dim=0

Output:
tensor([[1., 1.],
        [1., 1.],
        [1., 1.],
        [0., 0.],
        [0., 0.],
        [0., 0.]])

Example-2:

x = torch.full((3,3), fill_value=4)
y = torch.full((3,3), fill_value=7)
torch.cat((x, y), dim=1)

Output:
tensor([[4., 4., 4., 7., 7., 7.],
        [4., 4., 4., 7., 7., 7.],
        [4., 4., 4., 7., 7., 7.]])

Function 5: torch.take

torch.take returns a tensor with the elements of the input tensors at the given indices. The input tensor is treated as a 1D tensor to return the values.

Example-1:

# 1D input Tensor
b = torch.tensor([10, 20, 30, 40, 50])
torch.take(b, torch.tensor([2]))

Output:
tensor([30])

Example-2:

# 2D input tensor
a = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
torch.take(a, torch.tensor([3,4]))

Output:
tensor([4, 5])

Function 6: torch.unbind

torch.unbind removes a tensor dimension along the given dimension dim
The default dimension is 0 i.e. dim=0

Example-1:

a = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
torch.unbind(a)

Output:
(tensor([1, 2, 3]), tensor([4, 5, 6]))

Example-2:

a = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
torch.unbind(a, dim=1)

Output:
(tensor([1, 4]), tensor([2, 5]), tensor([3, 6]))

Function 7: torch.Tensor.clone

torch.Tensor.clone returns a copy of the tensor with the same size and data type.

When we create a copy of the tensor using x=y , changing one variable also affects the other variable since it points to the same memory location.

For example,

a = torch.tensor([[1., 2.],
                  [3., 4.],
                  [5., 6.]])
b = a
a[1,0]=9
b

Output:
tensor([[1., 2.],
        [9., 4.],
        [5., 6.]])

To avoid this, we can create a deepcopy of the tensor using .clone method.

Example:

a = torch.tensor([[1., 2.],
                  [3., 4.],
                  [5., 6.]])
b = a.clone()
a[1,0]=9
b

Output:
tensor([[1., 2.],
        [3., 4.],
        [5., 6.]])

Conclusion

In this article, we saw the working of seven functions available in PyTorch. Hope this article helped you understand these functions. There are a number of other useful functions. You can refer to the official documentation for the complete list of available functions.

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

References

• https://pytorch.org/docs/stable/torch.html
• https://pytorch.org/docs/stable/tensors.html

Resources

The code snippets used in this article are available on my GitHub Page.

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

7 PyTorch functions for your next Machine Learning project was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Web Scraping using Python and Pandas

Web Scraping is a technique to fetch data from websites. BeautifulSoup and Scrapy are the two widely used libraries in Python to perform Web Scraping. However, working with these libraries can be cumbersome since we need to find the element tags, extract text from them, and then clean the data.

This article will show guide you to an easy way of extracting tabular data using Pandas. Yes! Pandas!

Extracting tables from HTML page

For this tutorial, we will extract the details of the Top 10 Billionaires in the world from this Wikipedia Page.

We will use the read_html method of Pandas library to read the HTML tables.

import pandas as pd

url = 'https://en.wikipedia.org/wiki/The_World%27s_Billionaires'

df_list = pd.read_html(url)

This script returns HTML tables into a list of DataFrame objects.

Let’s check the total number of tables found:

len(df_list)

# Output:
# 32

To access a particular table, simply access that element of the list.
For example, df_list[2] will return the following table:

Set a particular column as an index

We can select a particular column to the index of the table by using the index_col parameter.

Example:

pd.read_html(url, index_col=1)[2]

returns the following table:

Return tables containing a string or regex

We can also specify to return the list of tables containing a particular string or a regular expression by using the match parameter.

Example:

pd.read_html(url, match='Number and combined net worth of billionaires by year')[0].head()

Specify strings to recognize as NA/NaN

We can specify the list of strings to recognize as NA/NaN by using the na_values parameter.

Example:

• without specifying na_values :

pd.read_html(url)[0].tail()

• after specifying na_values :

pd.read_html(
    url, 
    na_values=["Forbes: The World's Billionaires website"]
    )[0].tail()

Other Parameters

• skiprows parameter allows us to skip the starting ‘n’ rows
• header parameter can be used to make the specified row as the column header

Example:

pd.read_html(url, skiprows=3, header=0)[0].head()

Conclusion

In this article, we learned how to easily scrape HTML tables from pages using the read_html method. Also, we learned some of the important parameters which can further help us in scraping the desired table.

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

References

• https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_html.html

Resources

The code snippets used in this article are available on my GitHub page.

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

Scraping Tabular Data with Pandas was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

URL Shortener for GitHub.com using curl and Python

GitHub is the most popular Git repository hosting service for source codes. However, the URLs can get pretty long since we might have long names for repositories and files. Also, it will look messy when we need to share the URLs with others, on email and social networks.

Short URLs look much better when we need to share the projects with colleagues. GitHub has provided a service to turn these long, messy URLs into shorter, cleaner URLs. The answer is git.io.

Git.io is a service provided by GitHub to shorten URLs.

To shorten the URLs, simply go to https://git.io/ and enter your GitHub URL. The URLs can be GitHub repositories and even GitHub Pages URLs.

Note: This URL shortener can only be used for GitHub URLs and not for other URLs.

Shorten URL using curl

To create shortened URL

You can also use the curl command to shorten the URL:

curl -i https://git.io -F "url=GITHUB_URL"

Example:

curl -i https://git.io -F "url=https://github.com/jimit105/Sentiment-Analysis-of-Movie-Reviews-using-NLP"

Output:
Location: https://git.io/JfzQJ

To get a custom shortened URL, pass the custom text with the code parameter

curl -i https://git.io -F "url=GITHUB_URL" -F "code=CUSTOM_TEXT"

Example:

curl -i https://git.io -F "url=https://github.com/jimit105/Intro-to-Deep-Learning-with-PyTorch" -F "code=pytorch"

Output:
Location: https://git.io/pytorch

The shortened URL will appear in the Location field of the response header.

If you get SSL Error, then pass the --insecure flag along with the command to skip certificate verification.

To retrieve the full URL

Use the following command to retrieve the complete URL from the shortened URL:

curl -i SHORTENED-URL

Example:

curl -i https://git.io/JfzQJ

Output:
Location: https://github.com/jimit105/Sentiment-Analysis-of-Movie-Reviews-using-NLP

Shorten URL using Python

You can also use the following Python scripts to shorten the URL and to retrieve the complete URL from the shortened URL

To create shortened URL

import requests

url = 'https://git.io/'
data = {'url': 'https://github.com/jimit105/Intro-to-Deep-Learning-with-PyTorch', 
        'code': 'pytorch'}

r = requests.post(url, data=data)
print(r.headers.get('Location'))

# Output:
# https://git.io/pytorch

If you get SSLError while running the above script, add the parameter verify=False in the requests.post method to skip certificate validation.

To retrieve the full URL

import requests

r = requests.head('https://git.io/pytorch')
print(r.headers.get('Location'))

# Output:
# https://github.com/jimit105/Intro-to-Deep-Learning-with-PyTorch

Note: You can create only one shortened URL for each URL. You cannot create another shortened URL if that GitHub URL has already been shortened. If you try to shorten the same URL again, it will return the existing shortened URL.

Conclusion

In this article, we saw how we can use git.io to shorten GitHub’s URLs. This service is exclusive for GitHub websites i.e. you can only shorten GitHub URLs and not any other. So when you share the shortened URL with others, they can trust that the link will point to a GitHub website (just like g.co is Google’s official URL shortener for Google websites which will take you to a Google product or service).

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

References

• https://github.blog/2011-11-10-git-io-github-url-shortener/

Resources

All the code snippets used in this article are available on my GitHub Page.

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

GitHub URL Shortener was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Building Python APIs with Flask, Flask-RESTPlus / Flask-RESTX, and Swagger UI

How to build an interactive API dashboard in Python?

What is Swagger UI?

Swagger UI is a tool to visualize and interact with APIs which is automatically generated using the OpenAPI specification. It generates a webpage that helps us to document and interact with various APIs.

What is Flask-RESTPlus?

Flask-RESTPlus is an extension for Flask which encourages best practices with minimal setup. It provides a collection of decorators and tools to describe API and expose its documentation using Swagger.

Note: Flask-RESTPlus is no longer maintained. Consider using Flask-RESTX, a fork of Flask-RESTPlus

Installation

You can install Flask-RESTPlus with pip

pip install flask-restplus

Or install Flask-RESTX using pip (recommended):

pip install flask-restx

Minimal API

from flask import Flask
from flask_restplus import Api, Resource

app = Flask(__name__)
api = Api(app)

@api.route('/hello/')
class HelloWorld(Resource):
    def get(self):
        return "Hello World"
    
if __name__ == '__main__':
    app.run()

Note: If you are using Flask-RESTX then change the import from flask_restplus import Api, Resource to from flask_restx import Api, Resource. The rest of the code remains the same.

Save this file as app.py (or any other filename you want), go to the terminal, and type python app.py (i.e. python <filename>.py) to start the program.

If you get the following error while deploying:

from werkzeug import cached_property
ImportError: cannot import name 'cached_property'

Add this line before importing flask_restplus:

import werkzeug
werkzeug.cached_property = werkzeug.utils.cached_property

Now, launch a browser and go to http://localhost:5000 and you should see this screen:

This is the Swagger UI screen. It allows you to view all the endpoints and test the APIs using the Try it out button.

You can also view the contents of the Swagger file by visiting http://localhost:5000/swagger.json. The Swagger file generated for the above code is as follows:

{
    "swagger": "2.0",
    "basePath": "/",
    "paths": {
        "/hello/": {
            "get": {
                "responses": {
                    "200": {
                        "description": "Success"
                    }
                },
                "operationId": "get_hello_world",
                "tags": [
                    "default"
                ]
            }
        }
    },
    "info": {
        "title": "API",
        "version": "1.0"
    },
    "produces": [
        "application/json"
    ],
    "consumes": [
        "application/json"
    ],
    "tags": [
        {
            "name": "default",
            "description": "Default namespace"
        }
    ],
    "responses": {
        "ParseError": {
            "description": "When a mask can't be parsed"
        },
        "MaskError": {
            "description": "When any error occurs on mask"
        }
    }
}

Fetching Request Parameters

You can fetch the parameters passed during the API call using reqparse

from flask import Flask
from flask_restplus import Api, Resource, reqparse

app = Flask(__name__)
api = Api(app)

parser = reqparse.RequestParser()
parser.add_argument('name', help='Specify your name')

@api.route('/hello/')
class HelloWorld(Resource):
    @api.doc(parser=parser)
    def get(self):        
        args = parser.parse_args()
        name = args['name']
        return "Hello " + name
    
if __name__ == '__main__':
    app.run()

In the above code, parser.parse_args() returns a dictionary with the key as the argument's name and value as the value passed in the query.

This generates the Swagger UI as below:

Click on the Try it out button to check the API. It will result in the following output:

File Upload

To use File Upload, set the location to files and type to FileStorage

from flask import Flask
from flask_restplus import Api, Resource
from werkzeug.datastructures import FileStorage

app = Flask(__name__)
api = Api(app)

upload_parser = api.parser()
upload_parser.add_argument('file', 
                           location='files',
                           type=FileStorage)

@api.route('/upload/')
@api.expect(upload_parser)
class UploadDemo(Resource):
    def post(self):
        args = upload_parser.parse_args()
        file = args.get('file')
        print(file.filename)
        return "Uploaded file is " + file.filename

if __name__ == '__main__':
    app.run()

The Swagger UI generated for the above code will be as follows:

API parameters

api = Api(app,
          version='10.5',
          title='Flask Restplus Demo',
          description='Demo to show various API parameters',
          license='MIT',
          contact='Jimit Dholakia',
          contact_url='https://in.linkedin.com/in/jimit105',
          doc = '/docs/',
          prefix='/test'
          )

version → API Version (for Swagger Documentation)

title → API title (for Swagger Documentation)

description → API Description (for Swagger Documentation)

license → Specify License for the API (for Swagger Documentation)

license_url → Specify the License page URL (for Swagger Documentation)

contact → Specify contact person (for Swagger Documentation)

contact_email → Specify the email address of contact person (for Swagger Documentation)

contact_url → Specify URL to contact person (for Swagger Documentation)

doc → Specify the path for Swagger UI Documentation. Defaults to '/'

prefix → Specify a prefix for all endpoints of the URL

The Swagger UI generated for the above code is as follows:

Subscribe to my newsletter: https://jimit105.medium.com/subscribe

References

• https://flask-restplus.readthedocs.io/en/stable/
• https://flask-restplus.readthedocs.io/en/stable/index.html
• https://flask-restx.readthedocs.io/en/latest/index.html

Resources

All the code snippets of this article are available on my GitHub Page.

Suggested Reading

Creating RESTful Web APIs using Flask and Python

Let’s Connect

LinkedIn: https://www.linkedin.com/in/jimit105/
GitHub: https://github.com/jimit105
Twitter: https://twitter.com/jimit105

Building Python APIs with Flask, Flask-RESTPlus and Swagger UI was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.