**Course Title:** Modern Python Programming: Best Practices and Trends **Section Title:** Web Development with Python **Topic:** Create a RESTful API with Flask/Django and interact with it using Python.(Lab topic) **Introduction** In this lab topic, we will build a RESTful API using Flask and Django, two popular Python web frameworks. We will learn how to design and implement a simple API, interact with it using Python, and understand the concepts of RESTful APIs. **RESTful API Basics** A RESTful API (Representational State of Resource) is an architectural style for designing networked applications. It is based on the idea of resources, which are identified by URIs, and can be manipulated using a fixed set of operations. Here are the basic principles of RESTful APIs: 1. **Resources**: Everything in REST is a resource. 2. **Client-Server Architecture**: The client and server are separate, with the client making requests to the server to access or modify resources. 3. **Stateless**: The server does not maintain any information about the client state. 4. **Cacheable**: Responses from the server are cacheable, which can reduce the number of requests made to the server. **Flask RESTful API** We will use Flask, a micro web framework written in Python, to build a simple RESTful API. First, let's install Flask using pip: ```bash pip install flask ``` Next, let's create a simple API that can store and retrieve books: **app.py** ```python from flask import Flask, jsonify, request app = Flask(__name__) # Sample data books = [ {"id": 1, "title": "Book 1", "author": "Author 1"}, {"id": 2, "title": "Book 2", "author": "Author 2"}, {"id": 3, "title": "Book 3", "author": "Author 3"} ] # GET /books @app.route('/books', methods=['GET']) def get_books(): return jsonify({"books": books}) # GET /books/:id @app.route('/books/:id', methods=['GET']) @app.route('/books/<int:id>', methods=['GET']) def get_book(id): book = [book for book in books if book['id'] == id] if book: return jsonify({"book": book}) else: return jsonify({"error": "Book not found"}), 404 # POST /books @app.route('/books', methods=['POST']) def create_book(): new_book = { 'id': len(books) + 1, 'title': request.json['title'], 'author': request.json['author'] } books.append(new_book) return jsonify({"book": new_book}), 201 # PUT /books/:id @app.route('/books/<int:id>', methods=['PUT']) def update_book(id): book = [book for book in books if book['id'] == id] if book: book[0]['title'] = request.json.get('title', book[0]['title']) book[0]['author'] = request.json.get('author', book[0]['author']) return jsonify({"book": book[0]}) else: return jsonify({"error": "Book not found"}), 404 # DELETE /books/:id @app.route('/books/<int:id>', methods=['DELETE']) def delete_book(id): book = [book for book in books if book['id'] == id] if book: books.remove(book[0]) return jsonify({"message": "Book deleted"}) else: return jsonify({"error": "Book not found"}), 404 if __name__ == '__main__': app.run() ``` Run the application using Python: ```bash python app.py ``` Now you can interact with the API using tools like curl or Postman. **Django RESTful API** Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. We will use Django to build a simple RESTful API. First, let's install Django: ```bash pip install django ``` Next, let's create a new Django project and a Django app: ```bash django-admin startproject bookstore cd bookstore python manage.py startapp books ``` Now, let's define a model for books: **books/models.py** ```python from django.db import models class Book(models.Model): title = models.CharField(max_length=100) author = models.CharField(max_length=100) ``` Next, let's create and apply migrations: ```bash python manage.py makemigrations python manage.py migrate ``` Now, let's create serializers for books: **books/serializers.py** ```python from rest_framework import serializers from .models import Book class BookSerializer(serializers.ModelSerializer): class Meta: model = Book fields = ['id', 'title', 'author'] ``` Next, let's create API views for books: **books/views.py** ```python from rest_framework.response import Response from rest_framework.views import APIView from .models import Book from .serializers import BookSerializer class BookList(APIView): def get(self, request): books = Book.objects.all() serializer = BookSerializer(books, many=True) return Response(serializer.data) def post(self, request): serializer = BookSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400) class BookDetail(APIView): def get(self, request, pk): try: book = Book.objects.get(pk=pk) except Book.DoesNotExist: return Response(status=404) serializer = BookSerializer(book) return Response(serializer.data) def put(self, request, pk): try: book = Book.objects.get(pk=pk) except Book.DoesNotExist: return Response(status=404) serializer = BookSerializer(book, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=400) def delete(self, request, pk): try: book = Book.objects.get(pk=pk) except Book.DoesNotExist: return Response(status=404) book.delete() return Response(status=204) ``` Next, let's create API routes for books: **bookstore/urls.py** ```python from django.urls import path, include from rest_framework import routers from books import views router = routers.DefaultRouter() urlpatterns = [ path('', include(router.urls)), path('books/', views.BookList.as_view()), path('books/<pk>/', views.BookDetail.as_view()), ] ``` Now, let's include the books API in the main URL configuration: **bookstore/bookstore/urls.py** ```python from django.urls import path, include urlpatterns = [ path('api/', include('bookstore.urls')), ] ``` **Interacting with the API** You can interact with the API using tools like curl or Postman. For example, to get all books, use: ```bash curl http://localhost:8000/api/books/ ``` To create a new book, use: ```bash curl -X POST -H "Content-Type: application/json" -d '{"title": "New Book", "author": "New Author"}' http://localhost:8000/api/books/ ``` To get a specific book, use: ```bash curl http://localhost:8000/api/books/1/ ``` To update a book, use: ```bash curl -X PUT -H "Content-Type: application/json" -d '{"title": "Updated Book", "author": "Updated Author"}' http://localhost:8000/api/books/1/ ``` To delete a book, use: ```bash curl -X DELETE http://localhost:8000/api/books/1/ ``` **Conclusion** In this lab topic, we learned how to create RESTful APIs using Flask and Django. We designed and implemented simple APIs that can store and retrieve books. We also learned how to interact with the APIs using tools like curl or Postman. **Lab Exercises** 1. Implement authentication and authorization in your Flask API using Flask-JWT-Extended. 2. Implement pagination in your Django API using Django REST framework's pagination features. 3. Use a database like MySQL or PostgreSQL instead of the default SQLite database in Django. **Getting Help** If you are having trouble with this lab topic, you can: * Post a question on an online forum like Reddit's r/learnpython or r/django * Ask for help in a Python or Django community on Discord or Slack * Consult the [Flask documentation](https://flask.palletsprojects.com/en/2.0.x/) or the [Django documentation](https://docs.djangoproject.com/en/4.1/)