python - get_context_data - generic views django example

En un lenguaje sencillo, ¿cuáles son las vistas genéricas de Django?

Question

Los primeros dos párrafos de esta página explican que se supone que las vistas genéricas hacen que mi vida sea más fácil, menos monótona y me hagan más atractiva para las mujeres (inventé la última):

https://docs.djangoproject.com/en/1.4/topics/generic-views/

Estoy a favor de mejorar mi vida, pero ¿qué hacen realmente las vistas genéricas? Parece que se están lanzando muchas palabras de moda, que confunden más de lo que explican.

¿Las vistas genéricas son similares a los andamios en Ruby on Rails? El último punto de bala en la introducción parece indicar esto. ¿Es esa una declaración precisa?

Answer 1

Las vistas genéricas de Django son solo funciones de vista (funciones antiguas de Python) que hacen cosas que son muy comunes en las aplicaciones web.

Dependiendo del tipo de aplicación que esté creando, pueden evitar que escriba muchas vistas muy simples.

Por ejemplo, la vista genérica direct_to_template simplemente presenta una plantilla con el RequestContext (lo que significa que la plantilla tiene acceso a la información de la solicitud, como el usuario actual, etc.).

Como un simple ejemplo, puedes pasar de escribir cosas como esta:

# urls.py
url(''^some-url/$'', some_view)
# views.py
def some_view(request):
return render_to_response(''template_name.html'', context_instance=RequestContext(request))

Sólo para esto:

# urls.py
url(''^some-url/$'', direct_to_template, {''template'': ''template_name.html''})
# views.py doesn''t need any code for this view anymore

También hay vistas genéricas más complicadas para acciones comunes como "mostrar una lista de modelos" o "agregar un modelo a la base de datos".

Además, como las vistas genéricas son solo funciones, puede llamarlas dentro de sus propias funciones de vista para hacer "la mayor parte del trabajo", cuando necesite algo que sea un poco diferente de los casos genéricos.

Answer 2

Las vistas genéricas le permiten escribir código mucho más corto.

Comparar:

from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.shortcuts import render_to_response, get_object_or_404, redirect
from myapp.models import Context
def edit(request, item_id):
object = get_object_or_404(Context, pk=item_id)
if request.method == ''POST'':
form = ContextForm(request.POST, instance=object)
if form.is_valid():
form.save()
return redirect(''myapp-context-index'')
else:
form = ContextForm(instance=object)
return render_to_response("myapp/context/edit.html", {''object'': object, ''form'': form})

con:

from django.core import urlresolvers
from django.views.generic.create_update import update_object
from myapp.models import Context
def edit(request, item_id):
return update_object(request,
object_id=item_id,
form_class=ContextForm,
template_name="myapp/context/edit.html",
post_save_redirect=urlresolvers.reverse("myapp-context-index")
)

Al igual que sus vistas normales, son simplemente funciones normales. Es posible configurar la vista completamente en el URLconf, si lo desea, a través de este uso que me parece un poco más claro.

Como BONIFICACIÓN, también obtienes:

• Verificaciones de autenticación de inicio de sesión (pase login_required=True )
• Mensaje de estado de éxito de django.contrib.messages .
• Menos código para comprobar errores.
• Un ModelForm predeterminado cuando proporciona un parámetro de model lugar de form_class .

El template_name tiene un valor predeterminado de "appname / model_form.html", pero eso es demasiado para mí.

Aquí está la clase de formulario que ambos comparten:

class ContextForm(forms.ModelForm):
"""The form for a context"""
class Meta:
model = Context
exclude = (''collection'',)
def save(self, commit=True):
"""Overwritten save to force collection_id to a value"""
model = super(ContextForm, self).save(commit=False)
model.collection_id = 1
if commit:
model.save()
return model

Answer 3

Para responder a su segunda pregunta: no, las vistas genéricas no están relacionadas con los andamios en RoR. El andamiaje, como su nombre lo indica, es similar a la generación de código. Las vistas genéricas son otra cosa.

Mi uso principal de la vista genérica es como un reemplazo de nivel superior de las funciones muy básicas de render_to_response . Así es como puedes escribir una vista simple con render_to_response :

def my_view(request):
return render_to_response(''my_template.html'')

¡Pero esto es muy básico! Por ejemplo, la plantilla no tendrá acceso al contexto de la solicitud, a menos que la pase explícitamente.

Por lo tanto, prefiero usar una vista genérica en su lugar:

def my_view(request):
return direct_to_template(request, template=''my_template.html'')

Ahora el contexto de solicitud será pasado! Y eso es sólo un comienzo. Las vistas genéricas son útiles cuando se quieren mostrar listas o vistas detalladas, por ejemplo. Ellos gestionarán la consulta de la base de datos, y la mensajería al usuario, entre otros.

Así que las vistas genéricas son funciones de alto nivel para ayudarlo a crear una respuesta desde una vista.