Iterar sobre nombres y valores de campos de instancia de modelo en plantilla

Puede usar el serializador queryset de Django to-python.

Simplemente ponga el siguiente código en su vista:

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

Y luego en la plantilla:

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

Su gran ventaja es el hecho de que maneja campos de relación.

Para el subconjunto de campos intente:

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

Finalmente encontramos una buena solución a esto en la lista de correo dev :

En la vista añadir:

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})

En la plantilla añádase:

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

A la luz del lanzamiento de Django 1.8 (y la formalización del Modelo _meta API, pensé en actualizar esto con una respuesta más reciente.

Asumiendo el mismo modelo:

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

Django

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 + (Modelo formalizado _meta API)

Cambiado en Django 1.8:

El Modelo _meta La API siempre ha existido como interna de Django, pero no fue documentada ni soportada formalmente. Como parte del esfuerzo para hacer pública esta API, algunos de los puntos de entrada de la API ya existentes han cambiado ligeramente. Se ha proporcionado una guía de migración para ayudar a convertir su código para usar la nueva API oficial.

En el siguiente ejemplo, utilizaremos el método formalizado para recuperar todas las instancias de campo de un modelo a través de 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')]

En realidad, se ha traído a mi atención que lo anterior es un poco excesivo para lo que se necesitaba (¡estoy de acuerdo!). Simple es mejor que complejo. Dejo lo anterior como referencia. Sin embargo, para mostrarse en la plantilla, el mejor método sería usar un ModelForm y pasar en una instancia. Puede iterar sobre el formulario (equivalente a iterar sobre cada uno de los campos del formulario) y usar el atributo label para recuperar el verbose_name del campo del modelo, y usar el método value para recuperar el valor:

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}
    )

Ahora, renderizamos los campos en la plantilla:

<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>

Aquí hay otro enfoque usando un método modelo. Esta versión resuelve los campos de selección/elección, omite los campos vacíos y permite excluir campos específicos.

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

Luego en tu plantilla:

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

Bien, sé que esto es un poco tarde, pero ya que me topé con esto antes de encontrar la respuesta correcta, también podría hacerlo alguien más.

De los documentos de django :

# 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.'}]

Puedes hacer que un formulario haga el trabajo por ti.

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})

Luego en la plantilla:

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

Puede usar el método values() de a queryset, que devuelve un diccionario. Además, este método acepta una lista de campos para subconjuntos. El método values() no funcionará con get(), por lo que debe usar filter() (consulte la API QuerySet).

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

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

Para una colección de instancias devuelta por filter:

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

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

Realmente debería haber una forma incorporada de hacer esto. Escribí esta utilidad build_pretty_data_view que toma un objeto de modelo y una instancia de formulario (un formulario basado en su modelo) y devuelve un SortedDict.

Los beneficios de esta solución incluyen:

• Conserva el orden usando el SortedDict integrado en Django.
• Cuando intenta obtener la etiqueta/verbose_name, pero vuelve al nombre del campo si uno no está definido.
• También tomará opcionalmente una lista exclude() de nombres de campos para excluir ciertos campo.
• Si su clase de formulario incluye un Meta: exclude(), pero aún desea devolver los valores, agregue esos campos a la lista opcional append().

Para usar esta solución, primero agregue este archivo/función en algún lugar, luego impórtelo en su 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

Así que ahora en tu views.py podrías hacer algo como esto{[14]]}

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,}))

Ahora en su plantilla my-template.html puede iterar sobre los datos de esta manera...

{% for field,value in data.items %}

    <p>{{ field }} : {{value.label}}: {{value.fieldvalue}}</p>

{% endfor %}

Buena Suerte. Espero que esto ayude ¡alguien!

Abajo está el mío, inspirado por shacker get_all_fields. Obtiene un dict de una instancia de modelo, si encuentra campo de relación, entonces asigna el valor de campo un dict recursivamente.

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

Esta función se utiliza principalmente para volcar una instancia de modelo a datos json:

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

He utilizado https://stackoverflow.com/a/3431104/2022534 pero reemplazó model_to_dict() de Django con esto para poder manejar ForeignKey:

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

Tenga en cuenta que lo he simplificado bastante eliminando las partes del original que no necesitaba. Deberías devolverlos.

En lugar de editar cada modelo, recomendaría escribir una etiqueta de plantilla que devolverá todos los campos de cualquier modelo dado.
Cada objeto tiene una lista de campos ._meta.fields.
Cada objeto de campo tiene atributo name que devolverá su nombre y método value_to_string() que se suministró con su modelo object devolverá su valor.
El resto es tan simple como se dice en La documentación de Django.

Aquí está mi ejemplo de cómo podría verse esta templatetag como:

    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>] %}")

Sí, no es bonito, tendrás que hacer tu propia envoltura. Echa un vistazo a builtin databrowse aplicación, que tiene toda la funcionalidad que realmente necesita.

Esto puede ser considerado un truco, pero he hecho esto antes de usar modelform_factory para convertir una instancia de modelo en un formulario.

La clase Form tiene mucha más información dentro que es súper fácil de iterar y servirá para el mismo propósito a expensas de un poco más de gastos generales. Si los tamaños de sus conjuntos son relativamente pequeños, creo que el impacto en el rendimiento sería insignificante.

La única ventaja además de la comodidad, por supuesto, es que puede convertir fácilmente la mesa en un datagrid editable en una fecha posterior.

Se me ocurrió el siguiente método, que funciona para mí porque en cada caso el modelo tendrá un ModelForm asociado con él.

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, e.g.

    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)

Aquí hay un extracto de la plantilla que estoy usando para esta vista en particular:

<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>

Lo bueno de este método es que puedo elegir plantilla por plantilla el orden en el que me gustaría mostrar las etiquetas de campo, usando la tupla pasada a GetModelData y especificando los nombres de campo. Esto también me permite excluir ciertos campos (por ejemplo, una clave foránea de usuario) ya que solo los nombres de campo pasados a través de la tupla están integrados en el diccionario final.

No voy a aceptar esto como la respuesta porque estoy seguro de que a alguien se le puede ocurrir algo más "Djangónico": -)

Actualización: Estoy eligiendo esta como la respuesta final porque es la más simple de las dadas que hace lo que necesito. Gracias a todos los que aportaron respuestas.

Django 1.7 solución para mí:

Hay variables exactas a la pregunta, pero definitivamente debería ser capaz de diseccionar este ejemplo

La clave aquí es prácticamente usar el .__dict__ del modelo
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)

Plantilla:

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

En la plantilla utilicé un filtro para acceder al campo en el diccionario
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 ""

Estoy usando esto, 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>

Este enfoque muestra cómo usar una clase como ModelForm de django y una etiqueta de plantilla como {{ form.as_table }}, pero hacer que toda la tabla se vea como salida de datos, no como un formulario.

El primer paso fue subclase TextInput widget de django:

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))

Luego subclasé ModelForm de django para intercambiar los widgets predeterminados por versiones de solo lectura:

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" 

Esos eran los únicos widgets que necesitaba. Pero no debería ser difícil extender esta idea a otros widgets.

Solo una edición de @wonder

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

Deje que Django maneje todos los otros campos que no sean los campos relacionados. Siento que es más estable

Echa un vistazo a la aplicación django-etc. Tiene la etiqueta de plantilla model_field_verbose_name para obtener el nombre detallado del campo de las plantillas: http://django-etc.rtfd.org/en/latest/models.html#model-field-template-tags