Does 30 Days of Python Include Practical Projects and Web Development?

Yes, the 30 Days of Python challenge includes hands-on web development projects using Flask, MongoDB, and RESTful APIs from Day 26 onward.

The Asabeneh/30-Days-Of-Python repository extends far beyond basic syntax exercises. Starting on Day 26, the curriculum transforms into a practical, project-based learning path that teaches real-world web development skills including server-side programming, database integration, and API design.

Web Development Curriculum Overview

The final week of the challenge (Days 26–29) focuses exclusively on building production-ready web applications. According to the source code in python_for_web/app.py and the corresponding markdown tutorials, you progress through a complete full-stack workflow.

Day 26 – Flask Web Framework Basics

Day 26 introduces Flask as the web framework of choice. You build a minimal but functional website with multiple pages and static assets.

The tutorial in 26_Day_Python_web/26_python_web.md guides you through:

• Creating a Flask application instance
• Defining routes using @app.route() decorators
• Rendering HTML templates with Jinja2
• Serving static files (CSS, images)

In python_for_web/app.py, the entry point establishes the core application structure:

from flask import Flask, render_template, request, redirect, url_for
import os

app = Flask(__name__)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0   # disable static-file caching

@app.route('/')                     # Home page

def home():
    techs = ['HTML', 'CSS', 'Flask', 'Python']
    name = '30 Days Of Python Programming'
    return render_template('home.html', techs=techs, name=name, title='Home')

@app.route('/about')                # About page

def about():
    name = '30 Days Of Python Programming'
    return render_template('about.html', name=name, title='About Us')

The templates located in python_for_web/templates/ (including home.html, about.html, and layout.html) demonstrate template inheritance and variable interpolation using the Jinja2 syntax:

<ul>
  {% for tech in techs %}
    <li>{{ tech }}</li>
  {% endfor %}
</ul>

<h1>Welcome to {{ name }}</h1>

Day 27 – MongoDB Database Integration

Day 27 adds a NoSQL backend to your Flask application. The tutorial 27_Day_Python_with_mongodb/27_python_with_mongodb.md covers pymongo integration for persistent data storage.

You learn to:

1. Connect to MongoDB Atlas or local instances using environment variables
2. Create databases and collections dynamically
3. Perform CRUD operations (Create, Read, Update, Delete)

The implementation pattern shown in the repository:

import pymongo
import os

MONGODB_URI = os.getenv('MONGODB_URI',
    'mongodb+srv://<user>:<password>@cluster0.mongodb.net/test?retryWrites=true&w=majority')
client = pymongo.MongoClient(MONGODB_URI)

db = client.thirty_days_of_python          # creates DB if absent

students = db.students                     # creates collection if absent

# Insert a document

students.insert_one({
    "name": "Asabeneh",
    "country": "Finland",
    "city": "Helsinki",
    "age": 250
})

Day 28 – Building RESTful APIs

Day 28 transitions from server-rendered HTML to API development. The 28_Day_API/28_API.md file explains HTTP methods (GET, POST, PUT, DELETE) and how to expose your MongoDB data as JSON endpoints.

A minimal RESTful implementation combines Flask with pymongo to serve data:

from flask import Flask, jsonify
import pymongo

app = Flask(__name__)
client = pymongo.MongoClient(MONGODB_URI)
db = client.thirty_days_of_python

@app.route('/students', methods=['GET'])
def get_students():
    # Convert cursor to list of dicts, excluding Mongo's internal _id

    data = list(db.students.find({}, {"_id": 0}))
    return jsonify(data)

This endpoint returns a JSON array of student documents, suitable for consumption by frontend applications or mobile clients.

Project-Based Learning Structure

The 30 Days of Python repository organizes these concepts into a cumulative project pipeline:

• Phase 1 (Day 26): Static site with Flask routing and Jinja2 templates
• Phase 2 (Day 27): Database persistence layer using MongoDB
• Phase 3 (Day 28-29): RESTful API layer for full CRUD operations

Each phase includes working source code in the python_for_web/ directory, allowing you to run a complete application locally. The app.py file demonstrates production considerations like static file configuration (SEND_FILE_MAX_AGE_DEFAULT), while the static/css/main.css file shows how to integrate frontend assets.

Summary

• 30 Days of Python includes practical web development projects starting from Day 26
• The curriculum teaches Flask routing, Jinja2 templating, and static file handling
• MongoDB integration via pymongo enables database-backed applications
• RESTful API development is covered with full CRUD endpoint examples
• All projects include runnable source code in the python_for_web/ directory

Frequently Asked Questions

Does 30 Days of Python teach Flask or Django?

The repository teaches Flask for web development. According to the source code in python_for_web/app.py, the curriculum uses Flask's lightweight framework for routing (@app.route), template rendering (render_template), and request handling rather than Django's batteries-included approach.

What database does 30 Days of Python use for projects?

The practical projects use MongoDB as the primary database. Day 27 (27_Day_Python_with_mongodb/27_python_with_mongodb.md) specifically covers pymongo for connecting to MongoDB Atlas, creating collections, and performing document-based CRUD operations.

Are the web development projects in 30 Days of Python beginner-friendly?

Yes, the projects assume only basic Python knowledge. Day 26 starts with a minimal Flask application containing just two routes (home and about), then gradually adds complexity through database integration and API endpoints, making the progression manageable for beginners.

Does 30 Days of Python include frontend development?

The repository includes basic HTML templating using Jinja2 (shown in python_for_web/templates/home.html) and CSS for styling (located in python_for_web/static/css/main.css). However, the focus remains on backend Python development rather than advanced JavaScript frameworks.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}