Tutorial de Django. Vistas genéricas. context_object_name = 'latest_question_list'

Un ListView detrás de las cortinas realiza muchas operaciones para crear un contexto y pasarlo a un motor de renderizado. Podemos echar un vistazo a la implementación a través de Vistas con clase con clase .

En esencia, cuando active dicha vista basada en clases, según el método HTTP, activará el método get(..), post(..), etc.

El método get(..) está definido por la clase BaseListView y se define como:

def get(self, request, *args, **kwargs):
    self.object_list = self.get_queryset()
    allow_empty = self.get_allow_empty()
    if not allow_empty:
        # When pagination is enabled and object_list is a queryset,
        # it's better to do a cheap query than to load the unpaginated
        # queryset in memory.
        if self.get_paginate_by(self.object_list) is not None and hasattr(self.object_list, 'exists'):
            is_empty = not self.object_list.exists()
        else:
            is_empty = not self.object_list
        if is_empty:
            raise Http404(_("Empty list and '%(class_name)s.allow_empty' is False.") % {
                'class_name': self.__class__.__name__,
            })
    context = self.get_context_data()
    return self.render_to_response(context)

La parte de importación es que primero somos el resultado de get_queryset() a self.objects_list, y luego construimos un contexto con self.get_context_data(). Luego hacemos una llamada a self.render_to_response(..), que básicamente usará la plantilla especificada y la representaremos con el context dado.

Los datos get_context tienen dos padres con una implementación. El más básico (el más alto en la jerarquía de herencia) es el de ContextMixin, pero esta función no hace mucho:

def get_context_data(self, **kwargs):
    kwargs.setdefault('view', self)
    if self.extra_context is not None:
        kwargs.update(self.extra_context)
    return kwargs

Simplemente toma el diccionario construido por los argumentos de las palabras clave (vacío si no hay argumentos de palabras clave, como es el caso aquí), y agrega una clave adicional 'view' que está asociada con self. También puede agregar pares clave-valor adicionales que se pueden definir en self.extra_context, pero podemos ignorar eso aquí.

La lógica más interesante se implementa en MultipleObjectMixin:

def get_context_data(self, *, object_list=None, **kwargs):
    """Get the context for this view."""
    queryset = object_list if object_list is not None else self.object_list
    page_size = self.get_paginate_by(queryset)
    context_object_name = self.get_context_object_name(queryset)
    if page_size:
        paginator, page, queryset, is_paginated = self.paginate_queryset(queryset, page_size)
        context = {
            'paginator': paginator,
            'page_obj': page,
            'is_paginated': is_paginated,
            'object_list': queryset
        }
    else:
        context = {
            'paginator': None,
            'page_obj': None,
            'is_paginated': False,
            'object_list': queryset
        }
    if context_object_name is not None:
        context[context_object_name] = queryset
    context.update(kwargs)
    return super().get_context_data(**context)

Lo que sucede aquí es que primero asignamos self.object_list, la variable que primero hemos establecido con el resultado de self.get_queryset a una variable local llamada queryset. Luego paginaremos eso queryset, pero eso no es muy relevante para su pregunta.

Luego obtenemos el nombre llamando self.get_context_object_name(queryset). Por defecto esto se implementa como:

def get_context_object_name(self, object_list):
    """Get the name of the item to be used in the context."""
    if self.context_object_name:
        return self.context_object_name
    elif hasattr(object_list, 'model'):
        return '%s_list' % object_list.model._meta.model_name
    else:
        return None

Entonces, si ha establecido el atributo context_object_name, como lo hizo, simplemente devolverá ese nombre. Por lo tanto, podemos concluir que en el método get_context_data(..), el context_object_name tendrá el nombre que le dio, aquí 'latest_question_list'.

Seguimos procesando el código en get_context_data(..): construimos un diccionario y en la parte inferior verificamos si context_object_name no es None. Si ese es el caso, asociamos el queryset con esa clave (así que aquí con 'latest_question_list'). Eventualmente, cuando se construye el diccionario de contexto correcto, realizamos una llamada super() con el contexto construido como **kwargs, y como discutimos antes, el ContextMixin, simplemente devolverá ese diccionario con muy pequeño cambios

Entonces, al final, context tendrá el nombre de su lista (aquí 'latest_question_list') asociado con queryset, y mostrará la plantilla con los datos de contexto.