Geek Slack

Become an instructor

Start creating your course and become a part of GeekSlack.

Login
Facebook Linkedin
Course Content
Django – Introduction
0/6
Overview of Web Development
00:00
Introduction to Django
00:00
What is Django?
00:00
Key Features of Django
00:00
Installing Django
00:00
Creating a Django Project
00:00
Django – Fundamentals
This chapter introduces the core concepts of Django applications, views, routing, and templates, forming the foundation for building dynamic web applications.
0/5
Understanding Django Apps
00:00
Creating and Managing Apps
00:00
URL Routing and Views
00:00
Writing Views: Function-Based Views (FBVs)
00:00
Templates
00:00
Django – Models and Databases
This chapter explores Django's Object-Relational Mapping (ORM), a powerful feature that allows you to interact with databases using Python objects instead of raw SQL. You'll learn how to define models, perform database migrations, and work with data efficiently.
0/7
Introduction to Django ORM
00:00
Defining Models
00:00
Database Migrations
00:00
Interacting with the Database
00:00
Django CRUD Operations
00:00
QuerySets and Filters
00:00
Working with Relationships
00:00
Django – Forms and User Input
This chapter focuses on how to handle user input in Django applications using forms. You will learn how to create forms, validate data, process and render forms, and use models to create forms automatically. Additionally, you will explore handling file uploads, including saving and managing media files.
0/9
Working with Forms
00:00
Django Forms Basics
00:00
Form Validation
00:00
Rendering and Processing Forms
00:00
Model Forms
00:00
Automatically Generating Forms from Models
00:00
Handling File Uploads
00:00
Uploading and Saving Files
00:00
Managing Media Files
00:00
Django – Admin
The Django Admin panel is one of the most powerful features of Django, allowing developers and site administrators to manage content and data seamlessly through a web interface. This chapter explores advanced features of Django Admin, focusing on customization, registration of models, customizing the display and filtering, adding actions, and creating custom admin templates.
0/7
Overview of the Django Admin Panel
00:00
Registering Models
00:00
Customizing Display, Search, and Filtering
00:00
Advanced Customizations
00:00
Admin Filters
00:00
Admin Actions
00:00
Custom Admin Templates
00:00
Django – Advanced Views and URL Handling
This chapter explores advanced techniques for handling views, URLs, and middleware in Django. You'll gain a deep understanding of Class-Based Views (CBVs) and how they compare to Function-Based Views (FBVs), learn about organizing URLs effectively for large projects, and dive into middleware: a key component for processing requests and responses globally.
0/6
Class-Based Views (CBVs)
00:00
Difference Between FBVs and CBVs
00:00
Commonly Used CBVs
00:00
URL Namespaces
00:00
Organizing URLs in Large Projects
00:00
Django as Middleware
00:00
Django – User Authentication and Authorization
User authentication and authorization are crucial aspects of modern web applications. Django provides a comprehensive, built-in system for handling user authentication, allowing developers to easily manage user registration, login, password management, and access control. This chapter covers advanced techniques in managing users, roles, permissions, and custom user models in Django.
0/7
Built-in User Authentication System
00:00
Registering Users
00:00
Logging In and Out
00:00
Password Reset and Change
00:00
Permissions and Groups
00:00
Role-Based Access Control (RBAC)
00:00
Customizing User Models
00:00
Django – Static and Media Files
In Django, handling static and media files efficiently is an essential aspect of web development. Static files (e.g., JavaScript, CSS, images) are files that do not change during runtime, while media files (e.g., user-uploaded files like photos, documents) are dynamic and may change or be added over time. This chapter explores how to manage both static and media files in Django, including their configuration for development and production environments.
0/3
Serving Static Files
00:00
Managing Media Files
00:00
Configuring Static and Media Files for Production
00:00
Django – Testing and Debugging
Testing and debugging are critical skills for building robust, reliable Django applications. This chapter covers strategies to debug Django applications effectively, common errors and their fixes, and writing comprehensive tests using Django's built-in testing framework.
0/6
Debugging Django Applications
00:00
Using Django Debug Toolbar
00:00
Common Errors and Fixes
00:00
Writing Tests
00:00
Unit Tests for Models and Views
00:00
Integration Tests
00:00
Django – REST Framework (Optional Advanced Section)
Django REST Framework (DRF) is a powerful and flexible toolkit for building Web APIs with Django. This chapter introduces you to REST principles, guides you through setting up DRF, and explores advanced concepts like serializers, views, routers, and authentication mechanisms.
0/6
Introduction to REST APIs
00:00
Setting Up Django REST Framework (DRF)
00:00
Serializers
00:00
Views and Routers
00:00
Building and Consuming APIs
00:00
Authentication and Permissions in DRF
00:00
Django – Deployment
Deploying a Django application ensures that your project is accessible to users over the internet. This chapter covers the steps to prepare your application for deployment, tools and configurations for different deployment scenarios, and best practices for securing Django applications in a production environment.
0/6
Preparing for Deployment
00:00
Debugging vs Production Mode
00:00
Collecting Static Files
00:00
Deploying with Gunicorn and Nginx
00:00
Deploying with Docker
00:00
Environment Variables and .env Files
00:00
Django Tutorial

    Views in DRF handle HTTP requests and return responses. DRF provides both function-based views (FBVs) and class-based views (CBVs).

    Creating an API View

    Example: Using APIView

    from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Post
from .serializers import PostSerializer

class PostListView(APIView):
    def get(self, request):
        posts = Post.objects.all()
        serializer = PostSerializer(posts, many=True)
        return Response(serializer.data)

    Example: Using GenericAPIView and Mixins

    DRF provides mixins for common operations like list, create, retrieve, etc.

    from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin, CreateModelMixin
from .models import Post
from .serializers import PostSerializer

class PostListCreateView(ListModelMixin, CreateModelMixin, GenericAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    Example: Using ViewSets and Routers

    ViewSet classes combine logic for multiple actions (e.g., list, retrieve) in a single class, and routers automatically generate URLs.

    from rest_framework.viewsets import ModelViewSet
from .models import Post
from .serializers import PostSerializer

class PostViewSet(ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

    In urls.py, use a router to handle routing:

    from rest_framework.routers import DefaultRouter
from .views import PostViewSet

router = DefaultRouter()
router.register('posts', PostViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]
    Previous
    Next