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.

Capture user input, query the database, and generate a dynamic HTML page on the fly, then send the response through the web container back to the browser.

Learn what Django is and why we should use it: a versatile web application framework that handles server-side programming, with inbuilt ORM, content administration, RSS, security features, and scalable deployments.

Adopt the mvt pattern in Django by routing requests through urls.py to the appropriate view, which uses a model and a template to produce the response.

Learn how a Django project relies on multiple applications to maximize code reuse and maintainability, creating a project first and then modular applications within it.

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.

Install MySQL Workbench and launch the installer, then set up a local connection to a MySQL server and create a database in the query window.

Install mysqlclient to enable Django and Python applications to connect to a MySQL database using pip install mysqlclient.

Create your first django project with the django-admin command, organize it under a django projects folder, and learn files like settings.py, urls.py, wsgi.py, __init__.py, and manage.py with sqlite by default.

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.

Configure settings.py, register the first app in installed apps, and build a function-based view that returns an HttpResponse with an h1 message.

Configure a url to the view you created by importing the views module and mapping the path, then run the server on port 8000 and test the hello endpoint.

Create a Django view using the daytime module to return the current date and time as a string, and map the view to a URL in the dev server.

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.

Create and render a Django template using the render function in views.py, wiring a first_template.html under templates and displaying it in the browser; learn the basics of the model-view-template pattern.

Configure a url for the templates app view, map a path in the project, and render first_template.html using render; run the server and view it at localhost:8000/first_template.

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 pass data dynamically from a Django view to a template using render with a dictionary as context, and display it in the user interface via template tags.

Create a Django view and template to display an employee's id, name, and salary from a static dict, map it to a url, and render with template tags.

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.

Explore loading static files in a Django application after an upgrade, using the load static template tag instead of the older load staticfiles.

Load static images in Django templates with the load static tag and static paths, then reference images from static/images in the template.

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.

Create Django templates to power an online shopping portal by defining index.html with category links (electronics, toys, shoes) and a reusable products.html that renders category data from views.

Create three Django views in views.py that return three datasets to a single template via render, using dictionaries for products, price, and shoes and toys.

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.

Create an employee model with first name, last name, salary, and email, migrate to create database tables, then fetch data in a view and render with a template.

Create a Django project and an employee model within an app, configure the default SQLite database, run migrations, and validate the database connection via the Python shell.

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.

Learn to run and test a Django MVT application by wiring the model, view, and template, starting the local server, and rendering a data-driven HTML table from the database.

Discover how Django provides a default admin UI to view and edit models, access it at /admin, and log in using a created superuser to manage users, groups, and data.

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.

Learn to retrieve multiple or single employee records with Django ORM using the shell, via all and get, and inspect the queryset type and underlying query.

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 Django query syntax using and, or, and not with filter and Q objects, and exclude to combine conditions on first_name, last_name, and salary.

Learn to fetch selective columns in Django's ORM using values_list, values, or only, selecting first name and salary while noting that only includes id by default.

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.

Learn how to create, read, update, and delete employee records in Django ORM by saving a model instance and by using objects.create, with practical database examples.

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.

Create your first zango form in a user registration app by defining a user registration form class extending forms.form and adding first name, last name, and email fields.

Learn how cross site request forgery is prevented with a built-in csrf token, injected as a hidden field by zango and validated by middleware to protect server data.

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.

Add a CSRF token to the form to prevent cross-site request forgery, and configure the URL for user registration by mapping a path to the user_registration view.

Create and render your first zango form, include the CSRF token, and add a submit button; run the server to view the user registration form in the browser.

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.

Learn to customize Django forms with the widget attribute to render different html input types, including text, text area, file input, email, password, and select.

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.

Learn to build model-based forms in Django by creating a form that inherits from ModelForm, uses Meta class to link a model and fields, and saves data to the database.

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 a Django project and define a Project model with start date, end date, name, assigned to, and a numeric priority. Configure templates and settings to complete the setup.

Create a model form by extending forms.model form, import the project model, and define a Meta inner class to specify the model and include all fields from the project model.

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.

Create the index template by adding index.html in the templates folder and embedding two hyperlinks for list projects and add projects using anchor tags with hrefs, preparing for url mapping.

Create the add project template by wiring project.html under model forms, using a post form with CSRF token and a submit button to capture end-user input.

Configure urls for django views by importing views and defining paths for index, list_projects, and add_project, ensuring the root and trailing slash align with index.html and the navigation links.

Configure a mysql database for your Django project by creating Project DB, switching the engine from sqlite to mysql, and testing the connection with manage.py shell.

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.

Refactor and run the Django application, fixing minor issues such as the templates folder name, template syntax, and view references, then add and list a project to verify data persists.

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.

Implement the read operation by building a Django view that fetches all students and renders them in fbv/index.html as a table of id, first name, last name, and test score.

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

Test your Django app by running the server with python manage.py runserver, fix syntax errors in views.py, and insert records to verify data in the database.

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.

This lecture demonstrates implementing the update operation by fetching a student by id and rendering a prefilled update form. It then processes post data to save changes and redirect.

Learn to build an update.html form by hand in Django, including a post method and CSRF token, with prefilled fields for student id, first name, last name, and test score.

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.