Info general HazedawnCreating a basic CRUD (Create, Read, Update, Delete) application is an excellent way to learn about web development using Python. In this guide, we will explore how to build a simple CRUD application using both Flask and Django. We will cover the essential code needed to handle database operations and routing for each framework.
What is CRUD? 📋
CRUD stands for:
- Create: Adding new data to the database.
- Read: Retrieving data from the database.
- Update: Modifying existing data.
- Delete: Removing data from the database. Both Flask and Django provide tools to implement these operations effectively.
Option 1: Building a CRUD Application with Flask 🛠️
Step 1: Setting Up Flask
First, ensure you have Flask installed. You can do this via pip:
bash
pip install Flask Flask-SQLAlchemy
Step 2: Create Your Flask Application
Create a new directory for your project and add a file named app.py. Here’s a simple structure:
text
flask-crud-app/
│
├── app.py
└── models.py
Step 3: Define Your Models
In models.py, define your database model:
python
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
completed = db.Column(db.Boolean, default=False)
def __repr__(self):
return f"<Task {self.title}>"
Step 4: Create the Flask App and Routes
In app.py, set up your Flask application and routes:
python
from flask import Flask, request, jsonify
from models import db, Task
app = Flask(name)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tasks.db'
db.init_app(app)
@app.route('/tasks', methods=['POST'])
def create_task():
data = request.get_json()
new_task = Task(title=data['title'])
db.session.add(new_task)
db.session.commit()
return jsonify({'message': 'Task created!'}), 201
@app.route('/tasks', methods=['GET'])
def get_tasks():
tasks = Task.query.all()
return jsonify([{'id': task.id, 'title': task.title, 'completed': task.completed} for task in tasks])
@app.route('/tasks/int:id', methods=['PUT'])
def update_task(id):
task = Task.query.get(id)
if not task:
return jsonify({'message': 'Task not found!'}), 404
data = request.get_json()
task.title = data['title']
task.completed = data['completed']
db.session.commit()
return jsonify({'message': 'Task updated!'})
@app.route('/tasks/int:id', methods=['DELETE'])
def delete_task(id):
task = Task.query.get(id)
if not task:
return jsonify({'message': 'Task not found!'}), 404
db.session.delete(task)
db.session.commit()
return jsonify({'message': 'Task deleted!'})
if name == 'main':
with app.app_context():
db.create_all() # Create database tables
app.run(debug=True)
Explanation:
- Database Configuration: SQLite is used for simplicity.
- Routes: Each route corresponds to a CRUD operation.
Option 2: Building a CRUD Application with Django 🌟
Step 1: Setting Up Django
First, ensure you have Django installed:
bash
pip install django
Step 2: Create Your Django Project
Create a new Django project and app:
bash
django-admin startproject myproject
cd myproject
django-admin startapp tasks
Step 3: Define Your Models
In tasks/models.py, define your model:
python
from django.db import models
class Task(models.Model):
title = models.CharField(max_length=100)
completed = models.BooleanField(default=False)
def __str__(self):
return self.title
Step 4: Set Up Views and URLs
In tasks/views.py, create views for your CRUD operations:
python
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
import json
from .models import Task
@csrf_exempt
def create_task(request):
if request.method == 'POST':
data = json.loads(request.body)
task = Task.objects.create(title=data['title'])
return JsonResponse({'message': 'Task created!', 'id': task.id}, status=201)
def get_tasks(request):
tasks = list(Task.objects.values())
return JsonResponse(tasks, safe=False)
@csrf_exempt
def update_task(request, id):
try:
task = Task.objects.get(id=id)
if request.method == 'PUT':
data = json.loads(request.body)
task.title = data['title']
task.completed = data['completed']
task.save()
return JsonResponse({'message': 'Task updated!'})
except Task.DoesNotExist:
return JsonResponse({'message': 'Task not found!'}, status=404)
@csrf_exempt
def delete_task(request, id):
try:
task = Task.objects.get(id=id)
if request.method == 'DELETE':
task.delete()
return JsonResponse({'message': 'Task deleted!'})
except Task.DoesNotExist:
return JsonResponse({'message': 'Task not found!'}, status=404)
Step 5: Configure URLs
In myproject/urls.py, include the routes for your app:
python
from django.contrib import admin
from django.urls import path
from tasks.views import create_task, get_tasks, update_task, delete_task
urlpatterns = [
path('admin/', admin.site.urls),
path('tasks/', create_task),
path('tasks/', get_tasks),
path('tasks/int:id/', update_task),
path('tasks/int:id/', delete_task),
]
Final Steps for Django:
Run migrations to set up your database:
bash
python manage.py makemigrations tasks
python manage.py migrate
Start the server:
bash
python manage.py runserver
Conclusion: Building Your CRUD Application 🏗️
Whether you choose Flask or Django, creating a basic CRUD application is an excellent way to understand web development with Python. Both frameworks offer powerful tools for handling database operations and routing effectively.
Next Steps:
- Explore adding user authentication to your application.
- Consider deploying your application using platforms like Heroku or AWS.
Start building your CRUD applications today and enhance your web development skills! 💡✨
