Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I am new to Django. I have found the official topic guides an excellent place to learn from. But now I am in a place where I need quick reference to see what methods an object has, what arguments it takes, what it returns etc, kind of like the Python docs or Java docs. More of a reference than a tutorial. The official docs are tutorial style and do not necessarily have reference to all the methods.

Am I missing something here? Do the Django official docs suffice for everyone?

share|improve this question

migrated from Oct 21 '11 at 19:10

This question came from our site for professional and enthusiast programmers.

@Glycerine Well, I have been reading the libraries directly to see what the methods do. I am still surprised to see an important project like Django not having a library reference. – superxor Oct 20 '11 at 12:00
up vote 6 down vote accepted

I may be incorrect but I've been using django for over a year now and never found such a guide.

Slightly unfortunate - I would like to have a function reference like you mentioned. However, as an additional resource the is very good. I've always considered building one, but I'm very lazy.

There is also another reference you may use when you're stuck

share|improve this answer

Python has a built-in mechanism for that: docstrings. Example:

>>> import django.forms
>>> help(django.forms.ModelForm)
Help on class ModelForm in module django.forms.models:

class ModelForm(BaseModelForm)
 |  Method resolution order:
 |      ModelForm
 |      BaseModelForm
 |      django.forms.forms.BaseForm
 |      django.utils.encoding.StrAndUnicode
 |      __builtin__.object
 |  Data and other attributes defined here:
 |  __metaclass__ = <class 'django.forms.models.ModelFormMetaclass'>
 |  ----------------------------------------------------------------------
 |  Methods inherited from BaseModelForm:
 |  __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=<class 'django.forms.util.ErrorList'>, label_suffix=':', empty_permitted=False, instance=None)
 |  clean(self)

 |  save(self, commit=True)
 |      Saves this ``form``'s cleaned_data into model instance
 |      ``self.instance``.
 |      If commit=True, then the changes to ``instance`` will be saved to the
 |      database. Returns ``instance``.
 |  validate_unique(self)
 |      Calls the instance's validate_unique() method and updates the form's
 |      validation errors if any were raised.
 |  ----------------------------------------------------------------------
 |  Methods inherited from django.forms.forms.BaseForm:
 |  __getitem__(self, name)
 |      Returns a BoundField with the given name.
 |  __iter__(self)
 |  __unicode__(self)
 |  add_initial_prefix(self, field_name)

 |      Add a 'initial' prefix for checking dynamic initial values
 |  add_prefix(self, field_name)
 |      Returns the field name with a prefix appended, if this Form has a
 |      prefix set.
 |      Subclasses may wish to override.
 |  as_p(self)
 |      Returns this form rendered as HTML <p>s.
 |  as_table(self)
 |      Returns this form rendered as HTML <tr>s -- excluding the <table></table>.
 |  as_ul(self)
 |      Returns this form rendered as HTML <li>s -- excluding the <ul></ul>.
 |  full_clean(self)
 |      Cleans all of and populates self._errors and
 |      self.cleaned_data.
 |  has_changed(self)
 |      Returns True if data differs from initial.
 |  hidden_fields(self)
 |      Returns a list of all the BoundField objects that are hidden fields.
 |      Useful for manual form layout in templates.
 |  is_multipart(self)
 |      Returns True if the form needs to be multipart-encrypted, i.e. it has
 |      FileInput. Otherwise, False.
 |  is_valid(self)
 |      Returns True if the form has no errors. Otherwise, False. If errors are
 |      being ignored, returns False.
 |  non_field_errors(self)
 |      Returns an ErrorList of errors that aren't associated with a particular
 |      field -- i.e., from Form.clean(). Returns an empty ErrorList if there
 |      are none.
 |  visible_fields(self)
 |      Returns a list of BoundField objects that aren't hidden fields.
 |      The opposite of the hidden_fields() method.
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from django.forms.forms.BaseForm:
 |  changed_data
 |  errors
 |      Returns an ErrorDict for the data provided for the form
 |  media
 |      Provide a description of all media required to render the widgets on this form
 |  ----------------------------------------------------------------------
 |  Methods inherited from django.utils.encoding.StrAndUnicode:
 |  __str__(self)
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from django.utils.encoding.StrAndUnicode:
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  __weakref__
 |      list of weak references to the object (if defined)

Then you can look up the docstrings of individual methods:

>>> help(django.forms.ModelForm.is_valid)
Help on method is_valid in module django.forms.forms:

is_valid(self) unbound django.forms.models.ModelForm method
    Returns True if the form has no errors. Otherwise, False. If errors are
    being ignored, returns False.
share|improve this answer

Personally, I find using pycharm IDE helps speed up django development significantly. Also in the django shell you can use the ipython feature to get docstrings and source code, by typing something in and followed by ? (basic info) or ?? (source code). Also other ipython features like tab completion (only one level deep) are very helpful.

In [1]: from django.contrib.auth.models import User

In [2]: User ?
Type:       ModelBase
Base Class: <class 'django.db.models.base.ModelBase'>
String Form:    <class 'django.contrib.auth.models.User'>
Namespace:  Interactive
File:       /usr/local/lib/python2.6/dist-packages/Django-1.2.5-py2.6.egg/django/contrib/auth/
    Users within the Django authentication system are represented by this model.

    Username and password are required. Other fields are optional.

Constructor information:
Definition: User(self, *args, **kwargs)

In [3]: User ??
Type:             ModelBase
Base Class:       <class 'django.db.models.base.ModelBase'>
String Form:   <class 'django.contrib.auth.models.User'>
Namespace:        Interactive
File:             /usr/local/lib/python2.6/dist-packages/Django-1.2.5-py2.6.egg/django/contrib/auth/

class User(models.Model):
    Users within the Django authentication system are represented by this model.

    Username and password are required. Other fields are optional.
    username = models.CharField(_('username'), max_length=30, unique=True, help_text=_("Required. 30 characters or fewer. Letters, numbers and @/./+/-/_ characters"))
    first_name = models.CharField(_('first name'), max_length=30, blank=True)
    last_name = models.CharField(_('last name'), max_length=30, blank=True)
    email = models.EmailField(_('e-mail address'), blank=True)
    password = models.CharField(_('password'), max_length=128, help_text=_("Use '[algo]$[salt]$[hexdigest]' or use the <a href=\"password/\">change password form</a>."))
    is_staff = models.BooleanField(_('staff status'), default=False, help_text=_("Designates whether the user can log into this admin site."))
    is_active = models.BooleanField(_('active'), default=True, help_text=_("Designates whether this user should be treated as active. Unselect this instead of deleting accounts."))
    is_superuser = models.BooleanField(_('superuser status'), default=False, help_text=_("Designates that this user has all permissions without explicitly assigning them."))
    last_login = models.DateTimeField(_('last login'),
    date_joined = models.DateTimeField(_('date joined'),
    groups = models.ManyToManyField(Group, verbose_name=_('groups'), blank=True,
        help_text=_("In addition to the permissions manually assigned, this user will also get all permissions granted to each group he/she is in."))
    user_permissions = models.ManyToManyField(Permission, verbose_name=_('user permissions'), blank=True)
    objects = UserManager()

        class Meta:
        verbose_name = _('user')
share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.