El documento describe los pasos para configurar Django para interactuar con una base de datos PostgreSQL. Estos incluyen instalar PostgreSQL, crear una base de datos vacía, instalar el controlador psycopg2, configurar Django para usar la base de datos, crear modelos, sincronizar Django con la base de datos, y probar las operaciones CRUD a través de la interfaz de administración de Django.

1. Manual de usuario
Creación del Proyecto
Para proceder a interactuar con la base de datos primero debemos crear un proyecto en este caso
se llamara exposición, lo crearemos con el siguiente comando:
Al digitar este comando en la consola, se creará una carpeta llamada del mismo modo del
proyecto creado, en nuestro caso exposición, nos movemos dentro de esta carpeta y veamos lo
que contiene dentro, estos archivos se generan por defecto al crear el proyecto:
Una vez dentro de la carpeta de nuestro proyecto, pondremos en marcha nuestro servidor de
pruebas que viene por defecto con django, esto lo haremos con el siguiente comando:

2. Al colocar esta línea en la consola, ejecutara el servidor y habilitara el puerto (8000 por defecto)
para realizar las pruebas con django . Si queremos que funcione con un puerto distinto del puerto
por defecto indicamos el puerto que queremos utilizar. Para el puerto 8888 seria de la siguiente
forma:
Por el momento lo dejaremos funcionando sobre el puerto predeterminado 8000. Ahora
probaremos el correcto funcionamiento de nuestro servidor para lo cual en nuestro explorador
pondremos lo la dirección 127.0.0.1:8000
Creación de la Aplicación
Para crear una aplicación abrimos una nueva ventana de consola, nos ubicamos dentro de la
carpeta de nuestro proyecto y digitamos lo siguiente:
Donde crud es el nombre de la aplicación que hemos creado. Luego de creado vemos que se ha
creado un nuevo directorio con el nombre de nuestra aplicación, observamos lo que contiene:

3. Este es el esquema de archivos básico de un sitio web con aplicaciones, en django.
Instalación de PostgreSQL
Para el presente documento, como base de datos utilizaremos PostgreSQL, elegimos esta base de
datos por ser Open Source y una de las más seguras y robustas que existen.
Para descargar PostgreSQL lo podemos hacer desde su página oficial:
http://www.postgresql.org/
Si usamos Sistema Operativo Windows, el enlace directo para la descarga es:
http://www.enterprisedb.com/products-services-training/pgdownload#windows
En nuestro caso descargaremos la última versión disponible (1/11/2013), PostgreSQL 9.3.1. donde
también se descargara el interfaz pgAdmin III.
Una vez descargado ejecutamos el archivo precompilado de PostgeSQL y nos aparecerá un
asistente que nos ayudará a instalar PostgreSQL 9.3.1 en nuestro ordenador. Al aparecer la
primera pantalla damos click en Siguiente:

4. Ahora nos aparecerá una pantalla donde nos pedirá la ruta donde queremos que se instale
PostgreSQL 9.3.1, la dejaremos por defecto y damos click en Siguiente:

5. Luego nos aparecerá una pantalla que nos pedirá donde deseamos que se guarden nuestros datos
al momento de crear nuestras bases de datos, la ruta la dejaremos como se encuentra por
defecto:
Una vez damos Siguiente, nos aparecerá una pantalla que nos pedirá la contraseña que queremos
usar con nuestro superusuario postgres para conectarnos con nuestra base de datos, tener mucho
cuidado de no olvidarse esta contraseña, digitamos la contraseña las veces que nos pidan y damos
click en Siguiente:

6. Ahora nos aparecerá una pantalla que nos indicará el puerto que utilizara PostgreSQL para hacer la
conexión, por defecto es el puerto 5432. Es recomendable que dejemos el puerto por defecto y
damos click en Siguiente:
En la siguiente pantalla nos mostrará la configuración regional de nuestra base de datos que
vamos a instalar. La dejamos como está y damos click en Siquiente:

7. En esta interfaz nos dirá que si estamos listos para instalar, damos click en Instalar y empezará la
instalación de PostgreSQL en nuestro computador:
Esperamos un unos minutos hasta que se termine de instalar:

8. Una vez finalizada la instalación nos aparecerá una pantalla que nos pregunta si queremos iniciar
Stack Buider que es una herramienta para descargar otros componentes de PostgreSQL,
deshabilitamos esa casilla y damos click en Terminar y salir del asistente.
Instalando Psycopg2
Antes de usar la base de datos PostgresSQL con Django, debemos tener el controlador que nos
permitirá la conexión con esta base de datos, para trabajar con Django podemos hacer uso del
controlador psycopg2, la descarga de este controlador depende de la versión de Python que
tengamos instalada, para trabajar con Python 2.7 necesitaremos psycopg2 2.5.1. Este controlador
lo podemos descargar de los siguientes enlaces:
Para Windows:
http://stickpeople.com/projects/python/win-psycopg/
Para Unix:
http://initd.org/psycopg/articles/2013/06/23/psycopg-251-released/
Una vez descargado, ejecutamos el instalador de psycopg2. Se nos abrirá un asistente con un
mensaje de bienvenida, damos click en Siguiente:

9. En esta pantalla vemos que nos solicita que tengamos instalado Python 2.7, solo damos click en
Siguiente.
Al presionar Siguiente empezará la instalación del controlador.

10. Una vez finalizada la instalación, damos click en Terminar para salir del asistente.
Creación de la Base de Datos en PgAdmin III
Una vez ya tengamos instalada la Base de datos y su respectivo controlador para comunicarnos
con Django, procederemos a crear una base de datos vacía de PostgreSQL, para ellos abrimos su
herramienta de administración PgAdmin III.

11. Ya abierto pgAdmin III procederemos a concentrarnos al servidor, damos click derecho en el
servidor PostgreSQL 9.3 (localhost:5432) y damos click en Conectar.
Luego se nos abrirá una ventana que nos pedirá ingresar la contraseña que ingresamos en la
instalación para conectarnos con el servidor. La ingresamos y damos click en el botón Ok.

12. Ya conectados crearemos una nueva base de datos, para lo cual hacemos click derecho en
Databases y presionamos New Database.
Al presionarlo se nos abrirá una ventana donde pondremos el nombre de nuestra base de datos,
en nuestro caso será recetario. Presionamos Ok para crear nuestra base de datos.

13. Como vemos se nos ha creado satisfactoriamente nuestra base de datos. Para trabajar con Django
solo necesitamos crear la base de datos vacía ya que estas se crean automáticamente al
sincronizar Django con PostgreSQL, eso lo veremos en pasos siguientes.
Instalando Bootstrap
Para realizar este trabajo de interactuar Django con la Base de Datos, utilizaremos la API
gráfica de Twitter la cual es muy conocida, Bootstrap, la podremos descargar desde su
sitio oficial:
www.getbootstrap.com/2.3.2/

14. Damos click en el botón “Download Bootstrap” y empezara la descarga de
Bootstrap. Una vez descargado descomprimimos él .zip.
Para instalar Bootstrap solo debemos crear un directorio de nombre static dentro de la
carpeta de nuestro proyecto.
Lo siguiente será copiar los archivos del directorio de Bootstrap dentro de la carpeta
Static.

15. Con esto estaremos listos para usar Bootstrap con Django, solo quedaría configurar
Django para que reconozca esta ruta, eso lo haremos más adelante.
Configurando Django: Setups.py
Para configurar Django y que este pueda usar la base de datos en PostgreSQL que acabamos de
crear, procederemos a editar el archivo setups.py la cual se encuentra en la carpeta que tiene el
nombre del proyecto.

16. Podemos editarlo con cualquier editor de texto, en mi caso lo haré con Sublime Text 3. Lo primero
que haremos es permitir que Django reconozca los caracteres y letras especiales del idioma, como
las eñes y tildes, para eso pondremos lo siguiente:
Luego procedemos a configurar la ruta del proyecto para hacerla dinámica, esto permitirá que
pueda interpretar la estructura de los sistemas archivos tantos Windows como los basados en Unix
(MAC y Linux), y ejecutar nuestro proyecto independientemente de l a ruta que se encuentre.
Primero importamos el paquete que nos permitirá reconocer el Sistema Operativo en que se está
ejecutando el servidor de Django, luego asignamos a una variable RUTA_PROYECTO, la ruta
absoluta donde se encuentra nuestro proyecto, lo haremos de esta manera:

17. Ahora vamos a configurar los administradores de Django. Para esto en la parte donde dice
ADMINS incluimos una tupla con el nombre del administrador y su correo electrónico para que le
envíe los reportes de errores de la página.
Luego configuraremos la sección DATABASES, la editamos con los datos de la base de datos que
vamos a utilizar, en nuestro caso la dejaremos de la siguiente manera: En ENGINE pondremos el
driver que utilizaremos en este caso postgresql_psycopg2; en NAME pondremos el nombre de la
base de datos que creamos, en este caso “recetario”; en USER ponemos el superusuario por
defecto que es postgres; en PASSWORD pondremos en password de la base de datos, en nuestro
caso “root”; y los demás parámetros como HOST y PORT los dejamos por defecto ya que estamos
desarrollando localmente. Así nos quedará configurada esta sección:
Luego de esto configuraremos la Zona Horaria de Django, para esto buscaremos la indicada para
nuestro país en este enlace:

18. http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
Para lo cual, esta sección nos quedará asi:
De la misma forma configuraremos el idioma, la página para saber el formato que debemos poner
por país es el siguiente:
http://www.i18nguy.com/unicode/language-identifiers.html
Entonces la configuración de esta sección nos quedará de la siguiente forma:
Lo siguiente será, hacer que Django reconozca la ruta de nuestros archivos estáticos, en este caso
Bootstrap ya que son herramientas de diseño de nuestra interfaz, lo haremos modificando
STATIC_URL y STATICFILES_DIRS.

19. Como vemos STATIC_URL ya tenía por defecto la ruta de nuestra carpeta static así que la
dejaremos como está. En STATICFILES_DIRS utilizaremos una función de os.path llamada join la
cual nos combina la ruta del proyecto junto con la URL de nuestra carpeta static para hacer una
sola cadena de texto.
Ahora haremos lo mismo para las platillas de nuestras páginas webs, crearemos una carpeta
llamada plantillas donde iremos creando nuestras páginas html.
Una vez creado el directorio de nuestras plantillas vamos al archivo settings.py y en el lugar donde
dice TEMPLATE_DIRS colocaremos lo mismo que pusimos con static pero esta vez usando
plantillas, entonces quedará de esta forma:
Una vez esto hecho, en la sección de INSTALLED_APPS añadiremos la aplicación que creamos, esta
sección corresponde a las aplicaciones que están instaladas en nuestro proyecto de django, nos
quedará de la siguiente manera:

20. Gracias a esta configuración inicial, por el momento tenemos todo lo necesario para empezar a
trabajar en nuestra aplicación CRUD con Django y PostgreSQL.
Creación de Base de Datos
Una vez configurado Django debemos sincronizarlo con nuestra Base de Datos, para lo cual
abrimos una ventana de consola y digitamos el comando syncdb. Esto creará las tablas de la base
de datos y se definirá un superusuario administrador.
Como vemos la sintaxis es primero ubicarnos en nuestra carpeta de proyecto, luego usar e l
comando python que ejecutara manage.py y por último el syncdb que sincronizara nuestra
aplicación con la base de datos. Una vez ejecutado el comando Django nos preguntara datos para
crear nuestro superusuario.

21. Así estará lista nuestra base de datos por el momento, luego crearemos las tablas que
necesitaremos para la base de datos recetario.
Creación de Modelos
Para crear nuestros modelos, editaremos el archivo models.py que se encuentra en la carpeta de
nuestra aplicación. Usando nuestro editor de texto favorito dejaremos el archivo modelos.py de la
siguiente manera:
Como vemos hemos incluido un campo para la foto del Autor, las imágenes no se guardan
directamente en la base de datos sino que se guarda la URL de esta, para que reconozca este tipo
de campos de imagen necesitamos descargar la librería PIL. Para descargarla vamos a esta
dirección:
http://www.pythonware.com/products/pil/
Una vez descargado ejecutamos el instalador, damos click en siguiente en la primera ventana:

22. En la siguiente pantalla se especificara la ruta donde instalaremos esta librería, la dejaremos por
defecto y damos Siguiente:
Ahora nos pedirá que presionemos Instalar, damos click en Instalar. Una vez instalado damos click
en Terminar para salir del asistente.
Luego modificaremos el archivo Setups.py para la ruta MEDIA_ROOT.

23. Creamos el directorio donde se guardarán las imágenes subidas desde Django.
Ahora procederemos a sincronizar Django con la base de datos, si queremos ver antes las
sentencias sql necesarias para crear nuestras tablas en PostgreSQL utilizaremos en comando sqlall.

24. Una vez que hemos visto cómo quedará nuestras sentencias sql autogeneradas por Django
sincronizamos con la base de datos PostgreSQL. Si en este punto no hemos sincronizado antes
Django con nuestra base de datos nos creara todas las tablas y nos pedirá un superusuario con su
password. Caso contrario solo creará las tablas que faltan.
Veremos en nuestra base de datos, creadas todas las tablas de nuestros modelos y las necesarias
para autenticación.

25. Configuración de las URL
Este archivo nos permitirá controlar el flujo de la aplicación a través de las rutas que pueda usar el
usuario. Se encuentra ubicación en la carpeta que lleva el nombre del proyecto. Procederemos a
abrirlo con cualquier editor de texto para editarlo. Lo dejaremos de la siguiente manera:
Configuración del Archivo Admin.py
El archivo admin.py no existe, este nos servirá para colocar nuestra aplicación en el menú de
administración y darle las propiedades de registro, debemos crearlo manualmente, lo crearemos
en la carpeta de nuestra aplicación y le pondremos lo siguiente:
Prueba del CRUD con Interfaz de Django
Para hacer la prueba con el interfaz administrativa de Django primero reiniciar nuestro servidor de
pruebas:

26. Luego debemos con ir con nuestro navegador a la dirección http://localhost:8000/admin, donde
llenamos los datos de Usuario y contraseña:
Una vez ingresamos, Django nos mostrará un interfaz con todo lo que podemos hacer. Vemos un
hipervínculo con el nombre de nuestra aplicación y Modelo, accedemos a ella con un click.
En primera instancia nos muestra todos los datos de nuestra base de datos para esa tabla. Como
no tenemos datos nos muestra vacío.

27. Ingresar registros desde Django
Para ingresar datos damos click en Añadir autor y nos aparecerá un formulario para ingresar:
En el formulario llenamos todos los datos que nos pide y damos click en grabar.
Tenemos la posibilidad de Guardar y añadir otro y de Guardar y continuar añadiendo. Solo
guardaremos y se nos cargara el formulario principal con los datos actuales de la base de datos
para esa tabla.
Modificar registros desde Django
Si damos click en el registro, podremos modificar sus datos. Una vez hayamos presionado en el
registro se nos abrirá un nuevo formulario que nos permitirá modificar dicho registro.

28. Para este ejemplo modificaremos el nombre y la foto y luego le daremos a Grabar:
Una vez grabemos nos redirigirá a la página de inicio la cual se cargara con nuestro registro
modificado con un mensaje que nos indica el éxito de esta operación.
Eliminar registros desde Django
Para eliminar registro debemos dar click en el registro a eliminar, esto nos llevará a la interfaz de
edición del registro.

29. Una vez en la interfaz de edición del registro presionamos en Eliminar y este se borrará de nue stra
base de datos.
Una vez hecho click en Eliminar, nos aparecerá un mensaje de confirmación sobre si queremos o
no borrar dicho registros. Damos click en Si, estoy seguro para eliminar el registro.
Luego de confirmar, nos redirigirá a la interfaz de inicio de la aplicación y nos aparecerá un
mensaje que nos indica que el registro ha sido borrado correctamente.

30. Con esto terminamos el crud con la interfaz administrativa en django. Ahora veremos cómo sería
utilizando estilos personalizados, en este caso usaremos Bootstrap.
Realización del Crud con Bootstrap
Creación de la aplicación:
Creamos una nueva aplicación para este propósito:
Luego modificamos en archivo setup.py para incluir nuestra aplicación en el proyecto.

31. Creación de Forms.py
Este archivo nos permitirá crear dinámicamente los formularios desde los modelos que ya
tenemos definidos. Para esto crearemos un archivo forms.py en el directorio de la aplicación. Este
archivo contendrá lo siguiente:
La parte marcada de la clase nos permite que el formulario se cargue con los componentes de
nuestro modelo Editorial.
Creación y Visualización de registros desde Django Usando Bootstrap
Como trabajaremos con la misma base de datos modificaremos el archivo models.py con los datos
que pusimos en el anterior archivos de models.py.

32. Luego sincronizaremos esta aplicación de Django con la base de datos, para crear las tablas:
En ese caso seguiremos a crear las vistas editando el archivo views.py de nuestra carpeta de
aplicación.Al inicio este archivo lucirá así:
En este archivo cada función corresponde a una acción que solicitaremos de los registros de
nuestra base de datos. Para hacer el Select dejaremos este archivo de la siguiente manera:
Lo que hace es primero en una variable tomamos todos los objetos del modelo Editorial. Luego
devolvemos la página index.html llena de los datos recogidos en la variable.
Ahora vamos a modificar el archivo urls.py para establecer la ruta de la plantilla.

33. Haremos las plantillas necesarias para poder mostrar estos datos, haremos un archivo base .html
de donde van a heredar los demás, esto lo crearemos dentro de nuestra carpeta plantillas que se
encuentra en el proyecto:

34. Lo que podemos destacar aquí son los link, código embebido de django y scripts. Los links nos dice
que estamos utilizando esos archivos de bootstrap para cargar el diseño de la página. El código
exclusivo de Django se reconoce por bloques {% block %} {% endblock %} esto nos sirve para poder
agregar contenido dinámico desde otras plantillas o vistas. Finalmente los scrips que nos
permitirán darle la funcionalidad de bootstrap a sus controles.
Ahora crearemos la plantilla propia para nuestra vista index, para eso creamos el archivo
index.html.
Para probarlo vamos a acceder desde nuestro explorador a la ruta http://localhost:8000

35. Ingreso de registros desde Django usando Bootstrap
Lo primero que debemos hacer es crear la vista respectiva para el ingreso, el archivo views.py nos
quedará de la siguiente manera:
Para que está vista funcione debemos crear la plantilla agregar_editorial.html la cual será la
interfaz con el usuario. Pero esta interfaz como tendrá elementos similares con la de editar
crearemos un archivo base_add_edit.html el cual contendrá elementos en común entre ambos
formulario y aprovechar esta funcionalidad de Django en el sistema de plantillas.
El archivo agregar_editorial.html quedaría asi:

36. También pondremos un botón en el archivo de index.html para poder acceder a este formulario:
Es momento de modificar las URLs para acceder desde el navegador, modificaremos el archivo
urls.py de la siguiente manera:
Para probar vamos a nuestro navegador a la dirección http://localhost:8000
Damos click en Agregar Editorial y agregamos un nuevo Editorial.

37. El resultado de este ingreso es el siguiente:
Eliminar registros desde Django usando Bootstrap
Para eliminar registro de la base de datos primero crearemos el botón correspondiente en el
formulario html, para eso solo lo incluiremos en el archivo index.html.

38. Una vez hecho esto modificaremos las vistas del archivo views.py. Este quedará de la siguiente
forma:
Aquí la diferencia es que el método de vista recibe como parámetro la llave principal de los
registros de editorial. Se crea la referencia a ese objeto, luego lo elimina y por ultimo redirige a la
ruta principal.
Ahora modificaremos la url para poder acceder a esa funcionalidad.
En esta línea hay algo diferente, primero contendrá la id del registro al que elimina y luego con d+
nos dice que solo puede admitir números.
Al cargar el formulario en el navegador observamos que existe un botón borrar.

39. Al darle click en el botón Borrar eliminaremos automáticamente el registro.
Modificar registros desde Django usando Bootstrap
Para modificar los registros primero ingresaremos un registro con los datos que ingresamos
anteriormente. Luego procedemos a colocar un botón de editar en el formulario de index.html.
Ahora modificaremos la Vista, la cual quedara de la siguiente forma:
Luego de editar las vistas, procederemos a crear el formulario para la edición, el archivo
editar_editorial.html nos quedará de la siguiente manera:

40. Ese archivo como hereda su aspecto del archivo base_add_edit.html solo tenemos que Editar lo
que dice en las etiquetas y listo. Ahora editaremos las urls de para esta vista.
No hay mucho que explicar de esta url ya que es igual que la de borrar. Probaremos su
funcionalidad accediendo a la aplicación desde nuestro navegador.
Damos click en editar y editamos unos campos de nuestro registro. Luego presionaremos
Terminar. Para este caso cambiaremos el nombre de la Editorial y su página web.

41. Al presionar Terminar nos redirigirá a la página de inicio y observamos que los datos han sido
modificados.

42. BANCO DE PREGUNTAS SOBRE INTERACCION DE DJANGO CON BASES DE
DATOS
1.- ¿Cuál de estos archivos se utiliza para crear la base de datos desde Django?
1. Views.py
2. Models.py
3. Urls.py
4. __init__.py
2.- ¿Cuál es la mejor manera de crear base de datos con Django?
1. Programando modelos con Python y sincronizándola con la Base de Datos
2. Haciéndolo por Sentencias SQL
3. Usar una herramienta extra que permita hacerlo por nosotros
4. Desde la consola Python de Django
3.- ¿Cuál es la manera correcta de obtener el nombre y apellido del modelo?
1. class Autor(models.Model):
nombre = models.CharField(max_length=10)
apellido = models.CharField(max_length=30)
def __init__(self):
return self.nombre+ self.apellido
2. class Autor(models.Model):
nombre = models.CharField(max_length=10)
apellido = models.CharField(max_length=30)
def __unicode__(self):
return self.nombre+ self.apellido
3. class Autor(models.Model):
nombre = models.CharField(max_length=10)
apellido = models.CharField(max_length=30)
def __unicode__(self):
return ' %s %s ' % (self.nombre, self.apellido)
4.- ¿Cómo recomienda Django el almacenamiento de imágenes en la aplicación web?
1. Creando una ruta estática (STATIC_URL) en el directorio de proyecto
2. Creando una raíz para elementos multimedia (MEDIA_ROOT) en el directorio de
proyecto

43. 3. Guardando la imagen en la Base de Datos con campos que lo permitan
4. Guardar solo la ruta como testo en la base de datos sin cargar la imagen
5.- ¿Cuál es el driver específico para hacer conexiones entre Django y sqlite3?
1. Mysqldb
2. Psycopg2
3. Mssql
4. Adosql
5. Ninguno de los anteriores
6.- ¿Cómo podemos referenciar todos los objetos de una base de datos en una vista?
1. editoriales = Editorial.objects.all()
2. editoriales = Editorial.objects()
3. editoriales = Editorial.objects.get()
4. editoriales = Objects.getall()
7.- ¿Cuál es el nombre del super usuario que se crea por defecto en PostgreSQL?
1. sa
2. root
3. postgres
4. Lo elegimos al instalar
5. Toma el nombre de Usuario del sistema
8.- ¿Cuál de los siguientes parámetros no son necesarios para trabajar con una base de datos
sqlite3?
1. Engine
2. User
3. Password
4. Name
5. Port
6. Host

44. 9.- ¿Cuál de las siguientes líneas no causaría un error al validar el modelo de la base de datos?
1. nombre = models.CharField()
2. nombre = models.CharField(max_length=10)
3. email = models.EmailField(max_length=10)
4. email = models.EmailField()
10.- ¿Cuál de las siguientes sentencias son las indicadas para realizar una llave foránea dentro de
los modelos en Django?
1. autor = models.ManyToManyField(Autor)
2. autor = models.MToMKey(Autor)
3. editorial = models.ForeignKey(Editorial)
4. editorial = models. KeyForeign (Editorial)