दिलचस्प पोस्ट
आईओएस 6 में उपकरण अभिविन्यास को प्रोग्रामेटिक रूप से कैसे बदला जाए आईओएस 7 स्टेटस बार ओवरलैपिंग यूआई कैसे चेक बॉक्स राज्य सहित MVC में नियंत्रक के लिए IEnumerable सूची पारित करने के लिए? MobileWiFi.framework का उपयोग और उपयोग करना कौन सा प्रदर्शनकर्ता, सीटीई या अस्थायी तालिकाओं हैं? Jquery $ .jax के माध्यम से जावास्क्रिप्ट सरणी को PHP पास करना आईओएस 8 ने "न्यूनतम-यूआई" व्यूपोर्ट की संपत्ति को हटा दिया, क्या अन्य "सॉफ्ट फुलस्क्रीन" समाधान हैं? MySQL: किसी भी रेंज में सभी तिथियां चुनें, भले ही कोई रिकॉर्ड मौजूद न हो क्या नेस्टेड लेनदेन MySQL में अनुमत हैं? एक्लिप्स में एक्सएमएल सत्यापन अक्षम करें Angular.js: कैसे $ eval काम करता है और यह क्यों वेनिला eval से अलग है? अमेज़ॅन रूटे 53 में DNS आधारित यूआरएल अग्रेषण सेट अप करें SQL सर्वर: कैसे information_schema से विदेशी कुंजी संदर्भ प्राप्त करें? फ़ाइल एक्सेस के लिए मुझे एमएएमएप का उपयोग कब करना चाहिए? एक पीएनजी छवि सर्वर-साइड को कैसे सहेज सकता है, बेस 64 डेटा स्ट्रिंग से

टेम्पलेट में मॉडल इंस्टेंस फ़ील्ड नामों और मानों पर फिराना

मैं उनके नाम के साथ चयनित इंस्टेंस के फ़ील्ड वैल्यू को प्रदर्शित करने के लिए एक बुनियादी टेम्प्लेट बनाने का प्रयास कर रहा हूं। उस स्तंभ के प्रारूप में उस उदाहरण के मानों का सिर्फ एक मानक आउटपुट के रूप में सोचें, फ़ील्ड नाम के साथ (वर्बोज़_नाव विशेषकर यदि फ़ील्ड पर निर्दिष्ट होता है) पहले कॉलम में और दूसरे कॉलम में उस फ़ील्ड का मान।

उदाहरण के लिए, मान लें कि हमारे पास निम्न मॉडल की परिभाषा है:

class Client(Model): name = CharField(max_length=150) email = EmailField(max_length=100, verbose_name="E-mail") 

मैं चाहता हूं कि यह टेम्प्लेट में आउटपुट हो जैसे कि (दिए गए मानों के साथ एक उदाहरण मानें):

 Field Name Field Value ---------- ----------- Name Wayne Koorts E-mail waynes@email.com 

मैं क्या हासिल करने की कोशिश कर रहा हूं, इस टेम्पलेट को मॉडल का एक उदाहरण देना और टेम्पलेट में गतिशील रूप से इसे फिर से सक्षम करने में सक्षम होने के लिए सक्षम है, ऐसा कुछ:

 <table> {% for field in fields %} <tr> <td>{{ field.name }}</td> <td>{{ field.value }}</td> </tr> {% endfor %} </table> 

क्या ऐसा करने के लिए एक साफ, "Django-approved" तरीका है? यह एक बहुत ही सामान्य कार्य जैसा लगता है, और मुझे इस विशेष परियोजना के लिए अक्सर यह करना होगा।

वेब के समाधान से एकत्रित समाधान "टेम्पलेट में मॉडल इंस्टेंस फ़ील्ड नामों और मानों पर फिराना"

model._meta.get_all_field_names() आपको सभी मॉडल के क्षेत्र के नाम देगा, फिर आप model._meta.get_field() नाम, और getattr(model_instance, 'field_name') से मूल्य प्राप्त करने के लिए अपना रास्ता काम करने के लिए model._meta.get_field() का उपयोग कर सकते हैं। आदर्श।

नोट: model._meta.get_all_field_names() को model._meta.get_all_field_names() 1.9 में पदावनत किया गया है। इसके बजाय प्रत्येक फ़ील्ड का नाम प्राप्त करने के लिए मॉडल के फ़ील्ड्स और फील्ड.name प्राप्त करने के लिए field.name model._meta.get_fields() का उपयोग करें।

आखिरकार डेविल मेलिंग लिस्ट पर इसके लिए एक अच्छा समाधान मिला:

दृश्य में जोड़ें:

 from django.forms.models import model_to_dict def show(request, object_id): object = FooForm(data=model_to_dict(Foo.objects.get(pk=object_id))) return render_to_response('foo/foo_detail.html', {'object': object}) 

टेम्पलेट में जोड़ें:

 {% for field in object %} <li><b>{{ field.label }}:</b> {{ field.data }}</li> {% endfor %} 

आप Django के to-Python क्वेरीस सीरियललाइजर का उपयोग कर सकते हैं।

बस अपने दृश्य में निम्नलिखित कोड डाल:

 from django.core import serializers data = serializers.serialize( "python", SomeModel.objects.all() ) 

और फिर टेम्पलेट में:

 {% for instance in data %} {% for field, value in instance.fields.items %} {{ field }}: {{ value }} {% endfor %} {% endfor %} 

इसका महान लाभ यह है कि यह संबंध क्षेत्रों को संभालता है।

खेतों के सबसेट के लिए प्रयास करें:

 data = serializers.serialize('python', SomeModel.objects.all(), fields=('name','size')) 

Django 1.8 की रिहाई (और मॉडल _ मेटा एपीआई के औपचारिकरण के प्रकाश में , मुझे लगा कि मैं इसे एक हालिया उत्तर के साथ अद्यतन करेगा।

एक ही मॉडल मानते हुए:

 class Client(Model): name = CharField(max_length=150) email = EmailField(max_length=100, verbose_name="E-mail") 

Django <= 1.7

 fields = [(f.verbose_name, f.name) for f in Client._meta.fields] >>> fields [(u'ID', u'id'), (u'name', u'name'), (u'E-mail', u'email')] 

Django 1.8+ (औपचारिक मॉडल _meta API)

Django 1.8 में बदल दिया गया:

मॉडल _meta एपीआई हमेशा एक डीजेंगो के आंतरिक रूप में अस्तित्व में है, लेकिन औपचारिक रूप से दस्तावेज और समर्थित नहीं था। इस API को सार्वजनिक करने के प्रयास के भाग के रूप में, पहले से मौजूद एपीआई प्रविष्टियों के कुछ बिंदुओं में थोड़ा बदलाव आया है। आपके कोड को नए, आधिकारिक API का उपयोग करने में सहायता करने के लिए एक माइग्रेशन गाइड प्रदान किया गया है।

नीचे दिए गए उदाहरण में, हम Client._meta.get_fields() माध्यम से एक मॉडल के सभी फ़ील्ड उदाहरणों को पुनर्प्राप्त करने के लिए औपचारिक विधि का उपयोग करेंगे:

 fields = [(f.verbose_name, f.name) for f in Client._meta.get_fields()] >>> fields [(u'ID', u'id'), (u'name', u'name'), (u'E-mail', u'email')] 

दरअसल, यह मेरे ध्यान में लाया गया है कि ऊपर की जरूरत के लिए थोड़ा सा पानी है (मैं सहमत हूं!) जटिल जटिल से बेहतर है मैं संदर्भ के लिए ऊपर छोड़ रहा हूं। हालांकि, टेम्पलेट में प्रदर्शित करने के लिए, सबसे अच्छा तरीका ModelForm का उपयोग करना होगा और एक उदाहरण में पास करना होगा। आप फॉर्म पर फिर से दोहरा सकते हैं (फार्म के प्रत्येक फ़ील्ड पर दोहराव के बराबर) और मॉडल फ़ील्ड के वर्बोज़_नाव को पुनर्प्राप्त करने के लिए लेबल विशेषता का उपयोग करें, और मूल्य प्राप्त करने के लिए मान विधि का उपयोग करें:

 from django.forms import ModelForm from django.shortcuts import get_object_or_404, render from .models import Client def my_view(request, pk): instance = get_object_or_404(Client, pk=pk) class ClientForm(ModelForm): class Meta: model = Client fields = ('name', 'email') form = ClientForm(instance=instance) return render( request, template_name='template.html', {'form': form} ) 

अब, हम फ़ील्ड को टेम्प्लेट में प्रस्तुत करते हैं:

 <table> <thead> {% for field in form %} <th>{{ field.label }}</th> {% endfor %} </thead> <tbody> <tr> {% for field in form %} <td>{{ field.value|default_if_none:'' }}</td> {% endfor %} </tr> </tbody> </table> 

मॉडल पद्धति का उपयोग करते हुए यहां एक और दृष्टिकोण है यह संस्करण पिकलिस्ट / पसंद फ़ील्ड को हल करता है, खाली फ़ील्ड को छोड़ देता है, और आपको विशिष्ट फ़ील्ड को बाहर करने देता है।

 def get_all_fields(self): """Returns a list of all field names on the instance.""" fields = [] for f in self._meta.fields: fname = f.name # resolve picklists/choices, with get_xyz_display() function get_choice = 'get_'+fname+'_display' if hasattr( self, get_choice): value = getattr( self, get_choice)() else: try : value = getattr(self, fname) except AttributeError: value = None # only display fields with values and skip some fields entirely if f.editable and value and f.name not in ('id', 'status', 'workshop', 'user', 'complete') : fields.append( { 'label':f.verbose_name, 'name':f.name, 'value':value, } ) return fields 

फिर अपने टेम्पलेट में:

 {% for f in app.get_all_fields %} <dt>{{f.label|capfirst}}</dt> <dd> {{f.value|escape|urlize|linebreaks}} </dd> {% endfor %} 

ठीक है, मैं जानता हूँ कि यह थोड़ा देर हो चुकी है, लेकिन जब से मैं सही जवाब खोजने से पहले इस पर ठोकर खाई तो कोई और हो सकता है

डीजेंगो डॉक्स से :

 # This list contains a Blog object. >>> Blog.objects.filter(name__startswith='Beatles') [<Blog: Beatles Blog>] # This list contains a dictionary. >>> Blog.objects.filter(name__startswith='Beatles').values() [{'id': 1, 'name': 'Beatles Blog', 'tagline': 'All the latest Beatles news.'}] 

ऐसा करने के लिए वास्तव में एक अंतर्निहित तरीके होना चाहिए। मैंने यह उपयोगिता build_pretty_data_view लिखा था जो मॉडल ऑब्जेक्ट और प्रपत्र उदाहरण (आपके मॉडल पर आधारित एक प्रपत्र) लेता है और एक build_pretty_data_view रिटर्न करता है

इस समाधान में लाभ शामिल हैं:

  • यह Django के निर्मित-क्रमबद्ध SortedDict का उपयोग करके ऑर्डर सुरक्षित करता है।
  • जब लेबल / वर्बोज़_नाव प्राप्त करने की कोशिश करता है, लेकिन फ़ील्ड के नाम पर वापस आ जाता है, अगर कोई परिभाषित नहीं होता है।
  • यह कुछ फ़ील्ड को बाहर करने के लिए फ़ील्ड नामों की एक exclude() सूची भी लेगा।
  • यदि आपके फ़ॉर्म क्लास में Meta: exclude() शामिल है Meta: exclude() , लेकिन आप अभी भी मान वापस करना चाहते हैं, तो उन फ़ील्ड को वैकल्पिक append() सूची में append()

इस समाधान का उपयोग करने के लिए, पहले यह फ़ाइल / फ़ंक्शन कहीं जोड़ें, फिर इसे अपने views.py में आयात करें।

utils.py

 #!/usr/bin/env python # -*- coding: utf-8 -*- # vim: ai ts=4 sts=4 et sw=4 from django.utils.datastructures import SortedDict def build_pretty_data_view(form_instance, model_object, exclude=(), append=()): i=0 sd=SortedDict() for j in append: try: sdvalue={'label':j.capitalize(), 'fieldvalue':model_object.__getattribute__(j)} sd.insert(i, j, sdvalue) i+=1 except(AttributeError): pass for k,v in form_instance.fields.items(): sdvalue={'label':"", 'fieldvalue':""} if not exclude.__contains__(k): if v.label is not None: sdvalue = {'label':v.label, 'fieldvalue': model_object.__getattribute__(k)} else: sdvalue = {'label':k, 'fieldvalue': model_object.__getattribute__(k)} sd.insert(i, k, sdvalue) i+=1 return sd 

तो अब आपके views.py आप ऐसा कुछ कर सकते हैं

 from django.shortcuts import render_to_response from django.template import RequestContext from utils import build_pretty_data_view from models import Blog from forms import BlogForm . . def my_view(request): b=Blog.objects.get(pk=1) bf=BlogForm(instance=b) data=build_pretty_data_view(form_instance=bf, model_object=b, exclude=('number_of_comments', 'number_of_likes'), append=('user',)) return render_to_response('my-template.html', RequestContext(request, {'data':data,})) 

अब आपके टेम्पलेट -… टेम्पलेट में आप इस तरह से डेटा पर पुनरावृति कर सकते हैं …

 {% for field,value in data.items %} <p>{{ field }} : {{value.label}}: {{value.fieldvalue}}</p> {% endfor %} 

शुभ लाभ। उम्मीद है कि यह किसी को मदद करता है!

आप एक फार्म का काम आपके लिए कर सकते हैं।

 def my_model_view(request, mymodel_id): class MyModelForm(forms.ModelForm): class Meta: model = MyModel model = get_object_or_404(MyModel, pk=mymodel_id) form = MyModelForm(instance=model) return render(request, 'model.html', { 'form': form}) 

फिर टेम्पलेट में:

 <table> {% for field in form %} <tr> <td>{{ field.name }}</td> <td>{{ field.value }}</td> </tr> {% endfor %} </table> 

नीचे मेरा है, शेकर के get_all_fields से प्रेरित है अगर एक मुठभेड़ के क्षेत्र में, तो एक मॉडल उदाहरण के लिए एक शब्द मिल जाता है, फिर फ़ील्ड मूल्य को किसी भी क्रम में recursively asign करना

 def to_dict(obj, exclude=[]): """生成一个 dict, 递归包含一个 model instance 数据. """ tree = {} for field in obj._meta.fields + obj._meta.many_to_many: if field.name in exclude or \ '%s.%s' % (type(obj).__name__, field.name) in exclude: continue try : value = getattr(obj, field.name) except obj.DoesNotExist: value = None if type(field) in [ForeignKey, OneToOneField]: tree[field.name] = to_dict(value, exclude=exclude) elif isinstance(field, ManyToManyField): vs = [] for v in value.all(): vs.append(to_dict(v, exclude=exclude)) tree[field.name] = vs elif isinstance(field, DateTimeField): tree[field.name] = str(value) elif isinstance(field, FileField): tree[field.name] = {'url': value.url} else: tree[field.name] = value return tree 

यह फ़ंक्शन मुख्य रूप से मॉडल इंस्टेंस को जेसन डेटा के लिए डंप करने के लिए उपयोग किया जाता है:

 def to_json(self): tree = to_dict(self, exclude=('id', 'User.password')) return json.dumps(tree, ensure_ascii=False) 

मैंने https://stackoverflow.com/a/3431104/2022534 पर उपयोग किया लेकिन इसके साथ डीजेंगो के मॉडल_टो_डिक्ट () को विदेशी कील को संभालने में सक्षम होने के लिए बदला गया:

 def model_to_dict(instance): data = {} for field in instance._meta.fields: data[field.name] = field.value_from_object(instance) if isinstance(field, ForeignKey): data[field.name] = field.rel.to.objects.get(pk=data[field.name]) return data 

कृपया ध्यान दें कि मैंने मूल के कुछ हिस्सों को निकालने के लिए काफी कुछ सरल किया है, जिसकी मुझे आवश्यकता नहीं थी। आप उन पीठ को डालना चाहते हैं

आप queryset के values() विधि का उपयोग कर सकते हैं, जो एक शब्दकोश देता है इसके अलावा, यह विधि उप-श्रेणियों पर खेतों की एक सूची को स्वीकार करता है। values() विधि get() साथ काम नहीं करेगा, इसलिए आपको filter() उपयोग करना होगा ( QuerySet API का संदर्भ लें)

view

 def show(request, object_id): object = Foo.objects.filter(id=object_id).values()[0] return render_to_response('detail.html', {'object': object}) 

detail.html

 <ul> {% for key, value in object.items %} <li><b>{{ key }}:</b> {{ value }}</li> {% endfor %} </ul> 

फ़िल्टर द्वारा दिए गए उदाहरणों के संग्रह के लिए :

  object = Foo.objects.filter(id=object_id).values() # no [0] 

Detail.html में

 {% for instance in object %} <h1>{{ instance.id }}</h1> <ul> {% for key, value in instance.items %} <li><b>{{ key }}:</b> {{ value }}</li> {% endfor %} </ul> {% endfor %} 

मैं निम्नलिखित पद्धति के साथ आया हूं, जो मेरे लिए काम करता है क्योंकि हर मामले में मॉडल में इसके साथ जुड़े मॉडल फ़ार्म होगा

 def GetModelData(form, fields): """ Extract data from the bound form model instance and return a dictionary that is easily usable in templates with the actual field verbose name as the label, eg model_data{"Address line 1": "32 Memory lane", "Address line 2": "Brainville", "Phone": "0212378492"} This way, the template has an ordered list that can be easily presented in tabular form. """ model_data = {} for field in fields: model_data[form[field].label] = eval("form.data.%s" % form[field].name) return model_data @login_required def clients_view(request, client_id): client = Client.objects.get(id=client_id) form = AddClientForm(client) fields = ("address1", "address2", "address3", "address4", "phone", "fax", "mobile", "email") model_data = GetModelData(form, fields) template_vars = RequestContext(request, { "client": client, "model_data": model_data } ) return render_to_response("clients-view.html", template_vars) 

यहां इस विशिष्ट दृश्य के लिए मैं उपयोग कर रहा हूँ टेम्पलेट से एक उद्धरण है:

 <table class="client-view"> <tbody> {% for field, value in model_data.items %} <tr> <td class="field-name">{{ field }}</td><td>{{ value }}</td> </tr> {% endfor %} </tbody> </table> 

इस पद्धति के बारे में अच्छी बात यह है कि मैं टेम्पलेट-बाय-टेम्पलेट आधार पर उस ऑर्डर को चुन सकता हूं, जिसमें मैं फ़ील्ड लेबल प्रदर्शित करना चाहूंगा, GetModelData में दिए गए ट्यूपल का उपयोग करके और फ़ील्ड नामों को निर्दिष्ट कर रहा हूं। इससे मुझे कुछ फ़ील्ड (उदाहरण के लिए एक उपयोगकर्ता विदेशी कुंजी) को बाहर करने की अनुमति मिलती है क्योंकि केवल ट्यूपल के माध्यम से पारित क्षेत्र के नाम अंतिम शब्दकोश में बनते हैं

मैं इसे इस उत्तर के रूप में स्वीकार नहीं कर रहा हूँ क्योंकि मुझे यकीन है कि कोई और अधिक "जेजोनिक" के साथ आ सकता है 🙂

अद्यतन: मैं इसे अंतिम उत्तर के रूप में चुन रहा हूं क्योंकि यह उन लोगों में से सबसे आसान है जो मुझे उनकी जरूरत है। उत्तर देने वाले सभी लोगों के लिए धन्यवाद

प्रत्येक मॉडल को संपादित करने के बजाय मैं एक टेम्पलेट टैग लिखने की सलाह देता हूं जो दिए गए किसी भी मॉडल के सभी क्षेत्र को वापस कर देगा।
प्रत्येक ऑब्जेक्ट में फ़ील्ड की सूची है। ._meta.fields
हर फील्ड ऑब्जेक्ट में एट्रिब्यूट name जो इसका नाम और विधि value_to_string() जो आपके मॉडल object साथ प्रदान की जाती है, उसके मूल्य वापस आ जाएगा।
बाकी जितना आसान है उतना आसान है क्योंकि यह जेango दस्तावेज़ में कहा गया है।

यह मेरा उदाहरण है कि यह टेम्पलेटैटैग कैसा लग सकता है:

  from django.conf import settings from django import template if not getattr(settings, 'DEBUG', False): raise template.TemplateSyntaxError('get_fields is available only when DEBUG = True') register = template.Library() class GetFieldsNode(template.Node): def __init__(self, object, context_name=None): self.object = template.Variable(object) self.context_name = context_name def render(self, context): object = self.object.resolve(context) fields = [(field.name, field.value_to_string(object)) for field in object._meta.fields] if self.context_name: context[self.context_name] = fields return '' else: return fields @register.tag def get_fields(parser, token): bits = token.split_contents() if len(bits) == 4 and bits[2] == 'as': return GetFieldsNode(bits[1], context_name=bits[3]) elif len(bits) == 2: return GetFieldsNode(bits[1]) else: raise template.TemplateSyntaxError("get_fields expects a syntax of " "{% get_fields <object> [as <context_name>] %}") 

हाँ, यह सुंदर नहीं है, आपको अपना आवरण बनाना होगा। बिल्टिन डाटोबोसे ऐप पर एक नज़र डालें, जिसमें सभी की कार्यक्षमता आपको ज़रूरत है।

यह एक हैक माना जा सकता है, लेकिन मैंने एक मॉडल उदाहरण को एक प्रपत्र में बदलने के लिए modelform_factory का उपयोग करने से पहले यह किया है।

फॉर्म क्लास के पास बहुत अधिक जानकारी है, जो कि पुनरावृत्त करने के लिए सुपर आसान है और यह थोड़ी अधिक भूमि के ऊपर की कीमत पर उसी उद्देश्य की सेवा करेगी। यदि आपके सेट आकार अपेक्षाकृत छोटे हैं तो मुझे लगता है कि प्रदर्शन प्रभाव नगण्य होगा।

कोर्स की सुविधा के अलावा एक लाभ यह है कि आप बाद की तारीख में टेबल को आसानी से एक संपादन योग्य डेटाग्रिड में बदल सकते हैं।

मेरे लिए Django 1.7 समाधान:

वेरिएबल प्रश्न के लिए सटीक हैं, लेकिन आपको निश्चित रूप से इस उदाहरण का विश्लेषण करना चाहिए

यहां की कुंजी मॉडल के .__dict__ का उपयोग बहुत ज्यादा है
views.py :

 def display_specific(request, key): context = { 'question_id':question_id, 'client':Client.objects.get(pk=key).__dict__, } return render(request, "general_household/view_specific.html", context) 

टेम्पलेट :

 {% for field in gen_house %} {% if field != '_state' %} {{ gen_house|getattribute:field }} {% endif %} {% endfor %} 

टेम्प्लेट में मैं फ़ील्ड में तेंदुए में प्रवेश करने के लिए एक फिल्टर का उपयोग किया था
filters.py :

 @register.filter(name='getattribute') def getattribute(value, arg): if value is None or arg is None: return "" try: return value[arg] except KeyError: return "" except TypeError: return "" 

मैं इसका उपयोग कर रहा हूं, https://github.com/miracle2k/django-tables

 <table> <tr> {% for column in table.columns %} <th><a href="?sort={{ column.name_toggled }}">{{ column }}</a></th> {% endfor %} </tr> {% for row in table.rows %} <tr> {% for value in row %} <td>{{ value }}</td> {% endfor %} </tr> {% endfor %} </table> 

यह दृष्टिकोण दिखाता है कि डीजेंगो के मॉडल फॉर्म और क्लाइंट ({{form.as_table}} जैसे किसी टेम्पलेट का उपयोग कैसे करना है, लेकिन सभी तालिकाएं डेटा आउटपुट की तरह दिखती हैं, न कि कोई फॉर्म।

पहला कदम डीजेंगो के टेक्स्टइनपुट विजेट को उप-वर्ग देना था:

 from django import forms from django.utils.safestring import mark_safe from django.forms.util import flatatt class PlainText(forms.TextInput): def render(self, name, value, attrs=None): if value is None: value = '' final_attrs = self.build_attrs(attrs) return mark_safe(u'<p %s>%s</p>' % (flatatt(final_attrs),value)) 

फिर मैंने केवल डीजेन्गो के मॉडल फ़ॉर्म को subclassed करने के लिए केवल पढ़ने के संस्करणों के लिए डिफ़ॉल्ट विजेट को स्वैप किया है:

 from django.forms import ModelForm class ReadOnlyModelForm(ModelForm): def __init__(self,*args,**kwrds): super(ReadOnlyModelForm,self).__init__(*args,**kwrds) for field in self.fields: if isinstance(self.fields[field].widget,forms.TextInput) or \ isinstance(self.fields[field].widget,forms.Textarea): self.fields[field].widget=PlainText() elif isinstance(self.fields[field].widget,forms.CheckboxInput): self.fields[field].widget.attrs['disabled']="disabled" 

वे केवल वही विजेट थे जिनकी मुझे जरूरत थी। लेकिन अन्य विगेट्स को इस विचार को विस्तारित करना मुश्किल नहीं होना चाहिए।

केवल @ वंडर का संपादन

 def to_dict(obj, exclude=[]): tree = {} for field in obj._meta.fields + obj._meta.many_to_many: if field.name in exclude or \ '%s.%s' % (type(obj).__name__, field.name) in exclude: continue try : value = getattr(obj, field.name) except obj.DoesNotExist as e: value = None except ObjectDoesNotExist as e: value = None continue if type(field) in [ForeignKey, OneToOneField]: tree[field.name] = to_dict(value, exclude=exclude) elif isinstance(field, ManyToManyField): vs = [] for v in value.all(): vs.append(to_dict(v, exclude=exclude)) tree[field.name] = vs else: tree[field.name] = obj.serializable_value(field.name) return tree 

डीजेंगो को संबंधित क्षेत्रों के अलावा अन्य सभी फ़ील्ड को संभालने दें। मुझे लगता है कि अधिक स्थिर है

डीजेंगो-इत्यादि आवेदन पर एक नज़र डालें टेम्पलेट्स से फील्ड वर्बोस नाम प्राप्त करने के लिए model_field_verbose_name टेम्पलेट टैग है: http://django-etc.rtfd.org/en/latest/models.html#model-field-template-tags