Forem: Tabish Javed

Pythonic Python: Best Code Practices

Tabish Javed — Sun, 23 Jul 2023 17:27:41 +0000

Who doesn't love Python? It's easy to write code in Python and it does a lot of the work for you. However, there are several practices that we should follow to improve code readability and performance.

1. Pythonic conditions

Python provides a lot of ease in writing conditions. We are often used to other languages that require long conditions, so we end up doing it here.
Consider the following lines of code.

# Non-Pythonic
if condition:
    x = 10
else:
    x = 5

# Pythonic
x = 10 if condition else 5

This improves the appearance of your code and makes full use of Python's capabilities.

2. Use zip()

The zip function in Python combines multiple iterables (e.g., lists, tuples, or strings) element-wise into a new iterable of tuples. Each tuple contains the corresponding elements from all the input iterables.
It stops when the shortest iterable is exhausted. Here's an example!

items = ['milk', 'banana', 'yoghurt']
quantities = [1, 12, 2]
prices = [1.5, 0.8, 1.8]

combined = zip(items, quantities, prices)
print(list(combined))

[('milk', 1, 1.5), ('banana', 12, 0.8), ('yogurt', 2, 1.8)]

3. Look for built-in functions

You'll be surprised that there's built-in functionality for almost everything in Python. Whether it's to find min, max, or to reverse and sort an iterable, you don't need to write nested loops! Just do a quick Google search to see if an easy way out exists.

4. Use default and keyword arguments

You can define default values for function parameters, so if a user doesn't provide a value for that parameter, the default will be used.
Here's an example.

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")      
greet("Bob", "Hi")

Similarly, for keyword arguments, instead of relying on their order, you can pass arguments by their names, making the function call more explicit and easier to understand.

def calculate_interest(principal, rate, time):
    return principal * rate * time / 100

# Calling the function using positional arguments
interest1 = calculate_interest(1000, 5, 3)

# Calling the function using keyword arguments
interest2 = calculate_interest(principal=1000, rate=5, time=3)

5. Use PEP 8

Last but not least, follow pep-8 conventions. PEP 8 is the official style guide for Python programming, offering recommendations and best practices for well-structured Python code.
Key aspects covered by PEP 8 include guidelines on indentation, line length, variable and function naming conventions, import statements, and more.
You can read more about it here
Certain libraries can help you follow these conventions. Some famous ones are:

isort (sorts imports in required order)
pylint (checks for errors and suggest good practices)

Introduction to Jinja Template

Tabish Javed — Sun, 23 Jul 2023 17:22:26 +0000

Introduction

Jinja template is the most popular template engine for Flask and Django frameworks. It is used to make the templates in these frameworks dynamic and separate the backend from the frontend layer.

Installation

pip install jinja2

Variables

In case of showing the value of a variable in the HTML code, we can use the following format.

<h1>Hello, {{ name }}!</h1>

Expressions

Expressions can be evaluated in the HTML code and displayed using the following approach.

<p>{{ 2 + 2 }}</p>
<p>{{ 'Hello ' + 'World' }}</p>
<p>{{ 10 > 5 }}</p>

Conditional Statements

You can add conditional statements and use them to display HTML code based on conditions being true or false.

{% if user %}
  <p>Hello, {{ user }}!</p>
{% else %}
  <p>Hello, Guest!</p>
{% endif %}

Loops

Loops can be used in Jinja template to iterate through collections/lists of values and dynamically generate the elements as many times as required.

<ul>
  {% for fruit in fruits %}
    <li>{{ fruit }}</li>
  {% endfor %}
</ul>

Inheritance

It is also possible to inherit the code from other templates and add additional code to it removing redundancy.

The following is a code which is base HTML code which can be inherited by all the files. We have created two blocks title and content and these will be replaced by HTML code of the files inheriting this base HTML.

# Base Template: templates/base.html
<!DOCTYPE html>
<html>
<head>
  <title>{% block title %}{% endblock %}</title>
</head>
<body>
  <main>
    {% block content %}{% endblock %}
  </main>
</body>
</html>

In the following code, the title block gets text Home Page and the content block gets an HTML code.

{% extends "base.html" %}

{% block title %}Home Page{% endblock %}

{% block content %}
  <h1>Welcome to our website!</h1>
  <p>Content goes here...</p>
{% endblock %}

Handle form input in Flask

Tabish Javed — Sun, 16 Jul 2023 05:35:32 +0000

Flask is an easy-to-use web framework that follows an MVC architecture to develop web applications. It is popular because it is very easy to use and flexible allowing rapid development.

This is a guide to making a basic frontend and sending the response to the Flask API ultimately saving it in a database.

HTML Frontend

Let's begin by creating a simple frontend where our users can enter their name, age, and hobby.

<!DOCTYPE html>
<html>
<head>
  <title>User Form</title>
</head>
<body>
  <h2>User Input Form</h2>
  <form action="/submit" method="post">
    <label for="name">Name:</label>
    <input type="text" id="name" name="name" required><br><br>

    <label for="age">Age:</label>
    <input type="number" id="age" name="age" required><br><br>

    <label for="hobby">Hobby:</label>
    <input type="text" id="hobby" name="hobby" required><br><br>

    <input type="submit" value="Submit">
  </form>
</body>
</html>

It is a simple HTML form that submits to a route '/submit' and it contains three input tags in HTML that will help get the input from the user.

Flask Backend

Now we shall begin writing our flask API where we will handle this request from frontend.

from flask import Flask, render_template, request

app = Flask(__name__)

@app.route('/submit', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        name = request.form['name']
        age = request.form['age']
        hobby = request.form['hobby']

        return 'User data saved successfully!'
    return render_template('index.html')

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

In this flask API, we have set the route information at the top of the method to '/submit' where the form is submitted and allowed the method to have to get and post requests both.

In the API, request.form can be used to access the values of the input tags in the form. The values are accessed by the value of the name attribute assigned in the input tag.

Connect database

The last step is to save these values in a database table. Lets connect to a database and perform the insert operation.

from flask import Flask, render_template, request
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))
    age = db.Column(db.Integer)
    hobby = db.Column(db.String(100))

    def __init__(self, name, age, hobby):
        self.name = name
        self.age = age
        self.hobby = hobby

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        name = request.form['name']
        age = request.form['age']
        hobby = request.form['hobby']
        user = User(name=name, age=age, hobby=hobby)
        db.session.add(user)
        db.session.commit()
        return 'User data saved successfully!'
    return render_template('index.html')

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

The User class has modeled as a table for our input request and our data is going to get saved in the SQL lite database. By this, we are done with making a full-stack application.

AsyncIO basics in Python

Tabish Javed — Sun, 09 Jul 2023 16:15:23 +0000

While there are methods that facilitate parallel programming in Python, it is a single-threaded language by default. To avail the full advantage of single-threaded execution, we can make use of the AsyncIO library.

Asynchronous code

As its name suggests, AsyncIO provides asynchronous execution in Python. Asynchronous code runs in a non-blocking way. If a function has a longer wait time, another task can be performed during the waiting period, instead of all the tasks being put on hold.

The following image further explains synchronous vs asynchronous code execution. While waiting for the first response, we can make the second request to better utilize the processing capabilities.

Although it does not make use of multi-threading, it does perform concurrent execution of code and reduces wait time considerably in many cases.

Using AsyncIO

AsyncIO library has two major keywords:
1. async
2. await
We can use the keywords async def to define a coroutine.
The await keyword is used inside an async coroutine to suggest that the program should wait here and execute something else in the meantime.

Take a look at the code below.

import asyncio

async def co_routine(num):
    print('Entered coroutine number : ', num)
    await asyncio.sleep(2)
    print('Exiting coroutine number : ', num)

async def main():
    await asyncio.gather(co_routine(1), 
                         co_routine(2), 
                         co_routine(3))


asyncio.run(main())

Here's the output!

Entered coroutine number :  1
Entered coroutine number :  2
Entered coroutine number :  3
Exiting coroutine number :  1
Exiting coroutine number :  2
Exiting coroutine number :  3

As you can see, we did not have to wait for coroutine 1 to finish executing before moving on to coroutines 2 and 3. Let's see the code step by step.

import asyncio

This imports the asyncio library to your python code.

async def co_routine(num):
    print('Entered coroutine number : ', num)
    await asyncio.sleep(2)
    print('Exiting coroutine number : ', num)

This is our asynchronous coroutine. We define it using the async def keywords. We print a message on entering and then the coroutine sleeps for 2 seconds. This is where the magic happens. The await keywords signals that we have to wait, so the program can execute something else.
An await keyword can only be used inside an async coroutine!

async def main():
    await asyncio.gather(co_routine(1), 
                         co_routine(2), 
                         co_routine(3))

This defines our asynchronous main. asyncio.gather takes multiple coroutine calls and waits for them to execute concurrently before returning. Here, we run our coroutine for values 1, 2, and 3. Since we had to use the await keywords, our main is also defined as async.

However, for our final call, we can use asyncio.run.

asyncio.run(main())

This executes our main without the need to use await.

Now, you can use async/await in the programs you wish to run concurrently.