Python Django E-commerce Project Flashcards

24 sample cards from the Django E-commerce Project deck

Sampled from the end of the deck, so these are different cards from the ones shown on the syllabus page.

1. What is the standard pattern for a one-to-one user profile model?

   Define a `Profile` model with `user = models.OneToOneField(User, on_delete=models.CASCADE)` plus extra fields, so each user has exactly one profile accessed via `user.profile`.

2. How can you automatically create a profile whenever a new user registers?

   Connect a `post_save` signal on the `User` model: when `created` is True, create the related `Profile`. Register the receiver in the app's `apps.py` `ready()` method or `signals.py`.

3. What is the difference between `request.user` for an authenticated vs. anonymous request?

   For a logged-in request, `request.user` is a `User` instance with `is_authenticated == True`. For an anonymous request it is an `AnonymousUser` instance whose `is_authenticated` is `False`.

4. Write a minimal `Product` model with name, price, and stock fields.

   ```python class Product(models.Model): name = models.CharField(max_length=200) price = models.DecimalField(max_digits=10, decimal_places=2) stock = models.PositiveIntegerField(default=0) ```

5. Why use `DecimalField` rather than `FloatField` for product prices?

   `DecimalField` stores exact fixed-point decimals, avoiding the binary floating-point rounding errors of `FloatField`—essential for monetary values. You specify `max_digits` and `decimal_places`.

6. How do you link a `Product` to a `Category` so each product belongs to one category?

   Add `category = models.ForeignKey(Category, on_delete=models.CASCADE, related_name='products')`. This creates a many-to-one relation; access a category's products via `category.products.all()`.

7. What field type and setting let a product have a clean URL-friendly identifier?

   A `SlugField`, e.g. `slug = models.SlugField(unique=True)`. It stores a URL-safe string (letters, numbers, hyphens) used to build product detail URLs.

8. Why is defining `get_absolute_url()` on the `Product` model useful?

   It returns the canonical URL for a product instance (via `reverse()`), letting templates and the admin link to it with `{{ product.get_absolute_url }}` and centralizing URL logic.

9. What is the difference between a function-based `ListView` written manually and Django's generic `ListView` for product listing?

   A manual function view calls `Product.objects.all()` and renders a template explicitly. The generic `ListView` sets `model = Product` (or a `queryset`) and handles fetching, pagination, and context automatically via `object_list`.

10. How do you paginate a product listing in a function-based view?

    Use `django.core.paginator.Paginator`: `paginator = Paginator(products, 12)`, then `page_obj = paginator.get_page(request.GET.get('page'))`, and pass `page_obj` to the template.

11. How do you query only the products that are in stock for a listing view?

    Filter the queryset, e.g. `Product.objects.filter(available=True, stock__gt=0)`. The `__gt` lookup means "greater than" so only products with stock above zero are returned.

12. What does a product detail view need to do, and how does it fetch the right product?

    It retrieves a single product (typically by slug or pk) and renders its full information. Use `get_object_or_404(Product, slug=slug)` so a missing product returns a 404 instead of an exception.

13. In a URL pattern, how do you capture a product's primary key to pass to a detail view?

    Use a path converter: `path('product/<int:pk>/', views.product_detail, name='product_detail')`. The `<int:pk>` captures an integer and passes it as the `pk` keyword argument.

14. What does `get_object_or_404` do and why is it preferred over a plain `get()`?

    It calls the manager's `get()` and raises `Http404` (a proper 404 page) if no object matches, instead of letting `DoesNotExist` propagate as a 500 server error.

15. Describe two common strategies for storing a shopping cart in Django.

    1) Session-based: store cart data (product ids and quantities) in `request.session`—works for anonymous users, no DB model needed. 2) Database-based: `Cart` and `CartItem` models tied to a user—persists across devices and sessions.

16. Define a `CartItem` model that links a cart, a product, and a quantity.

    ```python class CartItem(models.Model): cart = models.ForeignKey(Cart, on_delete=models.CASCADE, related_name='items') product = models.ForeignKey(Product, on_delete=models.CASCADE) quantity = models.PositiveIntegerField(default=1) ```

17. For a cart item with unit price $p$ and quantity $q$, what expression gives its line subtotal?

    The line subtotal is $p \times q$. The cart total is the sum over all items: $$\text{total} = \sum_{i=1}^{n} p_i \cdot q_i$$

18. What is the core logic of an 'add to cart' view?

    Get the product (e.g. `get_object_or_404`), read the requested quantity, then either create a new cart item or increment the quantity of an existing one—commonly via `get_or_create`—save it, and redirect to the cart page.

19. How does `get_or_create` simplify add-to-cart logic?

    `CartItem.objects.get_or_create(cart=cart, product=product)` returns `(item, created)`. If the item exists you get it back (`created=False`) and increment its quantity; otherwise it creates a new one—avoiding manual existence checks.

20. After processing an add-to-cart POST, why return a redirect instead of rendering directly?

    To follow the Post/Redirect/Get pattern: redirecting prevents the form from being re-submitted if the user refreshes the page, avoiding accidental duplicate additions.

21. What must an 'update cart' view do when a user changes an item's quantity to zero?

    If the new quantity is zero (or less), delete the `CartItem` rather than saving a zero-quantity row; otherwise update `item.quantity` and save. Then redirect back to the cart view.

22. How does a cart view typically compute and display the grand total?

    It iterates the cart's items, multiplies each item's `product.price` by its `quantity` for line totals, and sums them—often via a model method `get_total()` returning `sum(item.get_subtotal() for item in self.items.all())`.

23. What two management commands apply model changes to the database, and what does each do?

    `python manage.py makemigrations` generates migration files from model changes; `python manage.py migrate` applies those migration files to the database schema.

24. What command creates an admin superuser so you can manage products and orders via Django admin?

    `python manage.py createsuperuser`. It prompts for username, email, and password, then you log in at `/admin/` to manage registered models.

What this deck covers

Django E-commerce Project flashcards FAQ