Woher kennt Django die Reihenfolge zum Rendern von Formularfeldern?

Wenn ich ein Django-Formular habe wie:

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    sender = forms.EmailField()

Und ich rufe die as_table () -Methode einer Instanz dieses Formulars auf. Django rendert die Felder in derselben Reihenfolge wie oben angegeben.

Meine Frage ist, woher weiß Django die Reihenfolge, in der Klassenvariablen definiert wurden?

(Wie überschreibe ich diese Reihenfolge, wenn ich beispielsweise ein Feld aus der Init- Methode der Klasse hinzufügen möchte ?)

[HINWEIS: Diese Antwort ist jetzt ziemlich veraltet - siehe die Diskussion darunter und neuere Antworten].

Wenn fes sich um ein Formular handelt, sind seine Felder f.fieldsa django.utils.datastructures.SortedDict (es zeigt die Elemente in der Reihenfolge an, in der sie hinzugefügt wurden). Nach der Formularerstellung verfügt f.fields über ein keyOrder-Attribut. Hierbei handelt es sich um eine Liste, die die Feldnamen in der Reihenfolge enthält, in der sie angezeigt werden sollen. Sie können dies auf die richtige Reihenfolge einstellen (obwohl Sie vorsichtig sein müssen, um sicherzustellen, dass Sie keine Artikel auslassen oder Extras hinzufügen).

Hier ist ein Beispiel, das ich gerade in meinem aktuellen Projekt erstellt habe:

class PrivEdit(ModelForm):
    def __init__(self, *args, **kw):
        super(ModelForm, self).__init__(*args, **kw)
        self.fields.keyOrder = [
            'super_user',
            'all_districts',
            'multi_district',
            'all_schools',
            'manage_users',
            'direct_login',
            'student_detail',
            'license']
    class Meta:
        model = Privilege

Neu in Django 1.9 sind Form.field_order und Form.order_fields () .

# forms.Form example
class SignupForm(forms.Form):

    password = ...
    email = ...
    username = ...

    field_order = ['username', 'email', 'password']


# forms.ModelForm example
class UserAccount(forms.ModelForm):

    custom_field = models.CharField(max_length=254)

    def Meta:
        model = User
        fields = ('username', 'email')

    field_order = ['username', 'custom_field', 'password']

Ich ging voran und beantwortete meine eigene Frage. Hier ist die Antwort zum späteren Nachschlagen:

In Django form.pywird dunkle Magie mit der __new__Methode ausgeführt, um Ihre Klassenvariablen letztendlich in self.fieldsder in der Klasse definierten Reihenfolge zu laden . self.fieldsist eine Django- SortedDictInstanz (definiert in datastructures.py).

Um dies zu überschreiben, sagen Sie in meinem Beispiel, dass der Absender an erster Stelle stehen soll, aber in einer Init- Methode hinzugefügt werden muss , würden Sie Folgendes tun:

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    def __init__(self,*args,**kwargs):
        forms.Form.__init__(self,*args,**kwargs)
        #first argument, index is the position of the field you want it to come before
        self.fields.insert(0,'sender',forms.EmailField(initial=str(time.time())))

Felder werden in der Reihenfolge aufgelistet, in der sie in ModelClass._meta.fields definiert sind. Wenn Sie jedoch die Reihenfolge in Form ändern möchten, können Sie dies mit der Funktion keyOrder tun. Zum Beispiel :

class ContestForm(ModelForm):
  class Meta:
    model = Contest
    exclude=('create_date', 'company')

  def __init__(self, *args, **kwargs):
    super(ContestForm, self).__init__(*args, **kwargs)
    self.fields.keyOrder = [
        'name',
        'description',
        'image',
        'video_link',
        'category']

Mit Django> = 1.7 müssen Sie ContactForm.base_fieldsFolgendes ändern :

from collections import OrderedDict

...

class ContactForm(forms.Form):
    ...

ContactForm.base_fields = OrderedDict(
    (k, ContactForm.base_fields[k])
    for k in ['your', 'field', 'in', 'order']
)

Dieser Trick wird in Django Admin PasswordChangeForm: Source auf Github verwendet

Formularfelder haben ein Attribut für die Erstellungsreihenfolge, das aufgerufen wird creation_counter. .fieldsAttribut ist ein Wörterbuch, daher creation_countersollte es ausreichen , das Wörterbuch einfach hinzuzufügen und Attribute in allen Feldern zu ändern , um die neue Reihenfolge widerzuspiegeln (dies wurde jedoch nie versucht).

Verwenden Sie einen Zähler in der Field-Klasse. Sortieren nach diesem Zähler:

import operator
import itertools

class Field(object):
    _counter = itertools.count()
    def __init__(self):
        self.count = Field._counter.next()
        self.name = ''
    def __repr__(self):
        return "Field(%r)" % self.name

class MyForm(object):
    b = Field()
    a = Field()
    c = Field()

    def __init__(self):
        self.fields = []
        for field_name in dir(self):
            field = getattr(self, field_name)
            if isinstance(field, Field):
                field.name = field_name
                self.fields.append(field)
        self.fields.sort(key=operator.attrgetter('count'))

m = MyForm()
print m.fields # in defined order

Ausgabe:

[Field('b'), Field('a'), Field('c')]

Ab Django 1.7-Formularen wird OrderedDict verwendet, das den Append-Operator nicht unterstützt. Sie müssen das Wörterbuch also von Grund auf neu erstellen ...

class ChecklistForm(forms.ModelForm):

  class Meta:
    model = Checklist
    fields = ['name', 'email', 'website']

  def __init__(self, guide, *args, **kwargs):
    self.guide = guide
    super(ChecklistForm, self).__init__(*args, **kwargs)

    new_fields = OrderedDict()
    for tier, tasks in guide.tiers().items():
      questions = [(t['task'], t['question']) for t in tasks if 'question' in t]
      new_fields[tier.lower()] = forms.MultipleChoiceField(
        label=tier,
        widget=forms.CheckboxSelectMultiple(),
        choices=questions,
        help_text='desired set of site features'
      )

    new_fields['name'] = self.fields['name']
    new_fields['email'] = self.fields['email']
    new_fields['website'] = self.fields['website']
    self.fields = new_fields 

Zum späteren Nachschlagen: Die Dinge haben sich seit den neuen Formen ein wenig geändert. Dies ist eine Möglichkeit, Felder aus Basisformelklassen neu zu ordnen, über die Sie keine Kontrolle haben:

def move_field_before(form, field, before_field):
    content = form.base_fields[field]
    del(form.base_fields[field])
    insert_at = list(form.base_fields).index(before_field)
    form.base_fields.insert(insert_at, field, content)
    return form

Außerdem gibt es eine kleine Dokumentation zu SortedDict, base_fieldsdie hier verwendet wird: http://code.djangoproject.com/wiki/SortedDict

Wenn entweder fields = '__all__':

class AuthorForm(ModelForm):
    class Meta:
        model = Author
        fields = '__all__'

oder excludeverwendet werden:

class PartialAuthorForm(ModelForm):
    class Meta:
        model = Author
        exclude = ['title']

Dann verweist Django auf die im Modell definierte Reihenfolge der Felder . Das hat mich nur erwischt, also dachte ich, ich würde es erwähnen. In den ModelForm-Dokumenten wird darauf verwiesen :

Wenn eine dieser Optionen verwendet wird, entspricht die Reihenfolge, in der die Felder im Formular angezeigt werden, der Reihenfolge, in der die Felder im Modell definiert sind, wobei die ManyToManyField-Instanzen zuletzt angezeigt werden.

Der einfachste Weg, Felder in Django 1.9-Formularen zu bestellen, ist die Verwendung field_orderin Ihrem Formular Form.field_order

Hier ist ein kleines Beispiel

class ContactForm(forms.Form):
     subject = forms.CharField(max_length=100)
     message = forms.CharField()
     sender = forms.EmailField()
     field_order = ['sender','message','subject']

Dies zeigt alles in der Reihenfolge an, die Sie in field_orderdict angegeben haben.

Die Verwendung fieldsin der inneren MetaKlasse hat für mich funktioniert Django==1.6.5:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Example form declaration with custom field order.
"""

from django import forms

from app.models import AppModel


class ExampleModelForm(forms.ModelForm):
    """
    An example model form for ``AppModel``.
    """
    field1 = forms.CharField()
    field2 = forms.CharField()

    class Meta:
        model = AppModel
        fields = ['field2', 'field1']

So einfach ist das.

Dies hat mit der Metaklasse zu tun, die beim Definieren der Formularklasse verwendet wird. Ich denke, es führt eine interne Liste der Felder und wenn Sie in die Mitte der Liste einfügen, könnte es funktionieren. Es ist eine Weile her, seit ich mir diesen Code angesehen habe.

Ich habe dies verwendet, um Felder zu verschieben über:

def move_field_before(frm, field_name, before_name):
    fld = frm.fields.pop(field_name)
    pos = frm.fields.keys().index(before_name)
    frm.fields.insert(pos, field_name, fld)

Dies funktioniert in Version 1.5 und ich bin mir ziemlich sicher, dass es auch in neueren Versionen funktioniert.