Consejos y características favoritas de Django?

Inspirado por la serie de preguntas 'Características ocultas de ...', tengo curiosidad por saber acerca de sus consejos favoritos de Django o características menos conocidas pero útiles que conoce.

• Por favor, incluya solo un consejo por respuesta.
• Agregue los requisitos de versión de Django si hay alguno.

Solo voy a comenzar con un consejo mío :)

Use os.path.dirname () en settings.py para evitar nombres de directorio codificados.

No codifique la ruta en su settings.py si desea ejecutar su proyecto en diferentes ubicaciones. Use el siguiente código en settings.py si sus plantillas y archivos estáticos se encuentran dentro del directorio del proyecto 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: Recibí este consejo del screencast ' Django From the Ground Up '.

Instale Extensiones de comando Django y pygraphviz y luego emita el siguiente comando para obtener una visualización del modelo Django realmente agradable:

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

Utilice el render_to decorador de django-molesto en lugar 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 señalar que devolver un HttpResponse (como una redirección) provocará un cortocircuito en el decorador y funcionará tal como espera.

Hay un conjunto de etiquetas personalizadas que uso en todas las plantillas de mi sitio. Buscando una manera de cargarlo automáticamente (SECO, ¿recuerdas?), Encontré lo siguiente:

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

Si coloca esto en un módulo que se carga de forma predeterminada (su urlconf principal, por ejemplo), tendrá las etiquetas y los filtros de su módulo de etiquetas personalizadas disponibles en cualquier plantilla, sin usar {% load custom_tag_module %}.

El argumento pasado a template.add_to_builtins()puede ser cualquier ruta de módulo; su módulo de etiqueta personalizada no tiene que vivir en una aplicación específica. Por ejemplo, también puede ser un módulo en el directorio raíz de su proyecto (por ejemplo 'project.custom_tag_module').

Virtualenv + Python = salvavidas si está trabajando en múltiples proyectos de Django y existe la posibilidad de que no dependan de la misma versión de Django / una aplicación.

¡No codifiques tus URLs!

Utilice nombres de URL en su lugar y la reversefunción para obtener la URL en sí.

Cuando defina sus asignaciones de URL, asigne nombres a sus URL.

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

Asegúrese de que el nombre sea único por URL.

Por lo general, tengo un formato consistente "project-appplication-view", por ejemplo, "cbx-forum-thread" para una vista de hilo.

ACTUALIZACIÓN (robando descaradamente la adición de ayaz ):

Este nombre se puede usar en plantillas con la urletiqueta .

Utilice la barra de herramientas de depuración de django . Por ejemplo, permite ver todas las consultas SQL realizadas mientras se visualiza la vista y también puede ver el seguimiento de pila para cualquiera de ellas.

No escriba sus propias páginas de inicio de sesión. Si está utilizando django.contrib.auth.

El secreto real y sucio es que si también usa django.contrib.admin y django.template.loaders.app_directories.load_template_source está en sus cargadores de plantillas, ¡ también puede obtener sus plantillas gratis!

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

Los procesadores de contexto son increíbles.

Supongamos que tiene un modelo de usuario diferente y desea incluirlo en cada respuesta. En lugar de hacer esto:

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

Los procesos de contexto le brindan la posibilidad de pasar cualquier variable a sus plantillas. Normalmente pongo el mío en'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='')

En tus settings.py agregar la siguiente línea a suTEMPLATE_CONTEXT_PROCESSORS

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

Ahora, cada vez que se realiza una solicitud, incluye la my_userclave automáticamente.

también señala victoria.

Escribí una publicación de blog sobre esto hace unos meses, así que voy a cortar y pegar:

Fuera de la caja, Django te da varias señales que son increíblemente útiles. Tiene la capacidad de hacer cosas antes y después de guardar, iniciar, eliminar o incluso cuando se procesa una solicitud. Entonces, alejémonos de los conceptos y demostremos cómo se usan. Digamos que tenemos un 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)

Entonces, de alguna manera, desea notificar a uno de los muchos servicios de ping-blog que hemos hecho una nueva publicación, reconstruir el caché de publicaciones más recientes y twittear al respecto. Bueno, con las señales tienes la capacidad de hacer todo esto sin tener que agregar ningún método a la clase 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)

Ahí vamos, definiendo esa función y usando la señal post_init para conectar la función al modelo Post y ejecutarla después de que se haya guardado.

Cuando estaba comenzando, no sabía que había un Paginador , ¡¡¡asegúrate de saber de su existencia !!

Use IPython para saltar a su código en cualquier nivel y depurar usando el poder de IPython. Una vez que haya instalado IPython, simplemente coloque este código donde desee depurar:

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

Luego, actualice la página, vaya a la ventana de su servidor de ejecución y se encontrará en una ventana interactiva de IPython.

Tengo un fragmento configurado en TextMate, así que solo escribo ipshell y presiono la pestaña. No podría vivir sin eso.

Ejecute un servidor SMTP de desarrollo que solo generará lo que se le envíe (si no desea instalar SMTP en su servidor de desarrollo).

línea de comando:

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

De la documentación de django-admin :

Si usa el shell Bash, considere instalar el script de finalización de bash de Django, que se encuentra extras/django_bash_completionen la distribución de Django. Permite completar tabulaciones django-admin.pyy manage.pycomandos, por lo que puede, por ejemplo ...

• Tipo django-admin.py .
• Presione [TAB] para ver todas las opciones disponibles.
• Escriba sql, luego [TAB], para ver todas las opciones disponibles cuyos nombres comienzan con sql.

La ./manage.py runserver_plusfacilidad que viene con django_extensions es realmente increíble.

Crea una página de depuración mejorada que, entre otras cosas, utiliza el depurador Werkzeug para crear consolas de depuración interactivas para cada punto de la pila (ver captura de pantalla). También proporciona un método de depuración de conveniencia muy útil dump()para mostrar información sobre un objeto / marco.

Para instalar, puedes usar pip:

pip install django_extensions
pip install Werkzeug

Luego agregue 'django_extensions'a su INSTALLED_APPStupla settings.pye inicie el servidor de desarrollo con la nueva extensión:

./manage.py runserver_plus

Esto cambiará la forma de depurar.

Me gusta usar el depurador Python pdb para depurar proyectos de Django.

Este es un enlace útil para aprender a usarlo: http://www.ferg.org/papers/debugging_in_python.html

Al intentar intercambiar datos entre Django y otra aplicación, request.raw_post_data es un buen amigo. Úselo para recibir y procesar a medida, por ejemplo, datos XML.

Documentación: http://docs.djangoproject.com/en/dev/ref/request-response/

Usa Jinja2 junto a Django.

Si encuentra que el lenguaje de plantillas de Django es extremadamente restrictivo (¡como yo!), Entonces no tiene que quedarse atrapado en él. Django es flexible, y el idioma de la plantilla está acoplado libremente al resto del sistema, ¡así que simplemente conecte otro idioma de plantilla y úselo para presentar sus respuestas http!

Yo uso Jinja2 , es casi como una versión mejorada del lenguaje de plantillas django, usa la misma sintaxis y te permite usar expresiones en declaraciones if. no más hacer etiquetas if personalizadas como if_item_in_list! simplemente puedes decir %{ if item in list %}, o {% if object.field < 10 %}.

Pero eso no es todo; tiene muchas más funciones para facilitar la creación de plantillas, que no puedo ver todas aquí.

Agregue assert Falsesu código de vista para volcar la información de depuración.

Esto se suma a la respuesta anterior sobre los nombres de URL de Django y el envío inverso de URL .

Los nombres de URL también se pueden usar de manera efectiva dentro de las plantillas. Por ejemplo, para un patrón de URL dado:

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

puede tener lo siguiente en plantillas:

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

Dado que las "vistas" de Django solo necesitan ser invocables que devuelvan un HttpResponse, puede crear fácilmente vistas basadas en clases como las de Ruby on Rails y otros marcos.

Hay varias formas de crear vistas basadas en clases, aquí está mi favorito:

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

Puede agregar todo tipo de otras cosas, como el manejo de solicitudes condicionales y la autorización en su vista base.

Una vez que haya configurado sus vistas, su urls.py se verá así:

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

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

En lugar de usar render_to_responsepara vincular su contexto a una plantilla y renderizarla (que es lo que suelen mostrar los documentos de Django), use la vista genérica direct_to_template. Hace lo mismo que render_to_responsehace, pero también agrega automáticamente RequestContext al contexto de la plantilla, permitiendo implícitamente el uso de procesadores de contexto. Puede hacerlo manualmente usando render_to_response, pero ¿por qué molestarse? Es solo otro paso para recordar y otro LOC. Además de utilizar procesadores de contexto, tener RequestContext en su plantilla le permite hacer cosas como:

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

lo cual es muy útil. De hecho, +1 en vistas genéricas en general. Los documentos de Django los muestran principalmente como accesos directos para ni siquiera tener un archivo views.py para aplicaciones simples, pero también puedes usarlos dentro de tus propias funciones de vista:

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

No tengo suficiente reputación para responder al comentario en cuestión, pero es importante tener en cuenta que si vas a usar Jinja , NO admite el carácter '-' en los nombres de bloque de plantilla, mientras que Django sí. Esto me causó muchos problemas y desperdicié el tiempo tratando de rastrear el muy oscuro mensaje de error que generó.

La aplicación de diseño web es muy útil al comenzar a diseñar su sitio web. Una vez importado, puede agregar esto para generar texto de muestra:

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

django.db.models.get_model le permite recuperar un modelo sin importarlo.

James muestra lo útil que puede ser: "Consejos de Django: escriba mejores etiquetas de plantilla - Iteración 4" .

Todo el mundo sabe que hay un servidor de desarrollo que puedes ejecutar con "manage.py runserver", pero ¿sabías que también hay una vista de desarrollo para servir archivos estáticos (CSS / JS / IMG)?

Los recién llegados siempre están desconcertados porque Django no viene con ninguna forma de servir archivos estáticos. Esto se debe a que el equipo de desarrollo piensa que es el trabajo para un servidor web de la vida real.

Pero al desarrollar, es posible que no desee configurar Apache + mod_wisgi, es pesado. Luego puede agregar lo siguiente a urls.py:

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

Su CSS / JS / IMG estará disponible en www.yoursite.com/site_media/.

Por supuesto, no lo use en un entorno de producción.

Aprendí este de la documentación de las miniaturas de sorl aplicación . Puede usar la palabra clave "como" en las etiquetas de plantilla para usar los resultados de la llamada en otra parte de su plantilla.

Por ejemplo:

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

Esto se menciona al pasar la documentación de Django templatetag, pero solo en referencia a los bucles. No dicen que puedes usar esto en otro lugar (¿en algún lugar?) También.

django.views.generic.list_detail.object_list : proporciona todas las variables lógicas y de plantilla para la paginación (una de esas borracheras que he escrito mil veces ahora). Envolverlo permite cualquier lógica que necesite. Esta gema me ha ahorrado muchas horas de depuración de errores fuera de uno en mis páginas de "Resultados de búsqueda" y hace que el código de vista sea más limpio en el proceso.

PyCharm IDE es un entorno agradable para codificar y especialmente depurar, con soporte integrado para Django.

Usa xml_models para crear modelos de Django que usen un backend API XML REST (en lugar de uno SQL). Esto es muy útil, especialmente al modelar API de terceros: obtienes la misma sintaxis de QuerySet a la que estás acostumbrado. Puede instalarlo desde PyPI.

XML de una 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>

Y ahora en 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'

También puede manejar relaciones y colecciones. Lo usamos todos los días en código de producción muy utilizado, por lo que, aunque es beta, es muy útil. También tiene un buen conjunto de talones que puede usar en sus pruebas.

(Descargo de responsabilidad: aunque no soy el autor de esta biblioteca, ahora soy un committer, después de haber realizado algunos commits menores)

Usar migraciones de bases de datos. Usa el sur .