DEV Community: Zubair Ahmad

Time Complexity and Big O Notation

Zubair Ahmad — Tue, 04 Apr 2023 20:47:55 +0000

Time complexity is an important concept in computer science that refers to the amount of time it takes for an algorithm or program to run as a function of its input size. In this tutorial, I will explore the time complexity of loops, nested loops, if-else statements, and different Python data structures, and discuss which ones are optimized for various use cases.

Time Complexity of Loops

Loops are a common programming construct used to repeat a block of code a certain number of times. The time complexity of a loop depends on the number of times the loop runs as a function of its input size.

Example: Simple for loop

for i in range(n):
    print(i)

The time complexity of this loop is O(n), where n is the input size. This is because the loop runs exactly n times, printing the value of i each time.

Example: Nested for loops

for i in range(n):
    for j in range(n):
        print(i, j)

The time complexity of this loop is O(n^2), because the loop runs n^2 times. This is because for each value of i, the inner loop runs n times, so the total number of iterations is n * n = n^2.

Time Complexity of If-Else Statements

If-else statements are used to conditionally execute code based on a given condition. The time complexity of an if-else statement is typically O(1), as the code will only execute once regardless of the input size.

Example: Simple if-else statement

if x > 0:
    print("x is positive")
else:
    print("x is non-positive")

The time complexity of this if-else statement is O(1), as the code inside the if or else block will only execute once.

Example: Nested if-else statements

if x > 0:
    if y > 0:
        print("x and y are positive")
    else:
        print("x is positive, y is non-positive")
else:
    print("x is non-positive")

The time complexity of this nested if-else statement is still O(1), as the code inside the if or else blocks will only execute once.

Time Complexity of Python Data Structures

Different Python data structures have different time complexities for common operations such as accessing, inserting, and deleting elements.

Lists

Lists are a common data structure in Python that can hold a sequence of elements. Lists are implemented as an array, and have the following time complexities:

Accessing an element by index: O(1)
Appending an element: O(1)
Inserting an element at a specific index: O(n)
Removing an element: O(n)

Sorting the list: O(n log n)

my_list = [1, 2, 3, 4, 5]

print(my_list[0])     # O(1)

my_list.append(6)     # O(1)

my_list.insert(2, 7)  # O(n)

my_list.remove(3)     # O(n)

my_list.sort()        # O(n log n)

Tuples

Tuples are similar to lists, but are immutable (i.e. cannot be changed after creation). Tuples have the following time complexities:

Accessing an element by index: O(1)

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])  # O(1)

Dictionaries

Dictionaries are a data structure that maps keys to values. Dictionaries are implemented as a hash table, and have the following time complexities:

Accessing a value by key: O(1)
Inserting a new key-value pair: O(1)

Deleting a key-value pair: O(1)

my_dict = {"apple": 1, "banana": 2, "orange": 3} 

print(my_dict["banana"])  # O(1)
my_dict["grape"] = 4      # O(1)
del my_dict["orange"]     # O(1)

Sets

Sets are a data structure that holds a collection of unique elements. Sets are implemented as a hash table, and have the following time complexities:

Adding an element: O(1)
Checking if an element is in the set: O(1)

Removing an element: O(1)

my_set = {1, 2, 3, 4, 5}

my_set.add(6)       # O(1)
print(2 in my_set)  # O(1)
my_set.remove(3)    # O(1)

Which Data Structure to Use

Choosing the right data structure for a given problem depends on the specific requirements of the problem and the expected input size. Generally, if quick access or modification of elements is required, lists and dictionaries are good choices. If uniqueness of elements is required, sets should be used. If the elements cannot be changed after creation, tuples should be used.

Conclusion

Understanding time complexity is important for designing efficient algorithms and choosing appropriate data structures for different use cases. By knowing the time complexity of loops, if-else statements, and Python data structures, we can make informed decisions about which algorithms and data structures to use to optimize performance.

Network Communication in Python: Sockets, Requests, and Urllib

Zubair Ahmad — Sun, 02 Apr 2023 08:54:51 +0000

Python provides several libraries for network communication, including sockets, requests, and urllib. These libraries can be used to send and receive data over the internet, make HTTP requests, and more. In this tutorial, we'll explore these libraries and provide examples of how to retrieve the content of a web page using each one.

Sockets

Sockets are a low-level interface to network communication. They allow you to directly send and receive data over a network connection. Sockets can be used to implement protocols like TCP, UDP, and more.

Here's how to use sockets to retrieve the content of a web page:

import socket

HOST = 'www.example.com'
PORT = 80

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))

sock.sendall(b'GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n')

response = b''
while True:
    data = sock.recv(1024)
    if not data:
        break
    response += data

print(response.decode())

In this example, we create a socket object using the socket.socket() method and connect to the web server at port 80 using the sock.connect() method. We then send a GET request to the server using the sock.sendall() method and receive the response in chunks using a while loop that reads data from the socket using the sock.recv() method. Finally, we print the response content as a string using the response.decode() method.

Requests

Requests is a high-level library that provides an easier-to-use interface for making HTTP requests. Requests can be used to send GET, POST, PUT, DELETE, and other types of HTTP requests.

Here's how to use requests to retrieve the content of a web page:

import requests

url = 'http://www.example.com'
response = requests.get(url)

print(response.text)

In this example, we use the requests.get() method to send a GET request to the specified URL and receive the response as a Response object. We can then access the content of the response using the text attribute, which returns the response content as a string.

Urllib

Urllib is a library that provides several modules for working with URLs and making HTTP requests. It can be used to send GET, POST, PUT, DELETE, and other types of HTTP requests.

Here's how to use urllib to retrieve the content of a web page:

import urllib.request

url = 'http://www.example.com'
response = urllib.request.urlopen(url)

print(response.read().decode())

In this example, we use the urllib.request.urlopen() method to send a GET request to the specified URL and receive the response as a file-like object. We can then read the content of the response using the read() method and decode it into a string using the decode() method.

Conclusion

In this tutorial, we explained how to use Python's network communication libraries, including sockets, requests, and urllib. We provided examples of how to retrieve the content of a web page using each library. Sockets are a low-level interface to network communication, requests are a high-level library for making HTTP requests, and urllib is a library for working with URLs and making HTTP requests. The choice of which library to use depends on the specific requirements of your application.

Flask Islamic Quiz Game

Zubair Ahmad — Thu, 30 Mar 2023 06:32:51 +0000

Here is a step-by-step guide on how to create an Islamic Quiz Game using Python and Flask:

Create a database of Islamic quiz questions and answers in a CSV file or any other database format. For example:

Question,Answer
What is the first pillar of Islam?,Shahada
What is the Islamic holy book?,Quran
What is the name of the pilgrimage to Mecca?,Hajj
What is the name of the month of fasting in Islam?,Ramadan
Who was the first Caliph of Islam?,Abu Bakr

Install the Flask library if it's not already installed in your Python environment. You can do this by running the following command in your terminal or command prompt:

pip install flask

Create a Flask app in your Python script app.py:

from flask import Flask, render_template, request
import random
import csv

app = Flask(__name__)

Load the quiz questions and answers from the CSV file into a list of dictionaries:

quiz_data = []

with open('data.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        quiz_data.append(row)

Create a route for the quiz page that displays a random question from the quiz data:

@app.route('/')
@app.route('/quiz')
def quiz():
    question = random.choice(quiz_data)
    return render_template('quiz.html', question=question)

Create a HTML template for the quiz page that displays the question and allows the user to submit their answer:

<!DOCTYPE html>
<html>
<head>
    <title>Islamic Quiz Game</title>
</head>
<body>
    <h1>Islamic Quiz Game</h1>
    <p>{{ question['Question'] }}</p>
    <form action="{{ url_for('answer') }}" method="POST">
        <input type="hidden" name="question" value="{{ question['Question'] }}">
        <input type="text" name="answer" placeholder="Enter your answer">
        <button type="submit">Submit</button>
    </form>
</body>
</html>

Create a route for the answer page that checks the user's answer and displays the result:

@app.route('/answer', methods=['POST'])
def answer():
    question = request.form['question']
    user_answer = request.form['answer']
    correct_answer = next((q['Answer'] for q in quiz_data if q['Question'] == question), None)
    if user_answer.lower() == correct_answer.lower():
        result = "Correct!"
    else:
        result = f"Sorry, the correct answer is {correct_answer}."
    return render_template('answer.html', result=result)

Create a HTML template for the answer page that displays whether the user's answer was correct or not:

<!DOCTYPE html>
<html>
<head>
    <title>Islamic Quiz Game</title>
</head>
<body>
    <h1>Islamic Quiz Game</h1>
    <p>{{ result }}</p>
    <a href="{{ url_for('quiz') }}">Next Question</a>
</body>
</html>

Here is complete app.py:

from flask import Flask, render_template, request
import random
import csv

app = Flask(__name__)

quiz_data = []
with open('data.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        quiz_data.append(row)


@app.route('/')
@app.route('/quiz')
def quiz():
    question = random.choice(quiz_data)
    return render_template('quiz.html', question=question)


@app.route('/answer', methods=['POST'])
def answer():
    question = request.form['question']
    user_answer = request.form['answer']
    correct_answer = next((q['Answer'] for q in quiz_data if q['Question'] == question), None)
    if user_answer.lower() == correct_answer.lower():
        result = "Correct!"
    else:
        result = f"Sorry, the correct answer is {correct_answer}."
    return render_template('answer.html', result=result)


if __name__ == "__main__":
    app.run(debug=True)

Run the Flask app in terminal:

flask run
or
python app.py

Author: Zubair Ahmad

Contact: Follow me on LinkedIn and Twitter

FastAPI Crash Course

Zubair Ahmad — Fri, 17 Mar 2023 07:06:21 +0000

FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.6+ based on standard Python type hints. It provides a simple and intuitive way to create robust, scalable, and maintainable web APIs. FastAPI leverages the latest Python features and the powerful data validation and serialization capabilities of the Pydantic library to provide a more efficient development experience with fewer bugs. FastAPI is also designed to be easy to learn and use, with excellent documentation and an active community of developers contributing to its development and support.Some of its notable features include:

High Performance: FastAPI is designed for high performance, thanks to its use of asynchronous programming and modern Python features like type hints.
Easy to Use: FastAPI is easy to learn and use, with a simple and intuitive API that makes it quick to get up and running.
Data Validation: FastAPI leverages the powerful data validation and serialization capabilities of the Pydantic library to ensure that data is well-formed and properly typed.
Integration with Popular Databases and ORMs: FastAPI seamlessly integrates with popular databases and ORMs such as PostgreSQL, MySQL, SQLite, MongoDB, SQLAlchemy, and Tortoise ORM, providing flexibility to developers to utilize their preferred database technology and ORM to manage their data.
Automatic API Documentation: FastAPI automatically generates comprehensive and interactive API documentation based on the code itself, making it easy to explore and understand the API.
OpenAPI and JSON Schema: FastAPI fully supports the OpenAPI and JSON Schema standards, providing a standardized way to describe APIs and their data.
Fast Development: FastAPI provides a smooth development experience with features like live reload, interactive API documentation, and an easy-to-use development server.
Testability: FastAPI is highly testable, with built-in support for testing and debugging APIs.

Terms related to FastAPI:

Here's a brief explanation of some of the terms related to FastAPI:

Path operation functions: In FastAPI, a path operation function is a Python function that handles a specific HTTP request method (such as GET, POST, PUT, DELETE, etc.) and URL path.
Path parameters: Path parameters are part of the URL path that are used to capture specific values from the client's request. They are defined in the path of a route using braces {}.
Query parameters: Query parameters are additional parameters that can be added to the end of a URL path to modify the behavior of an API endpoint. They are defined after a ? in the URL and can be accessed using the request object.
Request body: The request body is the data sent by the client in the request payload. FastAPI can automatically parse the request body and generate appropriate type hints for the data.
Response model: In FastAPI, you can specify the structure of the response data using Pydantic models. This allows for automatic serialization of response data into the appropriate format (such as JSON).
Pydantic: Pydantic is a data validation and serialization library that is used heavily in FastAPI. It provides a simple and intuitive way to validate and convert data between Python objects and JSON.
OpenAPI: OpenAPI is a specification for building APIs, including a standardized way to describe APIs and their data. FastAPI fully supports the OpenAPI standard and provides tools to generate OpenAPI documentation automatically.
Swagger UI: Swagger UI is a web-based tool for exploring and testing APIs. FastAPI automatically generates a Swagger UI page that allows developers to test and explore the API endpoints.
JSON Schema: JSON Schema is a vocabulary for describing JSON data, including its structure, data types, and validation constraints. FastAPI uses JSON Schema extensively for data validation and serialization.
ASGI: ASGI (Asynchronous Server Gateway Interface) is a protocol for building asynchronous web applications in Python. FastAPI is built on top of ASGI and provides a high-performance web server that is optimized for handling large volumes of traffic.

Overall, FastAPI is a powerful and flexible web framework that makes it easy to build high-performance APIs in Python. Its support for asynchronous code, automatic API documentation generation, and Pydantic data validation make it a great choice for building modern web applications.

Exploring Key Features and Code Examples

In FastAPI, path parameters and query parameters are two ways to accept data from a client.

Path Parameter

Path parameters are used to capture parts of the URL path, and are declared by wrapping them in curly braces {} in the path. For example, in the following path "/items/{item_id}", {item_id} is a path parameter. The value of the path parameter is extracted from the URL and passed as an argument to the corresponding function in the application.

Here's an example of a FastAPI endpoint that accepts a path parameter:

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  },
  2: {
    "name": "banana",
    "price": 0.25,
    "description": "A long curved fruit with a yellow skin and soft sweet flesh."
  },
  3: {
    "name": "orange",
    "price": 0.35,
    "description": "A round citrus fruit with a tough bright reddish-yellow rind and juicy acid pulp."
  }
}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

In this example, the read_item function accepts a path parameter item_id of type int. When the client requests a URL like /items/42, the value 42 will be passed as the item_id argument to the function.

Query Parameter

Query parameters are used to pass additional data in the URL query string. They are declared as function parameters with default values, and FastAPI will automatically parse the query string and populate the parameter with the corresponding value. For example, in the following URL /items?skip=0&limit=10, skip and limit are query parameters.

Here's an example of a FastAPI endpoint that accepts query parameters:

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  },
  2: {
    "name": "banana",
    "price": 0.25,
    "description": "A long curved fruit with a yellow skin and soft sweet flesh."
  },
  3: {
    "name": "orange",
    "price": 0.35,
    "description": "A round citrus fruit with a tough bright reddish-yellow rind and juicy acid pulp."
  }
}

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

In this example, the read_items function accepts two query parameters skip and limit, both of type int with default values of 0 and 10 respectively. When the client requests a URL like /items?skip=20&limit=5, the function will receive skip=20 and limit=5 as the values for the corresponding parameters. If no values are provided in the URL, the function will use the default values.

Combining Path and Query Parameters

We can combine path and query parameters in FastAPI.

Here's an example of how to define an endpoint that uses both path and query parameters:

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  },
  2: {
    "name": "banana",
    "price": 0.25,
    "description": "A long curved fruit with a yellow skin and soft sweet flesh."
  },
  3: {
    "name": "orange",
    "price": 0.35,
    "description": "A round citrus fruit with a tough bright reddish-yellow rind and juicy acid pulp."
  }
}

@app.get("/items/{item_id}")
def get_item(item_id: int, q: str = None):
    item = items.get(item_id)
    if not item:
        return {"error": "Item not found"}
    if q:
        item.update({"q": q})
    return item

In this example, the endpoint is defined using the @app.get decorator, which specifies that it responds to HTTP GET requests. The endpoint path includes a path parameter, item_id, which is defined by enclosing it in curly braces {}. The endpoint also includes a query parameter, q, which is optional and has a default value of None.

When the endpoint is called, the value of item_id is taken from the path parameter in the URL, and the value of q is taken from the query string, if it is present. The endpoint returns a JSON response containing both parameter values.

HTTP Methods

FastAPI supports several HTTP methods that can be used to define different types of endpoints in an application. Here's a short description of each HTTP method in FastAPI:

GET: Used to retrieve a resource or a list of resources. This method should be safe and idempotent, meaning it should not modify any data on the server.
POST: Used to create a new resource. This method is not idempotent, meaning multiple requests can result in multiple resource creations.
PUT: Used to update an existing resource. This method should be idempotent, meaning multiple requests should result in the same resource state.
PATCH: Similar to PUT, but used to partially update an existing resource.
DELETE: Used to delete an existing resource. This method should be idempotent, meaning multiple requests should result in the same resource state.
OPTIONS: Used to retrieve information about the communication options available for a resource.
HEAD: Similar to GET, but only retrieves the HTTP headers for a resource, without the actual content.

In FastAPI, each of these HTTP methods can be mapped to a Python function that defines the behavior of the corresponding endpoint.

The @app.get, @app.post, @app.put, @app.patch, @app.delete, @app.options, and @app.head decorators are used to create endpoints that respond to the corresponding HTTP methods.

Request Body and Post Method

In FastAPI, you can define a request body using the BaseModel class from the pydantic module. A request body is the data that the client sends to the server as part of a POST request.

Here's an example of how to define a request body for adding a new item to the items dictionary using the POST method:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

items = {}

@app.post("/create_item")
def create_item(item_id: int, item: Item):
    if item_id in items:
        return {"error": "Item already exists!"}
    items[item_id] = item
    return items[item_id]

In this example, we first define a new Item class that inherits from the BaseModel class in FastAPI's pydantic module. The Item class has three fields: name, price, and description.

Next, we define the create_item endpoint with the @app.post decorator. In the create_item function, we define a parameter called item with the type Item, which is the class we defined earlier. This means that the request body should have JSON data with the same keys as the attributes of the Item class. This endpoint takes an Item object as the request body, which is automatically parsed and validated by FastAPI based on the field types and validation rules specified in the Item class.

Inside the endpoint, we generate a new item_id based on the current length of the items dictionary, add the new item to the dictionary with the item_id as the key, and return a response containing the new item_id.

PUT Method

Here's an example of using the PUT method in FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class UpdateItem(BaseModel):
    name: Optional[str] = None
    price: Optional[float] = None
    description: Optional[str] = None

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  }
}

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: UpdateItem):
    if item_id not in items:
        return {"error": "Item not found"}

    if item.name != None:
        items[item_id]["name"] = item.name
    if item.price != None:
        items[item_id]["price"] = item.price
    if item.description != None:
        items[item_id]["description"] = item.description

    return {"message": "Item updated successfully"}

In this example, we have defined a PUT endpoint that updates an existing item by ID. We have used the Item class that we defined earlier, and we have assumed that we already have a dictionary called items that contains the existing items.

The endpoint takes two parameters - item_id and item. The item_id parameter is a path parameter that specifies the ID of the item that needs to be updated. The item parameter is a request body parameter that contains the updated information for the item.

We first check if the specified item_id exists in the items dictionary. If it doesn't, we return an error message. If it does, we update the corresponding item with the data from the item parameter. We use the dict() method of the Item object to convert it to a dictionary before updating the items dictionary.

Finally, we return a message indicating that the item was updated successfully.

DELETE Method

In FastAPI, you can define a DELETE method to handle HTTP DELETE requests. The DELETE method is typically used to delete a specific resource identified by a unique identifier.

Here's an example of how you can implement a DELETE method to delete an item from the items dictionary based on its ID:

from fastapi import FastAPI

app = FastAPI()

items = {
  1: {
    "name": "apple",
    "price": 0.5,
    "description": "A sweet fruit with a red or green skin and a core containing seeds."
  }
}

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    if item_id not in items:
        return {"error": "Item not found"}
    del items[item_id]
    return {"message": "Item deleted successfully"}

In this example, the delete_item function takes a item_id parameter which is passed in through the path parameter of the URL. If the item with the specified ID does not exist in the items dictionary, the function returns an error message. Otherwise, it deletes the item from the dictionary using the del keyword, and returns a success message.

Note that it's important to handle errors gracefully in your application to provide informative error messages to clients. In this example, if the item is not found, we return an error message with an appropriate HTTP status code (e.g. 404 Not Found).

Author: Zubair Ahmad

Contact: Follow me on LinkedIn and Twitter