• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
04 taller-django
 

04 taller-django

on

  • 204 views

 

Statistics

Views

Total Views
204
Views on SlideShare
204
Embed Views
0

Actions

Likes
0
Downloads
7
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    04 taller-django 04 taller-django Document Transcript

    • Taller Django Introducción El desarrollo web no es tarea fácil, en los tiempos que corren actualmente se están gestando cambios significativos en los paradigmas orientados a la web. Crear funcionalidades completas, que comprendan todas, el dinamismo que el usuario busca, creando librerías para automatizar parcialmente el trabajo, manejadores de bases de datos, interfaces gráficas sencillas para la administración, pero a la vez potentes, para brindar una solución completa. Esto sin entrar en el asunto de la seguridad, estabilidad y compatibilidad de las mismas. Una vez resuelto el asunto de las funcionalidades, comienza el arduo trabajo de actualización de estas “librerías mágicas”, con las que están basados todos nuestros desarrollos hasta el momento. Cuando hayamos terminado este paso, nos daremos cuenta que empleamos nuestro tiempo, creando y manteniendo funcionalidades, en vez de emplearlas en nuestros proyectos. Como solución completa a este problema, algunos programadores comenzaron a agrupar en paquetes funcionalidades orientadas a las labores básicas, que la mayoría de los desarrolladores de sistemas emplean en sus proyectos. De este modo surgieron los Frameworks, que permiten, pasar menos tiempo programando funcionalidades, para utilizarlo en los aspectos más fundamentales de los sistemas que estamos desarrollando.
    • Taller Django Django Framework Django es un framework de desarrollo web de código abierto, escrito en Python, que cumple en cierta medida el paradigma del Modelo Vista Controlador. Fue desarrollado en origen para gestionar varias páginas orientadas a noticias de la World Company de Lawrence, Kansas, y fue liberada al público bajo una licencia BSD en julio de 2005; el framework fue nombrado en alusión al guitarrista de jazz gitano Django Reinhardt. En junio del 2008 fue anunciado que la recién formada Django Software Foundation se haría cargo de Django en el futuro. La meta fundamental de Django es facilitar la creación de sitios web complejos. Django pone énfasis en el re-uso, la conectividad y extensibilidad de componentes, el desarrollo rápido y el principio No te repitas (DRY, del inglés Don't Repeat Yourself). Python es usado en todas las partes del framework, incluso en configuraciones, archivos, y en los modelos de datos. Preparando el entorno Antes de nada, cabe recordar, que Django está totalmente escrito en el Lenguaje de Programación Python, por lo que lo deberás tener instalado en tu sistema. Si usas GNU/Linux o Mac OS X, es más que seguro, de que tengas instalado una versión de python, de lo contrario puedes visitar http://www.python.org/ para descargar según la plataforma donde lo necesites usar. Un método simple de saber si tienes instalado python en tu computadora es abrir una consola y escribir “python” (sin comillas). Y deberías ver algo similar a esto: Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24) [GCC 4.5.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> Esto significa que tienes python, corriendo sin problemas en tu sistema. Descargar e Instalar Django Ahora que sabes que tienes python instalado, es momento oportuno para comenzar a trabajar con Django, y comenzar a embeber un par de procedimientos que realizarás cada vez que comiences un proyecto desde cero.
    • Taller Django Para obtener una copia de Django, en su última versión, visita http://www.djangoproject.com/ y sigue las instrucciones para descargar tu copia. (Hacer clic en descargar y guardar el archivo, así de simple) Cuando ya tengas tu archivo comprimido, debes descomprimirlo usando el descompresor que tengas en tu sistema. Bajo GNU/Linux y Mac OS X, escribe en una consola: tar xzvf Django-*.tar.gz Esto, generará una carpeta con el Nombre “Django-*versionActual*” (*versionActual* es la versión de Django que hayas descargado). Si utilizas otro sistema operativo, usa el descompresor que tengas instalado para realizar la operación anterior. Con estos archivos, tenemos lo necesario para instalar Django en nuestro sistema, para ello navega, hasta la carpeta generada en la extracción del archivo .tar.gz, abre una consola en ese lugar (o bien navega desde una que hayas abierto) y escribe: sudo python setup.py install Su estas en otras plataformas, puedes abrir una terminal de sistema, con privilegios administrativos, y escribir: python setup.py install Setup.py creará los directorios necesarios, como así también todos los enlaces y librerías que necesites para comenzar a crear y modelar tus proyectos con Django. Primeros Pasos con Django Una vez finalizada la instalación, estamos listos para verificar, si todo esta en orden y preparado para comenzar a desarrollar, para ello, verificar la versión instalada de Django es un buen comienzo. Abre una consola python y escribe lo siguiente. >>> import django >>> print django.VERSION
    • Taller Django Corriendo estos comandos, obtendrás una serie de números, que representan la versión exacta de Django que tienes corriendo. Por ejemplo, Django 1.4 estable imprimiría en pantalla algo como (1, 4, 0, 'final', 0), lo que significa, que estas corriendo la versión 1.4, que fue liberada como estable. Nota: Este material, está pensado para entornos de desarrollo bajo GNU/Linux, la mayoría de las instrucciones explícitas y comandos estarán orientadas al mismo, exceptuando instrucciones de Django, que son estándares para todas las plataformas que este soporte.
    • Taller Django Primer proyecto Django El momento esperado, ¡comenzar a desarrollar! . Antes de cualquier cosa que queramos iniciar con Django, primero debemos crearlo (se supone, que el desarrollador tiene almenos una idea dispersa del proyecto y sus elementos), para que el framework genere los elementos básicos que necesitamos para empezar a construir nuestro sistema. Para ello, nos situamos en un directorio, que utilicemos para nuestro desarrollo, (se aconseja crear un directorio vacío, que únicamente albergue elementos relacionados con este propósito), y escribimos en una terminal (ubicada en el antes mencionado directorio) el comando. django-admin.py startproject miProyecto Django-admin.py recibe como parámetro la sentencia “startproject” para crear una carpeta llamada “miProyecto”, y en su interior 4 archivos, en su interior y un subdirectorio llamado de igual forma que nuestra aplicación, en este caso “miProyecto”. Expliquemos un poco, la filosofía o el modo de trabajo de Django, es un poco diferente que el de otros sistemas que quizás hemos utilizado. Django “mira” a los proyectos como el nombre lo dice “projects” que se refiere a todo nuestro desarrollo, es decir, el proyecto es nuestro sistema. En cambio, cada funcionalidad o requerimiento de manejo de datos, se denomina “aplicación” o “app”, que están incluidos en nuestro proyecto. Debido a este enfoque, nuestra aplicación inicial, del proyecto “miProyecto”, albergada en el subdirectorio “miProyecto”, con el mismo nombre, aparece como parte del mismo. Cerrando el asunto, y volviendo al grano, un proyecto de Django, se compone de una serie de archivos, que utilizaremos a lo largo de nuestro desarrollo. __init__.py: Es un archivo vacío. Por ahora, no necesitas poner nada allí, éste es usado, para señalar a python que el directorio, es un módulo completo. manage.py: Es el manejador, del proyecto, contiene los manipuladores y referencias de todas las aplicaciones que tendrá nuestro sistema, además es el punto de arranque para iniciar el servidor que hace referencia a nuestro proyecto. settings.py: Este es el módulo de configuraciones de Django, que contiene toda la configuración de nuestro proyecto.
    • Taller Django urls.py: En este archivo, se encuentra el manejador principal de rutas del proyecto, Django maneja las urls, como por ejemplo “www.misitio.com/articulos”, como si fueran rutas referenciadas a las aplicaciones que configuremos, usando un método similar al de subdirectorios en un servidor como “Apache”. Nota: en las nuevas versiones de Django, el subdirectorio de cada aplicación contiene los archivos antes mencionados, exceptuando manage.py, dado que una aplicación, no debería manejar todo un proyecto, y agregando en su lugar wsgi.py, que permite enlazar el servidor Django de nuestro proyecto como elemento CGI a, por ejemplo Apache.
    • Taller Django Un simple CMS Uno de los desarrollos más populares, es crear un Sistema de Manejo de Contenidos (CMS), que le permite al usuario crear y administrar páginas basándose en una interfaz administrativa. Para ello, crea un proyecto llamado “cms”, al igual que creamos nuestro ejemplo “miProyecto”, en el inciso anterior. Sitúate en el directorio del directorio “cms” del proyecto, y abre con tu editor preferido, el archivo settings.py . • Bases de datos Una vez abierto, verás, cuan largo es, pero no te compliques todavía en pensar que es todo eso, simplemente vamos a modificar un par de líneas para enlazarlo a nuestro motor de base de datos. Comienza a moverte en el archivo, y busca la línea “DATABASE_ENGINE”, encontrarás algo similar a esto. DATABASES = { 'default': { 'ENGINE': 'django.db.backends.', 'NAME': '', 'USER': '', 'PASSWORD': '', 'HOST': '', 'PORT': '', } } ENGINE: El motor de bases de datos, que emplearemos en el proyecto. Agrega, “mysql”, “postgresql_psycopg2”, “postgresql”, “sqlite3” u “oracle”, según corresponda. NAME: El nombre de la base de datos, o la ruta del archivo, si usas Sqlite USER: Usuario de la base de datos, (no es necesario en Sqlite) PASSWORD: Clave del usuario, (no es necesario en Sqlite) HOST: La ip, o la dirección, del servidor de bases de datos.
    • Taller Django PORT: El puerto del servidor, donde corre el motor de bases de datos. Ahora, tenemos configurado nuestro acceso al motor de bases de datos, que emplearemos para el proyecto. • Templates Seguiremos en el archivo, configurando el directorio de “Templates”, que utilizaremos, para especificar el lugar donde se encuentran las plantillas que se renderizarán en los retornos de vista. Busca la línea del archivo de configuración, en la que aparezca algo así. TEMPLATE_DIRS = ( 'primerBlog/templates', #Agrega esto, como elemento de la tupla ) Y agrega la línea 'primerBlog/templates', como elemento de la tupla. Seguido a esto, crea una carpeta, llamada “templates” dentro de la carpeta de la aplicación del proyecto. En este caso dentro de /mipath/primerBlog/primerBlog. • Aplicaciones Instaladas Una vez configuradas las opciones de bases de datos y templates, solo nos falta un paso más, el inciso de “aplicaciones instaladas”, que contiene las aplicaciones que django, enlaza para utilizarlas como disponibles. Para ello navegamos hasta la línea que contenga algo similar a esto. INSTALLED_APPS = ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.messages', 'django.contrib.staticfiles', 'primerBlog', # Agregamos esta línea para habilitar a nuestra aplicación 'django.contrib.admin', # Agregamos esta línea para habilitar el administrador )
    • Taller Django • Modelos Una forma de desarrollo organizado, debe implementar técnicas genéricas que permitan la flexibilidad de expresar los datos, que nuestro proyecto necesita para funcionar. Por ejemplo en un blog, los artículos se componen de elementos individualizados que agrupados forman un artículo completo, el título, bajada, contenido y fecha. En Django, estos elementos se ven reflejados en las bases de datos, con lo que los modelos deben ser de intermediarios entre las bases de datos y nuestro esquema de abstracción. En Django, los modelos se encuentran en el archivo “models.py”, (de no existir, crearlo), con el siguiente código en su interior. from django.db import models class articulo(models.Model): titulo = models.CharField(max_length = 100) fecha = models.DateTimeField(auto_now_add=True) bajada = models.TextField() cuerpo = models.TextField() El objeto models, contiene todos los tipos de datos soportados, o serializados para ser soportados por la mayoría de las bases de datos. Por “ejemplomodels.CharField()” contiene las instrucciones para generar campos VarChar de longitud definida por “max_length”. Un modelo instanciado, es un objeto capaz de editar, eliminar y generar nuevos registros en las bases de datos. • Admin Un problema esencial en el desarrollo de sistemas, son los las interfaces que permiten al usuario, tener el control de su sistema. El framework nos ofrece una plataforma flexible, seguro y potente que es autogenerado en base a un archivo de configuración, que por supuesto está escrito en python. Situados en el directorio de la aplicación, el archivo “admin.py”, contiene toda la información necesaria para que Django pueda generar los elementos necesarios, vistas, y esquemas de administración. El script admin.py debe contener. from django.contrib import admin # Importa el módulo de admin from primerBlog.models import articulo # Importa el modelo de datos admin.site.register(articulo) # Enlazamos el modelo al # administrador
    • Taller Django • Views Desde un principio mencionamos, y en varias ocasiones interfaces gráficas, vistas, hasta configuramos un directorio “templates” en nuestro archivo de configuración para almacenar las plantillas que se usarán para renderizar las respuestas, al llegar a este punto, algunos suelen pensar ¿que otra cosa hará una vista?, en teoría sí, una vista, como el nombre hace referencia, debería devolver al cliente una “vista” del proceso realizado. Pero en Django, las vistas toman un nuevo rumbo, una vista es una interfaz intermedia, que relaciona datos recibidos, con los modelos de datos, y genera una respuesta apropiada al cliente. Probablemente estés pensando “no es tan complicado, es solo HTML”, ¡pero no es así!, porque las vistas pueden generar vistas HTML, inclusiones CSS organizadas, hasta respuestas AJAX, inclusiones JQuery controladas, y hasta usarse como servidor de funciones JavaScript. Bien, con esta breve pero descriptiva introducción a las vistas, comencemos a generar la nuestra, las vistas, es decir cada interacción, se guarda dentro del archivo “views.py”. La estructura básica de una vista es la siguiente. from django.shortcuts import render_to_response # Renderizador de respuesta from primerBlog.models import articulo # Modelo, para acceder a la # base de datos def home(request): pass Para organizar un poco las cosas, definamos algunos elementos que aparecen en este script. El objeto “render_to_response”, es el encargado de generar una respuesta para el cliente, este es el objeto que puede configurarse para responder desde un documento HTML, hasta una cadena JSON. En este caso “articulo”, es el objeto del modelo, que permite la consulta con las bases de datos, pero puede ser una librería de manejo de sockets, una función que lea un archivo, o simplemente cualquier objeto que genere una respuesta “String”, si es que se desea responder al cliente, caso contrario, puede ser cualquier objeto que ejecute una función, el único detalle, es que ese objeto no podrá referirse como elemento de respuesta a la plantilla. La función “home()”, hereda del objeto “request”, que contiene las funciones necesarias para manejar consultas desde el servidor. Cada función que definamos, es considerada como una vista individual, y accesible desde los patrones ubicados en “urls.py”. Tener en cuenta que cada función debe heredar al objeto “request”.
    • Taller Django Ahora que tenemos claro como se compone una vista, expliquemos un poco, como funciona la asignación dinámica en las plantillas. La función “render_to_response”, puede recibir de modo opcional un diccionario, con las referencias de las claves, donde son reemplazadas por su valor explícito. Así que generemos una para nuestro ejemplo. def home(request): entradas = articulo.objects.all()[:10] data = {"articulos" : entradas} return (render_to_response("home.html", data)) Expliquemos un poco esto, “articulo.objects.all()[:10]”, invoca al modelo de datos, y obtiene todos los registros de la base de datos, en la tabla “articulo”. Recuerda que el modelo es el “capacitado” para manejar la base de datos, en un inciso posterior se expondrá mejor el funcionamiento de “models”. Bien, esta consulta la almacenamos en la variable “entrada”, que se compone como valor de la clave “articulos” del diccionario almacenado en “data”, queda más que razonable mencionar que pueden agregarse más claves y valores a este diccionario y pasarlos al renderizador. Y como ultima línea “render_to_response” como retorno de esta vista, aquí nos detenemos un momento. Si recuerdas bien, en el inciso de “setting.py”, creamos un directorio llamado “templates”, que luego enlazamos al archivo de configuración bajo el parámetro “TEMPLATE_DIRS”, bueno allí mismo crearemos un archivo llamado, lógicamente “home.html” con el siguiente código dentro de la estructura básica de un archivo html (DOCType, etiquetas html, etc), dentro de las etiquetas “body”. <body> <h3>Blog</h3> <hr /> {% for post in articulos %} <h2>{{ post.titulo }}</h2> <h3> Posteado el {{ post.fecha }}</h3> <p> {{ post.bajada }}</p> <p> {{ post.cuerpo }}</p> <hr /> {% endfor %} </body> Ahora bien, pongamos atención total al sistema de plantillas que ofrece Django. Si recuerdas bien, a la función “render_to_response”, pasamos como parámetro un diccionario que contenía la clave “articulos”, bien, esa misma clave es referenciada para obtener su valor asociado, y como ese valor asociado es un objeto, podemos iterar sobre él. Cada vez que necesitemos mostrar una variable en una plantilla, lo único que
    • Taller Django tenemos que hacer es encerrarla en llaves dobles “{{ mivariable }}”, y estas pueden estar iteradas por una función. Y vamos otra vez pero con funciones, cada vez que necesitemos hacer una función iterable lo único que necesitamos hacer es encerrarla dentro de llaves seguidas del carácter porcentual “{% funcionIterable %}”, podemos incluir bucles “for” y validaciones “if” por ejemplo, y terminamos la iteración de dicha función con una llave seguida del carácter porcentual y la palabra “end” seguida del nombre de la función “{% endfuncionIterable %}”. Ahora bien, aparece la pregunta clásica, ¿que hace post.titulo?, y obtiene una respuesta muy fácil, “post.titulo”, hace referencia al objeto “models” asociado en el diccionario, donde “titulo”, “fecha”, “bajada” y “cuerpo”, son los atributos del objeto, es decir los campos de la base de datos. • Manage.py Una vez llegado a este punto, tenemos nuestro CMS configurado, y listo para funcionar, pero antes unos comandos esenciales. Sincronizar los modelos con las bases de datos y correr el servidor, para ello. python manage.py syncdb Con este comando sincronizamos todos los modelos a las bases de datos, y Django, crea por nosotros los necesarios para generar el Administrador, para ello, nos solicitará usuarios y claves durante este proceso. python manage.py runserver Con este comando arrancamos el servidor y podemos empezar a utilizar nuestro proyecto sin problemas, opcionalmente, runserver toma como parámetro extra ip y puerto para resolver por red, o acceso externo. Para implementarlo se ejecuta de la siguiente forma. python manage.py runserver 192.168.0.102:8000 • Models Extra Como anexo, al manejo de modelos proponemos como ejemplo, el uso de creación, obtención y eliminación de registros. Tomamos como ejemplo el modelo articulo, que utilizamos en el desarrollo del cms.
    • Taller Django Crear un nuevo registro. b2 = articulo(titulo='Titulo de articulo', fecha=None, bajada='Mi bajada de articulo', cuerpo='Cuerpo de articulo') b2.save() Primero, generamos un objeto artículo, asignando a cada campo un contenido, y lo almacenamos en b2, ahora es este último el que contiene un nuevo elemento de registro. Por último guardamos los datos llamando al método “save”. Obtener un registro b2 = articulo.objects.all() # Obtenemos todos los elementos b2 = articulo.objects.get(titulo='MiTitulo') # Obtenemos un objeto en base a un # criterio Filtros Específicos b2 = articulo.objects.filter(titulo__startswith= “MiTitulo”) # Titulo inicia con “MiTitulo”, por ejemplo si tenemos “MiTitulo1”, “MiTitulo2”, # etc en nuestra base de datos b2 = articulo.exclude(titulo__icontains= “Excluir”) # Excluir si el titulo contine “Excluir” b2 = articulo.objects.filter(titulo=“mitutulo”) # Filtro cuando titulo es igual a “mititulo” b2 = articulo.objects.order_by(“titulo”)[0] # Primer artículo, ordenado por “titulo” b2 = articulo.objects.get(titulo__iexact= “MiTituloExacto”) # El título contiene exactamente “MiTituloExacto” b2 = articulo.objects.get(cuerpo__contains= “Python”) # El cuerpo contiene la cadena “Python” Los filtros pueden tomar como parámetros más de una limitante, es decir “articulo.objects.filter(titulo=“mititulo”, bajada= “bajada1”)” y enlazar una salida a otra, es decir “articulo.objects.filter(titulo=“mititulo”).filter(bajada= “bajada1”)”.
    • Taller Django Eliminar un registro b2 = articulo.get(titulo= “mitituloEliminar”) b2.delete() Obtenemos un objeto con una condición, lo eliminamos con “delete()”. Actualizar un registro # Método 1 b2 = articulo.get(titulo = “miTutulu”) b2.update(titulo= “miTitulo”) # Método 2 b2 = articulo.get(titulo = “miTutulu”) b2.titulo = “miTitulo” b2.save() Obtenemos un objeto filtrado, y podemos optar si cambiamos explícitamente o implícitamente, dependiendo de los métodos que empleemos, y guardamos las modificaciones.