Django for Python Developers

Understand what a web application is, how web clients and servers communicate via http, and the roles of url, port 80, and common servers and browsers.

install Django with pip after confirming python 3.x is installed, then verify the Django version using python -m django --version and ensure you're using the latest release.

Install Visual Studio Code and configure Python and Django extensions to enable Django project development, use the integrated terminal to run commands, and drag and drop projects into VS Code.

Install and configure the atom ide to streamline Django project development, enabling Python autocomplete and Django support with the atom-django package, and adjust indentation and tab length.

Install MySQL and MySQL Workbench using the MSI installers, configure a root password, and ensure Workbench is selected so the server runs as a service on Windows or Mac.

Launch MySQL Workbench, establish a new local connection, test the connection with the configured root password, and create a database named mydb for use in lectures.

Learn to download and install the MySQL community server on Windows, including prerequisites like Visual C++ and server-only installation, set the root password, and start the service.

Start your first Django project by running manage.py with python3 in the project folder, then launch the development server and open localhost:8000 to view it.

Create a Django app inside your project with manage.py startapp named first_app, and learn core files like models.py, views.py, admin.py, and migrations that drive the app.

Create a new Django app inside the project, register it in settings, and build a view returning a code via stdp response; connect it with a /court URL.

Move each Django app’s URLs to the app level and include them in the project URL configuration. Enable reusable, app-level routing across projects.

Learn to create and activate Python virtual environments to isolate project dependencies and avoid conflicts in Django projects. Use pip to install packages, manage site-packages, and run server at localhost:8000.

Explore the Django MVT pattern, learn how templates render dynamic HTML using data from views, and handle static content with template tags to deliver a polished UI.

Create and render Django templates from a view, pass a user name and employee information, include static files, and use tags to display categorized products in a mini e-commerce project.

Create a new Django project and a templates app, establish a templates directory per application, and configure settings to point Django to that templates path for rendering templates.

Learn to render dynamic data in Django templates using template tags and the Django template library, including variables, csrf_token, extends, if, and for loops, processed by the Django template engine.

Learn to add static content by creating a static directory and configuring Django settings to point to static files, then reference images and styles via the static URL in templates.

Create a Django project called product templates and a product app, then configure templates and static directories to display the home page with category links for electronics, toys, and shoes.

Map views to urls in Django by defining url patterns for index, electronics, toys, and shoes, render the index.html template, run the server, and verify navigation in localhost:8000.

Explore how Django models map to database tables in the MVT architecture, with fields like first name, last name, and salary, and how makemigrations and migrate manage the tables.

Configure settings.py to use MySQL, set engine, database name, user, and password; create Employee DB and validate the connection with manage.py shell.

Create a Django model named employee by extending models.Model, defining first name, last name, salary, and email fields with appropriate types and constraints.

Convert your Django model to database tables by creating migrations with python manage.py makemigrations and applying them with python manage.py migrate, showing the generated sql and EMP app employee table.

Import the employee model and retrieve all employees with employee.objects.all, then pass the list in a dictionary named employees to the template.

Configure templates directory in django settings, create a templates folder, and render employee table using for loop with first name, last name, salary, and email, including no data found message.

Explore how to display employee model fields in the Django admin UI by creating an EmployeeAdmin class and configuring list_display to show first name, last name, salary, and email.

Configure and use the default SQLite database in a Django project, run migrations with manage.py, inspect tables via shell, and note production use of Oracle or MySQL.

Explore how the django orm filters data with filter and get, using operators like gt, gte, lt, lte, contains, and icontains, including in queries with in for multiple ids.

Learn to perform aggregate operations in Django by using aggregate with average, maximum, minimum, sum, and count on fields like salary to derive insights from data.

Use Django's ORM to bulk create employees with Employee.objects.bulk_create by passing a list of employee dictionaries. Include first name, last name, and salary, then verify records appear in the database.

Learn to delete a single record by fetching it and calling delete, and perform bulk deletes by filtering a query set and invoking delete on the results.

Fetch a single record in Django, update its first name, and save to apply the change in the database; this lecture also shows deleting all records as a contrast.

Order data with the order_by function, control ascending and descending orders, and slice results by index or range. Sort by salary or first name, and ignore case with lowercase function.

Learn to collect data from end users and process it with Zango forms that generate html forms on the fly, enabling Python-driven form creation with built-in and custom validations.

Create and render a user registration form with forms.py, send it via the view to a template, include a CFRS token, and process submitted data in the view.

Set up a Django project and forms app from the command line, configure templates, and integrate a templates directory into settings to prepare for form rendering.

Learn to use the user registration form inside a Django view by importing the forms module, initializing the form, and passing it in a dictionary to the template for rendering.

Create an html template in templates/forms_demo to render a Django form using template tags, with a user registration page and options to render as paragraphs, tables, or unordered lists.

Process form data in a Django view by handling post, constructing the user registration form, validating with is_valid, and reading form.cleaned_data for first name, last name, and email.

Discover default zango form validations that enforce required fields and numeric input for integer fields like ssn. Make fields optional by setting required to false.

Learn to add per-field custom clean methods in Django forms, validating first name and email with self.cleaned_data, raising validation errors, and returning cleaned data to the view.

Implement a single form clean method to validate all fields by calling super().clean, retrieving the cleaned data dictionary, and raising errors for fields such as first name with 20-character max.

Learn to replace custom validation with zango's inbuilt validators, including min length, max length, and regular expression validators, and use the built-in email field for automatic validation.

Create model-based forms from a project model using a meta class to include all fields, render and process the form in a view, and save the data to the database.

Create Django views for the app: an index view with links to list all projects and to add a project, and a list_projects view that displays all projects via Project.objects.all.

Create the add project view by rendering the project form, validating a post request, saving via the model form, and redirecting to the index page.

Run django migrations to create database tables, fix errors in model forms that require a max length attribute, and migrate the project, then verify the resulting tables in mysql workbench.

Run migrate creates security-related and internal tables, such as auth_user, auth_group, and mapping tables, plus contenttypes, admin log, migrations, and sessions used for authentication, authorization and admin features.

Create a student model in Django, read all students to display on the home page, and enable creating, updating, and deleting records via the interface using zango orm.

Create a Django project and app, configure templates, define a student model (first name, last name, test score), and generate a ModelForm using all fields.

Configure the database and URLs for the Django project, run makemigrations and migrate to create tables, then test the application.

Define create student view, import the student form, render an empty form on get, validate and save on post, then redirect to home, using a create.html template with csrf token.

Test the create functionality in Django by using the correct csrf token, linking to a create student form, saving the data to the database, and redirecting to the home page.

Implement the delete operation by fetching a student by id, deleting the record, and redirecting to the home page; configure a url with an id parameter and add delete links.

Configure the Django URL and test the update operation for a student record, using the update view, id-based retrieval, and database-backed UI changes to reflect edits.

Convert update flow to use a form built from the student object via form instance, render with form.as_table, and submit a dictionary instead of raw student data.