En inglés simple, ¿cuáles son las vistas genéricas de Django?

Question

Los primeros dos párrafos de esta página explican que las vistas genéricas se supone que deben hacer mi vida más fácil, menos monótona, y me hacen más atractivo para las mujeres (me inventé esto último):

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

I Estoy por mejorar mi vida, pero ¿qué hacen realmente las vistas genéricas? Parece que se lanzan muchas palabras de moda, que confunden más de lo que explican.

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

Answer 1

Las vistas genéricas de Django son simplemente funciones de visualización (antiguas funciones normales 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 muestra una plantilla con 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, se puede 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)) 

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 más complicados vistas genéricas para las acciones comunes, tales como "mostrando 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 desde 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

Para responder a su segunda pregunta: no, las vistas genéricas no están relacionadas con el andamiaje en RoR. El andamiaje, como su nombre 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 básicas render_to_response. Así es como se podría escribir un simple punto de vista 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 solicitud, a menos que la transmita explícitamente.

tanto, yo 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 la petición será pasado! Y eso es solo un comienzo. Las vistas genéricas son útiles cuando quiere mostrar listas, o vistas detalladas, por ejemplo. Gestionarán consultar la base de datos y enviar mensajes al usuario, entre otros.

Las vistas genéricas son funciones de alto nivel para ayudarlo a crear una respuesta desde una vista.

Answer 3

Las vistas genéricas te permiten escribir códigos mucho más cortos.

Compare:

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 puntos de vista normales, que son funciones simplemente normales. Es posible configurar la vista completamente en el URLconf si lo desea, a través de este uso me resulta un poco más claro.

Como beneficio adicional, también puede obtener:

• Iniciar sesión comprobaciones de autenticación (pasan login_required=True)
• mensaje de estado de éxito django.contrib.messages.
• Menos código para comprobar si hay errores.
• Valor predeterminado ModelForm cuando proporciona un parámetro model en lugar de form_class.

El template_name tiene un valor predeterminado de "nombre de aplicación/modelo_forma.html", pero eso es demasiado para mí.

---

Aquí es la clase de forma 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