Qual è il vantaggio di vedute Class-based?

Question

Ho letto oggi che Django 1.3 alpha è la spedizione, e la nuova caratteristica più propagandato è l'introduzione di vista di classe a base di .
Ho letto le relativa documentazione , ma trovo difficile vedere la grande vantaggio ™ che avrei potuto ottenere tramite loro, quindi mi sto chiedendo qui per un aiuto nella loro comprensione.
Facciamo un esempio avanzata dalla documentazione.

urls.py

from books.views import PublisherBookListView

urlpatterns = patterns('',
    (r'^books/(\w+)/$', PublisherBookListView.as_view()),
)

views.py

from django.shortcuts import get_object_or_404
from django.views.generic import ListView
from books.models import Book, Publisher

class PublisherBookListView(ListView):

    context_object_name = "book_list"
    template_name = "books/books_by_publisher.html",

    def get_queryset(self):
        self.publisher = get_object_or_404(Publisher, name__iexact=self.args[0])
        return Book.objects.filter(publisher=self.publisher)

    def get_context_data(self, **kwargs):
        # Call the base implementation first to get a context
        context = super(PublisherBookListView, self).get_context_data(**kwargs)
        # Add in the publisher
        context['publisher'] = self.publisher
        return context

E ora andiamo a confrontarlo con una soluzione “plain-old-vista”, fatto da me in 5 minuti per questa domanda (mi scuso per eventuali errori si possono trovare in esso).

urls.py

urlpatterns = patterns('books.views',
    url(r'^books/(\w+)/$', 'publisher_books_list', name="publisher_books_list"),
)

views.py

from django.shortcuts import get_object_or_404
from books.models import Book, Publisher

def publisher_books_list(request, publisher_name):
    publisher = get_object_or_404(Publisher, name__iexact=publisher_name)
    book_list = Book.objects.filter(publisher=publisher)

    return render_to_response('books/books_by_publisher.html', {
        "book_list": book_list,
        "publisher": publisher,
    }, context_instance=RequestContext(request))

La seconda versione mi sembra:

• equivalente in termini di funzionalità
• Un sacco più leggibile (self.args[0]? Terribile!)
• Shorter
• Non meno DRY-compatibile

C'è qualcosa di grosso che mi manca? Perché dovrei usare? Sono quelli sulla documentazione? Se è così allora quale sarebbe il caso d'uso ideale? mixins che utile?

Grazie in anticipo a tutti coloro che contribuiscono!

P.S per coloro che potrebbero chiedersi, non sono mai stato affascinato dalla vista generici così:. Non appena ho avuto bisogno alcune funzionalità avanzate, sono diventati non inferiore a vista regolari

.

Answer 1

È possibile ereditare una classe e metodi affinerà come get_context_data per casi specifici, e lasciare il resto così com'è. Non si può fare che con le funzioni.

Per esempio, potrebbe essere necessario creare una nuova vista che fa tutto un precedente fa, ma è necessario includere variabile aggiuntiva nel contesto. Sottoclasse la vista originale e l'override del metodo get_context_data.

Inoltre, separando i passi necessari per rendere il modello in metodi separati promuove codice più chiaro - il meno fatto in un metodo, più è facile da capire. Con funzioni visualizzazione normale, è tutto scaricato nel un'unità di elaborazione.

Answer 2

Se self.args[0] ti dà fastidio, l'alternativa è:

urlpatterns = patterns('books.views',
    url(r'^books/(?P<slug>\w+)/$', 'publisher_books_list', name="publisher_books_list"),
)

allora si potrebbe utilizzare self.kwargs['slug'] invece, che lo rende un po 'più leggibile.

Answer 3

Il tuo esempio di funzione e di classe non sono uguali nelle caratteristiche.

La versione base di classe forniscono impaginazione gratuitamente e vietare l'uso di altri verbi HTTP GET rispetto.

Se volete aggiungere questo alla funzione, che sta per essere molto più lungo.

Ma è, infatti, più complicato.

Answer 4

Questa è la prima che sento di questo - e mi piace.

Il vantaggio che vedo qui, onestamente, è che rende vista più coerente con Django complessiva. I modelli sono classi e ho sempre sentito che le opinioni devono essere troppo. So che non tutto è, ma viste e modelli sono i due molto utilizzato tipo .

Per quanto riguarda il vantaggio tecnico? lì così è davvero la differenza - Beh, in Python tutto è una classe ( o di un oggetto ?)? Non è lo zucchero del 99% sintattico, in primo luogo?

Answer 5

Un modo di pensare viste basate classe, è che sono come un admin Django con la formazione ruote off e quindi molto più flessibile (ma più difficile da capire).

Per esempio, la lista-display nella amministrazione è chiaramente basata sul ListView generico. La visualizzazione elenco più semplice si sarebbe solo definire un modello o set di query.

class MyExampleView(ListView);
    model = ExampleModel 

Sarà necessario fornire il proprio modello, ma sarà essenzialmente lo stesso del ModelAdmin più fondamentale. L'attributo list_display nel modello di amministrazione vi dirà che cosa campi da visualizzare, mentre nel ListView si dovrebbe fare questo nel modello.

class SpeciesAdmin(admin.ModelAdmin):
    list_display = ['name']
admin.site.register(ExampleModel , ExampleModelAdmin)

Con l'amministratore si dispone di un parametro

list_per_page = 100

che definisce il numero di oggetti per pagina. visualizzazione elenco ha

paginate_by = 100

che realizza la stessa cosa. Allo stesso modo se si guarda nel personalizzare l'amministratore pesantemente, vedrete un sacco di sovrapposizione.

Questo sito qui dovrebbe darvi una migliore idea di quello che fanno pure.

http://ccbv.co.uk/