Introduction to Django Training (DJG101)

This Introduction to Django course is designed for Python developers looking to build dynamic, database-driven web applications using the Django framework. You'll learn the fundamentals of Django, from setting up your development environment to creating a complete web application, working with models, templates, and views, and managing static and dynamic content.

The course begins with Setting Up Your Computer, where you will configure your development environment, install recommended software, and learn to run Python effectively.

Next, you'll dive into Getting Started with Django, which covers the basics of server-side development, creating a virtual environment, and installing Django. You'll learn to create new projects and apps, explore Django’s source code, work with templates, and build web pages such as an "About Us" page.

The Git, GitHub, and an App with a Model module introduces version control with Git and GitHub. You'll create Django projects and apps, build models, and understand different types of views. You will also practice creating, updating, and deleting objects using Django's built-in functionality.

In Template Filters and Tags, you'll learn to use Django's powerful templating language to dynamically render content. This module covers adding template context, using template filters and tags, and creating custom filters and tags.

The course then covers Static Files, explaining how to manage and serve static files in Django, and provides exercises to add static files to your Django project.

You'll explore the Django Admin and the User Model, learning to set up and customize the Django admin interface, create custom user models, and manage database integration with PostgreSQL.

In the URLs and Slugs module, you'll learn to create slug-generating functions for SEO-friendly URLs and modify your Django models to use slugs effectively.

The Sending Email with SendGrid module teaches you how to set up email functionality using SendGrid, including creating utility functions and handling transactional emails.

Forms and Widgets covers form processing in Django, including creating and customizing forms, using different field types, and enhancing forms with Django's crispy-forms package.

You'll dive into ModelForms, where you will learn to tie forms directly to Django models, manage many-to-one and many-to-many relationships, and update your templates accordingly.

Finally, the course concludes with User Registration, covering the user registration process using django-allauth, customizing authentication pages, and implementing user-specific content such as jokes and job applications.

By the end of this Introduction to Django course, you will have a solid foundation in building and deploying dynamic web applications using Django. You will be equipped with the skills to manage databases, handle forms and user input, create custom user models, use Git for version control, and implement key features like authentication, email sending, and URL management, allowing you to create robust and scalable web applications.

1. Setting Up Your Computer
   1. Demo and Exercise Files
   2. Recommended Software
   3. Running Python
2. Getting Started with Django
   1. Welcome to the Server-side
   2. Google Chrome DevTools: Network Tab
   3. Creating the Virtual Environment
   4. Exercise: Creating a Virtual Environment and Installing Django
   5. Exploring the Django Source Code
   6. Creating a New Project
   7. Exercise: Hello, Django!
   8. Settings
   9. Django Apps
   10. Creating a New App
   11. Exercise: First Django App
   12. Exercise: Working with Templates
   13. Exercise: Creating an About Us Page
3. Git, GitHub, and an App with a Model
   1. djangojokes.com
   2. Version Control Systems, Git, and GitHub
   3. Exercise: Setting Up VS Code, Git, and GitHub
   4. Exercise: Creating the Project
   5. Exercise: Creating a pages App
   6. Exercise: Creating the jokes App
   7. Models
   8. Exercise: Migrating
   9. Exercise: Creating a Model
   10. Types of Views
   11. Exercise: Creating a ListView
   12. Exercise: Creating a DetailView
   13. GET and POST Requests
   14. Exercise: Creating and Updating Jokes
   15. Deleting Objects
   16. Exercise: Deleting Jokes
4. Template Filters and Tags
   1. Exercise: Setting Up the Project
   2. get_context_data()
   3. Exercise: Adding Template Context
   4. Template Filter Basics
   5. Exercise: Adding Filters
   6. Most Useful Template Filters
   7. Template Filter Quick Reference
   8. Template Tag Basics
   9. Most Useful Template Tags
   10. Template Tag Quick Reference
   11. Custom Filters
   12. Exercise: Creating Custom Filters
   13. Custom Tags
   14. Exercise: Creating Custom Tags
5. Static Files
   1. Static File Basics
   2. Exercise: Adding Static Files to Django Jokes
   3. Review of the Settings
6. Django Admin and the User Model
   1. The Database
   2. Exercise: Setting Up PostgreSQL
   3. The Default User Model
   4. Exercise: Creating a Custom User Model
   5. Referencing the User Model
   6. Exercise: Getting Started with Django Admin
   7. Exercise: Adding the jokes Table to Django Admin
   8. Exercise: Installing the Django Admin Documentation Generator
7. URLs and Slugs
   1. Slugs
   2. Exercise: Creating a Slug-generating Function
   3. Exercise: Changing Jokes to Use Slugs
8. Sending Email with SendGrid
   1. Transactional Email Services
   2. Exercise: Getting a SendGrid Account
   3. Exercise: Creating an Email Utility Function
9. Forms and Widgets
   1. Form Processing
   2. Understanding Form Fields
   3. Exercise: Creating a Job Application Form
   4. Core Field Arguments
   5. Exercise: Building out the Application
   6. Typed Choice Fields
   7. Changing Widgets
   8. Exercise: Improving the Job Application Form
   9. Validators
   10. Exercise: Crispy Forms
   11. Exercise: Making the Joke Form Crispy
10. ModelForms
    1. Models
    2. Model Fields
    3. Model Field Arguments
    4. ModelForms
    5. Exercise: Creating a ModelForm
    6. Many-to-One Relationships
    7. Exercise: Adding Joke Categories
    8. Many-to-Many Relationships
    9. Exercise: Adding Joke Tags
    10. Exercise: Updating the Joke Templates
    11. Exercise: Tying Job Applications to Models
11. User Registration
    1. The User-Registration Process
    2. Exercise: Getting Started with django-allauth
    3. django-allauth Templates
    4. Exercise: Making the Authentication Pages Crispy
    5. Exercise: Updating the _base.html Template
    6. Email Templates
    7. Exercise: Custom User Registration
    8. Exercise: Creating a My Account Page
    9. Exercise: Associating Users with Jokes
    10. Mixins
    11. Exercise: Restricting Joke Creating and Updating

Each student receives a comprehensive set of materials, including course notes and all class examples.

Experience in the following is required for this Django class:

Experience in the following would be useful for this Django class: