Dicas e recursos favoritos do Django?

Inspirado na série de perguntas 'Recursos ocultos de ...', estou curioso para saber sobre suas dicas favoritas do Django ou sobre recursos menos conhecidos, porém úteis, que você conhece.

• Por favor, inclua apenas uma dica por resposta.
• Adicione os requisitos da versão do Django, se houver algum.

Vou começar com uma dica minha :)

Use os.path.dirname () em settings.py para evitar nomes de diretórios codificados.

Não codifique os caminhos em seu settings.py se você deseja executar seu projeto em locais diferentes. Use o seguinte código em settings.py se seus modelos e arquivos estáticos estiverem localizados no diretório do projeto Django:

# settings.py
import os
PROJECT_DIR = os.path.dirname(__file__)
...
STATIC_DOC_ROOT = os.path.join(PROJECT_DIR, "static")
...
TEMPLATE_DIRS = (
    os.path.join(PROJECT_DIR, "templates"),
)

Créditos: recebi essa dica do screencast ' Django From the Ground Up '.

Instale as extensões de comando do Django e pygraphviz e, em seguida, emita o seguinte comando para obter uma visualização de modelo do Django realmente bonita:

./manage.py graph_models -a -g -o my_project.png

Use o render_to decorador de django-annoying em vez de render_to_response.

@render_to('template.html')
def foo(request):
    bars = Bar.objects.all()
    if request.user.is_authenticated():
        return HttpResponseRedirect("/some/url/")
    else:
        return {'bars': bars}

# equals to
def foo(request):
    bars = Bar.objects.all()
    if request.user.is_authenticated():
        return HttpResponseRedirect("/some/url/")
    else:
        return render_to_response('template.html',
                              {'bars': bars},
                              context_instance=RequestContext(request))

Editado para indicar que o retorno de um HttpResponse (como um redirecionamento) irá causar um curto-circuito no decorador e funcionar da maneira que você espera.

Há um conjunto de tags personalizadas que uso em todos os modelos do meu site. Procurando uma maneira de carregá-lo automaticamente (SECO, lembra?), Encontrei o seguinte:

from django import template
template.add_to_builtins('project.app.templatetags.custom_tag_module')

Se você colocar isso em um módulo carregado por padrão (seu principal urlconf, por exemplo), você terá as tags e filtros do seu módulo de tag personalizado disponíveis em qualquer modelo, sem usar {% load custom_tag_module %}.

O argumento passado para template.add_to_builtins()pode ser qualquer caminho do módulo; seu módulo de tag personalizado não precisa estar em um aplicativo específico. Por exemplo, também pode ser um módulo no diretório raiz do seu projeto (por exemplo, 'project.custom_tag_module').

Virtualenv + Python = salva-vidas se você estiver trabalhando em vários projetos do Django e existe a possibilidade de que todos eles não dependam da mesma versão do Django / um aplicativo.

Não codifique seus URLs!

Use nomes de URL e a reversefunção para obter o próprio URL.

Ao definir seus mapeamentos de URL, atribua nomes aos seus URLs.

urlpatterns += ('project.application.views'
   url( r'^something/$', 'view_function', name="url-name" ),
   ....
)

Verifique se o nome é exclusivo por URL.

Normalmente, tenho um formato consistente "project-appplication-view", por exemplo, "cbx-forum-thread" para uma visualização de threads.

UPDATE (roubando descaradamente a adição de ayaz ):

Este nome pode ser usado em modelos com a urltag .

Use a barra de ferramentas de depuração do django . Por exemplo, ele permite visualizar todas as consultas SQL realizadas durante a renderização da visualização e você também pode visualizar o rastreamento de pilha para qualquer uma delas.

Não escreva suas próprias páginas de login. Se você estiver usando o django.contrib.auth.

O segredo real e sujo é que, se você também estiver usando o django.contrib.admin, e o django.template.loaders.app_directories.load_template_source estiver em seus carregadores de modelo, você também poderá obtê-lo gratuitamente!

# somewhere in urls.py
urlpatterns += patterns('django.contrib.auth',
    (r'^accounts/login/$','views.login', {'template_name': 'admin/login.html'}),
    (r'^accounts/logout/$','views.logout'),
)

Os processadores de contexto são impressionantes.

Digamos que você tenha um modelo de usuário diferente e deseje incluí-lo em todas as respostas. Em vez de fazer isso:

def myview(request, arg, arg2=None, template='my/template.html'):
    ''' My view... '''
    response = dict()
    myuser = MyUser.objects.get(user=request.user)
    response['my_user'] = myuser
    ...
    return render_to_response(template,
                              response,
                              context_instance=RequestContext(request))

Os processos de contexto permitem passar qualquer variável para seus modelos. Eu normalmente coloco o meu em 'my_project/apps/core/context.py:

def my_context(request):
    try:
        return dict(my_user=MyUser.objects.get(user=request.user))
    except ObjectNotFound:
        return dict(my_user='')

No seu, settings.pyadicione a seguinte linha ao seuTEMPLATE_CONTEXT_PROCESSORS

TEMPLATE_CONTEXT_PROCESSORS = (
    'my_project.apps.core.context.my_context',
    ...
)

Agora, toda vez que uma solicitação é feita, ela inclui a my_userchave automaticamente.

Também sinais de vitória.

Escrevi um post sobre isso há alguns meses, então vou apenas recortar e colar:

O Django fornece diversos sinais que são incrivelmente úteis. Você tem a capacidade de fazer as coisas antes e depois de salvar, iniciar, excluir ou mesmo quando uma solicitação está sendo processada. Então, vamos nos afastar dos conceitos e demonstrar como eles são usados. Digamos que temos um blog

from django.utils.translation import ugettext_lazy as _
class Post(models.Model):
    title = models.CharField(_('title'), max_length=255)
    body = models.TextField(_('body'))
    created = models.DateTimeField(auto_now_add=True)

Então, de alguma forma, você deseja notificar um dos muitos serviços de ping de blogs que criamos uma nova postagem, reconstruir o cache de postagens mais recentes e twittar sobre ela. Bem, com sinais, você tem a capacidade de fazer tudo isso sem precisar adicionar nenhum método à classe Post.

import twitter

from django.core.cache import cache
from django.db.models.signals import post_save
from django.conf import settings

def posted_blog(sender, created=None, instance=None, **kwargs):
    ''' Listens for a blog post to save and alerts some services. '''
    if (created and instance is not None):
        tweet = 'New blog post! %s' instance.title
        t = twitter.PostUpdate(settings.TWITTER_USER,
                               settings.TWITTER_PASSWD,
                               tweet)
        cache.set(instance.cache_key, instance, 60*5)
       # send pingbacks
       # ...
       # whatever else
    else:
        cache.delete(instance.cache_key)
post_save.connect(posted_blog, sender=Post)

Lá vamos nós, definindo essa função e usando o sinal post_init para conectar a função ao modelo Post e executá-la depois que ela foi salva.

Quando eu estava começando, eu não sabia que havia um Paginator , certifique-se de saber da sua existência!

Use o IPython para acessar seu código em qualquer nível e depurar usando o poder do IPython. Depois de instalar o IPython, basta colocar esse código onde quiser depurar:

from IPython.Shell import IPShellEmbed; IPShellEmbed()()

Atualize a página, vá para a janela do servidor de execução e você estará em uma janela IPython interativa.

Eu tenho um trecho configurado no TextMate, então digito ipshell e clico em tab. Eu não poderia viver sem isso.

Execute um servidor SMTP de desenvolvimento que apenas produza o que for enviado a ele (se você não deseja realmente instalar o SMTP no seu servidor de desenvolvimento).

linha de comando:

python -m smtpd -n -c DebuggingServer localhost:1025

Na documentação do django-admin :

Se você usa o shell Bash, considere instalar o script de conclusão do basquete do Django, que reside na extras/django_bash_completiondistribuição do Django. Permite o preenchimento de guias django-admin.pye manage.pycomandos, para que você possa, por exemplo ...

• Digite django-admin.py.
• Pressione [TAB] para ver todas as opções disponíveis.
• Digite sql, depois [TAB], para ver todas as opções disponíveis cujos nomes começam sql.

A ./manage.py runserver_plusfacilidade que vem com django_extensions é realmente incrível.

Ele cria uma página de depuração aprimorada que, entre outras coisas, usa o depurador Werkzeug para criar consoles de depuração interativos para cada ponto da pilha (veja a captura de tela). Ele também fornece um método de depuração de conveniência muito útil dump()para exibir informações sobre um objeto / quadro.

Para instalar, você pode usar o pip:

pip install django_extensions
pip install Werkzeug

Em seguida, adicione 'django_extensions'à sua INSTALLED_APPStupla settings.pye inicie o servidor de desenvolvimento com a nova extensão:

./manage.py runserver_plus

Isso mudará a maneira como você depura.

Eu gosto de usar o depurador Python pdb para depurar projetos do Django.

Este é um link útil para aprender como usá-lo: http://www.ferg.org/papers/debugging_in_python.html

Ao tentar trocar dados entre o Django e outro aplicativo, request.raw_post_dataé um bom amigo. Use-o para receber e processar, digamos, dados XML.

Documentação: http://docs.djangoproject.com/en/dev/ref/request-response/

Use Jinja2 ao lado do Django.

Se você acha a linguagem de modelo do Django extremamente restritiva (como eu!), Não precisa ficar presa a ela. O Django é flexível, e a linguagem do modelo é fracamente acoplada ao resto do sistema, então apenas conecte outra linguagem do modelo e use-a para renderizar suas respostas http!

Eu uso o Jinja2 , é quase como uma versão aprimorada da linguagem de modelo do django, usa a mesma sintaxe e permite que você use expressões nas instruções if! Não é mais necessário criar tags if personalizadas, como if_item_in_list! você pode simplesmente dizer %{ if item in list %}, ou {% if object.field < 10 %}.

Mas isso não é tudo; ele tem muitos outros recursos para facilitar a criação de modelos, que eu não posso usar em todos eles aqui.

Adicione assert Falseseu código de exibição para despejar informações de depuração.

Isso adiciona à resposta acima sobre nomes de URL do Django e envio reverso de URL .

Os nomes de URL também podem ser efetivamente usados ​​nos modelos. Por exemplo, para um determinado padrão de URL:

url(r'(?P<project_id>\d+)/team/$', 'project_team', name='project_team')

você pode ter o seguinte em modelos:

<a href="{% url project_team project.id %}">Team</a>

Como as "visualizações" do Django só precisam ser chamadas que retornam um HttpResponse, você pode criar facilmente visualizações baseadas em classe como as do Ruby on Rails e outras estruturas.

Existem várias maneiras de criar visualizações baseadas em classe, eis a minha favorita:

from django import http

class RestView(object):
    methods = ('GET', 'HEAD')

    @classmethod
    def dispatch(cls, request, *args, **kwargs):
        resource = cls()
        if request.method.lower() not in (method.lower() for method in resource.methods):
            return http.HttpResponseNotAllowed(resource.methods)
        try:
            method = getattr(resource, request.method.lower())
        except AttributeError:
            raise Exception("View method `%s` does not exist." % request.method.lower())
        if not callable(method):
            raise Exception("View method `%s` is not callable." % request.method.lower())
        return method(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        return http.HttpResponse()

    def head(self, request, *args, **kwargs):
        response = self.get(request, *args, **kwargs)
        response.content = ''
        return response

Você pode adicionar todos os tipos de outras coisas, como manipulação e autorização condicional de solicitações, na sua visão básica.

Depois de configurar suas visualizações, seu urls.py ficará mais ou menos assim:

from django.conf.urls.defaults import *
from views import MyRestView

urlpatterns = patterns('',
    (r'^restview/', MyRestView.dispatch),
)

Em vez de usar render_to_responsepara vincular seu contexto a um modelo e renderizá-lo (que é o que os documentos do Django geralmente mostram), use a visão genérica direct_to_template. Ele faz o mesmo que render_to_responsefaz, mas também adiciona automaticamente RequestContext ao contexto do modelo, permitindo implicitamente que processadores de contexto sejam usados. Você pode fazer isso manualmente usando render_to_response, mas por que se preocupar? É apenas mais um passo para lembrar e outro LOC. Além de usar processadores de contexto, ter RequestContext em seu modelo permite fazer coisas como:

<a href="{{MEDIA_URL}}images/frog.jpg">A frog</a> 

o que é muito útil. De fato, marque +1 nas visualizações genéricas em geral. Os documentos do Django geralmente os mostram como atalhos por não terem um arquivo views.py para aplicativos simples, mas você também pode usá-los dentro de suas próprias funções de exibição:

from django.views.generic import simple

def article_detail(request, slug=None):
    article = get_object_or_404(Article, slug=slug)
    return simple.direct_to_template(request, 
        template="articles/article_detail.html",
        extra_context={'article': article}
    )

Eu não tenho reputação suficiente para responder ao comentário em questão, mas é importante observar que, se você usar o Jinja , NÃO suporta o caractere '-' nos nomes dos blocos de modelo, enquanto o Django o faz. Isso me causou muitos problemas e perdi tempo tentando rastrear a mensagem de erro muito obscura gerada.

O aplicativo de web design é muito útil quando você começa a criar seu site. Depois de importado, você pode adicionar isso para gerar texto de exemplo:

{% load webdesign %}
{% lorem 5 p %}

django.db.models.get_model permite recuperar um modelo sem importá-lo.

James mostra como pode ser útil: "Dicas do Django: Escreva melhores tags de modelo - Iteração 4" .

Todo mundo sabe que existe um servidor de desenvolvimento que você pode executar com "manage.py runserver", mas você sabia que existe uma visão de desenvolvimento para servir arquivos estáticos (CSS / JS / IMG) também?

Os recém-chegados sempre ficam intrigados porque o Django não oferece nenhuma maneira de servir arquivos estáticos. Isso ocorre porque a equipe de desenvolvedores acha que é o trabalho para um servidor Web da vida real.

Mas, ao desenvolver, talvez você não queira configurar o Apache + mod_wisgi, é pesado. Em seguida, você pode adicionar o seguinte a urls.py:

(r'^site_media/(?P<path>.*)$', 'django.views.static.serve',
        {'document_root': '/path/to/media'}),

Seu CSS / JS / IMG estará disponível em www.yoursite.com/site_media/.

Obviamente, não o use em um ambiente de produção.

Eu aprendi este na documentação para as miniaturas sorl aplicativo . Você pode usar a palavra-chave "as" nas tags de modelo para usar os resultados da chamada em outro lugar do seu modelo.

Por exemplo:

{% url image-processor uid as img_src %}
<img src="{% thumbnail img_src 100x100 %}"/>

Isso é mencionado de passagem na documentação do Django templatetag, mas apenas em referência a loops. Eles não dizem que você pode usar isso em outro lugar (em qualquer lugar?).

django.views.generic.list_detail.object_list - Ele fornece todas as variáveis ​​lógicas e de gabarito para paginação (uma daquelas tarefas que escrevi que mil vezes agora). A quebra permite qualquer lógica necessária. Essa gema me salvou muitas horas de erros de depuração de um por um nas minhas páginas "Resultados da pesquisa" e torna o código de exibição mais limpo no processo.

O PyCharm IDE é um ambiente agradável para codificar e, especialmente, depurar, com suporte embutido para o Django.

Use xml_models para criar modelos do Django que usam um back-end da API XML REST (em vez de um SQL). Isso é muito útil, especialmente ao modelar APIs de terceiros - você obtém a mesma sintaxe QuerySet com a qual está acostumado. Você pode instalá-lo a partir do PyPI.

XML de uma API:

<profile id=4>
    <email>joe@example.com</email>
    <first_name>Joe</first_name>
    <last_name>Example</last_name>
    <date_of_birth>1975-05-15</date_of_birth>
</profile>

E agora em python:

class Profile(xml_models.Model):
    user_id = xml_models.IntField(xpath='/profile/@id')
    email = xml_models.CharField(xpath='/profile/email')
    first = xml_models.CharField(xpath='/profile/first_name')
    last = xml_models.CharField(xpath='/profile/last_name')
    birthday = xml_models.DateField(xpath='/profile/date_of_birth')

    finders = {
        (user_id,):  settings.API_URL +'/api/v1/profile/userid/%s',
        (email,):  settings.API_URL +'/api/v1/profile/email/%s',
    }

profile = Profile.objects.get(user_id=4)
print profile.email
# would print 'joe@example.com'

Ele também pode lidar com relacionamentos e coleções. Usamos todos os dias em códigos de produção muito usados, portanto, mesmo sendo beta, é muito útil. Ele também possui um bom conjunto de stubs que você pode usar em seus testes.

(Isenção de responsabilidade: embora eu não seja o autor desta biblioteca, agora sou um committer, tendo feito alguns commits menores)

Use migrações de banco de dados. Use o sul .