2 | Django training, initial installation and setup

Django Project Setup and Virtual Environments
📌 The session continues the Django framework tutorial, focusing on setting up the project structure after initial installation.
👩‍💻 While manually creating a virtual environment (using `pip install virtualenv`) is possible, the instructor strongly recommends using an IDE like PyCharm for new users to avoid confusion between manual and IDE-managed environments.
⚙️ PyCharm automatically manages the virtual environment (`venv`) when creating a new project, placing dependencies in the `venv/lib/site-packages` directory.

Understanding Django's Structure (MTV Pattern)
📚 Django primarily uses the Model-View-Template (MTV) pattern, contrasting with Node.js's Model-View-Controller (MVC).
🔹 Model: Handles all database interactions and defining table structures.
🔹 View: Contains the logic for handling requests, user authentication checks, and communicating with the Model and Template.
🔹 Template: Renders the final HTML output (UI) seen by the user.

Implementing a Custom Homepage (View and Template)
⚙️ To customize the default page, a new Python file named `views.py` must be created within the app directory.
➡️ A function (e.g., `home_page`) is defined in `views.py` that accepts a `request` object and uses the `render()` shortcut, importing it from `django.shortcuts`.
📌 The basic structure for rendering the home page is: `return render(request, 'home_page.html', context)`.

URL Routing Configuration
🔗 To map a URL path to the new view function, the `urls.py` file must be updated.
➡️ The configuration requires defining the path (e.g., empty string `''` for the root URL) and linking it to the imported view function (`home_page`).
➡️ If a view function is defined but not yet imported in `urls.py`, PyCharm can automatically add the necessary import statement upon using Alt+Enter or clicking the error indicator.

Passing Data from View to Template (Context)
📦 Data is passed from the View to the Template using a Python dictionary called `context`.
➡️ The dictionary keys become accessible variables within the HTML template. Example: defining `{'message': 'Hello World!'}` in the context makes `message` available.
➡️ In the template (e.g., `home_page.html`), variables are accessed using double curly braces: `{{ message }}`.
🔗 The instructor demonstrated rendering both static content and dynamic data passed via the context dictionary.

Creating and Routing the About Page
🆕 A second view function (`about_page`) and its corresponding HTML template (`about_page.html`) were created following the same process.
➡️ The `about_page` view was then registered in `urls.py` with the path `/about/`.
➡️ The template successfully displayed data passed from the view's context dictionary, confirming data flow.

Key Points & Insights
➡️ Use IDEs (like PyCharm) for virtual environment management to streamline setup and avoid confusion for beginners learning Django.
➡️ The MTV pattern is fundamental: Models handle the database, Views handle logic, and Templates handle presentation (HTML).
➡️ Data is passed dynamically from View to Template via the `context` dictionary, accessed in the template using `{{ key_name }}` syntax.
➡️ While passing individual variables directly in the `render()` call is technically possible, aggregating all dynamic data into a single `context` dictionary is the cleaner and recommended practice for maintainability.

📸 Video summarized with SummaryTube.com on Feb 13, 2026, 16:35 UTC