pontalk: Explore Python's Hidden Treasures!

Building a Simple E-commerce Site with Django

Written by

ken

in

Hey there, aspiring web developers and entrepreneurs! Have you ever dreamt of having your own online store, selling products to the world? It might sound complicated, but with the right tools, it’s more accessible than you think. Today, we’re going to dive into building a simple e-commerce site using Django, a powerful and popular web framework.

This guide is designed for absolute beginners. We’ll break down each step, explain technical terms, and get you started on your journey to creating a functional online shop.

What is an E-commerce Site?

An e-commerce site is essentially an online store where people can browse products, add them to a virtual shopping cart, and complete purchases using electronic payment methods. Think of popular sites like Amazon or Etsy – those are prime examples! For our simple site, we’ll focus on displaying products, which is the foundational first step.

Why Django for E-commerce?

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It’s often referred to as “batteries included” because it comes with many built-in features that are common in web applications, such as an object-relational mapper (ORM), an admin panel, and a templating engine.

  • Web Framework: A set of tools and components that helps you build web applications faster and more efficiently. Instead of writing everything from scratch, a framework provides a structure and common functionalities.
  • Python: A widely used, general-purpose programming language known for its readability and simplicity.
  • Object-Relational Mapper (ORM): A technique that lets you interact with your database using Python code instead of writing raw SQL queries. This makes database operations much easier.
  • Admin Panel: A ready-to-use interface that allows you to manage your site’s content (like adding or editing products) without writing any front-end code. This is a huge time-saver!

Django’s robust nature, security features, and a large, helpful community make it an excellent choice for everything from small projects to large-scale applications, including e-commerce platforms.

Setting Up Your Development Environment

Before we write any Django code, we need to set up our computer to work with Python and Django.

1. Install Python

Django is built with Python, so you’ll need Python installed on your system.
* Visit the official Python website (python.org) and download the latest stable version for your operating system.
* Follow the installation instructions. Make sure to check the box that says “Add Python X.X to PATH” during installation on Windows, as this makes it easier to use Python from your command line.

2. Create a Virtual Environment

A virtual environment is a isolated space for your Python projects. It allows you to manage dependencies (libraries and packages) for each project separately, preventing conflicts.

Open your command line or terminal and navigate to where you want to store your project. Then, run these commands:

mkdir my_ecommerce_site
cd my_ecommerce_site

python -m venv venv

.\venv\Scripts\activate
source venv/bin/activate

You’ll know it’s activated when you see (venv) at the beginning of your command line prompt.

3. Install Django

With your virtual environment activated, install Django using pip, Python’s package installer.

pip install Django
  • pip: Python’s package installer, used to install and manage software packages written in Python.

Starting Your Django Project

Now that Django is installed, let’s create our first project.

django-admin startproject store_project .
  • django-admin: This is Django’s command-line utility for administrative tasks.
  • startproject: A command to create a new Django project.
  • store_project: This is the name we’re giving to our main project.
  • .: This tells Django to create the project in the current directory, avoiding an extra nested folder.

This command creates a few files and folders:

my_ecommerce_site/
├── venv/
└── store_project/
    ├── manage.py
    └── store_project/
        ├── __init__.py
        ├── asgi.py
        ├── settings.py
        ├── urls.py
        └── wsgi.py
  • manage.py: A command-line utility for interacting with your Django project. You’ll use this a lot!
  • store_project/settings.py: This file contains all your project’s configuration, like database settings, installed apps, and static file locations.
  • store_project/urls.py: This is where you define URL patterns for your entire project, telling Django which view function to call for a given URL address.

1. Running Migrations

Django projects come with some default database tables (for users, sessions, etc.). We need to create these in our database.

python manage.py migrate
  • Migrations: Django’s way of managing changes to your database schema (the structure of your database). migrate applies these changes.

2. Starting the Development Server

You can see your project in action by starting Django’s development server:

python manage.py runserver

Open your web browser and go to http://127.0.0.1:8000/. You should see a “The install worked successfully! Congratulations!” page. This means your Django project is up and running!

Creating an App for Products

In Django, projects are typically divided into smaller, self-contained applications (apps). This makes your code more organized and reusable. Let’s create an app specifically for our products.

python manage.py startapp products

This creates a new products folder within your project.

1. Register Your New App

Django needs to know about your new app. Open store_project/settings.py and add 'products' to the INSTALLED_APPS list:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'products', # <-- Add your new app here
]

2. Defining Models (The Blueprint for Your Products)

Models are Python classes that define the structure of the data you want to store in your database. Think of them as blueprints for your products.

Open products/models.py and define a Product model:

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    image = models.ImageField(upload_to='products/', blank=True, null=True)
    available = models.BooleanField(default=True)
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.name

Let’s break down these fields:
* models.CharField: For short strings of text (like the product’s name). max_length is required.
* models.TextField: For longer text (like a product description).
* models.DecimalField: For numbers with decimal places (like prices). max_digits is the total number of digits allowed, and decimal_places is the number of digits after the decimal point.
* models.ImageField: For uploading image files. upload_to='products/' specifies a sub-directory within your media folder where images will be stored. blank=True, null=True means the image is optional.
* models.BooleanField: For true/false values (like whether a product is available).
* models.DateTimeField: For date and time stamps. auto_now_add=True sets the date/time automatically when the object is first created. auto_now=True updates the date/time every time the object is saved.
* def __str__(self):: This method tells Django how to represent a Product object as a string, which is helpful in the admin panel.

3. Making and Applying Migrations

Whenever you change your models, you need to tell Django to create new database migrations and then apply them.

python manage.py makemigrations products
python manage.py migrate
  • makemigrations products: This command inspects your products app’s models and creates migration files that describe how to change your database to match your new models.
  • migrate: This command executes the changes described in the migration files on your actual database.

4. Registering Models in the Admin Panel

Django comes with an amazing built-in admin panel that makes managing content incredibly easy. Let’s register our Product model so we can add products through the admin interface.

First, create a superuser (an admin account):

python manage.py createsuperuser

Follow the prompts to create a username, email (optional), and password.

Now, open products/admin.py and add the following:

from django.contrib import admin
from .models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ['name', 'price', 'available', 'created', 'updated']
    list_filter = ['available', 'created', 'updated']
    list_editable = ['price', 'available']
    prepopulated_fields = {'name': ('name',)} # Optional, for slug generation later

Restart your development server (python manage.py runserver). Go to http://127.0.0.1:8000/admin/, log in with your superuser credentials, and you should see “Products” under the “PRODUCTS” section. Click on “Products” and then “Add product” to start adding some items to your store!

  • list_display: Defines which fields are displayed on the list page in the admin.
  • list_filter: Adds a sidebar filter for these fields.
  • list_editable: Allows you to edit these fields directly from the list page.

Creating Views to Display Products

A view is a Python function (or class) that takes a web request and returns a web response, typically an HTML page. Our first view will fetch all products from the database and display them.

Open products/views.py and add this code:

from django.shortcuts import render
from .models import Product

def product_list(request):
    products = Product.objects.filter(available=True)
    return render(request, 'products/product_list.html', {'products': products})
  • render: A Django shortcut function that takes the request object, a template path, and a dictionary of data to “render” (combine the template with the data) into an HTML response.
  • Product.objects.filter(available=True): This uses Django’s ORM to query the database and retrieve all Product objects where the available field is True.

Setting Up URLs

Now, we need to tell Django which URL pattern should trigger our product_list view. This involves two steps:

1. Create products/urls.py

Inside your products app directory, create a new file named urls.py:

from django.urls import path
from . import views

app_name = 'products' # This helps Django distinguish URLs from different apps

urlpatterns = [
    path('', views.product_list, name='product_list'),
]
  • path('', views.product_list, name='product_list'): This defines a URL pattern.
    • '': An empty string means this URL pattern will match the base URL for this app (e.g., /products/ if we set it up that way in the project’s urls.py).
    • views.product_list: The view function to call when this URL is accessed.
    • name='product_list': A name for this URL pattern, which makes it easier to refer to it in templates and other parts of your code.

2. Include App URLs in Project urls.py

Open your main store_project/urls.py file and include the products app’s URLs:

from django.contrib import admin
from django.urls import path, include # <-- Import include
from django.conf import settings # For media files
from django.conf.urls.static import static # For media files

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('products.urls')), # <-- Include your app's URLs here
]

if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

We added path('', include('products.urls')). This means that any request to the root of our website (/) will be handled by the URL patterns defined in products/urls.py.

We also added configuration for MEDIA_URL and MEDIA_ROOT which are essential for displaying uploaded product images. Let’s define them in settings.py:

import os # <-- Add this at the top if not already there

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media/')
  • MEDIA_URL: The base URL from which media files (like uploaded images) will be served.
  • MEDIA_ROOT: The absolute path to the directory where uploaded media files will be stored on your file system.

Designing Templates (The Look of Your Pages)

Templates are HTML files that define the structure and layout of your web pages. Django’s templating engine allows you to embed Python-like logic to display dynamic data.

First, create a templates directory inside your products app, and then another products directory inside that (this is a common Django convention to prevent template name collisions):

my_ecommerce_site/
└── products/
    ├── templates/
    │   └── products/
    │       └── product_list.html # <-- We'll create this file
    └── ...

Now, create product_list.html inside products/templates/products/:

<!-- products/templates/products/product_list.html -->

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Simple Store</title>
    <style>
        body { font-family: sans-serif; margin: 20px; background-color: #f4f4f4; }
        h1 { color: #333; text-align: center; }
        .product-list { display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 20px; max-width: 1200px; margin: 0 auto; }
        .product-item { background-color: white; border: 1px solid #ddd; padding: 15px; border-radius: 8px; text-align: center; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
        .product-item img { max-width: 100%; height: 200px; object-fit: cover; border-radius: 4px; margin-bottom: 10px; }
        .product-item h2 { font-size: 1.2em; margin-bottom: 5px; color: #007bff; }
        .product-item p { font-size: 0.9em; color: #666; margin-bottom: 10px; }
        .product-item .price { font-weight: bold; color: #28a745; font-size: 1.1em; }
    </style>
</head>
<body>
    <h1>Welcome to My Simple Online Store!</h1>

    <div class="product-list">
        {% for product in products %}
            <div class="product-item">
                {% if product.image %}
                    <img src="{{ product.image.url }}" alt="{{ product.name }}">
                {% else %}
                    <img src="https://via.placeholder.com/200x200?text=No+Image" alt="No image available">
                {% endif %}
                <h2>{{ product.name }}</h2>
                <p>{{ product.description|truncatechars:100 }}</p>
                <p class="price">${{ product.price }}</p>
            </div>
        {% empty %}
            <p>No products available yet. Check back soon!</p>
        {% endfor %}
    </div>
</body>
</html>
  • {% for product in products %}: This is a Django template tag that loops through each product in the products list passed from our view.
  • {{ product.name }}: This is a Django template variable that displays the name attribute of the current product object.
  • {{ product.image.url }}: This gets the URL for the product’s image.
  • |truncatechars:100: A Django template filter that truncates (shortens) the description to 100 characters.
  • {% empty %}: An optional tag within a for loop that displays its content if the list is empty.

Now, restart your server (python manage.py runserver) and visit http://127.0.0.1:8000/. You should see a list of the products you added through the admin panel, complete with their names, descriptions, prices, and images!

What’s Next? Expanding Your E-commerce Site

Congratulations! You’ve built the foundation of a simple e-commerce site. This is just the beginning, of course. Here are some ideas for how you could expand your site:

  • Product Detail Pages: Create a separate page for each product with more details, using a path('<int:id>/', views.product_detail, name='product_detail') URL pattern.
  • Shopping Cart: Implement functionality for users to add products to a shopping cart, view their cart, and update quantities.
  • User Authentication: Allow users to register, log in, and manage their orders. Django has a built-in authentication system to help with this.
  • Checkout Process: Develop a multi-step checkout process.
  • Payment Integration: Connect with payment gateways like Stripe or PayPal to handle actual transactions.
  • Search and Filters: Add features for users to search for products or filter them by category, price, etc.
  • Deployment: Learn how to deploy your Django project to a live server so others can access it.

Conclusion

Building an e-commerce site can seem daunting, but by breaking it down into smaller, manageable steps, and leveraging powerful frameworks like Django, you can achieve a lot. We’ve covered setting up your environment, creating a Django project and app, defining models, populating data through the admin panel, and displaying products using views and templates.

Keep learning, keep building, and don’t be afraid to experiment! The world of web development is vast and rewarding. Happy coding!

Comments

Leave a Reply

More posts