Building RESTful APIs with Python: A Comprehensive Guide • ITER Academy

Welcome to our comprehensive guide on building RESTful APIs with Python! Application Programming Interfaces (APIs) play a critical role in modern web applications by allowing communication between different services. This guide will cover two popular frameworks for creating RESTful APIs in Python: Flask and FastAPI.

1. What is a RESTful API?

REST (Representational State Transfer) is an architectural style that provides a uniform way to interact with resources over the web. RESTful APIs use standard HTTP methods (GET, POST, PUT, DELETE) to perform CRUD (Create, Read, Update, Delete) operations on resources.

2. Why Use Python for Building APIs?

Python’s simplicity and readability, along with an extensive ecosystem of libraries, make it an excellent choice for building APIs. Its frameworks, like Flask and FastAPI, facilitate quick development with minimal overhead.

3. Setting Up Your Environment

To get started, ensure that you have Python installed on your system. You can set up a virtual environment and install the necessary libraries:

pip install Flask FastAPI uvicorn

4. Creating a RESTful API with Flask

Flask is a lightweight framework that is easy to set up and use for creating simple APIs. Here’s how to create a basic RESTful API using Flask:

from flask import Flask, jsonify, request

app = Flask(__name__)

# Sample data
items = []

@app.route('/items', methods=['GET'])
def get_items():
    return jsonify(items)

@app.route('/items', methods=['POST'])
def add_item():
    item = request.json  # Get JSON data from the request
    items.append(item)
    return jsonify(item), 201  # Return the created item with a 201 response code

@app.route('/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    if 0 < item_id < len(items):
        return jsonify(items[item_id])
    return jsonify({'error': 'Item not found'}), 404

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

This code creates a simple RESTful API with endpoints to get all items, add a new item, and fetch items by their ID.

5. Running Your Flask API

To run your Flask application, execute the script:

python app.py

Your API will be running locally at http://127.0.0.1:5000/. You can test it using tools like Postman or cURL.

6. Creating a RESTful API with FastAPI

FastAPI is a modern framework designed for high-performance APIs. Its automatic generation of OpenAPI documentation is a key feature. Let’s create a similar API using FastAPI:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

items = []

@app.get('/items')
def get_items():
    return items

@app.post('/items', response_model=Item)
def add_item(item: Item):
    items.append(item)
    return item

@app.get('/items/{item_id}', response_model=Item)
def get_item(item_id: int):
    if 0 < item_id < len(items):
        return items[item_id]
    return {'error': 'Item not found'}

if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host='0.0.0.0', port=8000)

This FastAPI implementation uses Pydantic for validating and parsing input data, making it easy to handle JSON requests.

7. Running Your FastAPI Application

To run your FastAPI app, use the following command:

uvicorn app:app --reload

This runs the API on http://127.0.0.1:8000/, along with automatic reloading on code changes.

8. Conclusion

In this guide, you learned how to create RESTful APIs using two popular Python web frameworks: Flask and FastAPI. Both frameworks have their strengths: Flask is great for smaller applications, while FastAPI excels in performance and automatic API documentation.

Start experimenting with these frameworks to build and deploy your own APIs, and unlock the potential for backend development with Python!

To learn more about ITER Academy, visit our website. https://iter-academy.com/