django1.8 guia definitivo

La gua definitiva de Django: Desarrolla aplicaciones web de forma rpida y sencilla.

Copyright 2015 Saul Garcia M. Se concede permiso para copiar, distribuir, y/o modificar este documento bajo los trminos de la GNU Free Documentation License, Versin 1.1 o cualquier versin posterior publicada por la Free Software Foundation; manteniendo y actualizando la la seccin de autores, Una copia de la licencia est incluida en el apndice titulado GNU Free Documentation License y una traduccin de esta al espaol en el apndice titulado Licencia de Documentacin Libre de GNU. La GNU Free Documentation License tambin est disponible a travs de www. gnu.org o escribiendo a la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. El cdigo fuente en RST para este libro y ms informacin sobre este proyecto se encuentra en el repositorio de Git: http://github.com/saulgm/djangobook.com Este libro ha sido preparado utilizando el lenguaje de marcas RST y la maquinaria de LATEX , para formatear el texto, para editar los grficos se utilizo Gimp y para el maquetado Scribus , las imgenes se obtuvieron libremente de OpenClipart . Todos estos programas son de cdigo abierto y gratuitos. Ideas, sugerencias; quejas: [email protected] Publicado, editado y compilado: en algn lugar de Celayita Mxico.

Django, la gua

definitiva Desarrolla aplicaciones Web de forma rpida y sencilla usando

Django

Saul Garcia M.

Django Software Corporation

Captulos

Sobre los autores................................................................................................I Sobre el editor tcnico........................................................................................II Sobre este libro..................................................................................................III Sobre esta versin.............................................................................................IV Reconocimientos................................................................................................IV Introduccin.........................................................................................................V

PARTE 1 Comenzando con lo bsico CAPITULO 1 Introduccin a Django............................................................3 CAPITULO 2 Empezando..........................................................................10 CAPITULO 3 Los principios de las pginas Web dinmicas......................22 CAPITULO 4 Plantillas...............................................................................42 CAPITULO 5 Modelos................................................................................73 CAPITULO 6 El sitio de Administracin Django.......................................101 CAPITULO 7 Formularios.........................................................................125 PARTE 2 Nivel avanzado CAPITULO 8 Vistas avanzadas y URLconfs...........................................177 CAPITULO 9 Plantillas Avanzadas..........................................................202 CAPITULO 10 Modelos Avanzados...........................................................219 CAPITULO 11 Vistas Genricas................................................................246 CAPITULO 12 Desplegar Django...............................................................277

PARTE 3 Bateras incluidas CAPITULO 13 Generacin de contenido no HTML...................................266 CAPITULO 14 Sesiones, usuario e inscripciones......................................287 CAPITULO 15 Cache.................................................................................310 CAPITULO 16 django.contrib.....................................................................326 CAPITULO 17 Middleware.........................................................................345 CAPITULO 18 Integracin con Base de datos y Aplicaciones...................353 CAPITULO 19 Internacionalizacin............................................................359 CAPITULO 20 Seguridad...........................................................................380

PARTE 4 Apndices de referencia Apndice A Referencia de la definicin de modelos............................392 Apndice B Referencia de la API de base de datos.............................421 Apndice C Referencia de las vistas genricas....................................449 Apndice D Variables de configuracin................................................484 Apndice E Etiquetas de plantilla y filtros predefinidos.........................510 Apndice F El utilitario django-admin....................................................543 Apndice G Objetos Peticin y Respuesta............................................566 Licencia...........................................................................................................567

Sobre los autores ADRIAN HOLOVATY, es un periodista y desarrollador Web, conocido en los crculos editoriales, como uno de los pioneros en el uso de la programacin en el periodismo, tambin es conocido en los crculos tcnicos como el Tipo que invento Django. Adrian trabajo como desarrollador en World Online cerca de 2.5 aos, tiempo en el cual desarrollo Django e implemento algunos sitios en World Onlines. Es el fundador de EveryBlock, una Web startup local de noticias y de Soundslice. Adrian vive in Chicago, USA. JACOB KAPLAN-MOSS, es socio de Revolution Systems la cual provee soporte y servicios de asistencia relacionadas con tecnologias libres alrededor de Django. Jacob trabajo anteriormente en World Online donde fue desarrollado Django, actualmente supervisa el desarrollo de Ellington, una plataforma de publicacin online de noticias para compaas de medios de comunicacin. Jacob vive en Lawrence, Kansas, USA.

Sobre el editor tcnico JEREMY DUNCK: fue rescatado del aburrido trabajo corporativo por el software libre, en parte por Django. Muchos de los intereses de Jeremy se centran en torno al acceso a la informacin. Es el principal desarrollador de Pegasus News, uno de los primeros sitios que usaron Django fuera de World Online, desde entonces se unio a Votizen, un startup que intenta reducir la influencia del dinero en la poltica. Sirve como secretario en DSF, organiza y ayuda a organizar eventos, cuida la vitalidad y la equidad en la comunidad Django. Aunque lleva bastante tiempo sin escribir en un blog. Jeremy vive en Mountain View, CA. USA.

Sobre este libro

Ests leyendo El libro de Django, libro publicado por primera vez en Diciembre de2007 por la editorial Apress con el ttulo de: The Definitive Guide to Django: Web Development Done Right. Hemos lanzado esta versin libremente, por un par de razones:

La primera es que amamos Django y queremos que sea tan accesible como sea posible. Muchos programadores aprenden su arte, usando material tcnico bien escrito, as que nosotros intentamos escribir una gua destacada, que sirva adems como referencia para usar Django.

La segunda, es que resulta que escribir libros sobre tecnologa es

particularmente difcil: sus palabras se vuelven anticuadas incluso antes de que el libro llegue a la imprenta. En la Web, sin embargo, la tinta nunca se seca por lo que podremos mantener este libro al da (y as lo haremos).

La respuesta de los lectores es una parte crtica de ese proceso. Hemos construido un sistema de comentarios que te dejar comentar sobre cualquier parte del libro; leeremos y utilizaremos estos comentarios en nuevas versiones. Sobre esta versin La traduccin al espaol de El libro de Django fue posible gracias a la colaboracin voluntaria de la comunidad Django en espaol. Este libro fue actualizado en 2009 y cubra Django 1.1. Desde entonces ha quedado un poco desactualizado, es por ello que estamos trabajando en la actualizacin del libro, para que cubra Django 2.0. Sin embargo necesitamos de tu ayuda para lograrlo. Es por ello que decidimos compartir este libro, con la esperanza de que encuentres en l un proyecto comunitario libre y en constante evolucin. As que si quieres echarnos una mano, toda ayuda ser bien recibida! El cdigo original de este libro, en la versin en Ingles est alojado en GitHub en http://github.com/jacobian/djangobook.com, mientras que la versin en espaol est alojada en http://github.com/saulgm/djangobook.com, en proceso de actualizacin. Toda ayuda ser bien recibida!

Compilador: Saul Garca M.

Titulo: Django, la gua definitiva Versin: 1.8.0 Ultima actualizacin: 13 de Enero de 2015

A la fecha, han contribuido de una u otra manera a este trabajo: Manuel Kaufmann, Martn Gaitn, Leonardo Gastn De Luca, Guillermo Heizenreder, Alejandro Autaln Renzo Carbonara, Milton Mazzarri, Ramiro Morales, Juan Ignacio Rodrguez de Len, Percy Prez Pinedo, Toms Casquero, Marcos Agustn Lewis, Lenidas Hernn Olivera, Federico M. Peretti, Csar Ballardini, Anthony Lenton, Csar Roldn, Gonzalo Delgado.

Reconocimientos

El aspecto ms gratificante al trabajar con Django es la comunidad. Hemos sido especialmente afortunados que Django haya atrado a tanta gente inteligente, motivada y amistosa. Una buena parte de esa comunidad nos sigui durante el lanzamiento online beta de este libro. Sus revisiones y comentarios fueron indispensables; este libro no hubiese sido posible sin esa maravillosa revisin de pares. Casi mil personas dejaron comentarios que ayudaron a mejorar la claridad, calidad y el flujo del libro final. Queremos agradecer a todos y cada uno de ellos. Estamos especialmente agradecidos con aquellos que dispusieron de su tiempo para revisar el libro en profundidad y dejarnos decenas (a veces cientos) de comentarios: Marty Alchin, Max Battcher, Oliver Beat-tie, Rod Begbie, Paul Bissex, Matt Boersma, RobbinBonthond, Peter Bowyer, Nesta Campbell, Jon Colverson, Jeff Croft, Chris Dary,Alex Dong, Matt Drew, Robert Dzikowski, Nick Efford, Ludvig Ericson, Eric Floehr, Brad Fults, David Grant, Simon Greenhill, Robert Haveman, Kent Johnson, Andrew Kember, Marek Kubica, Eduard Kucera, Anand Kumria, Scott Lamb, Fredrik Lundh, Vadim Macagon, Markus Majer, Orestis Markou, R. Mason, Yasushi Masuda, Kevin Menard, Carlo Miron, James Mulholland, R.D. Nielsen, Michael OKeefe, Lawrence Oluyede, Andreas Pfrengle, Frankie Robertson, Mike Robinson, Armin Ronacher, Daniel Roseman, Johan Samyn, Ross Shannon, Carolina F. Silva, Paul Smith, Bjrn Stabell, Bob Stepno, Graeme Stevenson, Justin Stockton, Kevin Teague, Daniel Tietze, Brooks Travis, Peter Tripp, Matthias Urlichs, Peter van Kampen, Alexandre Vassalotti, Jay Wang, Brian Will, y Joshua Works. Muchas gracias a nuestro editor tcnico, Jeremy Dunck. Sin Jeremy, este libro habra quedado en desorden, con errores, inexactitudes y cdigo roto. Nos sentimos realmente afortunados de que alguien con el talento de Jeremy encontrase el tiempo para ayudarnos. Estamos agradecidos por todo el duro trabajo que la gente de Apress hizo en este libro. Su ayuda y paciencia ha sido asombrosa; este libro no habra quedado terminado sin todo ese trabajo de su parte. Nos pone especialmente felices que Apress haya apoyado e incluso alentado el lanzamiento libre de este libro online; es maravilloso ver a un editor tan abrazado al espritu del open source. Finalmente, por supuesto, gracias a nuestros amigos, familias y compaeros que gentilmente toleraron nuestra ausencia mental mientras terminbamos este trabajo.

INTRODUCCIN

Introduccin

Al comienzo de internet, los desarrolladores Web escriban cada una de las pginasa mano. Actualizar un sitio significaba editar HTML; un rediseo implicaba rehacer cada una de las pginas, una a la vez. Como los sitios Web crecieron y se hicieron ms ambiciosos, rpidamente se hizo evidente que esta situacin era tediosa, consuma tiempo y al final era insostenible. Un grupo de emprendedores del NCSA (Centro Nacional de Aplicaciones para Supercomputadoras, donde se desarrollo el Mosaic; el primer navegador Web grfico) solucion este problema permitiendo que el servidor Web invocara programas externos capaces de generar HTML dinmicamente. Ellos llamaron a este protocolo Puerta de Enlace Comn, o CGI1, y esto cambi internet para siempre. Ahora es difcil imaginar la revelacin que CGI debe haber sido: en vez de tratar con pginas HTML como simples archivos del disco, CGI te permite pensar en pginas como recursos generados dinmicamente bajo demanda. El desarrollo de CGI hace pensar en la primera generacin de pgina Web dinmicas. Sin embargo, CGI tiene sus problemas: los scripts CGI necesitan contener gran cantidad de cdigo repetitivo que los hace difcil de reutilizar, as como complicados de entender y escribir para los desarrolladores novatos. PHP solucion varios de estos problemas y tom al mundo por sorpresa ---ahora es, por lejos, la herramienta ms popular usada para crear sitios Web dinmicos, y decenas de lenguajes y entornos similares (ASP, JSP, etc.) siguieron de cerca el diseo de PHP. La mayor innovacin de PHP es que es fcil de usar: el cdigo PHP es simple de embeber en un HTML plano; la curva de aprendizaje para algunos que recin conocen HTML es extremadamente llana. Pero PHP tiene sus propios problemas; por su facilidad de uso, alienta a la produccin de cdigo mal hecho. Lo que es peor, PHP hace poco para proteger a los programadores en cuanto a vulnerabilidades de seguridad, por lo que muchos desarrolladores de PHP se encontraron con que tenan que aprender sobre seguridad cuando ya era demasiado tarde. Estas y otras frustraciones similares, condujeron directamente al desarrollo de los actuales frameworks de desarrollo Web de tercera generacin. Estos frameworks Django y Ruby on Rails --- parecen ser muy populares en estos das --- reconocen que la importancia de la Web se ha intensificado en los ltimos tiempos. Con esta nueva explosin del desarrollo Web comienza otro incremento en la ambicin; se espera que los desarrolladores Web hagan ms y ms cada da.

1 N. del T.: Common Gateway Interface

INTRODUCCIN

Django fue desarrollado para satisfacer esas nuevas ambiciones. Django te permite construir en profundidad, de forma dinmica, sitios interesantes en un tiempo extremadamente corto. Django est diseado para hacer foco en la diversin, en las partes interesantes de tu trabajo, al mismo tiempo que alivia el dolor de las partes repetitivas. Al hacerlo, proporciona abstracciones de alto nivel a patrones comunes del desarrollo Web, agrega atajos para tareas frecuentes de programacin y claras convenciones sobre cmo resolver problemas. Al mismo tiempo, intenta mantenerse fuera de tu camino, dejando que trabajes fuera del alcance del framework cuando sea necesario. Escribimos este libro porque creemos firmemente que Django mejora el desarrollo Web. Est diseado para poner rpidamente en movimiento tu propio proyecto de Django, en ltima instancia aprenders todo lo que necesites saber para producir el diseo, desarrollo y despliegue de sitios satisfactorios y de los cuales te sientas orgulloso. Estamos extremadamente interesados en la retroalimentacin. La versin online de este libro te permite dejar un comentario en cualquier parte del libro y discutir con otros lectores. Hacemos cuanto podemos para leer todos los comentarios posteados all y responder tantos como nos sea posible. Si prefieres utilizar correo electrnico, por favor envanos unas lneas (en ingls) a [email protected]. De cualquier modo, nos encantara escucharte! Nos alegra que ests aqu, y esperamos que encuentres a Django tan emocionante, divertido y til como nosotros.

P A R T E 1

Comenzando

CAPTULO 1

Introduccin a Django

Este libro es sobre Django, un framework de desarrollo Web que ahorra tiempo yhace que el desarrollo Web sea divertido. Utilizando Django puedes crear y mantener aplicaciones Web de alta calidad con un mnimo esfuerzo. En el mejor de los casos, el desarrollo Web es un acto entretenido y creativo; en el peor, puede ser una molestia repetitiva y frustrante. Django te permite enfocarte en la parte creativa la parte divertida de tus aplicaciones Web al mismo tiempo que mitiga el esfuerzo de las partes repetitivas. De esta forma, provee un alto nivel de abstraccin de patrones comunes en el desarrollo Web, atajos para tareas frecuentes de programacin y convenciones claras sobre cmo solucionar problemas. Al mismo tiempo, Django intenta no entrometerse, dejndote trabajar fuera del mbito del framework segn sea necesario. El objetivo de este libro es convertirte en un experto de Django. Por lo que el enfoque es doble, primero, explicamos en profundidad lo que hace Django, y cmo crear aplicaciones Web con l, segundo, discutiremos conceptos de alto nivel cuando se considere apropiado, contestando la pregunta Cmo puedo aplicar estas herramientas de forma efectiva en mis propios proyectos? Al leer este libro, aprenders las habilidades necesarias para desarrollar sitios Web conectados a una base de datos, poderosos, de forma rpida, con cdigo limpio y de fcil mantenimiento. En este captulo presentamos una visin general sobre Django.

Qu es un Framework Web? Django es un miembro importante de una nueva generacin de frameworks Web. Pero qu significa este trmino exactamente? Para contestar esa pregunta, consideremos el diseo de una aplicacin Web escrita en Python, sin usar un framework. Una de las formas ms simples y directas para construir una aplicacin Web desde cero en python, es usando el estndar Common Gateway Interface (CGI), una tcnica muy popular para escribir aplicaciones Web alrededor del ao 1998. Esta es una explicacin de alto nivel sobre cmo trabaja. Solo crea un script Python, que produzca HTML, guarda el script en el servidor Web con la extensin .cgi y visita la pagina con un navegador Web. Eso Eso todo! Por ejemplo, aqu hay un sencillo script CGI, escrito en python 2.x, que muestra los diez ltimos libros publicados en una base de datos. No te preocupes por los detalles de la sintaxis; solo observa las cosas bsicas que hace:

CAPITULO 1 INTRODUCCIN A DJANGO

#!/usr/bin/envpythonimportMySQLdbprint"ContentType:text/html\n"printprint"Libros"print""print"Libros"print""connection=MySQLdb.connect(user='yo',passwd='dejamentrar',db='books.db')cursor=connection.cursor()cursor.execute("SELECTnombreFROMlibrosORDERBYfechaDESCLIMIT10")forrowincursor.fetchall():print"%s"%row[0]print""print""connection.close() Este cdigo es sencillo de entender. Primero imprime una lnea de Content-Type, seguido de una lnea en blanco, tal como requiere CGI. Imprime el HTML introductorio, se conecta a la base de datos y ejecuta una consulta que obtiene los diez ltimos libros publicados, de una tabla llamada libros. Hace un bucle sobre esos libros y genera una lista HTML desordenada. Finalmente imprime el cdigo para cerrar el HTML y cierra la conexin con la base de datos. Con una pgina nica y poco dinmica como esta, el enfoque desde cero no es necesariamente malo. Por un lado, este cdigo es sencillo de comprender incluso un desarrollador novato puede leer estas lneas de Python y entender todo lo que hace el script, de principio a fin. No hay ms nada que aprender; no hay ms cdigo para leer. Tambin es sencillo de utilizar: slo guarda este cdigo en un archivo llamado ultimoslibros.cgi, sube ese archivo a un servidor Web y visita esa pgina con un navegador. Sin embargo a medida que una aplicacin Web crece ms all de lo trivial, este enfoque se desmorona y te enfrentas a una serie de problemas: Qu sucede cuando mltiples pginas necesitan conectarse a la base de

datos? Seguro que ese cdigo de conexin a la base de datos no debera estar duplicado en cada uno de los scripts CGI, as que la forma pragmtica de hacerlo sera refactorizarlo en una funcin compartida.

Debera un desarrollador realmente tener que preocuparse por imprimir la

lnea de Content-Type y acordarse de cerrar la conexin con la base de datos? Este tipo de cdigo repetitivo reduce la productividad del programador e introduce la oportunidad para que se cometan errores. Estas tareas de configuracin y cierre estaran mejor manejadas por una infraestructura comn.

Qu sucede cuando este cdigo es reutilizado en mltiples entornos, cada

uno con una base de datos y contraseas diferentes? En ese punto, se vuelve esencial alguna configuracin especfica del entorno.

4


Qu sucede cuando un diseador Web que no tiene experiencia

programando en Python desea redisear la pgina? Lo ideal sera que la lgica de la pgina la bsqueda de libros en la base de datos est separada del cdigo HTML de la pgina, de modo que el diseador pueda hacer modificaciones sin afectar la bsqueda.

Precisamente estos son los problemas que un framework Web intenta resolver. Un framework Web provee una infraestructura de programacin para tus aplicaciones, para que puedas concentrarte en escribir cdigo limpio y de fcil mantenimiento sin tener que reinventar la rueda. En resumidas cuentas, eso es lo que hace Django.

El patrn de diseo MVC Comencemos con un ejemplo rpido, que demuestra la diferencia entre el enfoque anterior y el empleado al usar un framework Web. As es como se podra escribir el cdigo CGI anterior usando Django: models.py fromdjango.dbimportmodels'''Lastablasdelabasededatos'''classLibro(models.Model):nombre=models.CharField(max_length=50)fecha=models.DateField()views.py fromdjango.shortcutsimportrender_to_responsefrommodelsimportLibrodefultimos_libros(request):'''Lapartelgica'''lista_libros=Libro.objects.order_by('fecha')[:10]returnrender_to_response('ultimoslibros.html',{'lista_libros':lista_libros})urls.py fromdjango.conf.urlsimporturlimportviews#LaconfiguracindelaURLurlpatterns=[url(r'^ultimos_libros/$',views.ultimos_libros),]ultimos_libros.html {#Laplantilla#}LibrosLibros{%forlibroinlista_libros%}{{libro.nombre}}{%endfor%}

5


No es todava necesario preocuparse por los detalles sobre cmo funciona esto tan slo queremos que te acostumbres al diseo general. Lo que hay que notar principalmente en este ejemplo, son las cuestiones de separacin:

El archivo models.py contiene una descripcin de la tabla de la base de datos, como una clase Python. A esto se lo llama el modelo. Usando esta clase se pueden crear, buscar, actualizar y borrar entradas de tu base de datos usando solo cdigo Python en lugar de escribir declaraciones SQL repetitivas.

El archivo views.py contiene la lgica de la pgina, en la funcin

ultimos_libros() . A esta funcin se la denomina vista. El archivo urls.py especfica qu vista es llamada segn el patrn URL. En este

caso, la URL /ultimos_libros/ ser manejada por la funcin ultimos_libros(). En otras palabras, si el nombre de nuestro dominio es example.com, cualquier visita a la URL http://example.com/ultimos_libros/ llamara a la funcin ultimos_libros().

El archivo ultimos_libros.html es una plantilla HTML especial, que describe

el diseo de la pgina. Usa el lenguaje de plantillas de Django, con declaraciones bsicas y lgicas por ejemplo: {% for libro in lista_libros %}.

Tomadas en su conjunto, estas piezas se aproximan al patrn de diseo Modelo-Vista-Controlador (MVC). Dicho de manera ms fcil, MVC define una forma de desarrollar software en la que el cdigo para definir y acceder a los datos (el modelo) est separado del pedido lgico de asignacin de ruta (el controlador), que a su vez est separado de la interfaz del usuario (la vista). Una ventaja clave de este enfoque es que los componentes tienen un acoplamiento dbil entre s. Eso significa que cada pieza de la aplicacin Web que funciona sobre Django tiene un nico propsito clave, que puede ser modificado independientemente sin afectar las otras piezas. Por ejemplo, un desarrollador puede cambiar la URL de cierta parte de la aplicacin sin afectar la implementacin subyacente. Un diseador puede cambiar el HTML de una pgina sin tener que tocar el cdigo Python que la renderiza. Un administrador de base de datos puede renombrar una tabla de la base de datos y especificar el cambio en un nico lugar, en lugar de tener que buscar y reemplazar en varios archivos. En este libro, cada componente tiene su propio captulo. Por ejemplo, el captulo3 trata sobre las vistas, el captulo4 sobre las plantillas y el captulo5 sobre los modelos.

Historia de Django Antes de empezar a escribir cdigo, deberamos tomarnos un momento para explicar la historia de Django. Y para mostrar cmo se hacen las cosas sin usar atajos, esto nos ayudara a entenderlos mejor. Es til entender por qu se cre el framework, ya que el conocimiento de la historia pone en contexto la razn por la cual Django trabaja de la forma en que lo hace. Si has estado creando aplicaciones Web por un tiempo, probablemente ests familiarizado con los problemas del ejemplo CGI presentado con anterioridad. El camino clsico de un desarrollador Web es algo como esto:

1. Escribir una aplicacin Web desde cero. 2. Escribir otra aplicacin Web desde cero. 3. Darse cuenta de que la aplicacin del paso, 1 tiene muchas cosas en comn

con la aplicacin del paso 2.

6


4. Refactorizar el cdigo para que la aplicacin 1, comparta cdigo con la

aplicacin 2. 5. Repetir los pasos 2-4 varias veces. 6. Darse cuenta de que acabamos de inventar un framework.

As es precisamente como surgi Django. Django naci naturalmente de aplicaciones de la vida real escritas por un equipo de desarrolladores Web en Lawrence, Kansas. Naci en el otoo boreal de 2003, cuando los programadores Web del diario Lawrence Journal-World, Adrian Holovaty y Simon Willison, comenzaron a usar Python para crear sus aplicaciones. El equipo de The World Online, responsable de la produccin y mantenimiento de varios sitios locales de noticias, prosperaban en un entorno de desarrollo dictado por las fechas lmite del periodismo. Para los sitios incluidos LJWorld.com, Lawrence.com y KUsports.com los periodistas (y los directivos) exigan que se agregaran nuevas caractersticas y que aplicaciones enteras se crearan a una velocidad vertiginosa, a menudo con slo das u horas de preaviso. Es as que Adrian y Simon desarrollaron por necesidad un framework de desarrollo Web que les ahorrara tiempo era la nica forma en que podan crear aplicaciones mantenibles en tan poco tiempo. En el verano de 2005, luego de haber desarrollado este framework hasta el punto en que estaba haciendo funcionar la mayora de los sitios de World Online, el equipo de World Online, que ahora inclua a Jacob Kaplan-Moss, decidi liberar el framework como software de cdigo abierto. Lo liberaron en julio de 2005 y lo llamaron Django, por el guitarrista de jazz Django Reinhardt. Hoy en da, Django es un proyecto estable y maduro, de cdigo abierto con cientos de miles de colaboradores y usuarios de todo el mundo. Dos de los desarrolladores originales de Worl Online (Los benevolentes dictadores vitalicios Adrian y Jacob) siguen aportando una gua centralizada para el crecimiento del framework, por lo que es ms un equipo de colaboracin comunitario. Esta historia es relevante porque ayuda a explicar dos cuestiones clave. La primera es el punto dulce de Django. Debido a que Django naci en un entorno de noticias, ofrece varias caractersticas (en particular la interfaz administrativa, tratada en el captulo 6, que son particularmente apropiadas para sitios de contenido sitios como eBay, craigslist.org y washingtonpost.com que ofrecen informacin basada en bases de datos. (De todas formas, no dejes que eso te quite las ganas a pesar de que Django es particularmente bueno para desarrollar esa clase de sitios, eso no significa que no sea una herramienta efectiva para crear cualquier tipo de sitio Web dinmico. Existe una gran diferencia entre ser particularmente efectivo para algo y no ser particularmente efectivo para otras cosas). La segunda cuestin a resaltar es cmo los orgenes de Django le han dado forma a la cultura de su comunidad de cdigo abierto. Debido a que Django fue extrado de cdigo de la vida real, en lugar de ser un ejercicio acadmico o un producto comercial, est especialmente enfocado en resolver problemas de desarrollo Web con los que los desarrolladores de Django se han encontrado y con los que continan encontrndose. Como resultado de eso, Django es continuamente mejorado. Los desarrolladores del framework tienen un alto grado de inters en asegurarse de que Django les ahorre tiempo a los desarrolladores, produzca aplicaciones que sean fciles de mantener y rindan bajo mucha carga. Aunque existen otras razones, los desarrolladores estn motivados por sus propios deseos egostas de ahorrarse tiempo a ellos mismos y disfrutar de sus trabajos.

7


Como leer este libro Al escribir este libro, tratamos de alcanzar un balance entre legibilidad y referencia, con una tendencia a la legibilidad. Nuestro objetivo, como se mencion anteriormente, es hacerte un experto en Django, y creemos que la mejor manera de ensear es a travs de la prosa y numerosos ejemplos, en vez de proveer un exhaustivo pero intil catlogo de las caractersticas de Django (Como alguien dijo una vez, no puedes esperar ensearle a alguien cmo hablar simplemente ensendole el alfabeto). Con esto en mente, te recomendamos que leas los captulos del 1 al 7 en orden. Ellos forman los fundamentos bsicos sobre la forma en que se usa Django; una vez que los hayas ledo, sers capaz de construir sitios Web que funcionen sobre Django. Los captulos 7 al 12, muestran caracterstica avanzadas del framework, los captulos restantes, estn enfocados en caractersticas especficas de Django y pueden ser ledos en cualquier orden. Los apndices son para referencia. Que junto a la documentacin libre disponible en http://www.djangoproject.com/, son probablemente los documentos que tendrs que leer de vez en cuando, para recordar la sintaxis o buscar un resumen rpido de lo que hace ciertas partes de Django, no explicadas aqu. Conocimientos Requeridos Los lectores de este libro deben comprender las bases de la programacin orientada a objetos e imperativa: estructuras de control (por ejemplo: if, while, for)), estructuras de datos (listas, hashes/diccionarios), variables, clases y objetos. La experiencia en desarrollo Web es, como podrs esperar, muy til, pero no es requisito para leer este libro. A lo largo del mismo, tratamos de promover las mejores prcticas en desarrollo Web para los lectores a los que les falta este tipo de experiencia. Conocimientos de Python requeridos En esencia, Django es sencillamente una coleccin de bibliotecas escritas en el lenguaje de programacin Python. Para desarrollar un sitio usando Django escribes cdigo Python que utiliza esas bibliotecas. Aprender Django, entonces, es slo cuestin de aprender a programar en Python y comprender cmo funcionan las bibliotecas de Django. Si tienes experiencia programando en Python, no deberas tener problema en meterte de lleno. En conjunto, el cdigo Django no produce magia negra (es decir, trucos de programacin cuya implementacin es difcil de explicar o entender). Para ti, aprender Django ser slo cuestin de aprender las convenciones y APIs de Django. Si no tienes experiencia programando en Python, te espera una grata sorpresa. Es fcil de aprender y muy divertido de usar. A pesar de que este libro no incluye un tutorial completo de Python, s hace hincapi en las caractersticas y funcionalidades de Python cuando se considera apropiado, particularmente cuando el cdigo no cobra sentido de inmediato. An as, recomendamos leer el tutorial oficial de Python, disponible en http://pyspanishdoc.sourceforge.net/tut/tut.html o su versin ms reciente en ingls en http://docs.python.org/tut/. Tambin recomendamos el libro libre y gratuito de Mark Pilgrim Inmersin en Python, disponible en http://es.diveintopython.org/ y publicado en ingls en papel por Apress.

8


Versin requerida de Django Este libro cubre la versin 1.8 y superior. El equipo de desarrolladores de Django, trata en la medida de lo posible de mantener compatibilidad con versiones anteriores, sin embargo ocasionalmente, se introducen algunos cambios drsticos e incompatibles con versiones anteriores. En cada lanzamiento estos cambios son cubiertos en las notas del lanzamiento, que se pueden encontrar en: https://docs.djangoproject.com/en/dev/releases/2.X Nuevas caractersticas de Django Tal como mencionamos anteriormente, Django es mejorado con frecuencia, y probablemente tendr un gran nmero de nuevas ---e incluso esenciales caractersticas para cuando este libro sea publicado. Por ese motivo, nuestro objetivo como autores de este libro es doble:

Asegurarnos que este libro sea a prueba de tiempo tanto como nos sea posible, para que cualquier cosa que leas aqu todava sea relevante en futuras versiones de Django.

Actualizar este libro continuamente en el sitio Web en ingls, http://www.djangobook.com/, para que puedas acceder a la mejor y ms reciente documentacin tan pronto como la escribamos.

Si quieres implementar con Django algo que no est explicado en este libro, revisa la versin ms reciente de este libro en el sitio Web y tambin revisa la documentacin oficial de Django, para obtener detalles ms completos. Obtener ayuda Para obtener ayuda con cualquier aspecto de Django --- desde instalacin y diseo de aplicaciones, hasta diseo de bases de datos e implementaciones sintete libre de hacer preguntas online. En la lista de correo de usuarios de Django (en ingls) se juntan miles de usuarios para preguntar y responder dudas. Suscrbete gratuitamente en http://www.djangoproject.com/r/django-users. El canal de IRC de Django donde los usuarios de Django se juntan a chatear y se ayudan unos a otros en tiempo real. nete a la diversin en #django (ingls) o #django-es (espaol) en la red de IRC Freenode.

Qu sigue? A continuacin, en el captulo 2 utilizaremos Django, explicaremos su instalacin y la configuracin inicial.

9

CAPTULO 2

Empezando

Instalar Django es un proceso que consta de varios pasos, debido a las mltiplespartes mviles de las que constan los entornos modernos de desarrollo Web. En estecaptulo se explican las situaciones ms comunes de instalacin del framework y algunas de sus dependencias. Debido a que Django es solo cdigo Python, se puede utilizar en cualquier sistema que corra Python, incluyendo algunos telfonos celulares! Por lo que este captulo cubre los escenarios ms comunes para su instalacin. Asumiremos que quieres instalarlo en una computadora de escritorio/laptop o en un servidor. Ms adelante, en el captulo12 te mostraremos, cmo desplegar Django en un sitio de produccin.

Instalar Python Django est escrito totalmente en cdigo Python, por lo tanto lo primero que necesitas para usarlo, es asegurarte de que tienes instalada una versin apropiada de Python. El ncleo del framework en la versin 1.4 trabaja con cualquier versin de Python superior a la 2.5 y 2.7. Django 1.5 y Django 1.6, requieren Python 2.6.5 como mnimo. A partir de este lanzamiento Python 3 es oficialmente soportado. Recomendamos ampliamente utilizar las ltimas y menores versines de cada lanzamiento de Python soportados (2.7.X, 3.2.X, 3.3.X y 3.4.X). Toma en cuenta que Django 1.6 es la ltima versin que dar soporte a Python 2.6; ya que requiere como mnimo Python 2.7. Si no ests seguro, sobre que versin de Python instalar y tienes completa libertad para decidir, busca una de las ltimas versines de la serie 2, en especial la versin 3 o superior. Aunque Django trabaja bien con cualquiera de estas versines, las ltimas versines de la serie 3 proveen mejores caractersticas.

Django y Python3 A partir de la versin 1.7, Django admite oficialmente Python 3, 3.2, 3.3, y 3.4. Por lo que si estas empezando un nuevo proyecto y las dependencias que piensas usar, trabajan bien en Python 3 deberas usar Python 3. De cualquier forma si no la haces, no deberas tener ningn problema con el funcionamiento de tu cdigo. A partir de Django 1.6, el soporte para Python 3 es considerado estable y puede ser usado de forma segura en produccin. Es por ello que la comunidad est empezando a migrar paquetes de terceros y aplicaciones a Python 3, por lo que es una buena idea empezar a usarlo, ya que es ms sencillo escribir cdigo para Python 3 y luego hacerlo compatible con la serie 2, que viceversa.

CAPITULO 2 EMPEZANDO

Las nuevas versiones de Python, de la serie 3 son ms rpidas y contienen ms caractersticas que pueden ser muy tiles en tus proyectos Django, sin embargo si quieres usar una versin en especifico, toma en cuenta la siguiente tabla, para usar una versin de Python adecuada a la versin de Django que quieras usar:

Versin Django Versin Python

1.4 2.5, 2.6, 2.7 1.5 2.6, 2.7 y 3.2, 3.3 (experimental) 1.6 2.6, 2.7 y 3.2, 3.3 1.7 2.7 y 3.2, 3.3, 3.4 1.8 2.7 y 3.2, 3.3, 3.4 1.9 2.7 y 3.2, 3.3, 3.4

Tabla 2.1 Compatibilidad entre Python y Django

Instalacin Si ests usando Linux o Mac OS X probablemente ya tienes instalada alguna versin de python o dos (Python 2.7 y Python3). Escribe python o python3 en una terminal. Si ves algo as, Python est instalado: Python3.4.0(default,Apr112014,13:05:18)[GCC4.8.2]onlinuxType"help","copyright","credits"or"license"formoreinformation.>>> Si ves un error como: command not found u orden no encontrada, necesitas primero bajar e instalar Python. Para empezar puedes encontrar instrucciones ms detalladas en la pgina de descargas oficial de Python, disponible online en: http://www.python.org/download/. La instalacin es rpida y fcil.

Instalar Django En cualquier momento, puedes disponer de dos versiones distintas de Django:

1. El lanzamiento oficial ms reciente. 2. La versin de desarrollo.

La versin que decidas instalar depender de tus prioridades. Si quieres una versin estable, probada y lista para produccin, instala la primera opcin, sin embargo si quieres obtener las ltimas y mejores caractersticas y si tal vez te gustara contribuir con Django mismo, usa la segunda opcin si no te importa mucho la estabilidad. Nosotros recomendamos encarecidamente usar la versin oficial, pero siempre es importante conocer que existe una versin de desarrollo, ya que como se menciona en la documentacin, esta est disponible para cualquier miembro de la comunidad de forma libre. En esta seccin explicaremos algunas opciones de instalacin: instalar un lanzamiento oficial, ya sea manualmente o usando pip y explicaremos la forma de instalar la versin de desarrollo, desde el repositorio oficial Git.

11


Instalar un lanzamiento oficial Los lanzamientos oficiales tienen un nmero de versin, tal como 1.7, 1.8 o 1.9, la ltima versin siempre est disponible en la pgina de descargas del proyecto en: http://www.djangoproject.com/download/. Si estas usando alguna distribucin de Linux, la mayora incluye un paquete de Django, por lo que siempre es buena idea usar la versin que se distribuye para tu plataforma e instalar Django con el gestor de paquetes predeterminado. De esta forma la instalacin no traer problemas de seguridad al resto del sistema de paquetes, actualizando paquetes de forma innecesaria, adems los gestores se encargan automticamente de instalar las dependencias necesarias (como los conectores para la base de datos). Si no tienes acceso a una versin pre-empaquetada, puedes descargar e instalar el framework manualmente. Para hacerlo primero descarga el tarball, que se llamar algo as como Django-version.tar.gz (No importa cul sea el directorio local que elijas para la descarga, ya que el proceso de instalacin se encargara de colocar Django en el lugar correcto). Descomprmelo con alguna utilidad como: tar xzvf Django-.tar.gz, cmbiate al directorio recin creado con: cd Django- y usa el comando: setup.py install o python setup.py install, tal y como instalaras cualquier otra librera Python (No olvides usar sudo o privilegios de administrador). En sistemas tipo Unix, esta es la forma en que se ve el proceso:

1. tar xzvf Django-2.0.tar.gz 2. cd Django-* 3. sudo python setup.py install

En Windows, recomendamos usar 7-Zip (http://www.djangoproject.com/r/7zip/) para manejar archivos comprimidos de todo tipo, incluyendo .tar.gz. Una vez que has descomprimido el archivo, ejecuta un shell de comandos, con privilegios de administrador y ejecuta el siguiente comando desde el directorio que empieza con Django-:

pythonsetup.pyinstall Si eres algo curioso, te dars cuenta que la instalacin de Django, lo que hace es instalarse en un directorio llamado site-packages ---Un directorio de paquetes, donde Python busca las libreras de terceros. Usualmente est ubicado en el directorio /usr/lib/python3/site-packages/ Instalar un lanzamiento oficial con Pip Una forma muy sencilla y automtica, para instalar paquetes en Python, es usando un instalador independiente llamado pip. Si tienes instalado pip, lo nico que necesitas, es utilizar una versin actualizada. (Ya que en algunos casos la instalacin de Django no trabaja, con versiones muy antiguas de pip), pip es la opcin recomendada para instalar Django, usando virtualenv y virtualenvwrapper. Pip es un instalador de paquetes Python, usado oficialmente para instalar paquetes desde Python Package Index (PyPI). Con pip puedes instalar Django desde PyPI, si no tienes instalado pip instalalo y luego instala Django.

12


Abre una terminal de comandos y ejecuta el comando easy_install pip. Este comando instalara pip en tu sistema (La version 3.4 de Python, lo incluye como el instalador por defecto).

Opcionalmente puedes utilizar virtualenv o virtualenvwrapper. Estas herramientas, proveen un entorno independiente y aislado para ejecutar cdigo Python, con lo cual es mas practico instalar paquetes, sin alterar el sistema, ya que permite instalar paquetes, sin privilegios de administrador y sin riesgos de actualizar dependencias y con la ventaja de usar el interprete Python que desees. Por lo que de ti depende que quieras aprender a usarlo o no.

Si estas usando Linux, Mac OS X o algn otro sabor de Unix, usa el siguiente

comando en una terminal para instalar Django: sudo pip install django. Si estas usando Windows, inicia el shell de comandos con privilegios de administrador y ejecuta el comando: pip install django. Este comando instalara Django en el directorio de paquetes de tu instalacin por defecto de Python.

Si estas usando virtualenv, no necesitas usar sudo o privilegios de administrador, ya que los paquetes se instalaran en un directorio independiente, perteneciente al entorno de paquetes que crea el mismo virtualenv. Instalar la Versin de Desarrollo Django usa Git (http://git-scm.com) para el control del cdigo fuente. La ltima versin de desarrollo est disponible desde el repositorio oficial en Git (https://github.com/django/django). Si quieres trabajar sobre la versin de desarrollo, o si quieres contribuir con el cdigo de Django en s mismo, deberas instalar Django desde el repositorio alojado en Git. Git es libre, es un sistema de control de versiones de cdigo abierto, usado por el equipo de Django para administrar cambios en el cdigo base. Puedes descargar e instalar manualmente Git de http://git-scm.com/download, sin embargo es ms sencillo instalarlo con el manejador de paquetes de tu sistema operativo (si es tu caso). Puedes utilizar un cliente Git para hacerte con el cdigo fuente ms actual de Django y, en cualquier momento, actualizar tu copia local del cdigo fuente, conocido como un checkout local, para obtener los ltimos cambios y mejoras hechas por los desarrolladores de Django. Cuando uses un versin de desarrollo, debes tener en mente que cualquier cosa se puede romper en cualquier momento, por lo que no hay garantas de nada Una vez dicho esto, tambin debemos decirte que algunos miembros del equipo de Django ejecutan sitios de produccin sobre la versin de desarrollo con el incentivo de mantenerlo estable. Para obtener la ltima versin de desarrollo, sigue los siguientes pasos:

1. Asegrate de tener instalado Git. Puedes obtener el software de http://git-scm.com/, tambin puedes encontrar excelente documentacin en http://git-scm.com/documentation.

2. Clona el repositorio usando el comando:

gitclonehttps://github.com/django/djangodjmaster

13


3. Localiza el directorio site-packages de tu instalacin Python. Usualmente esta en el directorio: /usr/lib/python3/site-packages. Si no tienes idea de su localizacin, usa la lnea de comandos y tipea:

pythonc'importsys,pprintpprint.pprint(sys.path)'

El resultado de la salida, incluir el directorio de site-packages Si no tienes un directorio site-packages, crea un archivo con el nombre:

djmaster.pth edtalo y agrega la ruta completa al directorio djmaster. Por ejemplo, tu archivo puede contener una lnea como la siguiente:

o /path/to/djmaster

La carpeta: djmaster/django/bin en la ruta de tu sistema. Es el directorio que incluye las utilidades administrativas, tales como django-admin.py.

Si los archivo .pth son nuevos para ti, puedes aprender ms de ellos en http://www.djangoproject.com/r/python/site-module/.

Luego de descargar el cdigo fuentes desde Git y haber seguido los pasos anteriores, no necesitas ejecutar setup.py install Acabas de hacer este trabajo a mano! Debido a que el cdigo de Django cambia a menudo corrigiendo bugs y agregando funcionalidades, probablemente quieras actualizarlo con frecuencia o alguna que otra vez. Para actualizar el cdigo, solo ejecuta el comando: git pull origin master desde el directorio djmaster. Cuando ejecutes este comando, Git contactara https://github.com/django/django y automticamente determinar si el cdigo ha cambiado y actualizar tu versin local del cdigo con cualquier cambio que se haya hecho desde la ltima actualizacin. Es muy bueno. Finalmente, si estas usando la versin de desarrollo, necesitas conocer la versin de Django que estas ejecutando. Conocer el nmero de versin es importante en caso de que alguna vez necesites ayuda de la comunidad o para enviar alguna mejora del framework. En estos casos, es necesario informar sobre la revisin, esta revisin es tambin conocida como commit. Para encontrar el commit actual, tipea git log -1 dentro del directorio django y busca el identificador despus del commit. Este nmero cambia cada vez que Django cambia, se corrige algn error, se agrega alguna caracterstica, se mejora la documentacin o se implementa cualquier otra cosa. Probando la instalacin Para obtener un poco ms de retroalimentacin, despus del proceso de instalacin, tommonos un momento para probar la instalacin. Usando la lnea de comandos, cmbiate a otro directorio (no al directorio que contiene el directorio django) e inicia el intrprete interactivo tipeando python3 o python dependiendo de la versin que ests usando. Si el proceso de instalacin fue exitoso, deberas poder importar el modulo django: >>>importdjango>>>django.VERSION(1,8,'final',0)

14


Ejemplos en el intrprete interactivo

El intrprete interactivo de Python es un programa de lnea de comandos que te permite escribir un programa Python de forma interactiva. Para iniciarlo slo ejecuta el comando python o python3 en la lnea de comandos Durante todo este libro, mostraremos ejemplos de cdigo Python como si estuviesen escritos en el intrprete interactivo. El triple signo de mayor que (>>>) es el prompt de Python. Si estas siguiendo los ejemplos interactivamente, no copies estos signos. Toma en cuenta que en el intrprete interactivo, las declaraciones multilinea son completadas con tres puntos (...). Por ejemplo: >>>from__future__importprint_function>>>print("""Estaesuna...cadenadetextoqueabarca...treslineas.""")Estaesunacadenadetextoqueabarcatreslineas.>>>defmi_funcion(valor):...print(valor)>>>mi_funcion('hola')hola Estos tres puntos adicionales, al inicio de la lnea son insertados por el interprete Python --- No son parte de la entrada de datos. Los hemos incluido aqu para ser fieles a la salida del intrprete. Si copias estos ejemplos, asegrate de no incluir estos tres puntos. Observa tambin como importamos la funcin print_function del paquete future, para compatibilidad con Python 3. Esta es una solucin perfecta para proyectos en los cuales se requiere mantener una compatibilidad entre distintas versiones de Python, sin tener que ramificar el cdigo entre versiones 2.x y 3.x en especfico, de esta forma es posible mantener el cdigo independiente de la versin de Python.

Configurar la base de datos En este punto, podras escribir una aplicacin Web usando Django, por que el nico prerrequisito de Django es una instalacin funcionando de Python. Sin embargo, este libro se centra en una de las mejores funcionalidades de Django, el desarrollo de sitios Web con soporte para base de datos, para ello necesitars instalar un servidor de base de datos de algn tipo, para almacenar tus datos. Si slo quieres comenzar a jugar con Django, salta a la seccin titulada Empezar un proyecto --- pero crenos, querrs instalar una base de datos finalmente. Todos los ejemplos de este libro asumen que tienes una base de datos configurada. Hasta el momento de escribir esto, Django admite oficialmente estos cuatro motores de base de datos:

15


PostgreSQL http://www.postgresql.org/ SQLite3 http://www.sqlite.org/MySQL http://www.mysql.com/Oracle http://www.oracle.com/ Adems de las bases de datos oficialmente soportadas, existen otras ofrecidas por terceros, que permiten utilizar otras bases de datos con Django como son: SAP SQL, Anywhere, IBM, DB2, Microsoft SQL Server, Firebird, ODBC, ADSDB. En general, todos los motores que listamos aqu trabajan bien con Django (Una notable excepcin, es el soporte opcional para GIS, el cual es ms poderoso usando PostgreSQL, que usando otras bases de datos.) Si no ests atado a ningn sistema y tienes la libertad para cambiarte a cualquier base de datos, nosotros recomendamos PostgreSQL, el cual logra un balance fino entre el costo, caractersticas, velocidad y estabilidad. Configurar la base de datos, es un proceso que toma dos pasos: Primero, necesitas instalar y configurar la base de datos en s mismo. Este

proceso va mas all de los alcances de este libro, pero cada una de las cuatro bases de datos que mencionamos anteriormente posee una vasta documentacin en su sitio Web (Si usas un servicio de hosting compartido, lo ms probable es que la base de datos ya este configurada y lista para usarse.)

Segundo, necesitas instalar ciertas libreras Python para la base de datos en

especfico que vayas a utilizar (drivers). Estas forman parte del cdigo de terceros, que permiten a Python conectarse a la base de datos. Repasararemos mas los requisitos en las siguientes secciones.

SQLite merece especial atencin como herramienta de desarrollo. Es un motor de base de datos extremadamente simple y no requiere ningn tipo de instalacin y configuracin del servidor. Es por lejos el ms fcil de configurar si slo quieres jugar con Django, y viene incluido en la biblioteca estndar de Python. En Windows, obtener los drivers binarios para cualquier base de datos es a veces un proceso complicado. Ya que slo ests inicindote con Django, recomendamos usar Python 3 y el soporte incluido para SQLite. La compilacin de drivers puede ser estresante. Usar Django con PostgreSQL Si ests utilizando PostgreSQL, necesitars el paquete psycopg2 disponible en http://www.djangoproject.com/r/python-pgsql/. Toma nota de la versin de Python que ests usando; necesitars esta informacin para descargar la versin apropiada. Si ests usando PostgresSQL en Windows, puedes encontrar los binarios precompilados de psycopg en http://www.djangoproject.com/r/python-pgsql/windows/. Si estas usando Linux, checa el instalador o gestor de paquetes que ofrece t sistema, busca algo llamado python-psycopg, psycopg-python, python-postgresql o algo similar.

16


Usar Django con SQLite 3 Si quieres usar SQLite, estas de suerte, ya que no necesitas instalar nada, porque Python ofrece soporte nativo para SQLite, adems Django ofrece por omisin usar esta configuracin, por lo que puedes saltarte esta seccin. Usar Django con MySQL Django requiere MySQL 4.0 o superior; la versin 3.x no admite subconsultas anidadas, ni algunas otras sentencias SQL perfectamente estndar. Tambin necesitas instalar el paquete MySQLdb disponible en: http://www.djangoproject.com/r/python-mysql/. Si estas usando Linux, checa el instalador o gestor de paquetes que ofrece t sistema y busca algo llamado python-mysql, python-mysqldb, mysql-python o algo similar. Django con Oracle Django trabaja con versiones servidor de Oracle 9i o ms alto. Si estas usando Oracle necesitas instalar la librera cx_Oracle, disponible en http://cx-oracle.sourceforge.net/. Usa una versin superior a la 4.31, pero evita la versin 5.0 ya que existe un error en la versin del controlador. La versin 5.0.1 corrige ese error, de cualquier forma usa en lo posible una versin superior. Usar Django sin una base de datos Como mencionamos anteriormente, Django actualmente no requiere una base de datos. Si slo quieres usar este como un servidor dinmico de pginas que no use una base de datos, est perfectamente bien. Con esto dicho, ten en cuenta que algunas de las herramientas extras de Django requieren una base de datos, por lo tanto si eliges no usar una base de datos, perders estas utilidades. (Sealaremos estas utilidades a lo largo del libro).

Comenzar un proyecto Una vez que has instalado Python, Django y (opcionalmente) una base de datos (incluyendo los controladores), puedes empezar a dar tus primeros pasos en el desarrollo de aplicaciones, creando un proyecto. Un proyecto es una coleccin de configuraciones para una instancia de Django, incluyendo configuracin de base de datos, opciones especficas de Django y configuraciones especficas de aplicaciones. Si esta es la primera vez que usas Django, tendrs que tener cuidado de algunas configuraciones inciales. Primero crea un nuevo directorio para empezar a trabajar, por ejemplo algo como /home/username/djcode/.

17


Dnde debera estar este directorio? Si has trabajado con PHP, probablemente pondras el cdigo debajo de la carpeta raz del servidor Web (en lugares como /var/www). Con Django, no tienes que hacer esto. No es una buena idea poner cualquier cdigo Python en la carpeta raz del servidor Web, porque al hacerlo se arriesga a que la gente sea capaz de ver el cdigo en la Web. Esto no es bueno para la seguridad. Pon tu cdigo en algn directorio fuera de la carpeta raz, cmbiate al directorio que acabas de crear y ejecuta el siguiente comando: djangoadmin.pystartprojectmisitio Este comando creara un directorio llamado misitio en el directorio actual.

Nota: django-admin.py debera estar en la ruta de bsqueda de tu sistema o PATH, si instalaste Django con la utilidad setup.py. Si estas usando la versin de desarrollo, puedes encontrar django-admin.py en djmaster/django/bin. Como vas a utilizar con frecuencia django-admin.py considera agregarlo a tu PATH. En Unix, puedes hacer un enlace simblico a /usr/local/bin usando un comando como sudo ln -s /path/to/django/bin/django-admin.py /usr/local/bin/django-admin.py. En Windows, puedes actualizar tu variable de entorno PATH de forma grafica. Si instalaste Django a travs del gestor de paquetes de tu distribucin, django-admin.py o en sistemas Windows, ahora tienes un ejecutable llamado django-admn, A si que solo debes ejecutar el comando (omitiendo el .py): djangoadmin.pystartprojectmisitio Si obtienes un mensaje como permiso denegado, al usar el comando django-admin.py startproject, necesitas cambiarle los permisos al archivo, para hacerlo, navega al directorio donde se instalo django-admin.py, (e.g., cd /usr/local/bin) y ejecuta el comando chmod +x django-admin.py.

El comando startproject crea un directorio de trabajo que contiene varios archivos:

misitio/manage.pymisitio/__init__.pysettings.pyurls.pywsgi.py

Estos archivos son los siguientes: misitio/: El directorio de trabajo externo misitio/, es solo un contenedor, es

decir una carpeta que contiene nuestro proyecto. Por lo que se le puede cambiar el nombre en cualquier momento sin afectar el proyecto en s.

manage.py: Una utilidad de lnea de comandos que te permite interactuar

con un proyecto Django de varias formas. Usa manage.py help para ver lo que

18


puede hacer. No deberas editar este archivo, ya que este es creado en el directorio convenientemente para manejar el proyecto.

misitio/misitio/: El directorio interno misitio/ contiene el paquete Python

para tu proyecto. El nombre de este paquete Python se usara para importar cualquier cosa dentro del. (Por ejemplo importmisitio.settings).

__init__.py: Un archivo requerido para que Python trate el directorio misitio

como un paquete o como un grupo de mdulos. Es un archivo vacio y generalmente no necesitaras agregarle nada.

settings.py: Las opciones/configuraciones para nuestro proyecto Django.

Dale un vistazo, para que te des una idea de los tipos de configuraciones disponibles y sus valores predefinidos.

urls.py: Declaracin de las URLs para este proyecto de Django. Piensa que es

como una tabla de contenidos de tu sitio hecho con Django. wsgi.py: El punto de entrada WSGI para el servidor Web, encargado de servir

nuestro proyecto. Para ms detalles consulta el captulo12. Todos estos pequeos archivos, constituyen un proyecto Django, que puede albergar mltiples aplicaciones. Si estas usando SQLite como base de datos, no necesitaras crear nada de antemano - la base de datos se crear automticamente cuando esta se necesite. Observa que la variable INSTALLED_APPS, hacia el final del archivo settings.py, contiene el nombre de todas las aplicaciones Django que estn activadas en esta instancia de Django. Las aplicaciones pueden ser empacadas y distribuidas para ser usadas por otros proyectos. De forma predeterminada INSTALLED_APPS contiene todas las aplicaciones, que vienen por defecto con Django:

django.contrib.admin --- La interfaz administrativa. django.contrib.auth --- El sistema de autentificacin.

django.contrib.contenttypes --- Un framework para tipos de contenidos.

django.contrib.sessions --- Un framework. para manejar sesiones

django.contrib.messages --- Un framework para manejar mensajes

django.contrib.staticfiles --- Un framework para manejar archivos estticos.

Estas aplicaciones se incluyen por defecto, como conveniencia para los casos ms comunes. Algunas de estas aplicaciones hacen uso, de por lo menos una tabla de la base de datos, por lo que necesitas crear las tablas en la base de datos, antes de que puedas utilizarlas, para hacerlo entra al directorio que contiene tu proyecto (cd misitio) y ejecuta el comando siguiente, para activar el proyecto Django.:

pythonmanage.pymigrate

19


El comando migrate busca la variable INSTALLED_APPS y crea las tablas necesarias de cada una de las aplicaciones registradas en el archivo settings.py, que contiene todas las aplicaciones. Veras un mensaje por cada migracin aplicada. El servidor de desarrollo Para obtener un poco de informacin y ms retroalimentacin, ejecuta el servidor de desarrollo de Django, para ver el proyecto en accin. Django incluye un servidor Web ligero (Que es llamado con el comando runserver) que puedes usar mientras ests desarrollando tu sitio. Incluimos este servidor para que puedas desarrollar tu sitio rpidamente, sin tener que lidiar con configuraciones de servidores Web para produccin (por ejemplo, Apache) hasta que ests listo para produccin. Este servidor de desarrollo vigila tu cdigo a la espera de cambios y se reinicia automticamente, ayudndote a hacer algunos cambios rpidos en tu proyecto sin necesidad de reiniciar nada. Para iniciar el servidor, entra en el directorio que contiene tu proyecto (cd misitio) si an no lo has hecho y ejecuta el comando:

pythonmanage.pyrunserver Vers algo parecido a esto:

Performingsystemchecks...Systemcheckidentifiednoissues(0silenced).February16,201421:17:11Djangoversion1.8,usingsettings'misitio.settings'Startingdevelopmentserverathttp://127.0.0.1:8000/QuittheserverwithCONTROLC.

El comando runserver inicia el servidor de desarrollo en el puerto 8000, escuchando slo conexiones locales. Ahora que el servidor est corriendo, visita la direccin http://127.0.0.1:8000/ con tu navegador Web. Vers una pgina de Bienvenido a Django sombreada con un azul pastel agradable. Funciona! Bienvenido a Django

Imagen 2.1 Pgina de bienvenida a django, Funciona!

Aunque el servidor de desarrollo es extremadamente til para, bueno; desarrollar, resiste la tentacin de usar este servidor en cualquier entorno parecido a produccin. El servidor de desarrollo puede manejar fiablemente una sola peticin a la vez, y no ha pasado por una auditora de seguridad de ningn tipo. Cuando sea el momento de

20


lanzar tu sitio, mira el Captulo12 para obtener ms informacin, sobre cmo hacerlo con Django. Cambiar el host y el puerto Por defecto, el comando runserver inicia el servidor de desarrollo en el puerto 8000, escuchando slo conexiones locales. Si quieres cambiar el puerto del servidor, psaselo a este como un argumento en la lnea de comandos:

pythonmanage.pyrunserver8080 Tambin puedes cambiar las direcciones IP que escucha el servidor. Esto es utilizado especialmente si quieres compartir el desarrollo de un sitio con otros desarrolladores o miembros de tu equipo. Por ejemplo la direccin IP 192.148.1.103 har que Django escuche sobre cualquier interfaz de red, permitiendo que los dems miembros del equipo puedan conectarse al servidor de desarrollo.

pythonmanage.pyrunserver192.148.1.103:8000 Cuando hagas esto, otras computadoras de tu red local, podrn conectarse a tu sitio, visitando la direccin IP directamente en sus navegadores por ejemplo usando: http://192.148.1.103:8000/ . (Ten en cuenta que para poder acceder a tu red, es necesario primero determinar la direccin IP de tu red local, en sistemas Unix, puedes usar el comando ifconfig en la lnea de comandos o terminal, en sistemas Windows puedes conseguir esta misma informacin usando el comando ipconfig )

Qu sigue? Ahora que tienes todo instalado y el servidor de desarrollo funcionando, en el prximo captulo Los principios de las pginas Web dinmicas escribirs algo de cdigo, que muestra cmo servir pginas Web usando Django.

21

CAPTULO 3

Los principios bsicos de las pginas Web dinmicas

En el captulo anterior, explicamos cmo crear un proyecto en Django y cmo poner en marcha el servidor de desarrollo. Por supuesto, el sitio no hace nada til todava slo muestra el mensaje It worked!. Cambiemos eso. Este captulo presenta cmo crear pginas web dinmicas con Django.

Tu primera pagina creada con Django Como primer objetivo, vamos a crear una pgina web, que muestre por salida el famoso y clsico mensaje: Hola mundo. Si quisiramos publicar un simple Hola mundo en una pgina web, sin usar un framework, simplemente escribiramos Hola mundo en un archivo de texto y lo llamaramos "Hola_mundo", despus lo subiramos a alguna parte de nuestro servidor Web. Fjate en el proceso, hemos especificado dos piezas de informacin acerca de la pgina web: tenemos el contenido que es la cadena "Hola mundo" y la URL que puede ser http://www.example.com/hola.html o tal vez http://www.example.com/archivos/hola.html si lo pusimos en un subdirectorio. Con Django, es necesario especificar esas mismas cosas, pero de diferente modo. El contenido de la pgina ser producido por la funcin vista y la URL se especificara en la URLconf. Primero escribamos la vista Hola mundo, podramos crear una aplicacin Django para este propsito, pero lo haremos de forma manual, para conocer paso a paso el proceso de creacin, mas adelante te mostraremos como crear aplicaciones de forma automtica.

Tu primera vista creada con Django Dentro del directoriomisitio, el cual creamos en el captulo anterior con el comando djangoadmin.py startproject, crea un archivo vacio llamado views.py en el mismo nivel que settings.py. Este modulo Python contendr la vista que usaremos en este captulo. Observa que no hay nada especial acerca del nombre views.py --- A Django no le interesa como lo llames. Le dimos este nombre solo por convencin y para beneficio de otros desarrolladores que lean nuestro cdigo. Nuestra vista Hola mundo ser bastante simple. Esta es la funcin completa, la cual incluye las declaraciones que debemos escribir en un archivo llamado views.py: views.py fromdjango.httpimportHttpResponsedefhola(request):returnHttpResponse("HolaMundo")

CAPITULO 3 LOS PRINCIPIOS BSICOS DE LAS PAGINAS WEB DINMICAS

Repasemos el cdigo anterior lnea a lnea: Primero, importamos la clase HttpResponse, la cual pertenece al mdulo

django.http. Necesitamos importar esta clase porque ser usada posteriormente en nuestro cdigo.

Despus, definimos una funcin llamada hola, la funcin vista. Cada funcin de vista o vista, toma al menos un parmetro llamado por

convencin request. El cual es un objeto que contiene informacin sobre la vista que llama a la pgina actual, la cual es una instancia de la clase django.http.HttpRequest. En este ejemplo, no hace nada el mtodo request, no obstante siempre debe ser el primer parmetro de cualquier vista.

Observa tambin que el nombre de la funcin no importa; ya que no tiene que

ser nombrada de una determinada forma para que Django la reconozca. La llamamos hola, porque claramente indica lo que hace esta funcin, pero se podra haber llamado, hola_maravilloso_y_bello_mundo, o algo igualmente provocador. En la siguiente seccin Tu primera URLconf, te mostraremos como le decimos a Django, que encuentre esta funcin.

La funcin que hemos creado, es una simple lnea: que retorna un objeto HttpResponse que ha sido instanciado con el texto "Hola mundo", pero por ejemplo si quisiramos mostrar por salida HTML directamente, lo podramos hacer as, remplaza la vista anterior con esta: views.py fromdjango.httpimportHttpResponseHTML="""Holamundohtml*{padding:0margin:0}body*{padding:10px20px}body**{padding:0}body{font:smallsansserif}body>div{borderbottom:1pxsolid#ddd}h1{fontweight:normal}#summary{background:#e0ebff}HolaMundo!"""defhola(request):returnHttpResponse(HTML)

23


La leccin principal que debes aprender aqu, es que una vista es solo una funcin Python, que toma como primer argumento una peticin HttpRequest y retorna como respuesta una instancia de HttpResponse. Por lo que una funcin en Python es una vista en Django. (Hay excepciones, pero las veremos ms adelante)

Tu primera URLconf creada con Django En este punto, puedes ejecutar otra vez pythonmanage.pyrunserver y veras de nuevo el mensaje Bienvenido a Django, sin rastros de la vista Hola mundo que creamos anteriormente. Esto se debe a que nuestro proyecto misitio, no sabe nada acerca de esta vista, por lo que necesitamos decirle a Django explcitamente, como activar esta vista para una determinada URL (Continuando con la analoga que mencionamos anteriormente, sobre publicar archivos estticos, esto sera como crear un archivo HTML, sin subirlo al directorio del servidor). Para enganchar, enlazar o apuntar a una determinada URL una funcin vista, usamos una URLconf. Una URLconf es como una tabla de contenidos para tu sitio web hecho con Django. Bsicamente, es un mapeo entre los patrones URL y las funciones de vista que deben ser llamadas por esos patrones URL. Es como decirle a Django, Para esta URL, llama a este cdigo, y para esta otra URL, llama a este otro cdigo. Por ejemplo, Cuando alguien visita la URL /hola/, llama a la funcin vista_hola() la cual est en el modulo Python views.py. Cuando ejecutaste django-admin.py startproject en el captulo anterior, el script cre automticamente una URLconf por ti: el archivo urls.py. Por omisin, se ver as:

fromdjango.conf.urlsimportinclude,urlfromdjango.contribimportadminurlpatterns=[#Ejemplos:#url(r'^$','misitio.views.home',name='home'),#url(r'^blog/',include('blog.urls')),url(r'^admin/',include(admin.site.urls)),]

Repasemos el cdigo anterior lnea a lnea: La primera lnea importa las funciones: url e include, del modulo

django.conf.urls, la funcin url es una tupla, donde el primer elemento es una expresin regular simple y el segundo elemento es la funcin de vista que se usa para ese patrn, mientras que la funcin include se encarga de importar mdulos que contienen otras URLconf, al camino de bsqueda de Python, como una forma de incluir urls que pertenecen a otro paquete, en este caso al sitio administrativo, que viene activado por defecto (Esto lo veremos ms adelante).

Despus tenemos a la funcin urlpatterns(), una variable que recibe los

argumentos de las url en forma de lista, inclusive cadenas de caracteres vacas.

Por defecto, todo lo que est en la URLconf est comentado e incluye algunos

ejemplos de configuraciones comnmente usados, a excepcin del sitio

24


administrativo, el cual esta activado por omisin. (Para desactivarlo, solo es necesario comentarlo.)

Si ignoramos el cdigo comentado y las referencias a la interfaz

administrativa, esto es esencialmente una URLconf:

fromdjango.conf.urlsimporturlurlpatterns=[]

El principal punto que debes notar aqu es la variable urlpatterns, la cual Django espera encontrar en tu mdulo ROOT_URLCONF. Esta variable define el mapeo entre las URLs y el cdigo que manejan esas URLs. Por defecto, todo lo que est en la URLconf est comentado --- tu aplicacin de Django es una pizarra blanca. (Como nota adicional, esta es la forma en la que Django saba que deba mostrar la pgina It worked! en el captulo anterior. Si la URLconf est vaca, Django asume que acabas de crear el proyecto, por lo tanto, muestra ese mensaje). Para agregar una URL y una vista a la URLconf, solamente agrega un mapeo, es decir un enlace entre el patrn URL y la funcin vista a usar. Esta es la forma en la que enganchamos la vista hola a la URL: urls.py fromdjango.conf.urlsimporturlfrommisitio.viewsimportholaurlpatterns=[url(r'^hola/$',hola),](Nota que borramos todo el cdigo que hace referencia a la interfaz administrativa, y dejamos la URLconf vaca, para mostrar cmo funcionan las vistas en Django, activaremos la interfaz administrativa en captulos posteriores.)

Observa que hicimos dos cambios: Primero, importamos la vista hola, desde el modulo misitio/views.py que en la

sintaxis de import de Python se traduce a misitio.views. (La cual asume que el paquete misitio/views.py, est en la ruta de bsqueda de Python o python path).

Luego, agregamos la lnea url(r'^hola/$', hola), a urlpatterns Esta lnea hace

referencia a un URLpattern --- Una tupla de Python en dnde el primer elemento es una expresin regular simple y el segundo elemento es la funcin de vista que usa para manejar ese patrn. La url() puede tomar argumentos opcionales, los cuales cubriremos ms a fondo en l Captulo8,

Un detalle importante que hemos introducido aqu, es el carcter r al comienzo de la expresin regular. Esto le dice a Python que es una cadena en crudo --- lo que permite que las expresiones regulares sean escritas sin demasiadas sentencias de escape tal como cadenas '\n' , la cual es una cadena que indica una nueva lnea. Cuando agregamos la r hicimos una cadena en crudo, la cual Python no tratar de escapar con r'\n' una cadena de dos caracteres, la diagonal y la n minscula. Para

25


evitar colisiones entre las diagonales que usa Python y las encontradas en las expresiones regulares, es fuertemente recomendado usar cadenas en crudo, cada vez que necesites definir una expresin regular en Python. Todos los patrones en este libro usan cadenas en crudo. En resumidas cuentas, le estamos diciendo a Django que cualquier peticin a la URL /hola/ sea manejada por la funcin de vista: /hola/ (y no, no tienen que llamarse igual)

Tu ruta de python o python path Python path es la lista de directorios en tu sistema en donde Python buscar cuando uses la sentencia import de Python. Por ejemplo, supongamos que tu Python path tiene el valor ['', '/usr/lib/python3.4/site-packages', '/home/username/djcode/']. Si ejecutas el cdigo Python from foo import bar, Python en primer lugar va a buscar el mdulo llamado foo.py en el directorio actual. (La primera entrada en el Python path, una cadena de caracteres vaca, significa el directorio actual.) Si ese archivo no existe, Python va a buscar el mdulo en /usr/lib/python3.4/site-packages/foo.py. Si ese archivo no existe, entonces probar en /home/username/djcode/foo.py. Finalmente, si ese archivo no existe, Python lanzar una excepcin ImportError Si ests interesado en ver el valor de tu Python path, abre un intrprete interactivo de Python y escribe: >>>from__future__importprint_function>>>importsys>>>print(sys.path) De nuevo, importamos la funcin print_function() del paquete future para mantener compatibilidad entre Python 2 y 3. Generalmente no tienes que preocuparte por asignarle valores al Python path --- Python y Django se encargan automticamente de hacer esas cosas por ti entre bastidores. (Si eres un poco curioso, establecer el Python path es una de las primeras tareas que hace el archivo manage.py). Vale la pena discutir un poco ms la sintaxis que usada en el patrn ''URLpattern'', ya que no es muy obvio el ejemplo, si esta es la primera vez que tropiezas con las expresiones regulares: La r en r'^hola/$' significa que '^hola/$' es una cadena de caracteres en crudo

de Python. Esto permite que las expresiones regulares sean escritas sin demasiadas sentencias de escape.

Puedes excluir la barra al comienzo de la expresin '^hola/$' para que

coincida con /hola/. Django automticamente agrega una barra antes de toda expresin. A primera vista esto parece raro, pero una URLconf puede ser incluida en otra URLconf, y el dejar la barra de lado simplifica mucho las cosas. Esto se retoma en el captulo 8.

El patrn incluye el acento circunflejo (^) y el signo de dlar ($) estos son

caracteres de la expresin regular que tienen un significado especial. El acento circunflejo significa que requiere que el patrn concuerde con el inicio de la cadena de caracteres, y el signo de dlar significa que exige que el patrn concuerde con el fin de la cadena.

26


Este concepto se explica mejor con un ejemplo. Si hubiramos utilizado el

patrn '^hola/' (sin el signo de dlar al final), entonces cualquier URL que comience con hola/ concordara, as como /hola/foo y /hola/bar, no slo /hola/. Del mismo modo, si dejamos de lado el carcter acento circunflejo inicial ('hola/$'), el patrn coincidira con cualquier URL que termine con hola/, as como /foo/bar/time/. Por lo tanto, usamos tanto el acento circunflejo como el signo de dlar para asegurarnos que slo la URL /hola/ coincida. Nada ms y nada menos.

La mayor parte de los patrones URL, empiezan con el acento circunflejo (^) y

terminan con el signo de dlar ($), esto es bueno, ya que permite una mayor flexibilidad para realizar concordancias ms complejas y exactas.

Expresiones regulares Las Expresiones Regulares (o regexes) son la forma compacta de especificar patrones en un texto. Aunque las URLconfs de Django permiten el uso de regexes arbitrarias para tener un potente sistema de definicin de URLs, probablemente en la prctica no utilices ms que un par de patrones regex. Esta es una pequea seleccin de patrones comunes: Smbolo Coincide con . (punto) Cualquier carcter \d Cualquier dgito [A-Z] Cualquier carcter, A-Z (maysculas) [a-z] Cualquier carcter, a-z (minsculas) [A-Za-z] Cualquier carcter, a-z (no distingue entre mayscula y minscula) + Una o ms ocurrencias de la expresin anterior (ejemplo, \d+

coincidir con uno o ms dgitos) [^/]+ Cualquier carcter excepto la barra o diagonal. ? Cero o una ocurrencia (ejemplo \d? coincidir con cero o un digito * Cero o ms ocurrencias de la expresin anterior (ejemplo, \d*

coincidir con cero o ms dgitos) {1,3} Entre una y tres (inclusive) ocurrencias de la expresin anterior

(ejemplo \d{1,3} coincidir con uno, dos o tres dgitos) Para ms informacin acerca de las expresiones regulares, mira el mdulo http://www.djangoproject.com/r/python/re-module/.

Quizs te preguntes qu pasa si alguien intenta acceder a /hola. (sin poner la segunda barra o diagonal). Porque no concuerda con el patrn que definimos, sin embargo por defecto cualquier peticin a cualquier URL que no contenga una barra final y que no concuerde con un patrn, ser redireccionado a la misma URL con la diagonal final, siempre y cuando la variable APPEND_SLASH tenga asignado el valor True. (APPEND_SLASH, significa Agrega una diagonal al final. Consulta el apndice D,, si quieres ahondar ms en este tema). Si eres el tipo de persona que le gusta que todas sus URL, contengan una barra al final (como lo prefieren muchos desarrolladores de Django), todo lo que necesitas es agregar la barra a cada patrn URL o asignar True a la variable APPEND_SLASH. Si prefieres que tus URLs no contengan la barra o si quieres decidir esto en cada URL, agrega False a la variable APPEND_SLASH y pon las barras en tus patrones URL respectivamente, como lo prefieras. La otra cosa que debes observar acerca de las URLconf es que hemos pasado la funcin vista hola como un objeto, sin llamar a la funcin. Esto es una caracterstica

27


de Python (y otros lenguajes dinmicos): las funciones son objetos de primera clase, lo cual significa que puedes pasarlas como cualquier otra variable. Qu bueno! no? Para probar nuestros cambios en la URLconf, inicia el servidor de desarrollo de Django, como hiciste en el captulo 2, ejecutando el comando python manage.py runserver (Si no lo tenas corriendo.) El servidor de desarrollo automticamente detecta los cambios en tu cdigo de Python y recarga de ser necesario, as no tienes que reiniciar el servidor al hacer cambios). El servidor est corriendo en la direccin http://127.0.0.1:8000/, entonces abre tu navegador web y ve a la pgina http://127.0.0.1:8000/hola/. Deberas ver la salida de tu vista de Django, con el texto Hola mundo, en un tono azul.

Imagen 3.1 Pagina hola mundo, creada con Django.

Enhorabuena! Has creado tu primera pgina Web hecha con Django. Algunas notas rpidas sobre errores 404 En las URLconf anteriores, hemos definido un solo patrn URL: el que maneja la peticin para la URL /hola/. Qu pasara si se solicita una URL diferente? Para averiguarlo, prueba ejecutando el servidor de desarrollo Django e intenta acceder a una pgina Web como http://127.0.0.1:8000/adios/ o http://127.0.0.1:8000/hola/directorio/ , o mejor como http://127.0.0.1:8000/ (la raz del sitio). Deberas ver el mensaje Page not found (Pagina no encontrada, ver la Figura siguiente). Es linda, no? A la gente de Django seguro le gustan los colores pastel.

Imagen 3.2 Pagina de error 404 Django muestra este mensaje porque solicitaste una URL que no est definida en tu URLconf. La utilidad de esta pgina va ms all del mensaje bsico de error 404; nos dice tambin, qu URLconf utiliz Django y todos los patrones de esa URLconf. Con esa informacin, tendramos que ser capaces de establecer porqu la URL solicitada lanz un error 404.

28


Naturalmente, esta es informacin importante slo destinada a ti, el administrador Web. Si esto fuera un sitio en produccin alojado en Internet, no quisiramos mostrar esta informacin al pblico. Por esta razn, la pgina Page not found es slo mostrada si nuestro proyecto en Django est en modo de depuracin (debug mode). Explicaremos cmo desactivar este modo ms adelante. Por ahora, slo diremos que todos los proyectos estn en modo de depuracin cuando los creamos, y si el proyecto no lo estuviese, se retornara una respuesta diferente.

Algunas notas rpidas sobre la raz del sitio Como explicamos en la seccin anterior, si ests viendo un mensaje de error 404 al acceder a la raz de tu sitio http://127.0.0.1:8000/. Es porque Django no agrega mgicamente nada y las URLs no son un caso especial. Si quieres asignar un patrn a la raz de tu sito, necesitas crear una vista y agregarla a la URL conf. Cuando ests listo para implementar una vista para la raz de tu sitio, usa el patrn '^$', el cual coincidir con cualquier cadena vaca. Por ejemplo supongamos que creas una vista llamada 'raz' la cual quieres usar como raz de tu sitio: fromdjango.conf.urlsimporturlfrommisitio.viewsimportraiz,holaurlpatterns=[url(r'^$',raiz),url(r'^hola/$',hola),#...]

Cmo procesa una peticin Django Antes de crear una segunda vista, hagamos una pausa para aprender un poco ms sobre la forma en Django trabaja. Especialmente analicemos cuando recibimos el mensaje Hola mundo, al visitar la pgina http://127.0.0.1:8000/hola/ en el navegador web, esto es lo que Django hace tras bambalinas. Todo comienza cuando el comando manage.py runserver importa un archivo llamado settings.py desde el directorio interno misitio. Este archivo contiene todo tipo de configuraciones opcionales para esta instancia de Django en particular, todas estas configuraciones estn en maysculas: TEMPLATE_DIRS, DATABASES. Sin embargo una de las configuraciones ms importantes es ROOT_URLCONF. La variable ROOT_URLCONF le dice a Django qu mdulo de Python debera usar para la URLconf de este sitio Web. Recuerdas cuando django-admin.py startproject cre el archivo settings.py y el archivo urls.py? Bueno, el archivo settings.py generado automticamente contena una variable ROOT_URLCONF que apunta al urls.py generado automticamente. Qu conveniente! Si abres el archivo settings.py; encontraras algo como esto:

ROOT_URLCONF='misitio.urls'

Este corresponde al archivo misitio/urls.py. Cuando llega una peticin ---digamos, una peticin a la URL /hola/ Django carga la URLconf apuntada por la variable ROOT_URLCONF. Luego comprueba cada uno de los patrones de URL, en la URLconf en orden, comparando la URL solicitada con un

29


patrn a la vez, hasta que encuentra uno que coincida. Cuando encuentra uno que coincide, llama a la funcin de vista asociada con ese patrn, pasando un objeto HttpRequest como primer parmetro de la funcin. (Veremos ms de HttpRequest mas adelante). Como vimos en el ejemplo anterior, la funcin de vista es responsable de retornar un objeto HttpResponse. Una vez que hace esto, Django hace el resto, convierte el objeto Python en una apropiada respuesta Web, que contiene las cabeceras HTTP y un cuerpo (es decir el contenido de la pagina Web.) En resumen, el algoritmo sigue los siguientes pasos:

1. Se recibe una peticin, por ejemplo a /hola/ 2. Django determina la URLconf a usar, buscando la variable ROOT_URLCONF

en el archivo de configuraciones. 3. Django busca todos los patrones en la URLconf buscando la primera

coincidencia con /hola/. 4. Si encuentra uno que coincida, llama a la funcin vista asociada. 5. La funcin vista retorna una HttpResponse. 6. Django convierte el HttpResponse en una apropiada respuesta HTTP, la cual

convierte en una pgina Web. Ahora ya conoces lo bsico sobre cmo hacer pginas Web con Django. Es muy sencillo, realmente --- slo tienes que escribir funciones de vista y relacionarlas con URLs mediante URLconfs. Podras pensar que es lento enlazar las URL con funciones usando una serie de expresiones regulares, pero te sorprenders...!

Tu segunda Vista: Contenido dinmico El ejemplo anterior, Hola mundo fue bastante instructivo y demostr la forma bsica en la que trabaja Django, sin embargo no es un buen ejemplo de una pgina Web dinmica porque el contenido siempre es el mismo. Cada vez que visitemos /hola/, veremos la misma cosa; por lo que esta pgina, es ms un archivo esttico HTML. Para nuestra segunda vista, crearemos algo ms dinmico y divertido. Una pgina Web que muestre la fecha y la hora actual. Este es un buen ejemplo de una pgina dinmica, porque el contenido de la misma no es esttico --- ya que los contenidos cambian de acuerdo con el resultado de un clculo (en este caso, el clculo de la hora actual). Este segundo ejemplo no involucra una base de datos o necesita de entrada alguna, slo muestra la salida del reloj interno del servidor. Es un poco ms instructivo que el ejemplo anterior y demostrara algunos conceptos nuevos. La vista necesita hacer dos cosas: calcular la hora actual y la fecha, para retornar una respuesta HttpResponse que contenga dichos valores. Si tienes un poco de experiencia usando Python, ya sabes que Python incluye un modulo llamado datetime, encargado de calcular fechas. Esta es la forma en que se usa: >>>from__future__importprint_function>>>importdatetime>>>ahora=datetime.datetime.now()>>>ahoradatetime.datetime(2014101617:36:30.493000)>>>print(ahora)

30


2014101617:06:30.493000 El ejemplo es bastante simple y Django no necesita hacer nada. Ya que es solo cdigo Python. (Es necesario hacer nfasis en que el cdigo usado, es solo Python comparndolo especficamente con el cdigo Django que usaremos. Para que no solo aprendas Django, sino no para que puedas aplicar tu conocimiento Python en otros proyectos, no necesariamente usando Django) Para crear esta pgina, crearemos una funcin de vista, que muestre la fecha y la hora actual, por lo que necesitamos anclar la declaracin datetime.datetime.now() dentro de la vista para que la retorne como una respuesta HttpResponse. Esta es la vista que retorna la fecha y hora actual, como un documento HTML: fromdjango.httpimportHttpResponseimportdatetimedeffecha_actual(request):ahora=datetime.datetime.now()html=Fecha:%s"%ahorareturnHttpResponse(html) As como la funcin hola, que creamos en la vista anterior, la funcin fecha_actual deve de colocarse en el mismo archivo views.py. Si ests siguiendo el libro y programando al mismo tiempo, notars que el archivo views.py ahora contiene dos vistas. (Omitimos el HTML del ejemplo anterior slo por claridad y brevedad). Ponindolas juntas, veramos algo similar a esto: views.py fromdjango.httpimportHttpResponseimportdatetimedefhola(request):returnHttpResponse("Holamu

django1.8 guia definitivo

Documents