Function-based vs class-based decision in Django - Practice Questions

Challenge - 5 Problems

❓ component_behavior

intermediate

Output of a function-based view with a redirect

What will be the HTTP status code returned by this Django function-based view when accessed?

Django

from django.http import HttpResponseRedirect

def my_view(request):
    return HttpResponseRedirect('/home/')

A 302 Found

B 404 Not Found

C 200 OK

D 500 Internal Server Error

💡 Hint

Think about what HttpResponseRedirect does in Django.

HttpResponseRedirect returns a 302 status code to tell the browser to go to a new URL.

📝 Syntax

intermediate

Identify the syntax error in this class-based view

Which option correctly identifies the syntax error in this Django class-based view?

Django

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        return HttpResponse('Hello')
    def post(self, request):
        return HttpResponse('Posted')
    def put(self, request):
        return HttpResponse('Put')
    def delete(self, request):
        return HttpResponse('Deleted')
    def patch(self, request):
        return HttpResponse('Patched')
    def options(self, request):
        return HttpResponse('Options')
    def trace(self, request):
        return HttpResponse('Trace')
    def head(self, request):
        return HttpResponse('Head')
    def connect(self, request):
        return HttpResponse('Connect')
    def get(self, request):
        return HttpResponse('Duplicate get')

A Duplicate method definition for 'get' in the class

B Missing colon after class declaration

C HttpResponse import is missing

D Indentation error in method definitions

💡 Hint

Look for repeated method names inside the class.

Defining the 'get' method twice in the same class causes a syntax error because the second definition overwrites the first.

❓ state_output

advanced

State behavior difference between function-based and class-based views

Given these two views, what is the main difference in how they handle state between requests?

Django

from django.views import View
from django.http import HttpResponse

count = 0

def function_view(request):
    global count
    count += 1
    return HttpResponse(f'Count is {count}')

class ClassView(View):
    count = 0
    def get(self, request):
        ClassView.count += 1
        return HttpResponse(f'Count is {ClassView.count}')

A Class-based view count variable is instance-specific and resets each request

B Both views share the same count variable across all requests

C Function-based view resets count each request; class-based view does not

D Function-based view uses a global variable; class-based view uses a class variable to track count

💡 Hint

Consider where the count variable is stored and how Python handles globals and class variables.

The function-based view uses a global variable to track count, while the class-based view uses a class variable. Both persist across requests but are stored differently.

🔧 Debug

advanced

Why does this class-based view raise an error?

This Django class-based view raises an error when accessed. What is the cause?

Django

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self):
        return HttpResponse('Hello')

A HttpResponse is not imported correctly

B Missing 'request' parameter in the 'get' method

C Class does not inherit from the correct base class

D Method name 'get' is invalid in class-based views

💡 Hint

Check the method signature for class-based views.

Class-based view methods like 'get' must accept 'self' and 'request' parameters. Missing 'request' causes a TypeError.

🧠 Conceptual

expert

Choosing between function-based and class-based views for complex logic

Which statement best explains why you might choose a class-based view over a function-based view in Django for a complex page?

A Function-based views support middleware better than class-based views, so they are preferred for complex logic

B Function-based views automatically handle all HTTP methods without extra code, so they are better for complex logic

C Class-based views allow you to organize related HTTP methods and reuse code through inheritance, making complex logic easier to manage

D Class-based views are faster to execute than function-based views, so they improve performance for complex pages

💡 Hint

Think about code organization and reuse in object-oriented programming.

Class-based views let you group related methods and use inheritance to share code, which helps manage complex logic better than function-based views.