Development

When you’re testing or debugging a Django application, it’s often helpful to get a list of a model instance’s fields and their values. Let’s say you’re debugging a view involving some models like these:

class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    choice_text = models.CharField(max_length=200)
    votes = models.IntegerField(default=0)

and you want to quickly see their fields and values at a breakpoint. Django models have a _meta api that allows you to retrieve a model’s fields, among other things.

Let’s see what the question looks like at this breakpoint:

def detail(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    import pdb; pdb.set_trace()
    return render(request, 'polls/detail.html', {'question': question})

question is an instance of the Question model. _meta is a field of a Model, not its instances, so we need to get question‘s Model:

(Pdb) question_model = type(question)

Now we can get question‘s fields:

(Pdb) question_model._meta.get_fields()
(<ManyToOneRel: polls.choice>, <django.db.models.fields.AutoField: id>, 
<django.db.models.fields.CharField: question_text>, 
<django.db.models.fields.DateTimeField: pub_date>)

That’s not the most helpful output, but we can get the names of the fields like this:

(Pdb) question_fields = question_model._meta.get_fields()
(Pdb) [f.name for f in question_fields]
['choice', 'id', 'question_text', 'pub_date']

With these field names, we can get question‘s values:

(Pdb) field_names = [f.name for f in question_fields]
(Pdb) print(list(map(lambda name, question=question: getattr(question, name, None), field_names)))
[None, 1, 'What is it?', datetime.datetime(2020, 5, 20, 15, 56, 37, 675623, tzinfo=)]

There’s a lot going on here, so let’s break it down:
In python 3, map returns a map object instead of a list, so we need to wrap it with list(). Since we’re in pdb, though, list is a function that lists the code around your breakpoint, so we prevent this confusion by wrapping everything in print().

What about question=question? In python 3, lambda expressions have their own scope, so to use variables from the outer scope, we need to “capture” them using this syntax.

As for getattr(question, name, None), getattr is a handy function for retrieving an attribute from an object. It’s like a longhand form of the dot notation (e.g. foo.attr). It’s useful when you need to access attributes dynamically, since dot notation only works with literal attributes. Another handy feature we’re using here is getattr‘s third argument, which is a default value for getattr to return if the attribute doesn’t exist on the object. In our case, getattr would have returned an error without the default argument. _meta.get_fields returns ManyToMany relationships in addition to regular model fields, and ‘choice’ doesn’t actually exist as an attribute of question, because it’s a reverse relationship from the Choice model.

Now that we can get fields and values from a model instance, let’s take things a step further and write a function to list all fields and values of an instance:

def get_field_and_value(instance, field):
        return (field.name, getattr(instance, field.name, None))
   
def list_fields_and_values(instance):
        model = type(instance)
        fields = model._meta.get_fields()
        tuples = []
        for f in fields:
            tuples.append(get_field_and_value(instance, f))
        return tuples

Here it is in action:

(Pdb) list_fields_and_values(question)
[('choice', None), ('id', 1), ('question_text', 'What is it?'), ('pub_date', 
datetime.datetime(2020, 5, 20, 15, 56, 37, 675623, tzinfo=))]

This is a handy utility function to keep in your project for debugging and testing. There’s definitely some room for improvement, though. A good next step would be to extend the function to recurse on foreign key fields.

Hopefully this blog post has given you some ideas for how to use _meta to explore Django models. There are a lot of features I haven’t covered, so head over to the official docs if you want to learn more!