Foros del Web » Programando para Internet » Python »

[Aporte] Django Tutorial [Introducción]

Estas en el tema de [Aporte] Django Tutorial [Introducción] en el foro de Python en Foros del Web. Introducción a Django: Este tutorial está basado en el " Django book ". Cualquier duda, comentario o sugerencia aquí . Antes que empieces a leer ...
  #1 (permalink)  
Antiguo 04/06/2011, 22:46
Avatar de razpeitia
Moderador
 
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 12 años, 7 meses
Puntos: 1360
[Aporte] Django Tutorial [Introducción]

Introducción a Django:
Este tutorial está basado en el "Django book".

Cualquier duda, comentario o sugerencia aquí.

Antes que empieces a leer este grandioso tutorial, voy a necesitar que cumplas con unos pequeños requisitos.
  • Experiencia programación: Conceptos básicos como variables, estructuras de control (ejemplo: if, for, while), estructura de datos (listas, tuplas, diccionarios), clases y objetos y por supuesto programación orientada a objetos.
  • Experiencia programando en python: Django es una colección de librerías escritas en python. Entonces para desarrollar sitios usando django tienes que escribir código en python. En caso de que no sepas programar en python estas de suerte por que aprender a programar en python es un placer, cosas que te pueden llevar varias lineas de código en otros lenguajes con python puedes hacerlo de una manera simple y en pocas lineas. Si buscas libros para aprender python te recomiendo "Python para todos" o "Dive into python".

¿Qué es un web framework?
Django es un prominente miembro de una nueva generación de web frameworks - pero ¿que es lo que este termino precisamente significa?

Para contestar esta pregunta, vamos a considerar el diseño de una aplicación web escrita en python sin un framework. A través de este tutorial, vamos a tomar este enfoque de trabajar sin frameworks o atajos y después ver como lo haríamos con atajos.

Una de las maneras mas simples y directas de construir una aplicación web escrita en python sin utilizar ningún framework es usar CGI (Common Gateway Interface) estándar, que fue una técnica muy popular a finales de los 90's para desarrollar paginas web dinámicas y no simplemente HTML estático.

Aquí una explicación de alto nivel de como funciona: Solo crea un script en python que imprima HTML, luego salva el script en un servidor web con la extensión ".cgi" y visita la pagina desde tu explorador web favorito. Y eso es todo.

Aquí un ejemplo de Python CGI (Suponga que funciona):
Código Python:
Ver original
  1. #!/usr/bin/env python
  2.  
  3. import MySQLdb
  4.  
  5. print "Content-Type: text/html\n"
  6. print "<html><head><title>Books</title></head>"
  7. print "<body>"
  8. print "<h1>Books</h1>"
  9. print "<ul>"
  10.  
  11. connection = MySQLdb.connect(user='me', passwd='letmein', db='my_db')
  12. cursor = connection.cursor()
  13. cursor.execute("SELECT name FROM books ORDER BY pub_date DESC LIMIT 10")
  14.  
  15. for row in cursor.fetchall():
  16.     print "<li>%s</li>" % row[0]
  17.  
  18. print "</ul>"
  19. print "</body></html>"
  20.  
  21. connection.close()

Como pueden ver lo primero que hace es imprimir "Content-Type: text/html" seguido de una linea en blanco después imprimir algo de html, hace una conexión a una base de datos, obtiene algunos registros y los imprime formateado con html, termina de imprimir el html y cierra la conexión.

Con una pagina como esta, el escribir todo desde 0 no es necesariamente malo. Este código es simple de comprender - inclusive un programador novato puede leer estas 16 lineas de código de python y entender todo, de principio a fin. Como pueden observar no hay mucho que aprender y no hay otro código mas que leer. Ademas es simple de llevar a producción: Solo salva el código en un archivo que tenga la extensión ".cgi", sube el archivo al servidor web y visita la pagina desde tu explorador.

Pero a pesar de su simplicidad, este enfoque tiene números problemas y fastidios. Solo pregúntate a ti mismo las siguientes preguntas:
  • ¿Que pasa cuando múltiples partes de la aplicación necesitan estar conectadas a la base de datos? Seguramente ese código para conectar a la base de datos no necesitaría ser duplicado en cada script CGI que hagamos. Lo ideal sería refactorizar el código en una función compartida para conectarnos a la base de datos.
  • Debe el desarrollador realmente preocuparse acerca de imprimir la linea "Content-Type" y recordar cerrar la conexión a la base de datos? Este tipo de asuntos reduce la productividad de un programador e introduce oportunidades para errores.
  • ¿Que pasa cuanto el código es reutilizado en múltiples ambientes, cada uno con una base de datos y contraseñas separadas? En este punto, algunas configuraciones de ambientes específicos se vuelven esenciales.
  • ¿Que pasa cuando un diseñador web sin experiencia codificando en Python desea rediseñar la pagina? Un carácter mal puesto y la aplicación entera puede fallar. Idealmente, la lógica de la pagina - el obtener registros de libros de la base de datos - debería de estar separada del HTML que despliega la pagina, entonces el diseñador puede editar el html sin afectar la lógica de la aplicación.

Estos problemas son precisamente los problemas que un web framework trata de resolver. Un web framework provee de una infraestructura para programar tus aplicaciones, ademas de que te puedes concentrar en escribir código limpio y mantenible sin tener que reinventar la rueda. En pocas palabras eso es lo que Django hace.


El diseño del patrón MVC
Vamos a ver un rapido ejemplo que demuestra la diferencia entre el anterior y un enfoque con un web framework. Aquí esta como mas o menos se escribiría el anterior codigo de CGI usando Django. Y la primera cosa que notamos es que dividimos todo el 4 archivos (models.py, views.py, urls.py) y un template HTML (latest_books.html):
Código Python:
Ver original
  1. # models.py (the database tables)
  2.  
  3. from django.db import models
  4.  
  5. class Book(models.Model):
  6.     name = models.CharField(max_length=50)
  7.     pub_date = models.DateField()
  8.  
  9.  
  10. # views.py (the business logic)
  11.  
  12. from django.shortcuts import render_to_response
  13. from models import Book
  14.  
  15. def latest_books(request):
  16.     book_list = Book.objects.order_by('-pub_date')[:10]
  17.     return render_to_response('latest_books.html', {'book_list': book_list})
  18.  
  19.  
  20. # urls.py (the URL configuration)
  21.  
  22. from django.conf.urls.defaults import *
  23. import views
  24.  
  25. urlpatterns = patterns('',
  26.     (r'^latest/$', views.latest_books),
  27. )
  28.  
  29.  
  30. # latest_books.html (the template)
  31.  
  32. <html><head><title>Books</title></head>
  33. <body>
  34. <h1>Books</h1>
  35. <ul>
  36. {% for book in book_list %}
  37. <li>{{ book.name }}</li>
  38. {% endfor %}
  39. </ul>
  40. </body></html>

Otra vez, no te preocupes de la sintaxis; solo trata de entender el diseño general. La principal cosa a notar aquí es la separación de asuntos:
  • El archivo models.py contiene una descripción de las tablas de la base de datos, representadas por una clase. Esta clase es llamada un modelo. Usándola puedes crear, obtener, actualizar y borrar registros en tu base de datos usando simple código Python en vez de escribir una sentencia SQL que puede ser repetitiva.
  • El archivo views.py contiene la lógica del negocio para la pagina. La función latest_book es llamada una vista.
  • El archivo urls.py especifica que vista debe ser llamada dado un patron de URL. In este caso, la URL /latest/ sera manejada por la función latest_books(). En otras palabras, si tu dominio es example.com, cualquiera que visite http://example.com/latest/ va a llamar a la función latest_books().
  • El archivo latest_books.html es un template (o plantilla) que describe el diseño de la pagina, usando un lenguaje de template con básicas sentencias lógicas - ejemplo {% for book in book_list %}.

Si tomamos todas las piezas y las juntamos aproximadamente siguen un patron llamado MVC (Model-View-Controller).

La ventaja clave de tal enfoque es que los componentes son loosely coupled. Cada pieza de una aplicación web hecha con Django tiene un solo propósito clave y puede ser cambiado independientemente sin afectar las otras piezas. For ejemplo, un desarrollador puede cambiar la URL de cierta parte de la aplicación sin afectar las otras piezas de la aplicación. Un diseñador puede cambiar el HTML de un template (o plantilla) sin tener que tocar el código de python. Un administrador de base de datos puede renombrar una tabla de la base de datos y especificar el cambio en un solo lugar, en vez de tener que buscar y reemplazar a través de una docena de archivos.

Última edición por razpeitia; 15/06/2011 a las 22:02
  #2 (permalink)  
Antiguo 04/06/2011, 22:48
Avatar de razpeitia
Moderador
 
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 12 años, 7 meses
Puntos: 1360
Respuesta: [Aporte] Django Tutorial [Introducción]

La historia de Django

Antes de empezar a bucear entre mas código, debemos tomar un momento para explicar la historia de Django. Como dijimos anteriormente te vamos a mostrar como hacer las cosas sin usar atajos ademas vas a entender mejor los atajos. Similarmente, es útil entender por que fue creado Django, por que el conocimiento de la historia te pondrá en un contexto de porque Django trabajo en la manera en que lo hace.

Si has estado construyendo aplicaciones web por un tiempo, probablemente estas familiarizado con los problemas del ejemplo CGI que presentamos anteriormente. La ruta clásica del desarrollo web va mas o menos así:
  1. Escribe una aplicación web desde 0
  2. Escribe otra aplicación web desde 0
  3. Date cuenta que la aplicación del paso 1 comparte mucho en común con la aplicación del paso 2
  4. Refactoriza el código entonces la aplicación 1 y 2 pueden compartir el código
  5. Repite los pasos del 2 al 4 varias veces
  6. Date cuenta que has inventado un framework
Esto es precisamente como Django fue creado.

Django creció organicamente de aplicaciones del mundo real escritas por un equipo desarrollo web en Lawrence, Kansas, USA. Django nació en el otoño de 2003, cuando los programadores web del periódico "Lawrence Journal-World", Adrian Holovaty y Simon Willison, empezaron usando Python para construir aplicaciones.

El equipo "World Online", responsable de la producción y mantenimiento de varios sitios de noticias locales, prosperado en un ambiente de desarrollo dictado por los tiempos limites del periodismo. Para los sitios - incluyendo LJWorld.com, Lawrence.com y KUsports.com - periodistas (y administradores) demandaban que fueran añadidas características y aplicaciones enteras fueran construidas en una intensamente rápida agenda, comúnmente con solo días u horas para desarrollarlo. De este modo, Simon y Adrian habían desarrollado un web framework que les ahorraba tiempo - esa fue la única manera en que ellos pudieron construir aplicaciones mantenibles bajo los estrictos tiempos de entrega.

En el verano del 2005, después de habiendo desarrollado este framework hasta un punto donde eficientemente impulsaba la mayoría de los sitios "World Online", el equipo, el cual ahora incluía a Jacob Kaplan-Moss, decidieron liberar el framework como software de codigo abierto. Lo liberaron en Julio de 2005 y lo llamaron Django, en honor al guitarrista de jazz Django Reinhardt.

Ahora, varios años después, Django esta bien establecido como un proyecto de software libre con mas de diez mil usuarios y colaboradores esparcidos a traves de todo el mundo. Dos de los desarrolladores originales de Word Online ("Los benevolentes dictadores de la vida", Adrian y Jacob) aun proveen una guía central para el crecimiento del framework, pero es mucho mas el esfuerzo colaborativo de todo el equipo.

Esta historia es relevante por que ayuda a explicar 2 cosas clave. La primera Django es el "lugar dulce" (sweet spot). Porque Django nació en un ambiente de noticias, ofrece varias características (como un sitio de administración) que son particularmente adecuados para sitios de "contenido" - sitios como Amazon.com, craigslist.org y washingtonpost.com que ofrecen datos de una manera dinámica. - A pesar de que Django es particularmente bueno para desarrollar ese tipo de sitios, que no lo excluye de ser una herramienta efectiva para construir cualquier tipo de sitio web dinámico.

El segundo punto, muestra como los orígenes de Django han formado la cultura de su comunidad de software libre. Porque Django fue extraído desde el código del mundo real, en vez de empezar como un ejercicio académico o producto comercial, esta sumamente enfocado en resolver problemas de desarrollo web que los mismos desarrolladores de Django se han enfrentado - y continúan enfrentando. Como resultado, el mismo Django es activamente mejorado en una base casi diaria.


Versión que vamos a usar Django 1.2.3

Última edición por razpeitia; 06/06/2011 a las 09:06 Razón: Errores ortográficos
  #3 (permalink)  
Antiguo 06/06/2011, 09:00
Avatar de razpeitia
Moderador
 
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 12 años, 7 meses
Puntos: 1360
Respuesta: [Aporte] Django Tutorial [Introducción]

Iniciando
Django es "solo" código en Python y como Python corre donde sea - incluyendo celulares! Pero este capitulo solo cubre escenarios comunes para instalaciones de Django. Vamos a asumir que estas instalándolo en un escritorio/laptop o servidor.

Después (Varios capítulos mas adelante) veremos como llevar a producción un sitio hecho con Django.

Instalando Python
En si mismo Django esta escrito completamente en Python, entonces el primer paso en instalar el framework es estar seguro que Python esta instalado.

Versiones de Python
El núcleo del framework Django funciona con cualquier version de Python desde la 2.3 hasta la 2.7, dependiendo de la versión del framework las versiones mas recientes están dejando de dar soporte a las versiones mas antiguas de Python. Por eso te recomendamos usar de python 2.5 en adelante.

Si no estas seguro cual versión de Python instalar y tienes la libertad de decidir que versión instalar, entonces te recomendamos instalar la ultima versión de la serie 2.x. A pesar de que Django trabaja igual con cualquier versión de Python, las ultimas versiones de Python tienen mejoras de rendimiento y características adicionales del lenguaje que tal vez te guste usar en tus aplicaciones. Ademas existen add-ons (o extensiones) de terceros para Django podrían requerir versiones mas nuevas que las versiones 2.3 o 2.4

Django y Python 3.x
Como saben Python esta en un proceso de transición donde Python 3.x intenta desplazar las versiones 2.x, como ya saben cada versión de Python que cambia en su primer dígito tiene cambios importantes y ademas no es compatible con versiones anteriores, por lo que muchas aplicaciones se tienen que reescribir y eso incluye a Django.

Actualmente Django no corre completamente en python 3.x, afortunadamente esto se ha estado planeando y desarrollando por años así que esperamos que muy pronto Django se pueda correr completamente en versiones de Python 3.x

Instalacion
Si estas corriendo Linux o Mac OS X, probablemente ya tienes Python instalado. Solo escribe python en tu consola (terminal o linea de comandos) favorita. Si vez algo parecido a esto, entonces tienes Python instalado en tu sistema.
Código:
Python 2.6.5 (r265:79096, Mar 19 2010, 21:48:26) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
Si eres un usuario del sistema operativo windows, lo mas probable es que no tengas instalado python.
De cualquier forma, si necesitas descargar python puedes hacerlo desde aqui http://www.python.org/download/. Las instrucciones son rápidas y fáciles de seguir.
Si estas en windows, te recomiendo bajarte el .exe o .msi ya que compilarlo puede ser algo complicado (por lo menos en windows).
En cambio si te encuentras en linux y tienes un administrador de paquetes te recomiendo usarlo ya que regularmente los módulos para python también puedes instalarlo desde tu administrador de paquetes. Ademas estos paquetes son elegidos para que trabajen de una manera optima con tu distribución también regularmente tienes actualizaciones para estos paquetes. Pero si no cuentas con un administrador de paquetes siempre puedes descargate el código fuente, compilarlo e instalarlo.

Instalando Django
Django tiene tipicamente 2 versiones disponibles: La ultima versión oficial lanzada y la versión experimental llamada "trunk". La versión que decidas instalar depende en tus prioridades. ¿Quieres una versión estable y probada de Django o quieres una versión que tenga las ultimas características y probablemente puedas contribuir al mismo framework Django, a costo de la estabilidad?

Nosotros te recomendamos que te pegues a las versiones oficiales (o estables), pero también es importante saber que la versión "trunk" (o versión en desarrollo) existe.



Instalando la version oficial
La ultima versión en el momento que escribo este tutorial, es la versión 1.3. Para descargar la ultima versión puedes visitar https://www.djangoproject.com/download/

Para los usuarios linux que tengan administrador de paquetes pueden instalar Django desde su administrador de paquetes, por lo regular la versión de Django que instala es una versión estable.

Si no tienes acceso a un administrador de paquetes, puedes descargar e instalar Django manualmente.
Para hacer eso visiten la pagina anterior y bajen la ultima versión, después corran estos comandos.
Código:
tar xzvf Django-<versión>.tar.gz #Suponiendo que estan en el directorio donde lo descargaron
cd Django-*
sudo python setup.py install
Y listo a disfrutar Django.


Probando Django
Para saber que efectivamente instalamos Django, abrimos el interprete dinámico de Python y escribimos lo siguiente:
Código:
import django
django.VERSION
Ajustando las bases de datos
Para trabajar con Django no es necesario tener una base de datos, pero Django tiene muchas funciones que requieren tener una base de datos y seguramente también te interesara guardar, obtener, actualizar y borrar datos así que por eso es tan necesaria una base de datos.

Django soporta 4 motores para base de datos:
Si no estas atado a algún sistema viejo y tienes la libertad de escoger una base de datos te recomendamos PostgreSQL, que logra tener un buen balance entre costo, características, velocidad y estabilidad.

Ajustar la base de datos es proceso de 2 pasos:
  • Primero, vas a necesitar instalar y configurar el servidor de base de datos. Es proceso va mas allá del alcance de este tutorial, pero afortunadamente estos 4 motores que soporta Django tienen mucha documentación, una gran comunidad en cada una de estas y la mayoría de estas son fáciles de instalar.
  • Segundo, vas a necesitar instalar una librería de python que te permita conectarte a tu base de datos.

Si solo estas jugando o probando Django y no quieres instalar una base de datos te recomendamos usar SQLite. SQLite es el único motor de base de datos que soporta Django que no requiere de ninguna instalación, claro eso si estas usando una versión de Python 2.5 en adelante.

En windows, obtener una libreria para trabajar con una base de datos puede ser frustante, afortunadamente existe una lista de librerías para python hechas binarios (.exe) que puedes conseguir aquí http://www.lfd.uci.edu/~gohlke/pythonlibs/

Librerías de python recomendadas para conectarnos a la base de datos:
  • PostgreSQL: psycopg2
  • SQLite3: No requerido para python 2.5 en adelante.
  • MySQL: MySQLdb
  • Oracle: cx_Oracle

Empezando un proyecto
Una vez instalado python, Django y opcionalmente la librería para conectarnos a la base de datos, puedes dar el primer paso en desarrollar una aplicación en Django que es crear un proyecto

Un proyecto es una colección de ajustes para una instancia de Django, incluyendo: Configuración de la base de datos, opciones especificas de Django y la aplicación.

NOTA: Para fines prácticos, no pongas tu código de Python en el document root.

Lo primero que vamos hacer es crear un directorio (o carpeta) y correr el siguiente comando: django-admin.py startproject mysite
Esto va a crear una carpeta llamada mysite en tu actual directorio.

NOTA: Para los usuarios unix django-admin.py debe se estar en el "path" de tu sistema y ademas debe de tener permisos de ejecución esto en caso que hallas instalado Django de manera manual. Si lo instalaste desde un administrador de paquetes probablemente el comando no se llame django-admin.py si no django-admin . Si estas usando windows muy probablemente tengas que añadir python al path y luego ejecutar lo siguiente python C:\ruta\a\django\django-admin.py mysite . De cualquier manera te recomendamos que instales eclipse + pydev para que sea mas fácil trabajar en tu proyecto.

Una vez que comenzamos con nuestro proyecto tenemos una estructura mas o menos así:
Código:
mysite/
    __init__.py
    manage.py
    settings.py
    urls.py
  • __init__.py: Un archivo que requiere Python para que la carpeta mysite pueda ser tratado como un paquete. Es un archivo vació y generalmente no vamos añadir nada en el.
  • manage.py: Es una utilidad de la linea de comando, con este archivo vamos a interacturar con el proyecto de varias maneras. Intenta con python manage.py help para darte una idea de lo que puedes hacer. Nunca, pero nunca debes de editar este archivo.
  • settings.py: Ajustes/configuraciones para el proyecto. Hechale un vistazo a los diferentes tipos de configuraciones disponibles y a sus valores por default.
  • urls.py: Las URLs del proyecto están en este archivo. Básicamente esto es una "table de contenidos" para tu proyecto. Por el momento esta vació.
A pesar de su tamaño, estos archivos constituyen una aplicación completamente funcional.

Última edición por razpeitia; 27/06/2011 a las 21:39
  #4 (permalink)  
Antiguo 06/06/2011, 09:03
Avatar de razpeitia
Moderador
 
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 12 años, 7 meses
Puntos: 1360
Respuesta: [Aporte] Django Tutorial [Introducción]

Corriendo el servidor de desarrollo
La mayoría del tiempo vamos a correr el servidor de desarrollo para ver como va quedando nuestro proyecto.

El servidor de desarrollo de Django (también llamado "runserver" en honor al comando que lo lanza) es un servidor web integrado y ligero que puedes usar para desarrollar tu sitio. Esta incluido en la instalación de Django entonces puedes desarrollar rápidamente tu sitio, sin estar teniendo que lidiar con la configuración de un servidor web de producción (ejemplo apache) hasta que este listo para la producción. El servidor de desarrollo vigila tu código y automáticamente lo recarga, haciendo fácil para tu cambiar el código sin la necesidad de reiniciar nada.

Para iniciar el servidor, muévete al tu directorio de proyecto (mysite) y ejecuta el siguiente comando:

Código:
python manage.py runserver
Despues deberías de ver algo como esto:
Código:
Validating models...
0 errors found

Django version 1.2.3, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
Esto lanza el servidor localmente en el puerto 8000, accesible solo para las conexiones de tu propia computadora. Ahora que esta corriendo, visita http://127.0.0.1:8000/ con tu navegador web favorito. Entonces vas a ver "Welcome to Django" en una pagina de tono azul.


También pueden cambiar el puerto por donde escucha el servidor web de la siguiente manera:
Código:
python manage.py runserver 8080
Inclusive pueden admitir otras conexiones que no sean de su computadora:
Código:
python manage.py runserver 0.0.0.0:8000
Obviamente este pequeño servidor solo es para hacer pruebas y no se debe de usar para producción ya no esta probado intensivamente como otros servidores web.
  #5 (permalink)  
Antiguo 15/06/2011, 19:11
Avatar de razpeitia
Moderador
 
Fecha de Ingreso: marzo-2005
Ubicación: Monterrey, México
Mensajes: 7.321
Antigüedad: 12 años, 7 meses
Puntos: 1360
Respuesta: [Aporte] Django Tutorial [Introducción]

Vistas y URLconfs


Tu primera pagina hecha con Django: Hola Mundo!
Una vez que ya tenemos instalado django podemos empezar a jugar. Como primera pagina vamos hacer el popular "Hola mundo!"

Vamos a ver un ejemplo sencillo de como hacer un hola sin un framework:
  1. Creas un archivo de texto plano que contenga "Hola mundo!"
  2. Guardas el archivo con el nombre hola.html
  3. Finalmente, lo subes a tu servidor web y listo.
En este proceso hemos identificado 2 piezas claves para el desarrollo de paginas. La primera es el contenido del archivo en este caso "Hola mundo" y la URL (http://www.example.com/hola.html o tal vez http://www.example.com/files/hola.html if lo pusiste en un subdirectorio).

Con Django, también debes de especificas estas 2 cosas, pero de una manera diferente. El contenido de un archivo es renderizado por una función llamada vista, y la URL es especificada por un URLconf. Primero vamos a escribir la función "hola".


Tu primera vista
En el directorio mysite que hiciste con el comando django-admin startproject, tienes un archivo llamado views.py. Este modulo de Python contendrá las vistas que haremos durante esta entrada. Nota que cuando abras este archivo por primera vez estará vació. Ademas a Django no le importa como se llame este archivo pero por convención lo mantendremos como views.py.

Nuesta vista "Hola mundo" es muy simple, aqui esta un ejemplo de como sería nuestra función:
Código:
from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hola mundo")
Vamos a leer el código linea por linea:
Primero, importamos la clase HttpResponse, la cual reside en el modulo django.http. Necesitamos importar esta clase por que la vamos a usar mas adelante en nuestro codigo.
Segundo, definimos una funcion llamada hello - la funcion vista.

Cada funcion vista recibe al menos 1 paramero, llamado request por convención. Este es un objeto que contiene información acerca de la peticion web que fue disparada por esta vista, ademas este objeto es una instancia de la clase django.http.HttpRequest. En este ejemplo no vamos a hacer nada con request, pero este siempre debe de ser el primer parametro en cualquier vista.

Nota que el nombre de la función no importa, no tiene que ser llamada de cierta manera para que Django la reconozca. La estamos llamando hello, por que el nombre claramente indica la esencia de la vista, pero también pudo ser llamada hola_hermoso_bello_mundo o algo igual de repulsivo.

La función es un simple "one-liner": Simplemente regresa un objeto de la clase HttpResponse que has inicializado con el texto "Hola mundo".

Aquí la principal lección es esta: Una vista es una función de Python que toma como primer parámetro un objeto HttpRequest y regresa una instancia de la clase HttpResponse. Para que una función pueda ser una vista Django, necesita hacer estas 2 cosas. (Claro que hay excepciones y vamos a ver estas excepciones después).

Si el lector es lo suficiente agudo pudo darse cuenta que este es básicamente el modelo cliente-servidor.

Tu primer URLconf
Hasta es te punto si corres python manage.py runserver otra vez, todavía vas a ver el mensaje "It worked", sin pista alguna de nuestro "Hola mundo". Y esto es por que nuestro proyecto mysite aun no sabe de la existencia de nuestra vista hello. Necesitamos decirle a Django que estamos activando esta vista en una URL especifica. (Continuando con la analogía de los archivos HTML estáticos, en este momento todavía no hemos subido nuestro archivo al servidor.) Para enlazar una vista a una URL en particular usando Django, usamos un URLconf.

Un URLconf es como una tabla de contenidos para tu sitio hecho con Django. Básicamente es una tabla de relaciones donde describe que función debe de ser llamada cada vez que visitan cierta URL. Por ejemplo cuando alguien visite foo llama a la vista foo_view(), que vive en el modulo views.py.

Cuando ejecutaste django-admin startproject, el script creo un URLconf por ti automáticamente: El archivo urls.py. Por defecto se ve mas o menos asi:

Código:
from django.conf.urls.defaults import *

# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()

urlpatterns = patterns('',
    # Example:
    # (r'^mysite/', include('mysite.foo.urls')),

    # Uncomment the admin/doc line below and add 'django.contrib.admindocs'
    # to INSTALLED_APPS to enable admin documentation:
    # (r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment the next line to enable the admin:
    # (r'^admin/', include(admin.site.urls)),
)
Este archivo urls.py por defecto incluye algunas características comentadas usadas por Django, para activar estas características es fácil solo tienes que descomentar las lineas necesarias y listo. Si ignoramos los comentarios entonces tenemos algo mas o menos así.

Código:
from django.conf.urls.defaults import *

urlpatterns = patterns('',
)
Vamos a analizar linea por linea el código.
La primera linea importa todos los objetos de el modulo django.conf.urls.defautls, la cual es la infraestructura de los URLconfs de Django. Esto también incluye una función llamada patterns.
La segunda linea llama a la función patterns y salva su resultado en una variable llamada urlpatterns. La funcion patterns se le pasa un solo argumento - una cadena vacía. (Esto se puede usar como prefijo pero lo veremos mas adelante)

El principal punto a notar aquí es la variable urlpatterns, el cual Django espera encontrar en nuestro modulo de URLconfs. Esta variable define las relaciones entre las URLs y las vistas que manejan estas URLs. Por defecto la URLconf esta vacía. Ademas si el URLconf esta vació Django asume que acabas de crear tu proyecto mostrando el mensaje "It worked!".

Ahora lo único que tienes que hacer es añadir una tupla para definir la relación entre una URL y una vista.
Ejemplo:
Código:
from django.conf.urls.defaults import *
from mysite.views import hello

urlpatterns = patterns('',
    ('^hello/$', hello),
)
Nosotros hemos quitado los comentarios para brevedad, pero si quieres puedes dejarlos.

Hicimos 2 cambios:
Primero, importamos la función hello de nuestro modulo mysite.views
Segundo, añadimos la linea ('^hello/$', hello), a urlpatterns. A esta linea la vamos a llamar URLpattern.

Ahora vamos a discutir un poco sobre la sintaxis de un URLpattern por que no es obvio a primera vista. A pesar de que queremos hacer coincidir la URL /hello/, el patrón se ve un poco diferente a eso. Vamos a ver porque:

Django quita los slash (/) del el frente de la URL antes de que la cheque con los URLpatterns. Esto significa que nuestro URLpattern no incluye los slash del frente entonces /hello/ quedaría hello/

Los patrones incluyen un circunflejo (^) y el signo de dollar (%). Esto son caracteres especiales de expresiones regulares que tienen un significado especial: El circunflejo (^) significa que "el patrón requiere coincidir desde el inicio de la cadena", por el otro lado el signo de dolar ($) significa que "requiere que el patrón coincida con el final de la cadena".

Este concepto se puede explicar mejor con un ejemplo. Si en vez del patrón '^hello/$' hubiéramos usado '^hello/' (Sin el signo de dolar al final). Entonces cualquier URL que empiece con /hello/ coincidiría, tal como /hello/foo y /hello/bar y no solamente /hello/. Igualmente si hubiéramos usado la expresión 'hello/$' sin el circunflejo al principio entonces coincidiría cualquier cadena que termine en hello/ como /foo/bar/hello/. Si no hubiéramos usado ni el signo de dolar ni el circunflejo solo 'hello/' entonces coincidiría cualquier cadena que contenga 'hello/' tal como /foo/hello/bar. Y es por eso que tan importante usar el circunflejo y el signo de dolar.

La mayoría de los URLpatterns empezaran con un circunflejo y terminaran con signo de dolar pero es importante saber que también podemos hacer patrones mas sofisticados.

Hasta este momento te estarás preguntando que pasaría si alguien hiciera una petición a la URL /hello. Porque nuestro URLpattern requiere un slash al final, esa URL no coincidiría. Sin embargo, por defecto cualquier petición que no coincida con URLpattern y no termine con un slash va ser redireccionado a la misma URL con un slash al final. (Esto es regulado por la variable APPEND_SLASH que puedes encontrar en tu archivo de configuración settings.py.)

Otra cosa que deberías notar acerca de los URLconfs es que hemos pasado la función hello como un objeto sin llamar a la función. Esto es una característica clave de Python (y de muchos otros lenguajes dinámicos): Las funciones son objetos de primera clase, lo que significa que puedes pasarlos como si fuera cualquier otra variable.

Para probar nuestros cambios en el URLconf, inicia el servidor de desarrollo de Django, como lo hiciste anteriormente corriendo el comando (python manage.py runserver). Si lo dejaste corriendo esta bien, no es necesario que lo reinicies, el servidor automáticamente detecta cambios en tu código y recarga lo necesario, entonces no necesitas reiniciar el servidor para ver cambios. El servidor esta corriendo en la dirección http://127.0.0.1:8000/, entonces abre tu navegador web favorito y entra a http://127.0.0.1:8000/hello/. Entonces debes de ver el texto "Hola mundo" - la salida de tu vista hello.
  #6 (permalink)  
Antiguo 17/04/2014, 17:28
Avatar de Italico76  
Fecha de Ingreso: abril-2007
Mensajes: 3.303
Antigüedad: 10 años, 6 meses
Puntos: 290
Respuesta: [Aporte] Django Tutorial [Introducción]

Ejemplo presentado arriba pero actualizado para Python 3 conectando a MYSQL, bajo Windows 7/8 de 64 bits

A muchos les resulta un dolor de cabeza encontrar que conector usar o como hacerlo funcionar, lean los comentarios en el codigo. En mi caso me llevo 30 minutos de investigacion (tuve suerte)

Código Python:
Ver original
  1. #!/usr/bin/env python
  2.  
  3. # Para instalar el conector de MySQL--Python3 para Windows 7/8 64 bits:
  4. # bajar "Visual Studio C++ 2008 Express Edition"
  5. # ejecutar "C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\Tools\vsvars64.bat"
  6. # mas en http://stackoverflow.com/questions/2817869/error-unable-to-find-vcvarsall-bat
  7. # pip install -U PyMySQL3
  8.  
  9. import pymysql
  10.  
  11. print("Content-Type: text/html\n")
  12. print("<html><head><title>Books</title></head>")
  13. print("<body>")
  14. print("<h1>Posts</h1>")
  15. print("<ul>")
  16.  
  17. connection = pymysql.connect(user='root', passwd='', db='encontron')
  18. cursor = connection.cursor()
  19. cursor.execute("SELECT * FROM posts ORDER BY titulo DESC LIMIT 10")
  20.  
  21. for row in cursor.fetchall():
  22.     print("<li>%s</li>" % row[0])
  23.  
  24. print("</ul>")
  25. print("</body></html>")
  26.  
  27. connection.close()

Notar que no uso 'MySQLdb' sino que respecto al ejemplo dado arriba uso PyMySQL3
__________________
Salu2!

Etiquetas: django, tutoriales
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta

SíEste tema le ha gustado a 24 personas




La zona horaria es GMT -6. Ahora son las 21:26.