Existe uma referência ao Django?

Eu sou novo no Django. Eu achei os guias oficiais de tópicos https://docs.djangoproject.com/en/1.3/ um excelente lugar para aprender. Mas agora estou em um local em que preciso de referência rápida para ver quais métodos um objeto tem, quais argumentos leva, o que retorna etc., como os documentos Python ou Java. Mais uma referência do que um tutorial. Os documentos oficiais são do estilo tutorial e não têm necessariamente referência a todos os métodos.

Estou faltando alguma coisa aqui? Os documentos oficiais do Django são suficientes para todos?

Posso estar incorreto, mas uso o django há mais de um ano e nunca encontrei esse guia.

Um pouco infeliz - eu gostaria de ter uma referência de função como você mencionou. No entanto, como um recurso adicional, o http://www.djangobook.com/ é muito bom. Eu sempre considerei construir um, mas sou muito preguiçoso.

Há também outra referência que você pode usar quando estiver preso http://www.thedjangoforum.com

O Python possui um mecanismo interno para isso: docstrings. Exemplo:

>>> 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 self.data 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)

Depois, você pode procurar as doutrinas de métodos individuais:

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

Pessoalmente, acho que o uso do pycharm IDE ajuda a acelerar significativamente o desenvolvimento do django. Também no shell django, você pode usar o recurso ipython para obter documentos e código-fonte, digitando algo e seguido por? (informações básicas) ou ?? (Código fonte). Além disso, outros recursos do ipython, como o preenchimento de guias (apenas um nível de profundidade), são muito úteis.

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/models.py
Docstring:
    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/models.py
Source:

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'), default=datetime.datetime.now)
    date_joined = models.DateTimeField(_('date joined'), default=datetime.datetime.now)
    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')
[...]