Python Django: Ultimate Beginners Course

install and run the final Django project on Windows by setting up a virtual environment, installing dependencies from requirements.txt, and launching the Django server with manage.py runserver.

Install Python 3.11.1 on Windows, add to path, verify version, then install and configure Visual Studio Code with themes and extensions like plastic, prettier, auto rename tag, and Django support.

install Python 3 on macOS and verify Python 3 and pip3, then install Visual Studio Code, customize the theme, and add extensions like Prettier, Auto Rename Tag, and Django support.

Discover how pip installs and manages Python packages, explore the Python package index at pypi.org, and learn to install Django and Django Rest framework to build your application.

Explore virtual environments that isolate each project's dependencies and packages. See how Twitter, Airbnb, and Uber would run in separate environments, preparing you to create your own per-project setups.

Set up a Django project on Windows by creating a dev folder and a virtual environment, activating it, then installing Django. Create the Elevate project and run the development server.

Set up a Django project on macOS by creating a dev folder and a virtual environment. Install Django, start a project Elevate, and run the server.

Explore the default Django project structure, including manage.py for commands, settings.py for configuration and databases, urls.py for routing, wsgi/asgi for servers, and the initial SQLite database for local development.

Explore the concept of a Django app within a Django project, distinguishing internal apps from external ones installed via pip, and learn how apps use urls, views, templates, and models.

Configure a Django app by creating a CRM app and adding it to installed apps. Migrate external apps and run the server to verify no errors.

Examine the Django app's default files, including admin.py, models.py, migrations, views.py, and __init__.py. Learn how these files configure the admin page, define models, manage migrations, support views, and sqlite databases.

Explore how URLs map to routes and how views return HTTP responses in Django, with examples like registration pages, blog routes, and base website structure.

Create a simple Django web page by defining a register view that returns an HttpResponse and mapping it to a register URL in urls.py, then test by visiting /register.

Set up and organize your Django app by using the views.py file alongside urls.py, ensuring clean structure, coherent URLs, and clearly defined views.

Learn to structure Django URLs by creating an app-level urls.py, wiring it to the project with include, and defining views.py functions like register and a home page that return HttpResponse.

Explore templates in Django, text files using the Django template language to render HTML templates, with CSV and XML as other examples, and learn how to configure rendering in views.

Configure template rendering by creating a templates/CRM directory in your Django app and adding index.html and register.html, then replace HttpResponse with render in views and reference CRM/index.html and CRM/register.html.

Learn how template inheritance lets you build a base template with reusable elements and blocks, then extend and override those blocks in child templates using Django's template language.

Configure template inheritance in Django by creating a base.html, using extends and block content in index.html and register.html to share elements like a nav bar and headings.

Explore the Django template language (DTL) for rendering data in templates, passing variables with double curly braces, and using if statements, for loops, lists and dictionaries as object-like data.

Learn how to pass variables to a Django template using a context dictionary, render the template, and reference the key first_name to output values like John Doe.

Explore phase two of the Django template language, learning built-in tags like csrf token, extend, if, and for, and how they enable Python-styled logic in templates.

Pass a context dictionary and render data using if, else, and end if tags in a Django template, then test conditions to display welcome messages or access denied.

Explore the Django template language dot notation for dictionary, attribute, and list index lookups, recap lists and dictionaries, and prepare for the hands-on looping activity.

Render data with for loop tags in Django templates by building a client list of two dictionaries and looping to output id, name, and occupation in index.html.

Practice looping lists and dictionaries in Django templates, using a sample exam list with id, name, and grade, and learn how to pass context and render for endfor blocks.

Learn what databases are, compare relational and non-relational models, and see how SQL, SQLite, Postgres, and MySQL store, query, and output data in Django apps.

Evaluate the SQLite database in a Django project by revisiting the default database settings in settings.py. Learn how to swap to MySQL or Postgres for development and testing.

Learn how to access the Django admin panel, start the server, create a super user, log in, and manage users, groups, and models through the admin dashboard.

Learn how Django models map to database tables using Python classes in models.py, with fields defined as attributes and the Django ORM handling an automatic id for each record.

Create a Django model named task with title (char field, max 50), description (text field, max 1000), and created (date time, auto add). Run makemigrations and migrate to SQLite.

Register your Django models in the admin panel by importing the task model, calling admin.site.register, and managing task objects through the admin interface.

Explore how foreign keys link two database tables by referencing attributes from another table, with examples using task and review tables and the FK notation in Django models.

Learn how to link two Django models with a foreign key, create a review model tied to a task, and configure on_delete cascade and migrations.

Discover how database queries work in Django, using the ORM to select all records or a single record, and to update or delete data on a model like user.

Learn to perform database queries on Django model objects by creating sample tasks and wiring views, templates, and URLs to render all tasks on a task page.

Execute single-object queries using Django's ORM: fetch a task by id with Task.objects.get(id=...), pass its title, description, and created to a template, and confirm in the admin page.

Explore CRUD—create, read, update, delete—and how Django model forms convert a Django model into a form to collect and submit data for user registration.

Create your first Django model form by building forms.py with TaskForm (ModelForm), linking to the Task model and fields title and description, and wire up a task_form.html view with URLs.

Create your first Django model form and render it via a view and context. Link the URL, enable CSRF protection, and display fields from forms.py.

Create a task using Django model forms, validate and save on post, then redirect to the task page; rename the url, view, and template to create task for clarity.

Improve your Django app’s design and navigation by adding a base navigation bar, clearer task routes (home, create task, view tasks, register), and clean template inheritance.

Review the read operation in model forms by querying the database, passing the result to the template via context, and displaying each task's id, title, description, and creation date.

Explore how dynamic urls let you navigate to unique pages by inserting values into the url during an http request, using placeholders like str and pk.

Learn to implement the update step of CRUD in Django by building a dynamic update form with a primary key, pre-filled data, validation, and redirection.

Implement delete functionality for a Django model form by creating a delete task page, wiring URLs, handling post requests to delete the task, and redirecting to the view tasks page.

Explore static files in Django by understanding how CSS, JavaScript, and images that don't change are served directly from the server, while media folders handle user uploads.

Create a static folder in the project root and configure Django to use it. Edit settings.py to point static files to base directory/static, then run the server to verify.

Set up CSS and JavaScript files in Django by creating static/css and static/js, linking styles.css and app.js in base.html, and testing with a Hello world alert.

Set up and display a simple image in a Django app by using a static/images folder, loading static in templates, and updating index.html while noting media for user uploads.

Create a new user by using Django's user creation form and a model form, rendering a registration page, validating and saving data via a post request with CSRF protection.

Learn to implement user authentication in a Django app by creating login and dashboard templates, wiring views and urls, and handling post requests with an authentication form.

Add logout functionality to a Django app by creating a logout view, wiring a URL, and linking it in dashboard to expire the session and redirect to the home page.

Learn to protect views in Django by applying the login_required decorator to restrict access to dashboards and other pages, redirecting unauthenticated users to the login page.