Introduction to Python and Django

TL;DR

You'll learn why Python is a great first programming language due to its simplicity and readability, and then see how Django uses Python to quickly build powerful web applications. Understanding these basics will set you up to create your own web projects.

1. The Mental Model

Think of Python as a versatile toolset for solving many problems, from simple scripts to complex programs. Django is like a pre-built workshop that uses Python tools specifically to construct web applications efficiently.

2. The Core Material

Python is a high-level, interpreted programming language, meaning it's designed to be easy for humans to read and write, and you don't need to compile it before running. This makes it a fantastic language for beginners.

Why Python?

Photo by Diana ✨ on Pexels

• Readability: Python's syntax is very clean and often looks like plain English. This makes it easier to learn and understand what code does.
• Versatility: You can use Python for web development, data analysis, artificial intelligence, automation, and more.
• Large Community: Lots of people use Python, so there are many resources, libraries, and support available.

Here's a simple Python example:

# This is a comment - Python ignores it
name = "Alice"
age = 30
print(f"Hello, {name}! You are {age} years old.")

When you run this code, it'll output: Hello, Alice! You are 30 years old.

What is Django?

Photo by Ann H on Pexels

Django is a web framework built with Python. A web framework provides a structure and tools to build web applications faster and more securely. Think of it as a set of blueprints and pre-made components for building websites.

Django follows the Model-View-Controller (MVC) architectural pattern, though Django itself calls it Model-View-Template (MVT).

graph TD
    A["User's Browser"] --> B["HTTP Request"];
    B --> C["Django URL Dispatcher"];
    C --> D["View (Python function/class)"];
    D --> E{"Needs Data?"};
    E -- Yes --> F["Model (Database interaction)"];
    F --> G["Database"];
    G --> F;
    F --> D;
    E -- No --> D;
    D --> H["Template (HTML structure)"];
    H --> I["Rendered HTML Response"];
    I --> J["User's Browser (Displayed Page)"];

• Model: This is your data structure. It defines how your data is stored in the database (e.g., a "User" model might have fields for username, email, password). Django's Object-Relational Mapper (ORM) lets you interact with the database using Python code instead of raw SQL.
• View: This is where the logic happens. A view receives a web request, processes it (maybe retrieves data from the Model), and then prepares a response.
• Template: This is the visual part. It's usually an HTML file with special Django syntax that allows it to display dynamic data passed from the View.

How Django Simplifies Web Development

Photo by Pixabay on Pexels

• Don't Repeat Yourself (DRY) Principle: Django encourages reusing code and components, which saves time and reduces errors.
• Batteries Included: It comes with many features out-of-the-box, like an admin panel, authentication system, and ORM.
• Security: Django has built-in protections against common web vulnerabilities like SQL injection and cross-site scripting (XSS).

3. Worked Example

Let's imagine creating a simple blog post using Django's MVT structure.

1. Model (Python): You'd define how a blog post looks in your models.py file.

   ```python

   myblog/models.py

   from django.db import models

   class Post(models.Model):
   title = models.CharField(max_length=200)
   content = models.TextField()
   pub_date = models.DateTimeField('date published')

   def __str__(self):
       return self.title
   

   `` ThisPostmodel tells Django to create a table in your database withtitle(text up to 200 chars),content(longer text), andpub_date` (date and time).

2. View (Python): You'd write a function in views.py to get all blog posts and send them to a template.

   ```python

   myblog/views.py

   from django.shortcuts import render
   from .models import Post

   def post_list(request):
   posts = Post.objects.all().order_by('-pub_date') # Get all posts, newest first
   context = {'posts': posts} # Prepare data for the template
   return render(request, 'myblog/post_list.html', context)
   `` Thispost_listfunction fetches allPostobjects and puts them into a dictionary calledcontext` to be used by the template.

3. Template (HTML + Django template language): You'd create an HTML file post_list.html to display the posts.

   html <!-- myblog/templates/myblog/post_list.html --> <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>My Blog</title> </head> <body> <h1>Blog Posts</h1> {% for post in posts %} <div> <h2>{{ post.title }}</h2> <p>{{ post.content }}</p> <small>Published on: {{ post.pub_date }}</small> </div> <hr> {% endfor %} </body> </html>
   The {% for post in posts %} loop iterates through each post passed from the view, and {{ post.title }} displays the title for each one.

4. Key Takeaways

• Python is a highly readable and versatile programming language, great for beginners.
• Django is a powerful Python web framework that streamlines web application development.
• Django uses the Model-View-Template (MVT) pattern to organize application logic.
• The Model handles data, the View handles logic, and the Template handles presentation.
• Django includes many features "out-of-the-box" like an admin interface and authentication.

Common Mistakes to Avoid:
- Not indenting your Python code correctly; Python uses indentation for code blocks.
- Trying to write raw SQL when Django's ORM can usually do it more simply and safely.
- Mixing too much logic directly into your templates; templates should mostly be for display.
- Forgetting to run Django migrations after changing your models, which updates your database schema.

5. Now Try It

Install Python on your computer if you haven't already. Then, open your Python interpreter or a Python file and write a short program that:
1. Asks you for your favorite animal using input().
2. Prints a message saying something nice about that animal.

What success looks like: You can run your Python script, input your animal, and see your customized message printed in your terminal.