Class Based vs Function Based Views

A core feature of Django is views, which define how data is presented to users. Views can be implemented in two main ways: Function-Based Views (FBVs) and Class-Based Views (CBVs).

Function-Based Views (FBVs)

FBVs are simple Python functions that receive a request, process it and return a response. They provide a straightforward way to handle HTTP requests.

Pros of FBVs:

• Easy to understand, especially for beginners.
• Explicit code flow for each HTTP method.
• Flexible and quick to implement.
• Simple decorator usage (e.g., @login_required).

Cons of FBVs:

• Code duplication in larger projects.
• Conditional branching for multiple HTTP methods can get messy.

Example: Creating a function-based view

In this example:

• Renders a form using template_name and form_class.
• On POST, validates and saves the form.
• Redirects if successful; re-renders with errors if invalid.

Class-Based Views (CBVs)

CBVs are Python classes that handle requests using object-oriented principles such as inheritance and mixins. They promote reusable and organized view logic, making it easier to manage complex views and avoid code duplication.

Pros of CBVs:

• Promotes DRY (Don’t Repeat Yourself) principle.
• Better code organization via methods like get(), post().
• Supports inheritance and mixins for modularity.
• Built-in generic views (CreateView, UpdateView, DeleteView).

Cons of CBVs:

• More abstract, harder for beginners to grasp.
• Less explicit code flow (uses dispatch() and as_view()).
• May require extra imports and method overrides.

Example: Creating a class-based view

Note: Ensure that the template file 'form.html' exists inside your app's templates directory (e.g., templates/form.html), otherwise Django will raise a TemplateDoesNotExist error.

• as_view() is inherited from View and returns a callable to handle requests.
• When a request arrives, as_view() calls dispatch(), which determines the correct method (get(), post(), etc.).

You can override class attributes dynamically when defining URL patterns:

• Generic CBVs (like CreateView) allow overriding helper methods such as get_form_class() or get_template_names() to insert custom logic instead of just changing class attributes.
• Example: With ModelFormMixin, you can override form_valid() to modify self.object before saving.

Generic Class-Based View

Django’s generic CBVs provide pre-built views for common tasks like creating, updating, listing and deleting objects. They reduce boilerplate by automatically handling standard operations such as form display, validation, and saving.

In this example:

• CreateView automatically handles GET and POST requests.
• Only need to specify model, form, template, and success URL.
• Saves time and avoids repetitive code for standard CRUD operations.

FBVs vs CBVs