Question

Pizzeria: Start a new project called pizzeria with an app called pizzas. Define a model Pizza with a field called name, which will hold name values such as Hawaiian and Meat Lovers. Define a model called Topping with fields called pizza and name. The pizza field should be a foreign key to Pizza, and name should be able to hold values such as pineapple, Canadian bacon, and sausage. Register both models with the admin site, and use the site to enter some pizza names and toppings. Use the shell to explore the data you entered.

Short answer

Create a Django project and app, define models with relationships, register them, and use the admin to enter and query data.

Step-by-step solution

Create the Django Project

Begin by creating a new Django project called 'pizzeria'. You can do this by running the following command in your terminal: `django-admin startproject pizzeria`. This creates a new directory called 'pizzeria' with the necessary configuration for a Django project.

Create the Django App

Within the 'pizzeria' project, create a new app called 'pizzas'. Navigate to the pizzeria directory and run: `python manage.py startapp pizzas`. This will create a new directory named 'pizzas' within your project.

Define the Pizza Model

In the 'pizzas/models.py' file, define a model named `Pizza`. This model will have a single field, `name`, which is a CharField for storing the name of the pizza. ```python from django.db import models class Pizza(models.Model): name = models.CharField(max_length=100) def __str__(self): return self.name ```

Define the Topping Model

In the same 'pizzas/models.py' file, define another model called `Topping`. This model will have two fields: `pizza` as a ForeignKey linking to the `Pizza` model, and `name` as a CharField for storing topping names. ```python class Topping(models.Model): pizza = models.ForeignKey(Pizza, on_delete=models.CASCADE) name = models.CharField(max_length=100) def __str__(self): return self.name ```

Register Models with the Admin Site

To make these models accessible from the Django admin site, register them in 'pizzas/admin.py'. ```python from django.contrib import admin from .models import Pizza, Topping admin.site.register(Pizza) admin.site.register(Topping) ```

Apply Migrations

Create and apply migrations to generate the database schema for the new models. Run `python manage.py makemigrations` followed by `python manage.py migrate` in the terminal.

Enter Data in the Admin Site

Start the Django development server with `python manage.py runserver` and log in to the admin interface at `http://127.0.0.1:8000/admin`. Use the interface to add data for pizzas like 'Hawaiian', 'Meat Lovers', and their accompanying toppings.

Explore Data Using the Shell

Open the Django shell by running `python manage.py shell`. Import the models and use them to query the database. Example: ```python from pizzas.models import Pizza, Topping pizzas = Pizza.objects.all() for pizza in pizzas: toppings = Topping.objects.filter(pizza=pizza) print(pizza.name, [topping.name for topping in toppings]) ```

Key concepts

Django Project Structure

When you start with Django, getting familiar with its project structure is essential. A typical Django project consists of multiple components that work together. This structure is organized in such a way to keep the code clean and manageable.

After running `django-admin startproject pizzeria`, the following directories are created:

• pizzeria/: This is the main directory containing your project, holding the settings and configuration files.
• manage.py: This is a command-line utility that lets you interact with your project in various ways, such as running the server and creating apps.
• pizzeria/: The inner directory shares the project's name and contains crucial configuration files:
  • __init__.py: An empty file that tells Python this directory should be considered a package.
  • settings.py: Where all project's settings are specified.
  • urls.py: Controls the URLs used in your application.
  • wsgi.py: A standard for web servers and applications on how to talk to each other.
  • asgi.py: Used for asynchronous applications, bridging communication between servers.

Understanding this structure will help you navigate through your Django projects and know where and how to make changes.

Database Migrations in Django

Database migrations are an integral part of Django, used to manage changes to your database schema over time. When you define models in Django, migrations allow you to evolve these models without having to manually make changes to your database.

Once you've defined your `Pizza` and `Topping` models, you need to create migrations. These are performed using: `python manage.py makemigrations`. This command inspects your models and prepares the migration file.

After preparing the migration file, you'll execute `python manage.py migrate`. This applies the changes specified in the migration files to your actual database. By doing so, it ensures that your database schema matches your Django models.

Migrations are a powerful feature because they:

• Ensure all changes to the database schema are version controlled.
• Make it easy to replay changes across different environments.
• Help in deploying updates more safely.

Effective use of migrations will save you time and minimize errors as your project grows.

Django Admin Interface

The Django Admin Interface is a built-in tool designed for managing your Django application. It provides you with a web-based interface where you can view, add, modify, and delete content.

After defining your models, you can register them in 'pizzas/admin.py'. Once registered, these models become accessible through the admin interface, allowing you to manage your data without needing to write any SQL queries by hand.

The Django admin interface is known for its robust features:

• Data Management: Add and update entries in your database with ease.
• User Management: Manage user permissions and groups.
• Customization: Customize it by redefining admin classes or even through third-party packages!

To start the admin site, run `python manage.py createsuperuser` to create an admin user, then `python manage.py runserver`, and navigate to `http://127.0.0.1:8000/admin`. Here, you will have a powerful view to handle your pizza and topping models, making data manipulation a breeze.

Django QuerySet and Shell Usage

QuerySets in Django are a way to interact with your database models and are a powerful feature for retrieving data. By using the Django shell, a command-line interface, you can experiment with QuerySets without writing Django views or templates.

To use the shell, start by running `python manage.py shell`. This opens an interactive console where you can import your models and start querying your database.

For instance, to fetch all pizzas and their respective toppings, use the following commands:
from pizzas.models import Pizza, Topping
pizzas = Pizza.objects.all()
for pizza in pizzas:
  toppings = Topping.objects.filter(pizza=pizza)
  print(pizza.name, [topping.name for topping in toppings])

This code retrieves all pizza entries and their linked topping names from the database. QuerySets can handle most of the database operations you'll need, such as filtering, excluding, sorting, and aggregating.

Advantages of Using QuerySets and Shell:

• Quickly test database queries and model methods.
• Debug and verify data integrity.
• Understand and predict the output of your queries efficiently.

Embrace QuerySets and the shell to gain deeper insights into your data model operations.