pontalk: Explore Python's Hidden Treasures!

Building a Simple RESTful API with Flask

Written by

ken

in

Welcome, aspiring developers! Have you ever wondered how different applications talk to each other? How does your phone app get the latest weather forecast, or how does a website display real-time stock prices? The secret often lies in something called an API. Today, we’re going to dive into the exciting world of Application Programming Interfaces (APIs) and learn how to build a simple one using Flask, a lightweight Python web framework.

What’s an API, and Why Does it Matter?

Imagine you’re at a restaurant. You don’t go into the kitchen to cook your meal yourself. Instead, you tell the waiter what you want, and they communicate your order to the kitchen. Once your food is ready, the waiter brings it back to you.

In this analogy:
* You are the client (e.g., a mobile app, a web browser).
* The kitchen is the server (where the data and logic live).
* The waiter is the API (Application Programming Interface).

An API is a set of rules and definitions that allows different software applications to communicate with each other. It defines how data is requested and how it’s sent back. When you use an app that shows weather, that app is using a weather API to ask a weather server for information.

What is RESTful?

Our goal is to build a RESTful API. “REST” stands for Representational State Transfer. It’s a set of architectural principles for designing networked applications. Think of it as a widely accepted “style guide” for building APIs.

Key characteristics of a RESTful API:
* Stateless: Each request from a client to the server contains all the information needed to understand the request. The server doesn’t “remember” past requests from that client.
* Client-Server: The client and server are separate entities, allowing them to evolve independently.
* Uniform Interface: It uses standard HTTP methods (like GET, POST, PUT, DELETE) and standard data formats (like JSON) for communication.

Why Flask?

Flask is a “micro” web framework for Python. This means it’s very lightweight, doesn’t come with many built-in tools, and lets you choose the tools you want to use. This makes it perfect for beginners and for building smaller, focused applications like the API we’re creating today. It’s simple to set up and easy to understand, making it a great starting point for learning web development with Python.

What We’ll Build

We’re going to build a very simple API that manages a list of books. Our API will allow us to:
* Get a list of all books.
* Get details of a specific book by its ID.
* Add a new book to the list.
* Update an existing book’s details.
* Delete a book from the list.

Prerequisites

Before we start, make sure you have:
* Python installed on your computer (version 3.6 or higher is recommended). You can download it from python.org.
* A basic understanding of Python syntax (variables, lists, dictionaries, functions).
* A text editor (like VS Code, Sublime Text, Atom) or an IDE (like PyCharm).

Setting Up Your Environment

It’s good practice to work within a virtual environment. A virtual environment is like a separate, isolated space for your Python projects. It ensures that the packages you install for one project don’t interfere with others.

  1. Create a Project Directory:
    First, create a folder for your project.
    bash
    mkdir flask_book_api
    cd flask_book_api

  2. Create a Virtual Environment:
    bash
    python3 -m venv venv
    (On some systems, you might just use python -m venv venv)
    This command creates a folder named venv inside your project directory, which contains a clean Python installation.

  3. Activate the Virtual Environment:

    • On macOS/Linux:
      bash
      source venv/bin/activate
    • On Windows (Command Prompt):
      bash
      venv\Scripts\activate.bat
    • On Windows (PowerShell):
      bash
      venv\Scripts\Activate.ps1
      You’ll know it’s active when you see (venv) at the beginning of your terminal prompt.

  4. Install Flask:
    Now that your virtual environment is active, install Flask.
    bash
    pip install Flask
    pip is Python’s package installer, used for installing libraries like Flask.

Understanding Core Concepts for Our API

Before coding, let’s clarify a few essential API concepts:

HTTP Methods (Verbs)

These are the actions you want to perform on a resource (like a book):
* GET: Retrieve data from the server. (e.g., “Give me all books,” or “Give me book with ID 1.”)
* POST: Send new data to the server to create a resource. (e.g., “Here’s a new book to add.”)
* PUT: Send data to the server to update an existing resource. (e.g., “Update book with ID 1 with this new information.”)
* DELETE: Remove a resource from the server. (e.g., “Delete book with ID 1.”)

Routes

In Flask, a route is a specific URL pattern that your application listens to. When a user or client accesses that URL, Flask “routes” the request to a specific Python function that you define.
For example, /books could be a route to get all books, and /books/1 could be a route to get a book with ID 1.

JSON (JavaScript Object Notation)

JSON is a lightweight data-interchange format. It’s easy for humans to read and write, and easy for machines to parse and generate. It’s the standard format for sending and receiving data in web APIs.
A JSON object looks very similar to a Python dictionary:

{
    "title": "The Hitchhiker's Guide to the Galaxy",
    "author": "Douglas Adams",
    "id": 1
}

Building Our API – Step by Step

Create a new file named app.py in your flask_book_api directory.

1. Basic Flask App

Let’s start with a “Hello, World!” Flask application to ensure everything is set up correctly.

from flask import Flask, jsonify, request

app = Flask(__name__) # Create a Flask application instance

books = [
    {'id': 1, 'title': 'The Hitchhiker\'s Guide to the Galaxy', 'author': 'Douglas Adams'},
    {'id': 2, 'title': 'Pride and Prejudice', 'author': 'Jane Austen'},
    {'id': 3, 'title': '1984', 'author': 'George Orwell'}
]

@app.route('/', methods=['GET'])
def home():
    return "<h1>Welcome to our Book API!</h1><p>Use /books to interact with the API.</p>"

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

To run this:

python app.py

You should see output like:

 * Serving Flask app 'app'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: ...

Open your web browser and go to http://127.0.0.1:5000. You should see “Welcome to our Book API!”. This confirms Flask is working!

2. Get All Books (GET /books)

This route will return our entire list of books.

@app.route('/books', methods=['GET'])
def get_all_books():
    return jsonify(books) # jsonify converts Python dictionary/list to JSON response

Now, if you go to http://127.0.0.1:5000/books in your browser, you’ll see the list of books in JSON format.

3. Get a Single Book by ID (GET /books/)

We want to be able to fetch a specific book. The <int:book_id> part in the route means Flask will expect an integer (a whole number) after /books/, and it will pass that number as the book_id argument to our function.

@app.route('/books/<int:book_id>', methods=['GET'])
def get_book_by_id(book_id):
    for book in books:
        if book['id'] == book_id:
            return jsonify(book)
    # If no book is found with the given ID, return a 404 Not Found error
    return jsonify({'message': 'Book not found'}), 404

Try http://127.0.0.1:5000/books/1 or http://127.0.0.1:5000/books/5 (which should give you a “Book not found” message).

4. Add a New Book (POST /books)

To add a book, the client will send data in the request body. We’ll use request.json to get this data, which Flask automatically parses from the incoming JSON.

@app.route('/books', methods=['POST'])
def add_book():
    new_book = request.json
    if not new_book or 'title' not in new_book or 'author' not in new_book:
        return jsonify({'message': 'Missing title or author in request'}), 400 # 400 Bad Request

    # Assign a new ID (in a real app, this would be handled by a database)
    new_id = max([book['id'] for book in books]) + 1 if books else 1
    new_book['id'] = new_id
    books.append(new_book)
    return jsonify(new_book), 201 # 201 Created status code

To test this, you can use a tool like curl in your terminal or a browser extension like Postman/Insomnia.

Using curl:

curl -X POST -H "Content-Type: application/json" -d '{"title": "New Book Title", "author": "New Author"}' http://127.0.0.1:5000/books

You should get a response like: {"author":"New Author","id":4,"title":"New Book Title"}.
Then, if you refresh http://127.0.0.1:5000/books, you’ll see your new book!

5. Update an Existing Book (PUT /books/)

Updating works similarly to adding, but we need to find the book first and then modify its details.

@app.route('/books/<int:book_id>', methods=['PUT'])
def update_book(book_id):
    updated_data = request.json
    for book in books:
        if book['id'] == book_id:
            book.update(updated_data) # Update the book's attributes
            return jsonify(book)
    return jsonify({'message': 'Book not found'}), 404

Using curl to update book with ID 1:

curl -X PUT -H "Content-Type: application/json" -d '{"title": "The Hitchhiker\'s Guide to the Galaxy (Updated)"}' http://127.0.0.1:5000/books/1

The response will show the updated book. Check http://127.0.0.1:5000/books/1 to confirm.

6. Delete a Book (DELETE /books/)

Finally, let’s implement the delete functionality.

@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
    global books # We need to tell Python we're modifying the global 'books' list
    initial_len = len(books)
    books = [book for book in books if book['id'] != book_id] # Create a new list without the deleted book

    if len(books) < initial_len:
        return jsonify({'message': 'Book deleted successfully'})
    return jsonify({'message': 'Book not found'}), 404

Using curl to delete book with ID 1:

curl -X DELETE http://127.0.0.1:5000/books/1

You should get {"message": "Book deleted successfully"}. If you try to access http://127.0.0.1:5000/books/1 now, it will return “Book not found”.

Testing Your API with Python requests

Instead of curl, you can also use Python’s excellent requests library to test your API programmatically. First, install it:

pip install requests

Then, create a new Python file (e.g., test_api.py) and try these examples:

import requests
import json

BASE_URL = "http://127.0.0.1:5000/books"

print("--- GET all books ---")
response = requests.get(BASE_URL)
print(f"Status Code: {response.status_code}")
print(f"Response: {json.dumps(response.json(), indent=2)}")

print("\n--- GET book with ID 2 ---")
response = requests.get(f"{BASE_URL}/2")
print(f"Status Code: {response.status_code}")
print(f"Response: {json.dumps(response.json(), indent=2)}")

print("\n--- POST a new book ---")
new_book_data = {"title": "The Great Gatsby", "author": "F. Scott Fitzgerald"}
response = requests.post(BASE_URL, json=new_book_data)
print(f"Status Code: {response.status_code}")
print(f"Response: {json.dumps(response.json(), indent=2)}")

book_to_update_id = 4 # Adjust if your book IDs are different
print(f"\n--- PUT (update) book with ID {book_to_update_id} ---")
update_data = {"title": "The Great Gatsby (Classic Edition)"}
response = requests.put(f"{BASE_URL}/{book_to_update_id}", json=update_data)
print(f"Status Code: {response.status_code}")
print(f"Response: {json.dumps(response.json(), indent=2)}")

print(f"\n--- DELETE book with ID {book_to_update_id} ---")
response = requests.delete(f"{BASE_URL}/{book_to_update_id}")
print(f"Status Code: {response.status_code}")
print(f"Response: {json.dumps(response.json(), indent=2)}")

print("\n--- GET all books after operations ---")
response = requests.get(BASE_URL)
print(f"Status Code: {response.status_code}")
print(f"Response: {json.dumps(response.json(), indent=2)}")

Run this script while your app.py Flask server is running in another terminal.

Conclusion

Congratulations! You’ve successfully built a basic RESTful API using Flask. You’ve learned about:
* What APIs are and why they are important for application communication.
* The principles of RESTful design.
* How to set up a Flask project with a virtual environment.
* Implementing different HTTP methods (GET, POST, PUT, DELETE) for various API operations.
* Handling JSON data for requests and responses.

This is just the beginning! In a real-world application, you would replace our simple Python list with a proper database (like SQLite, PostgreSQL, or MongoDB) to store your data persistently. You would also add error handling, user authentication, and more robust validation. But for now, you have a solid foundation to build upon. Keep experimenting and happy coding!

Comments

Leave a Reply

More posts