Desarrollo Web con

Python - Django

1
MG. Jorge Santiago Nolasco Valenzuela
DR. Javier Arturo Gamboa Cruzado
MG. Luz Elena Nolasco Valenzuela
DR. Roberto Casas Miranda

2
Dedicado a quienes no cesan en su afán de su Superación y cambio, El cambio
lo único constante

3
 Introducción
Python es un lenguaje de programación de propósito general muy popular
creado por Guido Van Rosum en los 90 trabajo en Google y en la actualidad en
Dropbox.
Su nombre proviene del cómic Monty Python. El creador de Python nombró el
lenguaje en honor al programa de televisión.

Posee una amplia comunidad de desarrolladores que giran en torno a él y buscan

aportar, compartir y construir software escalable en comunidad.

Posee un Ecosistema muy amplio esto atrae a programadores, investigadores y

profesionales de otras áreas que buscan mejorar su rendimiento laboral
haciendo uso de código.

Cuenta con una sintaxis muy limpia y legible. Posee tipado dinámico esto quiere
decir que una variable puede poseer datos de varios tipos, junto con su
naturaleza interpretada, hacen de éste un lenguaje para ser el primer en
aprender. Python es un lenguaje interpretado, lo que significa que no se necesita
compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas como la
rapidez de desarrollo.

4
 Guido van Rossum renuncia como el
“Dictador Benevolente de por vida” de
Python
Guido van Rossum, el "dictador benevolente para la vida" creador de Python,
renuncia a su cargo actual en Dropbox y cuelga su teclado.

Dropbox contrató a van Rossum hace seis años y medio. La contratación tenía
mucho sentido, dado que la compañía usa alrededor de cuatro millones de líneas
de código Python. Cuando van Rossum comenzó en 2011, el servidor de Dropbox
y el cliente de escritorio estaban escritos "casi exclusivamente en Python".

Con los años, otros idiomas se han infiltrado en los proyectos de Dropbox,
incluidos Go, Rust y TypeScript. Python, sin embargo, continúa siendo utilizado
en gran medida tanto en Dropbox como en todo el mundo a pesar de tener ahora
casi 30 años.
En algunos índices, Python es el lenguaje más popular del mundo. Por ejemplo,
en el sexto ranking anual de IEEE Spectrum, Python ocupa el primer lugar con
una puntuación de 100 en comparación con el segundo lugar de Java con 96.3.
En el Índice TIOBE, Python ocupa el puesto número tres detrás de Java y C, pero
está subiendo en el ranking más rápido entre los 20 mejores.

5
Python es amado por ser fácil de entender, tener una comunidad sólida y rápida.
El idioma es actualmente el más enseñado en los cursos introductorios de
informática.
Parte del interés reciente de Python está impulsado por el uso del lenguaje para
la inteligencia artificial y el aprendizaje automático. Python tiene una serie de
bibliotecas populares para tales aplicaciones, incluidas TensorFlow de Google,
Theano y Cognitive Toolkit (CNTK) de Microsoft.

Dropbox dice que van Rossum tuvo un gran impacto en la cultura de ingeniería
de la compañía.

"Hubo un pequeño número de codificadores realmente inteligentes y jóvenes

que produjeron una gran cantidad de código muy inteligente que solo ellos
podían entender", dijo van Rossum. "Esa es probablemente la actitud correcta
que debes tener cuando eres un startup muy pequeño".

A medida que la compañía creció, los nuevos ingenieros no pudieron entender

el código inteligente escrito por desarrolladores anteriores. Van Rossum lo llamó
una "cultura de codificación de vaqueros" y trabajó para cambiarla; educar a los
codificadores en Dropbox sobre la importancia del código mantenible.

"Si me encontraba con un código inteligente que fuera particularmente críptico,

y tuviera que hacer algo de mantenimiento, probablemente lo reescribiría", dijo.
"Así que di el ejemplo y también hablé con otras personas".

El trabajo de Van Rossum ya ha impactado a millones en algún aspecto; no solo

en Dropbox, sino en todo el mundo. Mucho después de su retiro, continuará
haciéndolo, y probablemente de formas difíciles de imaginar para nosotros hoy
dada la importancia de Python en la IA.

"Ha sido un viaje increíble ver cómo este pequeño truco mío afecta a tantas
personas en sus vidas", dijo van Rossum.

FUENTE : https://tecnoticias.net/2019/11/01/adios-dictador-benevolente-
el-creador-de-python-guido-van-rossum-se-retira/

6
Python está escrito en el lenguaje C, por lo que se puede extender a través de
su api en C o C++ y escribir nuevos tipos de datos, funciones, etc.

En la actualidad hay dos vertientes la versión 2.x y 3.x, al final llegara el

momento que se integraran estas dos versiones, es recomendable utilizar la
última versión estable 3.x

El 1 de enero del 2020 finalizó oficialmente el soporte a la versión 2.7 del

lenguaje de programación Python. La Python Software Foundation, liderada por
el creador del lenguaje, Guido van Rossum, anunció que en el futuro dejaría de
recibir actualizaciones de seguridad y correcciones de errores.

A priori podría no parecer algo demasiado grave, ya que el lanzamiento de su

sucesor, Python 3, tuvo lugar hace nada menos que 14 años, en 2006. De hecho,
el soporte para Python 2.7 tendría que haber finalizado en 2015. Sin embargo,
la enorme popularidad de esta versión (sigue siendo la versión de Python por
defecto en muchas distribuciones de Linux, por ejemplo) convenció a la
fundación de la necesidad de apoyar ambas ramas de desarrollo, y de posponer
la fecha de la 'muerte' Python 2.7.

7
Algunas de las características más importantes es que Python es
multiparadigma: Programación estructurada, Programación Orientada a Objetos
y Programación Funcional.
Python en el desarrollo web se puede utilizar los framework: Django y Flask.
Entre las empresas más conocidas que utilizan Python tenemos: La Nasa,
Dropbox y Instagram.

Existen otros proyectos realizados con Python:

• Pinterest
• Battlefield 2
• BitTorrent
• Ubuntu Software Center
• Panda 3
• Google App Engine

Puede acceder al sitio donde encontraras información más detallada de otros

proyectos en Python: https://www.escuelapython.com/grandes-proyectos-hechos-python/

En Data science y Machine Learning tenemos: Pandas, Scikit-Learn y

TensorFlow.Además, es multiplataforma: Linux, Windows, Mac OS, Solaris, etc.

Con Python puedes crear lo que sea, desde el sitio web hasta un programa o
aplicación para llevar a cabo alguna tarea científica como calcular valores
estadísticos o resolver matemática compleja.

Entre las diferentes cosas que podemos desarrollar con Python tenemos:
• Juegos
• Desarrollo web
• Gráficos y diseño
• Aplicaciones financieras
• Ciencia
• Automatización de diseño electrónico
• Desarrollo de software
• Software dedicado a negocios

Python permite ser implementado en diferentes lenguajes:

• CPython - Python tradicional escrito en C
• Jython - Python para la JVM
• IronPython - Python para .NET
• Pypy - Python más rápido con compilador JIT
• StacklessPython - Branch de CPython con soporte para microthreads

A día de hoy, Python es uno de los lenguajes de programación más populares

y extendidos, continúa aumentando su popularidad en el Índice TIOBE.

8
Fuente: https://www.tiobe.com/tiobe-index/

9
A continuación, El índice PYPL (PopularitY of Programming Language),
considera a Python el lenguaje más popular y el que ha experimentado un mayor
crecimiento en estos últimos años.

Fuente: http://pypl.github.io/PYPL.html

10
A continuación, enumeraremos las fortalezas de Python:

• es fácil de aprender
• es fácil de enseñar
• es fácil de usar
• es fácil de entender
• es fácil de obtener, instalar e implementar

Por que aprender a programar con Python

▪ Es Fácil de Aprender. - su curva de aprendizaje no es muy elevada(poco

tiempo par aprender)
▪ Hay que escribir poco código. - solo escribir lo necesario y no repetirlo
según pep8
▪ Obtienes resultado demasiado fácil. -podrás construir aplicación
orientadas a construir paginas web, análisis de datos, seguridad, juego,
inteligencia artificial
▪ Es Interpretado. - dando flexibilidad a los programadores
▪ Es Multiplataforma. - Se puede utilizar en distintos Sistemas Operativos
▪ Es un Lenguaje de Programación de Alto Nivel de Propósito General (puede
crear lo que tu creas conveniente)
▪ Es MultiParadigma. - Podemos utilizar programación estructurado,
modular, orientado a objetos y programación funcional
▪ Es Libre. - No hay que hacer ningún pago de licencia
▪ Sintaxia muy Limpia y sencilla. - Es muy fácil de leerlo, El código que es
tan comprensible como el inglés simple

Hoy, el entusiasmo por Python se ha extendido mucho más allá de ese círculo
inicial de desarrolladores, y algunos predicen que pronto se convertirá en
el lenguaje de programación más popular del mundo , ya que continúa
agregando nuevos usuarios más rápido que cualquier otro lenguaje . Millones de
personas usan Python cada día , con un crecimiento exponencial en los usuarios
que muestran pocas señales de disminuir.

Python es utilizado para tareas grandes y pequeñas por desarrolladores

profesionales y aficionados y es particularmente popular entre desarrolladores
web, científicos de datos y administradores de sistemas. Fue Python que a

11
principios de este año ayudó a unir las primeras imágenes de un agujero
negro a unos 500 millones de billones de kilómetros de distancia
https://www.youtube.com/watch?v=BIvezCVcsYs , al igual que Python es el que
impulsa innumerables scripts pirateados en computadoras de escritorio en todo
el mundo.
Python desempeña un papel fundamental en algunas de las organizaciones más
conocidas del mundo, ayudando a Netflix a transmitir videos a más de 100
millones de hogares en todo el mundo
(https://www.techrepublic.com/article/how-netflix-uses-python-streaming-
giant-reveals-its-programming-language-libraries-and-frameworks/) ,
potenciando el fenómeno de compartir fotos Instagram y ayudando a la NASA
en la exploración espacial.
Fuente:https://www.techrepublic.com/article/python-is-eating-the-world-
how-one-developers-side-project-became-the-hottest-programming-
language-on-the-
planet/?fbclid=IwAR04iHFkk51TXWGRXUPd_d_eLI8LIUt7ZjhOlKNDBCECzS2
vEAdNjiEyejo

12
Trabajar con PyCharm tiene ventajas básicas (similares a las ofrecidas por otros
IDE) pero también algunas específicas a las cuales debe su popularidad. Es así
que PyCharm tiene un editor inteligente, que permite completar código con
algunos atajos de teclado. Asimismo, permite navegar a través de nuestro
código, saltando entre las clases y métodos creados, haciendo el flujo de trabajo
mucho más dinámico.

Una de las características notables de PyCharm es la posibilidad que tiene de

refactorizar el código, que en términos generales, significa modificar el código
sin comprometer la ejecución del mismo.

Esta operación se realiza de forma constante dentro de la Ingeniería de Software

y es más conocida como limpiar el código para que este pueda ser interpretado
con facilidad cuando hay distintas personas integrando un equipo de trabajo.

Por último, la gran cantidad de desarrolladores que trabajan con PyCharm ha

generado que se tenga una gran cantidad de temas y plugins que se pueden
usar para trabajar más cómodamente.

Ellos permiten la integración con otros lenguajes y frameworks (como Node JS)
y un acceso más fácil a bases de datos y debugging.

13
Python y la Web
A mediados de la década de 1990, Python comenzaba a usarse de nuevas
maneras, desde secuencias de comandos para la grabación y reproducción de
audio hasta su primera incursión en el desarrollo web, que se convertiría en un
pilar para Python.

"Una de las grandes cosas fue el desarrollo web, que también fue algo muy
interesante para mí", dice van Rossum, quien dice que Python comenzó a usarse
para scripts de back-end en servidores web junto con scripts de Perl y
Shell. "Podrías crear páginas web dinámicas y esa se convirtió en una de mis
aplicaciones favoritas de Python".
Ryan, de Gartner, dice que lo que selló la popularidad de Python entre los
desarrolladores durante la década de 1990 fue cómo se convirtió en una opción
favorita para crear rápidamente scripts potentes. "Ser un lenguaje de secuencias
de comandos con una funcionalidad muy fuerte redujo las barreras de entrada
para muchos usuarios", dice.

Sin embargo, más que eso, Ryan dice que el lenguaje era lo suficientemente
versátil y tan fácil de aprender que atrajo a muchos tipos diferentes de usuarios
con una amplia gama de experiencia técnica. "Los administradores de sistemas
y otros tomaron el lenguaje para la automatización y programación de sistemas,
los desarrolladores para funciones como la programación funcional y la
disponibilidad de clases con herencia. Perl, por ejemplo, fue mucho menos
destacado en este sentido", dice. "Una vez que las personas se familiarizaron
con el idioma, y tiene una curva bastante baja para comenzar, se volvieron
extremadamente productivos muy rápidamente".

Este libro fue escrito en Django 3.x . En cuanto a la versión de Python, este libro
se prueba en Python 3.9 La mayoría de los ejemplos pueden funcionar en Python
3.7.x y 3.6.x.
Fuente:https://www.techrepublic.com/article/python-is-eating-the-world-
how-one-developers-side-project-became-the-hottest-programming-
language-on-the-
planet/?fbclid=IwAR04iHFkk51TXWGRXUPd_d_eLI8LIUt7ZjhOlKNDBCECzS2
vEAdNjiEyejo

14
15
Contenido
Capítulo 1 Requerimientos Iniciales..... 21
1.1 Python .............................................................................. 22
1.2 Instalación de Python en Linux......................... 22
1.3 Instalación de Python en Windows ................ 23
1.4 Comprobar la Instalación ..................................... 26
1.5 Ahora ya podemos realizar pruebas ............... 27
1.6 Operaciones Matemáticas..................................... 27
1.7 Entornos de Trabajo -PyCharm ......................... 28
1.8 Código Legible ............................................................. 34
1.9 Creando El Proyecto Hola Mundo ..................... 35
Capítulo 2 Instalacion Django ............. 39
2.1 Django .............................................................................. 40
2.1.1 Conociendo Django............................................ 40
2.1.2 Por que Utilizar Django .................................. 41
2.1.3 Versiones Soportadas ...................................... 41
2.1.4 Futuras Versiones............................................... 42
2.1.5 Basado en la Filosofia DRY: Don’t Repeat Yourself (¡No Te Repitas!) 43
2.1.6 Quienes usa Django .......................................... 43
2.1.7 Pre Requisitos ....................................................... 46
2.1.8 Version Recomendada ..................................... 46
2.1.9 Patrón Arquitectónico...................................... 47
2.1.10 Buenas Practicas y Convenciones ........... 48
2.1.11 (PEP8) ........................................................................ 48
2.1.12 El Zen de Python – PEP 20............................ 49
2.1.13 Instalar Django .................................................... 51
2.1.14 Verificando la Versión Django ................... 53

Capítulo 3 Creando un Proyecto Django54

3.1.1 Creando el proyecto .......................................... 55
3.1.2 Abrir el el proyecto ............................................ 56
3.1.3 Configuracion de un Entorno Virtual ..... 57
3.1.4 Instalando Modulo Django ........................... 61
3.1.5 Estructura del Proyecto: ................................ 63
3.1.6 Explicación del Archivo settings.py........ 66

Capítulo 4 Servidor de Prueba y Base de Datos71

4.1.1 Servidor de Desarrollo o prueba .............. 72
4.1.2 manage.py ............................................................... 74
4.1.3 Definicion del Idioma y la Zona Horaria75
4.1.4 Configurando su Base de Datos ................ 76
4.1.5 Mi Primera Ejecucion en Pycharm........... 77

16
4.1.6 Migraciones Pendientes ................................. 79
4.1.7 Aplicando Migraciones .................................... 81

Capítulo 5 Administracion ................... 84

5.1.1 Administracion Django.................................... 85
5.1.2 Crear SuperUsuario de Administración 85

Capítulo 6 Creacion de la Aplicacion .... 88

6.1.1 Creación de Aplicación .................................... 89
6.1.2 Estructura de La App: principal................. 91
6.1.3 Configuración de las Apps ............................ 92

Capítulo 7 Modelos ............................. 94

7.1.1 Que es un Modelo ............................................... 95
7.1.2 Campos ...................................................................... 95
7.1.3 Pillow........................................................................... 96
7.1.4 Creamos los siguientes modelos: ............ 97
7.1.5 Construccion de la Base de Datos ........... 99
7.1.6 Base de Datos BDNoticias........................... 106
7.1.7 Relacionando Tablas....................................... 107
7.1.8 Manejo de Imágenes ...................................... 109
7.1.9 Creando urls.py de la aplicacion para indicar la vista110
7.1.10 Haga que la aplicación Noticias se pueda modificar desde el sitio administrativo
112
7.1.11 Administracion Django.................................. 112
7.1.12 Utilizar verbose_name y verbose_name_plural117
7.1.13 Utilizar __str__() .............................................. 126
7.1.14 The Django admin site .................................. 129
7.1.15 Gestion de Permisos ....................................... 135

Capítulo 8 Vistas............................... 142

8.1.1 Que son las Vistas ............................................ 143
8.1.2 Modificando la vista : views.py ............... 143
8.1.3 Modificando la urls.py del proyecto1 para indicar la vista145
8.1.4 Vistas Adicionales............................................. 148
8.1.5 Formato de Cadenas ....................................... 151
8.1.6 Pasando A rgumento ...................................... 152
8.1.7 Modifcando archivo urls.py: ...................... 152

Capítulo 9 Template y Plantillas ........ 153

9.1.1 lenguaje de plantilla de Django .............. 154
9.1.2 Configuración de la carpeta Template 161
9.1.3 Creacion de Templates.................................. 161
9.1.4 Añadiendo las Plantillas ............................... 161
9.1.5 Creando base.html ........................................... 162
9.1.6 Usando Plantilla ................................................. 163
9.1.7 Explicacion de Bloques de la Plantilla 164
17
9.1.8 Nuestra Plantilla Base ................................... 165
9.1.9 Carpeta Static ...................................................... 166
9.1.10 Utilizando la Plantilla ..................................... 167
9.1.11 Creando urls.py de la aplicacion para indicar la vista167
9.1.12 Listado de Noticias........................................... 171
9.1.13 Creamos la función noticias en la vista172
9.1.14 Modificamos el archivo urls de la aplicación noticias172
9.1.15 Listado de Noticias en base a una Plantilla174
9.1.16 Modificamos la función noticias ............. 175
9.1.17 Numero de Registros de Noticia ............. 178
9.1.18 Contactenos en base a una Plantilla.... 180
9.1.19 Creamos la función contactanos en las vistas 182
9.1.20 Portada en base a una Plantilla .............. 183
9.1.21 Creamos la función contactanos en la vista184
9.1.22 QuerySet Referencia de API ...................... 185
9.1.23 Modificamos la función contactanos en las vistas 187
Modificamos el archivo urls del proyecto ....................... 188
9.1.24 Modificamos el archivo urls de la aplicación noticias189
9.1.25 Utilizando Template tag {% url %} .... 191

Capítulo 10 Formularios ...................... 195

10.1.1 Formularios ........................................................... 196
10.1.2 The Django Form class.................................. 196
10.1.3 Creando nuestro primer Formulario .... 197
10.1.4 Creamos la función nuevoTipoNoticia en la vista200
10.1.5 Modificamos el archivo urls de la aplicación noticias201

Capítulo 11 Despliegue ....................... 203

11.1.1 Heroku ...................................................................... 204
11.1.2 Crear cuenta Heroku....................................... 204
11.1.3 Git ................................................................................ 205

11.2 Que es Git y GitHub ....................................... 205

11.3 Mis Primeros Pasos con GitHub.............. 206
11.4 Instalando Heroku Cli .................................. 214
11.5 Comprobamos la Version Heroku.......... 216
11.6 Loguearse con Heroku ................................. 217
11.7 3.9 Variable de Entorno ............................. 217
11.8 3.9 Loguearse con Heroku Login.......... 218
11.9 Iniciando Repositorio ................................... 219
11.10 Creacion del archivo .env........................... 220
11.11 Generando las Dependencias .................. 224
11.12 Instalacion de gunicorn y otros ............. 225
18
11.13 Creacion del Archivo Procfile ................... 226
11.14 Creacion del Archivo runtime.txt .......... 227
11.15 Creacion del Archivo mysite/local_settings.py(Produccion) 228
11.16 Settings.py (Desarrollo) ............................. 229
11.17 Desplegando en Heroku.............................. 232
11.18 Probando la Aplicacion ................................ 234
11.19 Configurando Aplicación............................. 235

19
 Convenciones y Métodos Abreviados

Para una mejor lectura encontrara una seria de estilos en este Libro.
A continuación, detallamos los estilos:

Paso: Pasos a Seguir

Consejos y Trucos

Advertencias

Preguntas de Revisión por

Capitulo

use el siguiente método

comentar o de comentar rápidamente abreviado de
teclado: CTRL + / (Windows)

20
Capítulo 1 Requerimientos
Iniciales

21
1.1 Python
Python es un lenguaje de programación de alto nivel orientado a objetos y es una
gran herramienta para aprender a programar. Python viene instalado de forma
predeterminada en los sistemas operativos Mac y Linux, pero deberás instalarlo
si eres usuario de Windows. Si utilizas una computadora con un sistema operativo
Mac o Linux, puedes instalar la versión más reciente para asegurarte de tener las
últimas actualizaciones.

1.2 Instalación de Python en Linux

Python viene instalado de forma predeterminada en los sistemas operativos Mac

y Linux ya que Python es utilizada intensamente por muchos componentes del
sistema operativo Linux
Si es un usuario de Linux, abra la terminal / consola y escriba:

python3

En el indicador de shell, presiona Enter y espera. Si ves algo como esto:

22
1.3 Instalación de Python en Windows
Si eres usuario de Windows, puedes instalar la versión más reciente para
asegurarte de tener las últimas actualizaciones.

Paso 1: Ingrese a la siguiente URL para descargar:

https://www.python.org/

Puede descargar directamente la ultima versión desde la siguiente URL:

https://www.python.org/downloads/

Paso 2: Ejecute el Instalador descargado:

23
Paso 3: Inicie el proceso de Instalacion, Pulsado en el texto: Install Now

puede marcar la casilla "Add Python to PATH" para poder

ejecutar programas desde la línea de comandos.

24
A continuación, se iniciará el proceso de instalación, puede durar algunos minutos

Paso 4: Una vez completada la instalación, se mostrará la pantalla , haga

clic en en el botón "Close" para cerrar el programa de instalación

Disable path length limit.-Es recomendable tener desactivada esta

opción a menos que alguna aplicación ncesite tener el limite activado
para ello deberar modificar la siguiente clave:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\
FileSystem\LongPathsEnabled (el valor 0 significa que el límite
está desactivado y 1 significa que está activado).

25
1.4 Comprobar la Instalación

Para el sistema operativo Windows, abra símbolos del sistema e ingrese el

comando Python, como se muestra. El intérprete interactivo debe abrirse. Escriba
quit() para salir del intérprete interactivo de Python.

En Windows acceder a travez de: Win + R y luego digite CMD y luego

clic en aceptar

Para el sistema operativo Mac o Linux, abra símbolos del sistema e ingrese el
comando python3, Escriba quit () para salir del intérprete interactivo de Python.

26
1.5 Ahora ya podemos realizar pruebas
Los tres corchetes angulares ( >>> ) indican que usted está en el intérprete
interactivo de Python. Desde aquí, puede realizar su primera prueba:

El símbolo >>> indica que usted se encuentra en la sesión del intérprete

de Python, también llamada Python shell.

1.6 Operaciones Matemáticas

A continuación, mostramos la sintaxis de Python a usar para los operadores
matemáticos más comunes:

27
1.7Entornos de Trabajo -PyCharm
PyCharm es un entorno de desarrollo integrado (IDE) utilizado específicamente
para el lenguaje Python, para descargarlo Ingrese a la siguiente URL para
descargar: https://www.jetbrains.com/pycharm/
Paso 1: A continuación, presionara clic en el botón Download:

Paso 2: Puede instalar Pycharm versión gratuita Pycharm Community

presionando clic en DOWNLOAD:

28
Paso 3: Una vez que se complete la descarga, ejecute el instalador
descargado:

Paso 4: Haga clic en Siguiente(next):

Paso 5: Haga clic en Siguiente(next):

Puede cambiar la ruta de instalación si fuera necesario

29
Paso 6: Puede crear un acceso directo de escritorio si lo desea y
hacer clic en Siguiente(next).

Paso 7: haga clic en Instalar(Install):

30
Paso 8: Espere que termine la instalación:

Paso 9: Al finalizar la instalación, recibirá una pantalla de mensaje que

PyCharm está instalado. Si desea continuar y ejecutarlo, primero haga
clic en el cuadro "Run PyCharm Community Edition" y haga clic en
Finalizar(finish).

31
Paso 10: haga clic en OK:

Paso 11: Seleccionamos el tema y damos click en la opcion "Skip

remaining and set defaults" para establecer las configuraciones
predefinidas por el instalador.

32
Paso 12: Después de hacer clic en "Finalizar", aparecerá la siguiente pantalla.

33
1.8 Código Legible
Para explicar de una manera general la sintaxis de Python vamos a escribir el
clásico Hola Mundo:

En Python se manejan las identaciones o tabulación, no se hagan problemas

solo use 4 espacios a continuación escribiendo una función lo mostramos:

En python existe lo que se llaman PEP's o Python Enhancement

Proposals que son las propuestas de mejoras de Python .

34
1.9 Creando El Proyecto Hola Mundo
Ahora procedemos a crear el proyecto... HolaMundo:

Paso 1: Presione Clic en +Create New Project

Paso 2: Escribimos el nombre de nuestro proyecto: HolaMundo y

hacemos clic en Create:

35
Paso 3: Al finalizar recibimos la bienvenida por parte de pycharm y
hacemos clic en Create:

Paso 4: Ahora tenemos que crear un archivo nuevo, para ello damos clic
derecho sobre la carpeta creada, en nuevo y en Python.file, nombrando
posteriormente el archivo

36
Paso 5: Escriba el nombre del Archivo: Ejemplo1 y luego presione enter:

Paso 6: Escribimos el codigo y lo ejecutamos:

37
Paso 7: Para ejecutarlo damos clic derecho sobre el Archivo
Ejemplo1.py, seleccionamos Run “Ejemplo1”

La palabra print es un nombre de una función, el significado

de la misma proviene del contexto en el que es utilizada:

Permite Mostrar por consola Hola Mundo

38
Capítulo 2 Instalacion
Django

39
2.1 Django

2.1.1 Conociendo Django

Django es un framework web Python de alto nivel que fomenta el desarrollo
rápido y el diseño limpio y pragmático. Creado por desarrolladores
experimentados, se ocupa de gran parte de la molestia del desarrollo web, por lo
que puede concentrarse en escribir su aplicación sin necesidad de reinventar la
rueda. Es gratis y de código abierto.
A continuación, describiremos algunas de sus características:
Muy Rápido. - Django fue diseñado para ayudar a los desarrolladores a
construir aplicaciones con mucha rapidez.
Muy Seguro. - Django toma en serio la seguridad y ayuda a los desarrolladores
a evitar muchos errores de seguridad comunes
Extremadamente Escalable. - Algunos de los sitios más activos de la Web
aprovechan la capacidad de Django para escalar de manera rápida y flexible.

Se podría clasificar a django como una framework de Tercera generación los

cuales son bastantes agiles y dinámicos:

40
2.1.2 Por que Utilizar Django
Django es un marco web Python de alto nivel que fomenta el desarrollo rápido
y el diseño limpio y pragmático. Creado por desarrolladores experimentados,
se ocupa de gran parte de la molestia del desarrollo web, por lo que puede
concentrarse en escribir su aplicación sin necesidad de reinventar la rueda. Es
gratis y de código abierto.

Ridículamente rápido. -Django fue diseñado para ayudar a los

desarrolladores a llevar las aplicaciones desde el concepto hasta su
finalización. reduciendo tiempo y recursos (cualquier requerimiento ya lo tiene
django desarrollado como una sección de administarcion muy bien elaborada).

Tranquilamente seguro. -Django toma en serio la seguridad y ayuda a los

desarrolladores a evitar muchos errores de seguridad comunes. Algunas
medidad de seguridad Implementadas en Django son:
• Protección de scripts de sitios cruzados (XSS)
• Protección de falsificación de solicitud de sitio cruzado (CSRF)
• Protección de inyección SQL
• Protección de clickjacking

Fuente:https://docs.djangoproject.com/en/1.10/topics/security/

Extremadamente escalable. -Algunos de los sitios más activos de la Web

aprovechan la capacidad de Django para escalar de manera rápida y flexible
(podemos manejas aplicaciones pequeñas a enormes, puedes ser utilizada
para el propocito que usted desee).

2.1.3 Versiones Soportadas

A continuación, observaremos las versiones Django:

41
Fuente: https://www.djangoproject.com/download/

2.1.4 Futuras Versiones

Así es como se ve la hoja de ruta futura:

[1] Correcciones de seguridad, errores de pérdida de datos, errores

de bloqueo, errores importantes de funcionalidad en funciones
recién introducidas y regresiones de versiones anteriores de Django.
[2] Correcciones de seguridad y errores de pérdida de datos.
[3] Última versión para soportar Python 2.7.

42
2.1.5 Basado en la Filosofia DRY: Don’t Repeat Yourself (¡No Te
Repitas!)
“Cada pieza de conocimiento debe tener una representación única,
inequívoca y autorizada dentro de un sistema.”

La duplicación (duplicación involuntaria o intencional) puede conducir a pesadillas

de mantenimiento, factoring deficiente y contradicciones lógicas.
La duplicación y la fuerte posibilidad de una eventual contradicción pueden surgir
en cualquier lugar: en arquitectura, requisitos, código o documentación. Los
efectos pueden variar desde código mal implementado y confusión del
desarrollador hasta la falla completa del sistema.

Se podría argumentar que la mayor parte de la dificultad en la remediación Y2K

se debe a la falta de una abstracción de fecha única dentro de cualquier sistema
dado; El conocimiento de las fechas y el manejo de las fechas está muy
extendido.
Fuente: http://wiki.c2.com/?DontRepeatYourself

2.1.6 Quienes usa Django

Son muchos los sitios web que usan django, entre los que tenemos:

Instagram Pinterest

Dropbox Disqus

43
Battlefield 2 National Geographic

BitTorrent The New York Times

Nasa Science Addons.Mozilla.org

44
Ubuntu Software Center Spotify

Netflix Uber

Instacart Reddit

Lyft

45
2.1.7 Pre Requisitos
Django escrito en código Python, por lo tanto, lo primero quenecesitas para
usarlo, es asegurarte de que tienes instalada una versión apropiada de Python.
El núcleo del framework en la versión 3 trabaja solo con versión de Python3.
A continuación, listaremos Las versiones de Django con su versión de Python:

2.1.8Version Recomendada

Se recomienda usar Python 3. Django 1.11 es la última versión que soporta

Python 2.7. El soporte para Python 2.7 en Django 1.11 termina en 2020.

Dado que las nuevas versiones de Python son a menudo más rápidas, tienen más
funcionalidades, y mejor soporte, la última versión de Python 3 es recomendada.

No pierde nada en Django al usar una versión anterior, pero no aprovechará las
mejoras y optimizaciones en las nuevas versiones de Python. Las aplicaciones de
terceros que se usan en Django son, por supuesto, libres de establecer sus
propios requerimientos de versiones.

Generalmente, si está usando código en producción, debería estar usando una

versión estable. El proyecto Django publica una versión estable cada nueve meses
mas o menos, con actualizaciones de parches entre estas. Estas versiones
estables contienen la API que está cubierta por nuestras garantías de
compatibilidad con versiones anteriores; si escribe código en la versión estable,
no debería tener ningún problema actualizándola cuando la siguiente versión
oficial sea lanzada.

Para cada versión de Python, sólo la última micro-version (A.B.C) es

oficialmente soportada. Puede encontrar la última micro-versión de
cada serie en la Página de descarga de Python
<https://www.python.org/downloads/>.

46
2.1.9 Patrón Arquitectónico
Django utiliza una variante del modelo MVC llamado MTV:
• M (Modelo), la capa de acceso a la base de datos. Se encarga de la
manipulación de la base de datos.
• T significa "Template" (Plantilla), Recibe la información que recibe de la vista
y lo muestra en el navegador.
• V significa "View" (Vista), decide que información se mostrara y en que
templete se mostrara la información.

47
2.1.10 Buenas Practicas y Convenciones
“PEPs son Python Enhancement Proposals (Propuestas de mejora de Python).
Describen cambiar Python, o los estándares alrededor del lenguaje en sí.”

2.1.11 (PEP8)

PEP es el acrónimo de Pythom Enhancement Proposal o mejora de propuesta a

Python, para ello el PEP 8 es una guía de estilo o convenciones recomendables.
Entre las convenciones recomendables mas importantes tenemos:
1.Usar cuatro especios por cada Nivel de Identacion
2.Separar la definición de funciones y clases con 2 lineas en blanco
3.La defincion de los métodos separados por una línea en blanco
4. Nunca mezcles tabulaciones y espacios, El método de indentación más popular
en Python es con espacios. El segundo más popular es con tabulaciones, sin
mezclar unos con otros.
5. Limita todas las líneas a un máximo de 79 caracteres
6. Nunca debes usar import *
7. Utilizar un mismo motor de base de datos para ambientes de desarrollo local
y producción.

Puede encontrar las diferentes convenciones de codificación para el

código Python que comprende la biblioteca estándar en la
distribución principal de Python en la siguiente URL:

https://legacy.python.org/dev/peps/pep-0008/
48
2.1.12 El Zen de Python – PEP 20

La poesía de Python se basa en las siguientes convenciones:

• Bello es mejor que feo (esto se refiere que programar en Python deberá ser
agradable y la lección de código no sea un aburrimiento)
• Explícito es mejor que implícito.(esto se refiere a nombrar en forma
explicita lo que se va usar)
• Simple es mejor que complejo.(la solución mas sencilla posible es la mejor)
• Complejo es mejor que complicado.
• Plano es mejor que anidado.(El anidamiento es muchas veces sinónimo de
complejidad extra, de dependencias que a veces incomodan, de tener que
mirar con cuidado. Lo plano es más directo, más claro. Y así debe ser tu
decisión, directo al grano, sin vueltas.)

49
 • Disperso es mejor que denso.(No intentes pegar demasiado código en una
línea)
• La legibilidad cuenta.(es importante que el código sea legible o entendible)
• Los casos especiales no son tan especiales como para quebrantar las
reglas.(Los idiomas y las bibliotecas deberían aspirar a la coherencia y
deberían apoyar el caso general.)
• Aunque lo práctico gana a la pureza.
• Los errores nunca deberían dejarse pasar silenciosamente.(Nunca permita
que los errores que pueden ocurrir confundan al lector)
• A menos que hayan sido silenciados explícitamente.
• Frente a la ambigüedad, rechaza la tentación de adivinar.(De nuevo, esto
vuelve al tema de hacer que tu código sea específico, claro y hermoso)
• Debería haber una -y preferiblemente sólo una manera obvia de hacerlo.
• Aunque esa manera puede no ser obvia al principio a menos que usted sea
holandés.
Podra acceder a estos versos mediante la consola de la siguiente manera:

50
2.1.13 Instalar Django

Al ser un framework web Python, Django requiere Python. Python incluye una
base de datos ligero llamado SQLite por lo que no tendrá que configurar una
base de datos por el momento. puedes disponer de dos versiones distintas de
Django:

• El lanzamiento oficial más reciente.

• La versión de desarrollo.
1. El lanzamiento oficial más reciente.
Si deseas una versión estable, probada y lista para producción, instala la
primera opción desde la siguiente url:
https://www.djangoproject.com/download/

Una forma muy sencilla y automática, para instalar paquetes en Python, es

usando un instalador independiente llamado pip. Si tienes instalado pip, lo único
que necesitas, es utilizar una versión actualizada., pip es la opción

51
recomendada para instalar Django. Ejecute el siguiente comando para instalar
Django:
pip install Django==3.1.3

2.1.13.1 Actualizar PIP

Al observar el siguiente mensaje de alerta:
WARNING: You are using pip version 20.1.1; however, version 20.2.1 is available.
You should consider upgrading via the
'c:\users\jsnv5\appdata\local\programs\python\python38-32\python.exe -m pip install --
upgrade pip' command.
Recomendamos actualizar PIP, es importante mantenerse al tanto de las nuevas
versiones, para ello es necesario actualizar PIP:

pip es un sistema de gestión de paquetes utilizado para instalar y

administrar software escrito en el lenguaje de programación Python

52
2. La versión de desarrollo.
La última y mejor versión de Django es la que está en nuestro repositorio Git
(nuestro sistema de control de revisiones). Esto es solo para usuarios
experimentados que desean probar los cambios entrantes y ayudar a identificar
errores antes de un lanzamiento oficial. Consígalo usando este comando de shell,
que requiere Git :

git clone https://github.com/django/django.git

2.1.14 Verificando la Versión Django
Para verificar que versión Django que se esta ejecutando escriba los siguientes
comandos en un indicador de shell:

import django
django.get_version ()
3.1.2

También puede verificar la versión django de la

siguiente manera:

53
Capítulo 3 Creando un
Proyecto Django

54
3.1.1 Creando el proyecto

Lo primero que debemos hacer es crear un nuevo proyecto, esto significa que
podrás correr algunos scripts proporcionados por Django que crearán la
estructura del proyecto.
En la consola debes ejecutar:

django-admin startproject proyecto1

Si luego de Ejecutar el script para la creación de proyecto no

se emite ningún mensaje se tuvo éxito.

Esto nos creara una carpeta en el directorio actual con una

serie de archivos especificos , es recomendable evitar el uso
de nombre con django , test.

55
3.1.2 Abrir el el proyecto
A continuación, abra el nuevo proyecto: proyecto1. Los archivos y directorios
estarán visibles.

Selecciones la carpeta del proyecto:

56
3.1.3 Configuracion de un Entorno Virtual

PyCharm hace posible utilizar la herramienta virtualenv para crear un entorno

virtual aislado específico del proyecto. El objetivo principal de los entornos
virtuales es administrar la configuración y las dependencias de un proyecto en
particular, independientemente de otros proyectos de Python. La herramienta
virtualenv viene incluida con PyCharm, por lo que el usuario no necesita instalarla.
A continuacion especificamos los pasos para crear un entorno virtual:

• Presione Ctrl+Alt+S para abrir la Configuración / Preferencias del

proyecto.

57
• Haga clic en el icono y seleccione Agregar .

• Haga clic en add..

• Seleccione un nuevo entorno:

58
• Haga clic en botón ok.

• Espere mientras finalice la creación de el nuevo entorno virtual

59
• Haga clic en botón ok.

Puede crear tantos entornos virtuales sea necesario. Para

distinguirlos podrá utilizar nombres diferentes.

60
3.1.4 Instalando Modulo Django
A continuacion especificamos los pasos para instlar el modulo django:

• Presione Ctrl+Alt+S para abrir la Configuración / Preferencias del

proyecto.

• Haga clic en el + y escriba django y presione click en el botón Install

Package.

61
• Espere mientras instale el paquete django

• Cierre la ventana y haga click el botón Ok

62
3.1.5 Estructura del Proyecto:
Observe los archivos que se crearon:

manage.py .-permite para gestionar y controlar nuestro proyecto , en la

amyoria de los casos este archivo no sera modificado

63
__init__.py .- Indica a Python que considere una carpeta como un
módulo o también llamado paquete(por defecto esta vacio)

settings.py .- Contiene las configuraciones de base de datos, archivos

estático y zona de horario, etc

64
urls.py.- Contiene las URLs direcciones de las web , principales del
proyecto (accesos a los dispositivos)

wsgi.py.- Permite conectar nuestro proyecto con un Servidor Web al

momento de hacer deploy (produccion)

65
3.1.6 Explicación del Archivo settings.py

Es el encargado de controlar toda la configuración de un proyecto a continuación

describiremos algunas de la configuración por defecto:

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
Especificacion de rutas dentro del proyecto

SECRET_KEY = 'm89trau%cm49vj7)48t=+-o8&n&6b)a#g^)g$klnowob9nlss='
Llave secreta del proyecto. - Este valor es la clave para proteger los datos
firmados. Esto es parte del sistema de seguridad de Django,
y este valor es crítico para mantener seguro un proyecto de Django

DEBUG = True
Es la variable para entrar en un estado de
depuración, permite mostrar los errores,
este modo es recomendadp en entornos de
desarrollo y no en entornos de produccion

ALLOWED_HOSTS = []

Una lista de cadenas que representan los

nombres de host / dominio
permiotidos. Esta es una medida de
seguridad para evitar HTTP Host header
attacks, que son posibles incluso bajo
muchas configuraciones de servidor web
seguras.

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
Definición de las aplicaciones de
terceros a utilizar dentro de
nuestro proyecto.

66
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

Django viene equipado con una serie de clases de middleware, algunas de las
cuales están habilitadas de forma predeterminada.
A continuación, una breve explicación de las siete clases anteriores

Clase Funcionalidad
django.middleware.security.SecurityMiddleware Proporciona mejoras de
seguridad, como:
• Redirecciones SSL basadas
en SECURE_SSL_REDIRECT y
Configuración de
SECURE_SSL_HOST.
• Seguridad de transporte
estricta a través de una
variedad de configuraciones.

Permite el soporte de sesion

django.contrib.sessions.middleware.SessionMiddleware

Proporciona un conjunto
django.middleware.common.CommonMiddleware común de características,
como:
• Prohibir el acceso a los
agentes de usuario en
DISALLOWED_USER_
Configuración de AGENTES,
que puede ser una lista de
compilados regulares
objetos de expresión
• Realización de una
reescritura de URL basada
en APPEND_SLASH y
PREPEND_WWW
configuración para
normalizar las URL.
• Configuración del
encabezado HTTP Content-
Length para la no
transmisión
Respuestas

67
django.middleware.csrf.CsrfViewMiddleware Agrega protección contra
falsificaciones de
solicitudes de sitios
cruzados

django.contrib.auth.middleware.AuthenticationMiddleware Agrega el atributo de

usuario, que representa al
usuario actualmente
conectado,
a cada objeto HttpRequest
entrante.

django.contrib.messages.middleware.MessageMiddleware Permite el soporte de

mensajes basados en
cookies y sesiones

django.middleware.clickjacking.XFrameOptionsMiddleware Proporciona protección de

clickjacking a través de X-
Frame-Options
encabezamiento

ROOT_URLCONF = 'proyecto1.urls'
Una cadena que representa la ruta raíz. Por
ejemplo:
proyecto1.urls

TEMPLATES = [
{
'BACKEND':
'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [

'django.template.context_processors.debug',

'django.template.context_processors.request',

'django.contrib.auth.context_processors.auth',

'django.contrib.messages.context_processors.messages',
],
},
},
]

Manejador de templates, actualmente en la versión 2.0

podemos utilizar 2 motores de templates, los de django y
jinja.

68
django.contrib.auth.context_processors.auth.-
autentificación de usuarios

django.template.context_processors.request.- Si este
procesador está habilitado, cada RequestContext
contendrá una variable request es el actual objeto
HttpRequest

django.template.context_processors.debug.- añade
información de depuracion

django.contrib.messages.context_processors.messages.-
El enterno de mensajes de Django simplifica el envío de
mensajes únicos a los usuarios

WSGI_APPLICATION = '
proyecto1.wsgi.application'
La ruta completa de Python del objeto de
aplicación WSGI que los servidores integrados
de Django (por ejemplo runserver)

DATABASES = {
'default': {
'ENGINE':
'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR,
'db.sqlite3'),
}
}
Es la variable que se utiliza para determinar que
motor de base de datos vamos a utilizar, por
defecto sqlite.

Puede conectarse a otros servidores de bases

de datos, como MariaDB, MySQL, Oracle o
PostgreSQL.

AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.
UserAttributeSimilarityValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.
MinimumLengthValidator',
},

69
 {
'NAME':
'django.contrib.auth.password_validation.
CommonPasswordValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.
NumericPasswordValidator',
},
]
La lista de validadores que se utilizan para
comprobar la solidez de las contraseñas del
usuario.

LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
Son las variables para cambiar:
• Idioma
• zona horaria
• traducción
• habilitar fechas y números según la
configuración regional
• utilizará las fechas internas de la zona
horaria

STATIC_URL = '/static/'
URL a utilizar cuando se refiere a archivos
estáticos ubicados en STATIC_ROOT

Es importante tener en cuenta las secciones que contienen

comentarios con la documentación oficial.

70
Capítulo 4 Servidor de
Prueba y Base de Datos

71
4.1.1 Servidor de Desarrollo o prueba
Verifiquemos que su proyecto Django funcione. Cambie al directorio del
proyecto, si aún no lo ha hecho, y ejecute los siguientes comandos:

python manage.py runserver

Mediante el comando runserver ejecutamos un servidor de

prueba . Ignore la advertencia sobre migraciones de bases de
datos no aplicadas por ahora; Nos ocuparemos de la base de
datos en breve.

Puede Inicira el servidor de prueba o desarrollo en la

siguiente UR: http://127.0.0.1:8000/

Con la combinación de teclas CTRL-BREAK podemos parar el

Servidor de Prueba o desarrollo.

Has iniciado el servidor de desarrollo Django, un servidor web ligero escrito

exclusivamente en Python. Hemos incluido esto con Django para que pueda
desarrollar las cosas rápidamente, sin tener que lidiar con la configuración de un
servidor de producción, como Apache, hasta que esté listo para la producción.

Ahora es un buen momento para tener en cuenta: no use este servidor en nada
parecido a un entorno de producción. Está destinado solo para su uso durante el
desarrollo.

72
Ahora que el servidor se está ejecutando, visite:

http://127.0.0.1:8000/

con su navegador web. Verás una página de "¡Felicitaciones!", Con un cohete

despegando. ¡Funcionó!

Por defecto, el runservercomando inicia el servidor de desarrollo

en la IP interna (127.0.0.1) en el puerto 8000.

Si desea cambiar el puerto del servidor, páselo como un

argumento de línea de comandos. Por ejemplo, este comando
inicia el servidor en el puerto 8080:

py manage.py runserver 8080

En un entorno de producción no es recomendable DEBUG = True

es potencialmente peligroso

73
4.1.2 manage.py
es un script que ayuda con la administración del sitio. Con él podremos iniciar un
servidor web.
Podra examinar la lista de comandos de la siguiente manera:
python manage.py
Available subcommands:

[auth]
changepassword
createsuperuser

[contenttypes]
remove_stale_contenttypes

[django]
check
compilemessages
createcachetable
dbshell
diffsettings
dumpdata
flush
inspectdb
loaddata
makemessages
makemigrations
migrate
sendtestemail
shell
showmigrations
sqlflush
sqlmigrate
sqlsequencereset
squashmigrations
startapp
startproject
test
testserver

[sessions]
clearsessions

[staticfiles]
collectstatic
findstatic
runserver

74
4.1.3 Definicion del Idioma y la Zona Horaria

Si deseas que django defina el idioma nativo simplemente hay que configurar una
preferencia de idioma fija LANGUAGE_CODE en tu archivo de configuración.
settings.py:
LANGUAGE_CODE = 'es'

La Zona Horaria se especifica en la variable de configuración TIME_ZONE. Por lo

tanto, todas tus vistas y modelos operarán automáticamente en la zona horaria
definida. Si deseas configurarlos de forma manual hay que modificar la
preferencia de Zona Horaria TIME_ZONE = 'UTC' , para nuestro caso lo
cambiaremos a:
TIME_ZONE = 'America/Lima'

Modificando settings.py

Puede encontrar la lista de Zonas Horarias en la siguiente URL:

https://en.wikipedia.org/wiki/List_of_tz_database_time_zones

75
4.1.4 Configurando su Base de Datos
abra el archivo settings.py. Es un módulo normal de Python con variables de
nivel de módulo que representan la configuración de Django.

Modificamos el nombre de la base de datos por BDNoticias:

Ejecutamos nuevamente el servidor de prueba y Refrescamos la pagina y

observamos el cambio de idioma:

76
4.1.5 Mi Primera Ejecucion en Pycharm

77
1: nombre del nuevo ejecutador de phyton
2: script nombre del archivo principal del proyecto
3: script parameters es el comando de django para ejecutar el servidor
4: interpretador de phyton a usar
5: ruta de proyecto (proyecto1)
6: aplicamos
7: ok, para crear el nuevo ejecutador

78
Luego ejecutamos el proyecto

4.1.6 Migraciones Pendientes

Tienes 17 migraciones y deberas aplicarlas para que tu proyecto funcione
adecuadamente:

79
Presione en la siguiente URL http: //127.0.0.1:800/ :

80
4.1.7 Aplicando Migraciones
4.1.7.1 Migraciones
Las migraciones es la manera como Django aplica los cambios que hace a sus
modelos (agregando un campo, eliminando un modelo, etc.) en su esquema
de base de datos
4.1.7.2 Comandos
Hay varios comandos que usará para interactuar con las migraciones y el
manejo de Django del esquema de la base de datos:
• migrate.-que es responsable de aplicar y dejar de aplicar las
migraciones.
• makemigrations.- que es responsable de crear nuevas migraciones
basadas en los cambios que ha realizado en sus modelos.
• sqlmigrate.-que muestra las declaraciones de SQL para una migración.
• showmigrations.- que enumera las migraciones de un proyecto y su
estado.

Debería pensar en las migraciones como un sistema de control de versiones

para su esquema de base de datos. makemigrationses es el responsable de
empaquetar los cambios de su modelo en archivos de migración individuales,
análogos a los commits, y migrate es responsable de aplicarlos a su base de
datos.
Ahora vamos al terminal del ide y escribimos lo siguiente python manage.py
migrate lo que crea las tablas que brindara a django seguridad
python manage.py migrate

81
4.1.7.3 Soporte con Otras Bases de Datos
4.1.7.4 PostgreSQL
PostgreSQL es la más capaz de todas las bases de datos aquí en términos de
soporte de esquema.
La única advertencia es que antes de PostgreSQL 11, agregar columnas con
valores predeterminados causa una reescritura completa de la tabla, por un
tiempo proporcional a su tamaño. Por esta razón, se recomienda que siempre
cree nuevas columnas con null=True, ya que de esta manera se agregarán de
inmediato.
4.1.7.5 MySQL
MySQL carece de soporte para las transacciones relacionadas con las
operaciones de alteración del esquema, lo que significa que si una migración
no se aplica, tendrá que deseleccionar manualmente los cambios para volver
a intentarlo (es imposible volver a un punto anterior).
Además, MySQL reescribirá completamente las tablas para casi todas las
operaciones de esquema y generalmente toma un tiempo proporcional al
número de filas en la tabla para agregar o eliminar columnas. En un hardware
más lento, esto puede ser peor que un minuto por millón de filas: agregar

82
algunas columnas a una tabla con solo unos pocos millones de filas podría
bloquear su sitio durante más de diez minutos.
Finalmente, MySQL tiene límites relativamente pequeños en las longitudes de
nombre para columnas, tablas e índices, así como un límite en el tamaño
combinado de todas las columnas que cubre un índice. Esto significa que los
índices que son posibles en otros backends no se crearán en MySQL.

4.1.7.6 SQLite

SQLite tiene muy poco soporte de alteración de esquema incorporado, por lo

que Django intenta emularlo:

• Crear una nueva tabla con el nuevo esquema

• Copiando los datos a través de
• Dejando caer la vieja mesa
• Cambiar el nombre de la nueva tabla para que coincida con el nombre
original

Este proceso generalmente funciona bien, pero puede ser lento y ocasionalmente
defectuoso. No se recomienda que ejecute y migre SQLite en un entorno de
producción a menos que esté muy consciente de los riesgos y sus limitaciones; El
soporte con el que se entrega Django está diseñado para permitir a los
desarrolladores usar SQLite en sus máquinas locales para desarrollar proyectos
Django menos complejos sin la necesidad de una base de datos completa.

4.1.7.7 Oracle notes

Django es compatible con Oracle Database Server versiones 12.2 y
superiores. Se requiere la versión 6.0 o superior
del controlador cx_Oracle Python.

Ahora Django soporta MariaDB oficialmente, seguramente esto

les encantará a muchos porque MariaDB es uno de los
servidores de base de datos más populares que ha sido creado
por los mismos desarrolladores de MySQL. En otras palabras es
un reemplazo mejorado de MySQL.

83
Capítulo 5 Administracion

84
5.1.1 Administracion Django
El panel de administrador de Django es una funcionalidad que viene creada por
defecto. Para acceder tenemos que entrar a la dirección /admin de nuestra
página:

5.1.2 Crear SuperUsuario de Administración

ahora solo falta crear un usuario para poder entrar a la parte administrativa del
sistema proyecto1.
escribimos lo siguiente:
python manage.py createsuperuser

Introduzca su nombre de usuario deseado y pulse enter.

Username: super1

A continuación, se le solicitará su dirección de correo electrónico deseada:

Email address: [email protected]
El paso final es introducir su contraseña. Se le pedirá que introduzca su
contraseña dos veces, la segunda vez como confirmación de la primera.
Password: **********
Password (again): *********
Superuser created successfully.

Es una mala práctica usar contraseñas simples en ent ornes de desarrollo

o producción

85
Reiniciamos el servidor, Presione en la siguiente
URL http://127.0.0.1:800/admin:

Ahora ingresamos al panel de administración a través de la URL:

http://127.0.0.1:8000/admin/

86
Ahora Ingresamos las credenciales:

Usted estará utilizando la interfaz de administración podra

verificar que los datos se almacenan correctamente.

87
Capítulo 6 Creacion de la
Aplicacion

88
6.1.1 Creación de Aplicación

Un proyecto Django es una agrupación de aplicaciones (Apps) que en conjunto

forman una Web.
Algunas Apps ya se encuentran creadas como las observamos en el archivo
setting.py:

Por defecto, INSTALLED_APPS contiene las siguientes aplicaciones y Django

viene equipado con todas ellas:
• django.contrib.admin - El sitio administrativo. Usted lo utilizará dentro de
poco.
• django.contrib.auth– Un sistema de autenticación.
• django.contrib.contenttypes– Un framework para los tipos de contenido.
• django.contrib.sessions – Un framework de sesión.
• django.contrib.messages – Un framework de mensajería.
• django.contrib.staticfiles – Un framework para la gestión de archivos
estáticos.
89
La idea es desarrollar una serie de pequeñas aplicaciones, para ello es necesario
crear aplicaciones con funcionalidades particulares.
Por ejemplo, en nuestro caso deseamos crear una app que denominaremos
noticias donde publicaremos diferentes noticias económicas, financieras, etc.

Para ellos emitimos el siguiente comando dentro de la carpeta principal proyecto:

Python manage.py startapp noticias

Ahora observamos la estructura del proyecto

90
6.1.2 Estructura de La App: principal

__init__.py .- Indica a Python que considere una carpeta

como un módulo o también llamado paquete
admin.py .-se realizan todos los cambios en la
administración
apps.py.- proporciona un lugar para cualquier
configuración específica de la aplicación.
models.py .- Es donde tendremos que crear todos
nuestros modelos referidos a nuestra app
tests.py.- Es el archivo donde tendremos que hacer
nuestras pruebas unitarias
view.py .- Todas nuestras vistas referidas a la app

91
Tambien puede observar la estructura del proyecto de la siguiente manera:

6.1.3 Configuración de las Apps

Por último, es necesario indicarle a django de la existencia de la app almacén
para ello configuramos nuestras apps reconocidas por el sistema en el archivo
settings propiedad INSTALLED_APPS:

92
INSTALLED_APPS. - Verás una serie de aplicaciones ya definidas en INSTALLED_APPS , Ahora es necesario
especificar su Aplicación:

93
Capítulo 7 Modelos

94
7.1.1 Que es un Modelo

Un modelo es un objeto Python que describe los datos de una tabla de una base
de datos especifica. En lugar de trabajar directamente en la base de datos a través
de SQL, sólo necesita un modelo para ejecutar código SQL. Django también usa
modelos para representar conceptos de alto nivel que no necesariamente pueden
ser manejados por SQL.

El manejo de base de datos en Django se ha creado para satisfacer una

variedad de diferentes bases de datos: PostgresSQL, MySQL y Microsoft
SQL Server. Para otros motores de base de datos

7.1.2 Campos

Los modelos pueden tener la cantidad de campos requeridos. Cada uno

representa una columna de datos que queremos guardar en nuestras tablas de la
base de datos. A continuación, listados los tipos de campos:

• CharField: para campos de caracteres. Tiene un argumento obligatorio,

max_length.

• TextField se usa para cadenas de longitud grande o arbitraria. Puedes

especificar una max_length para el campo, pero sólo se usa cuando el
campo se muestra en formularios (no se fuerza al nivel de la base de datos).

• IntegerField es un campo para almacenar valores de números enteros y

para validar los valores introducidos como enteros en los formularios.

• ImageField: para ficheros con extensiones de imagen. Aquí usamos el

argumento
upload_to para especificarle en que directorio queremos que se guarden las
imágenes de nuestra aplicación

• DateField: para fechas. Al indicarle auto_now_add como True, estamos

almacenando la fecha en la que la foto se ha guardado por primera vez.

• BooleanField: para valores booleanos, indicándole que el valor por defecto

es false,
en caso de no definirlo estaríamos usando None como valor por defecto.

95
 • AutoField es un tipo especial de IntegerField que se incrementa
automáticamente. Cuando no especificas una clave primaria para tu
modelo, se añade -automáticamente- una de este tipo.

• ForeignKey: para establecer relaciones entre clases. null y blank para

especificar que este campo puede estar vacío.

• ManyToManyField se usa para especificar una relación muchos a muchos

(ej. un libro puede tener varios géneros, y cada género puede contener
varios libros). En nuestra aplicación de la biblioteca usaremos ésta de forma
muy similar a ForeignKeys, pero pueden usarse de formas más complicadas
para describir las relaciones entre grupos. Éstas tienen el
parámetro on_delete para definir que ocurre cuando un registro asociado
se borra (ej. un valor de models.SET_NULL establecería simplemente el
valor a NULL).

7.1.3 Pillow
La librería Pillow de imágenes de Python agrega capacidades de procesamiento
de imágenes a su intérprete de Python.

Esta librería proporciona un amplio soporte de formato de archivo, una

representación interna eficiente y capacidades de procesamiento de imágenes.

La librería Pillow de imágenes principal está diseñada para un acceso rápido a los
datos almacenados en algunos formatos de píxeles básicos. Debería proporcionar
una base sólida para una herramienta general de procesamiento de imágenes.

Pillow es la librería que nos permitirá usar el campo ImageField para poder
guardar imágenes:

Python -m pip install Pillow

96
7.1.4 Creamos los siguientes modelos:
En nuestra sencilla aplicación registraremos:
• TipoNoticia .- Donde clasificamos el tipo de noticias a publicar.
• Paises .- Donde registramos los diferentes países que son originarios los
autores.
• TipoDoc .- Donde registramos los difrentes tipos de documentos de
identidad de los autores de las noticias.
• Autor.- Donde registramos los datos de lso autores de las noticias a
publicar.
• Noticia.- Donde registramos información de la noticias como:
a) Titulo
b) Descripción
c) Fecha
d) Autor
e) Tipo de Noticias
• Contacto. - Donde registramos información si alguien desea contactarse con
nosotros.

Primero crearemos el modelo Noticias:

from django.core.validators import RegexValidator

from django.db import models
from django.utils import timezone

class TipoNoticia(models.Model):
tipo = models.CharField('Tipo de noticias', max_length=30, blank=False,
null=False)
descripcion = models.TextField('Descripcion del tipo de noticia',
max_length=300, blank=False, null=False)

97
class Paises(models.Model):
codigo = models.CharField(max_length=2, blank=False, null=False,
primary_key=True)
Nombre = models.CharField('Nombre del pais', max_length=50, blank=False,
null=False)

class TipoDoc(models.Model):
descripcion = models.TextField('Descripcion del tipo de documento',
max_length=20, blank=False, null=False)

class Autor(models.Model):
tipodoc = models.ForeignKey(TipoDoc, on_delete=models.CASCADE,
default=None)
documento= models.CharField('Documento de identidad', max_length=16,
blank=False, null=False, primary_key=True)
nombres = models.CharField('Nombre del Autor', max_length=200,
blank=False, null=False, default=None)
apellidos = models.CharField('Apellidos', max_length=200, blank=False,
null=False, default=None)
image = models.ImageField(upload_to='images/', blank=False, default=None)
pais = models.ForeignKey(Paises, on_delete=models.CASCADE, default=None)
estado = models.BooleanField('Activo', default=True, blank=False, null=False)
correo = models.EmailField('Correo Electronico', max_length=254,
blank=False, null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}",
message="Correo inválido")])
telefono = models.CharField('Telefono', max_length=20, blank=False,
null=False, default=None)
fecha_creacion = models.DateField('Fecha de creación', default=timezone.now,
blank=False, null=False)

class Noticia(models.Model):
titulo = models.CharField('Titulo de la noticia', max_length=200, blank=False,
null=False)
descripcion = models.TextField('Descripcion de la noticia', max_length=500,
blank=False, null=False)
fecha = models.DateTimeField('Fecha de creacion', default=timezone.now,
blank=False, null=False)
autor = models.ForeignKey(Autor, to_field=' documento',
on_delete=models.CASCADE, default=None)
tipo = models.ForeignKey(TipoNoticia, on_delete=models.CASCADE,
default=None)
98
class Contacto(models.Model):
id = models.AutoField(primary_key=True)
nombreu = models.CharField("Nombres", max_length=200, blank=False,
null=False)
correo = models.CharField("Correo Electronico", max_length=200,
blank=False, null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}",
message="Correo inválido")])
mensaje = models.TextField("Mensaje", max_length=400, blank=False,
null=False)
fecha_creacion = models.DateField("Fecha de Crecion", auto_now=True,
blank=False, null=False)

7.1.5 Construccion de la Base de Datos

Ahora deberemos construir la base de datos:

Al ejecutar makemigrations, usted le indica a Django que ha realizado algunos

cambios a sus modelos (en este caso, ha realizado cambios nuevos) y que le
gustaría que los guarde como una migración en un archivo py con una numeración
de acuerdo a cada cambio relizadoeste es el primer paso para construir la base
de datos con las respectivas tablas.

python manage.py makemigrations

Django guarda los cambios en sus modelos como migraciones (y por lo tanto en su
esquema de base de datos); son solo archivos en el disco. Usted puede leer la migración

99
para su nuevo modelo si lo desea, es el archivo migrations/0001_initial.py. No
se preocupe, no se espera que usted las lea cada vez que Django hace una, sino que
están diseñadas para que sean editables en caso de que usted desee modificar
manualmente como Django cambia las cosas.

# Generated by Django 3.1.2 on 2020-10-14 00:37

import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone

class Migration(migrations.Migration):

initial = True

dependencies = [
]

operations = [
migrations.CreateModel(
name='Autor',
fields=[
('doc', models.CharField(max_length=16, primary_key=True, serialize=False,
verbose_name='Documento de identidad')),
('nombre', models.CharField(default=None, max_length=200,
verbose_name='Nombre del Autor')),
('apellidos', models.CharField(default=None, max_length=200,
verbose_name='Apellidos')),
('image', models.ImageField(default=None, upload_to='images/')),
('estado', models.BooleanField(default=True, verbose_name='Activo')),
('correo', models.EmailField(default=None, max_length=254,
validators=[django.core.validators.RegexValidator(message='Correo inválido',
regex='\\S{1,}@\\S{2,}\\.\\S{2,}')], verbose_name='Correo Electronico')),
('telefono', models.CharField(default=None, max_length=20,
verbose_name='Telefono')),
('fecha_creacion', models.DateField(default=django.utils.timezone.now,
verbose_name='Fecha de creación')),
],
),
migrations.CreateModel(
name='Contacto',
fields=[
('id', models.AutoField(primary_key=True, serialize=False)),
100
 ('nombreu', models.CharField(max_length=200, verbose_name='Nombres')),
('correo', models.CharField(default=None, max_length=200,
validators=[django.core.validators.RegexValidator(message='Correo inválido',
regex='\\S{1,}@\\S{2,}\\.\\S{2,}')], verbose_name='Correo Electronico')),
('mensaje', models.TextField(max_length=400, verbose_name='Mensaje')),
('fecha_creacion', models.DateField(auto_now=True, verbose_name='Fecha de
Crecion')),
],
options={
'verbose_name': 'Contacto',
'verbose_name_plural': 'Contactos',
'ordering': ['id'],
},
),
migrations.CreateModel(
name='Paises',
fields=[
('codigo', models.CharField(max_length=2, primary_key=True,
serialize=False)),
('Nombre', models.CharField(max_length=50, verbose_name='Nombre del
pais')),
],
),
migrations.CreateModel(
name='TipoDoc',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False,
verbose_name='ID')),
('descripcion', models.TextField(max_length=20, verbose_name='Descripcion
del tipo de documento')),
],
),
migrations.CreateModel(
name='TipoNoticia',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False,
verbose_name='ID')),
('tipo', models.CharField(max_length=30, verbose_name='Tipo de noticias')),
('descripcion', models.TextField(max_length=300,
verbose_name='Descripcion del tipo de noticia')),
],
),
migrations.CreateModel(
name='Noticia',
fields=[

101
 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False,
verbose_name='ID')),
('titulo', models.CharField(max_length=200, verbose_name='Titulo de la
noticia')),
('descripcion', models.TextField(max_length=500,
verbose_name='Descripcion de la noticia')),
('fecha', models.DateTimeField(default=django.utils.timezone.now,
verbose_name='Fecha de creacion')),
('autor', models.ForeignKey(default=None,
on_delete=django.db.models.deletion.CASCADE, to='noticias.autor')),
('tipo', models.ForeignKey(default=None,
on_delete=django.db.models.deletion.CASCADE, to='noticias.tiponoticia')),
],
),
migrations.AddField(
model_name='autor',
name='pais',
field=models.ForeignKey(default=None,
on_delete=django.db.models.deletion.CASCADE, to='noticias.paises'),
),
migrations.AddField(
model_name='autor',
name='tipodoc',
field=models.ForeignKey(default=None,
on_delete=django.db.models.deletion.CASCADE, to='noticias.tipodoc'),
),
]
Hay un comando que ejecutará las migraciones para usted y gestionará el
esquema de base de datos automáticamente; este se denomina migrate, y
hablaremos de ello en un momento, pero primero, vamos a ver cuál SQL esa
migración ejecutaría. El comando sqlmigrate recibe nombres de migración y
devuelve su SQL:

python manage.py sqlmigrate noticias 0001

BEGIN;
--
-- Create model Autor
--
CREATE TABLE "noticias_autor" ("doc" varchar(16) NOT NULL
PRIMARY KEY, "nombre" varchar(200) NOT NULL, "apellidos"
varchar(200) NOT NULL, "image" var

102
char(100) NOT NULL, "estado" bool NOT NULL, "correo"
varchar(254) NOT NULL, "telefono" varchar(20) NOT NULL,
"fecha_creacion" date NOT NULL);
--
-- Create model Contacto
--
CREATE TABLE "noticias_contacto" ("id" integer NOT NULL
PRIMARY KEY AUTOINCREMENT, "nombreu" varchar(200) NOT
NULL, "correo" varchar(200) NOT NULL, "
mensaje" text NOT NULL, "fecha_creacion" date NOT NULL);
--
-- Create model Paises
--
CREATE TABLE "noticias_paises" ("codigo" varchar(2) NOT NULL
PRIMARY KEY, "Nombre" varchar(50) NOT NULL);
--
-- Create model TipoDoc
--
CREATE TABLE "noticias_tipodoc" ("id" integer NOT NULL
PRIMARY KEY AUTOINCREMENT, "descripcion" text NOT NULL);
--
-- Create model TipoNoticia
--
CREATE TABLE "noticias_tiponoticia" ("id" integer NOT NULL
PRIMARY KEY AUTOINCREMENT, "tipo" varchar(30) NOT NULL,
"descripcion" text NOT NULL);
--
-- Create model Noticia
--
CREATE TABLE "noticias_noticia" ("id" integer NOT NULL
PRIMARY KEY AUTOINCREMENT, "titulo" varchar(200) NOT NULL,
"descripcion" text NOT NULL, "fecha
" datetime NOT NULL, "autor_id" varchar(16) NOT NULL
REFERENCES "noticias_autor" ("doc") DEFERRABLE INITIALLY
DEFERRED, "tipo_id" integer NOT NULL RE
FERENCES "noticias_tiponoticia" ("id") DEFERRABLE INITIALLY
DEFERRED);
--
-- Add field pais to autor
--

103
CREATE TABLE "new__noticias_autor" ("doc" varchar(16) NOT
NULL PRIMARY KEY, "nombre" varchar(200) NOT NULL,
"apellidos" varchar(200) NOT NULL, "image
" varchar(100) NOT NULL, "estado" bool NOT NULL, "correo"
varchar(254) NOT NULL, "telefono" varchar(20) NOT NULL,
"fecha_creacion" date NOT NULL, "pa
is_id" varchar(2) NOT NULL REFERENCES "noticias_paises"
("codigo") DEFERRABLE INITIALLY DEFERRED);
INSERT INTO "new__noticias_autor" ("doc", "nombre",
"apellidos", "image", "estado", "correo", "telefono",
"fecha_creacion", "pais_id") SELECT "doc",
"nombre", "apellidos", "image", "estado", "correo", "telefono",
"fecha_creacion", NULL FROM "noticias_autor";
DROP TABLE "noticias_autor";
ALTER TABLE "new__noticias_autor" RENAME TO
"noticias_autor";
CREATE INDEX "noticias_noticia_autor_id_23bbfa4c" ON
"noticias_noticia" ("autor_id");
CREATE INDEX "noticias_noticia_tipo_id_81555bb7" ON
"noticias_noticia" ("tipo_id");
CREATE INDEX "noticias_autor_pais_id_8938e1cf" ON
"noticias_autor" ("pais_id");
--
-- Add field tipodoc to autor
--
CREATE TABLE "new__noticias_autor" ("doc" varchar(16) NOT
NULL PRIMARY KEY, "nombre" varchar(200) NOT NULL,
"apellidos" varchar(200) NOT NULL, "image
" varchar(100) NOT NULL, "estado" bool NOT NULL, "correo"
varchar(254) NOT NULL, "telefono" varchar(20) NOT NULL,
"fecha_creacion" date NOT NULL, "pa
is_id" varchar(2) NOT NULL REFERENCES "noticias_paises"
("codigo") DEFERRABLE INITIALLY DEFERRED, "tipodoc_id"
integer NOT NULL REFERENCES "noticias_
tipodoc" ("id") DEFERRABLE INITIALLY DEFERRED);
INSERT INTO "new__noticias_autor" ("doc", "nombre",
"apellidos", "image", "estado", "correo", "telefono",
"fecha_creacion", "pais_id", "tipodoc_id")
SELECT "doc", "nombre", "apellidos", "image", "estado", "correo",
"telefono", "fecha_creacion", "pais_id", NULL FROM
"noticias_autor";
104
DROP TABLE "noticias_autor";
ALTER TABLE "new__noticias_autor" RENAME TO
"noticias_autor";
CREATE INDEX "noticias_autor_pais_id_8938e1cf" ON
"noticias_autor" ("pais_id");
CREATE INDEX "noticias_autor_tipodoc_id_26f8167b" ON
"noticias_autor" ("tipodoc_id");
COMMIT;

A continuación, ejecute de nuevo el comando migrate para crear esas tablas modelos
en su base de datos:

python manage.py migrate

C:\Users\Jorge Nolasco\proyecto1>python manage.py migrate

Operations to perform:
Apply all migrations: admin, auth, contenttypes, noticias,
sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying auth.0012_alter_user_first_name_max_length... OK
Applying noticias.0001_initial... OK
Applying sessions.0001_initial... OK

105
7.1.6 Base de Datos BDNoticias
Ahora observaremos la base de datos: BDNoticias

106
7.1.7 Relacionando Tablas
Claramente, el poder de las bases de datos relacionales reside en relacionar tablas entre
sí. Django ofrece formas de definir los tres tipos más comunes de relaciones de bases de
datos: muchos a uno, muchos a muchos y uno a uno.

• Relaciones de muchos a uno : ForeignKey

• Relaciones de muchos a muchos : ManyToManyField
• Relaciones uno a uno : OneToOneField
Vamos a observar las relaciones creadas:

from django.core.validators import RegexValidator

from django.db import models
from django.utils import timezone

class TipoNoticia(models.Model):
tipo = models.CharField('Tipo de noticias', max_length=30, blank=False, null=False)
descripcion = models.TextField('Descripcion del tipo de noticia', max_length=300,
blank=False, null=False)

class Paises(models.Model):
# https://www.sbs.gob.pe/prevencion-de-lavado-
activos/publicaciones/estadisticas/tablas-y-valores-generales/tabla-de-paises-iso-3166
codigo = models.CharField(max_length=2, blank=False, null=False,
primary_key=True)
Nombre = models.CharField('Nombre del pais', max_length=50, blank=False,
null=False)

class TipoDoc(models.Model):
descripcion = models.TextField('Descripcion del tipo de documento', max_length=20,
blank=False, null=False)

class Autor(models.Model):
tipodoc = models.ForeignKey(TipoDoc, on_delete=models.CASCADE, default=None)
documento= models.CharField('Documento de identidad', max_length=16,
blank=False, null=False, primary_key=True)
nombres = models.CharField('Nombre del Autor', max_length=200, blank=False,
null=False, default=None)
107
 apellidos = models.CharField('Apellidos', max_length=200, blank=False, null=False,
default=None)
image = models.ImageField(upload_to='images/', blank=False, default=None)
pais = models.ForeignKey(Paises, on_delete=models.CASCADE, default=None)
estado = models.BooleanField('Activo', default=True, blank=False, null=False)
correo = models.EmailField('Correo Electronico', max_length=254, blank=False,
null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}",
message="Correo inválido")])
telefono = models.CharField('Telefono', max_length=20, blank=False, null=False,
default=None)
fecha_creacion = models.DateField('Fecha de creación', default=timezone.now,
blank=False, null=False)

class Noticia(models.Model):
titulo = models.CharField('Titulo de la noticia', max_length=200, blank=False,
null=False)
descripcion = models.TextField('Descripcion de la noticia', max_length=500,
blank=False, null=False)
fecha = models.DateTimeField('Fecha de creacion', default=timezone.now,
blank=False, null=False)
autor = models.ForeignKey(Autor, to_field=' documento ',
on_delete=models.CASCADE, default=None)
tipo = models.ForeignKey(TipoNoticia, on_delete=models.CASCADE,
default=None)

class Contacto(models.Model):
id = models.AutoField(primary_key=True)
nombreu = models.CharField("Nombres", max_length=200, blank=False, null=False)
correo = models.CharField("Correo Electronico", max_length=200, blank=False,
null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}",
message="Correo inválido")])
mensaje = models.TextField("Mensaje", max_length=400, blank=False, null=False)
fecha_creacion = models.DateField("Fecha de Crecion", auto_now=True, blank=False,
null=False)

__str__()
Un «método mágico» de Python que devuelve una representación de
cadena de cualquier objeto. Esto es lo que usarán Python y Django cada
vez que una instancia de modelo deba ser forzada y mostrada como una
cadena simple. En particular, esto sucede cuando muestra un objeto en
una consola interactiva o en el administrador.

108
7.1.8 Manejo de Imágenes
Añadimos las siguientes líneas en el archivo settings.py

Ahora agregamos la función get_foto en el modelo

109
7.1.9 Creando urls.py de la aplicacion para indicar la vista

Hasta este momento solo hemos construido la vista, ahora para que un usuario vea la
vista, debe asignar un Localizador Uniforme de Recursos (URL) a la vista.
Podemo enlazar la vista con la URL del proyecto, Lo mas recomendable es que la
aplicación tengo su propio archivo urls que acontinuacion lo crearemos:

Escribimos el nombre del Archivo:

En lugar de asignar directamente las URL desde el proyecto a la Apps, podemos

hacer que nuestra app Sea más reutilizable al cambiar la forma que llamamos a
la vista Urls de la app noticias:

110
Ahore escribimos en la Urls del proyecto:

111
7.1.10 Haga que la aplicación Noticias se pueda modificar desde el
sitio administrativo
Para ello, abra el archivo admin.py y edítelo para que se vea de la siguiente
manera:

7.1.11 Administracion Django

Reiniciamos el servidor, Presione en la siguiente URL http://127.0.0.1:800/admin:

112
Ahora ingresamos al panel de administración a través de la URL:
http://127.0.0.1:8000/admin/

Ahora Ingresamos las credenciales:

113
Usted estará utilizando la interfaz de administración podra verificar que los datos se almacenan
correctamente.

114
Ahora Ingresamos un Autor:

115
Observamos el registro añadido:

116
7.1.12 Utilizar verbose_name y verbose_name_plural
Las tablas deben declararse como una forma singular, porque en la página de administración de Django, termina con la
pluralización del nombre de la tabla. Esto se debe a que una tabla es realmente una representación de objetos. Entonces, si
declara un nombre como Comentario, realmente es una colección de Comentarios (por lo que Django lo pluraliza
automáticamente en la página de administración una vez que se crea y registra la tabla de la base de datos.

Por defecto, Django agrega una 's' al nombre de una tabla en la página de administración.

Si crea una tabla de base de datos llamada 'Child' y la registra en el archivo admin.py y va a la página de administración,
verá 'Childs'.

Entonces, hay una manera en Django, puede declarar explícitamente cuál debería ser la forma singular de los objetos de la
base de datos y cuál debería ser la forma plural de los objetos de la base de datos. Y esto se puede hacer usando los
atributos verbose_name y verbose_name_plural.

A continuación, Resolveremos ese problema para nuestros modelos:

117
Modificamos los modelos:

from django.core.validators import RegexValidator

from django.db import models
from django.utils import timezone
from django.utils.safestring import mark_safe

class TipoNoticia(models.Model):
tipo = models.CharField('Tipo de noticias', max_length=30, blank=False, null=False)
descripcion = models.TextField('Descripcion del tipo de noticia', max_length=300, blank=False, null=False)

class Meta:

118
 verbose_name = "Tipo de Noticia"
verbose_name_plural = "Tipos de Noticias"
ordering = ['tipo']

class Paises(models.Model):
codigo = models.CharField(max_length=2, blank=False, null=False, primary_key=True)
Nombre = models.CharField('Nombre del pais', max_length=50, blank=False, null=False)

class Meta:
verbose_name = "Pais"
verbose_name_plural = "Paises"
ordering = ['Nombre']

class TipoDoc(models.Model):
descripcion = models.CharField('Descripcion del tipo de documento', max_length=20, blank=False, null=False)

class Meta:
verbose_name = "Tipo Documento"
verbose_name_plural = "Tipos Documentos"
ordering = ['descripcion']

class Autor(models.Model):
tipodoc = models.ForeignKey(TipoDoc, on_delete=models.CASCADE, default=None)
documento = models.CharField('Documento de identidad', max_length=16, blank=False, null=False, primary_key=True)
nombres = models.CharField('Nombre del Autor', max_length=200, blank=False, null=False, default=None)
apellidos = models.CharField('Apellidos', max_length=200, blank=False, null=False, default=None)

119
 def get_foto(self):
if self.image:
return mark_safe(u'<img src="%s" width="60" height="75"/>' % self.image.url)
else:
return ''
get_foto.short_description = 'Photo'
get_foto.admin_order_field = 'name'

image = models.ImageField(upload_to='images/', blank=False, default=None)

pais = models.ForeignKey(Paises, on_delete=models.CASCADE, default=None)
estado = models.BooleanField('Activo', default=True, blank=False, null=False)
correo = models.EmailField('Correo Electronico', max_length=254, blank=False, null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}", message="Correo inválido")])
telefono = models.CharField('Telefono', max_length=20, blank=False, null=False, default=None)
fecha_creacion = models.DateField('Fecha de creación', default=timezone.now, blank=False, null=False)

class Meta:
verbose_name = "Autor"
verbose_name_plural = "Autores"
ordering = ['nombres', 'apellidos']

class Noticia(models.Model):
titulo = models.CharField('Titulo de la noticia', max_length=200, blank=False, null=False)
descripcion = models.TextField('Descripcion de la noticia', max_length=500, blank=False, null=False)
fecha = models.DateTimeField('Fecha de creacion', default=timezone.now, blank=False, null=False)
autor = models.ForeignKey(Autor, to_field='documento', on_delete=models.CASCADE, default=None)
tipo = models.ForeignKey(TipoNoticia, on_delete=models.CASCADE, default=None)

120
 class Meta:
verbose_name = "Noticia"
verbose_name_plural = "Noticias"
ordering = ['descripcion']

class Contacto(models.Model):
id = models.AutoField(primary_key=True)
nombreu = models.CharField("Nombres", max_length=200, blank=False, null=False)
correo = models.CharField("Correo Electronico", max_length=200, blank=False, null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}", message="Correo inválido")])
mensaje = models.TextField("Mensaje", max_length=400, blank=False, null=False)
fecha_creacion = models.DateField("Fecha de Crecion", auto_now=True, blank=False, null=False)

class Meta:
verbose_name = "Contacto"
verbose_name_plural = "Contactos"
ordering = ['id']

Ahora volveremos a construir la base de datos:

Al ejecutar makemigrations, usted le indica a Django que ha realizado algunos cambios a sus modelos (en este caso, ha
realizado cambios nuevos) y que le gustaría que los guarde como una migración en un archivo py con una numeración de
acuerdo a cada cambio relizadoeste es el primer paso para construir la base de datos con las respectivas tablas.

python manage.py makemigrations

C:\Users\Jorge Nolasco\proyecto1>python manage.py makemigrations

Did you rename autor.nombre to autor.Autores (a CharField)? [y/N] y

121
Migrations for 'noticias':
noticias\migrations\0002_auto_20201013_2009.py
- Change Meta options on autor
- Change Meta options on noticia
- Change Meta options on paises
- Change Meta options on tipodoc
- Change Meta options on tiponoticia
- Rename field nombre on autor to Autores

Django guarda los cambios en sus modelos como migraciones (y por lo tanto en su esquema de base de datos); son solo
archivos en el disco. Usted puede leer la migración para su nuevo modelo si lo desea, es el archivo migrations/
0002_auto_20201013_2009.py . No se preocupe, no se espera que usted las lea cada vez que Django hace una, sino
que están diseñadas para que sean editables en caso de que usted desee modificar manualmente como Django cambia las
cosas.
# Generated by Django 3.1.2 on 2020-10-14 01:09
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('noticias', '0001_initial'),
]
operations = [
migrations.AlterModelOptions(
name='autor',
options={'ordering': ['Autores', 'apellidos'], 'verbose_name': 'Autor', 'verbose_name_plural': 'Autores'},
),
migrations.AlterModelOptions(
name='noticia',
options={'ordering': ['descripcion'], 'verbose_name': 'Noticia', 'verbose_name_plural': 'Noticias'},
122
 ),
migrations.AlterModelOptions(
name='paises',
options={'ordering': ['Nombre'], 'verbose_name': 'Pais', 'verbose_name_plural': 'Paises'},
),
migrations.AlterModelOptions(
name='tipodoc',
options={'ordering': ['descripcion'], 'verbose_name': 'Tipo Documento', 'verbose_name_plural': 'Tipo
Documentos'},
),
migrations.AlterModelOptions(
name='tiponoticia',
options={'ordering': ['tipo'], 'verbose_name': 'Tipo de Noticia', 'verbose_name_plural': 'Tipo de Noticias'},
),
migrations.RenameField(
model_name='autor',
old_name='nombre',
new_name='Autores',
),
]

Hay un comando que ejecutará las migraciones para usted y gestionará el esquema de base de datos automáticamente; este
se denomina migrate, y hablaremos de ello en un momento, pero primero, vamos a ver cuál SQL esa migración ejecutaría . El
comando sqlmigrate recibe nombres de migración y devuelve su SQL:
python manage.py sqlmigrate noticias 0002

C:\Users\Jorge Nolasco\proyecto1>python manage.py sqlmigrate noticias 0002

BEGIN;
--
-- Change Meta options on autor
123
--
--
-- Change Meta options on noticia
--
--
-- Change Meta options on paises
--
--
-- Change Meta options on tipodoc
--
--
-- Change Meta options on tiponoticia
--
--
-- Rename field nombre on autor to Autores
--
ALTER TABLE "noticias_autor" RENAME COLUMN "nombre" TO "Autores";
COMMIT;

A continuación, ejecute de nuevo el comando migrate para crear esas tablas modelos en su base de datos:

python manage.py migrate

C:\Users\Jorge Nolasco\proyecto1>python manage.py migrate

Operations to perform:
Apply all migrations: admin, auth, contenttypes, noticias, sessions
Running migrations:
124
Applying noticias.0002_auto_20201013_2009... OK

125
7.1.13 Utilizar __str__()

Un «método mágico» de Python que devuelve una representación de cadena de

cualquier objeto. Esto es lo que usarán Python y Django cada vez que una
instancia de modelo deba ser forzada y mostrada como una cadena simple. En
particular, esto sucede cuando muestra un objeto en una consola interactiva o en
el administrador.

from django.core.validators import RegexValidator

from django.db import models
from django.utils import timezone
from django.utils.safestring import mark_safe

class TipoNoticia(models.Model):
tipo = models.CharField('Tipo de noticias', max_length=30, blank=False, null=False)
descripcion = models.TextField('Descripcion del tipo de noticia', max_length=300,
blank=False, null=False)

class Meta:
verbose_name = "Tipo de Noticia"
verbose_name_plural = "Tipos de Noticias"
ordering = ['tipo']

def __str__(self):
return '%s %s' % (self.tipo,self.descripcion)

class Paises(models.Model):
codigo = models.CharField(max_length=2, blank=False, null=False,
primary_key=True)
Nombre = models.CharField('Nombre del pais', max_length=50, blank=False,
null=False)

class Meta:
verbose_name = "Pais"
verbose_name_plural = "Paises"
ordering = ['Nombre']

def __str__(self):
return '%s %s' % (self.codigo,self.Nombre)

class TipoDoc(models.Model):
descripcion = models.CharField('Descripcion del tipo de documento',
max_length=20, blank=False, null=False)
126
 class Meta:
verbose_name = "Tipo Documento"
verbose_name_plural = "Tipos Documentos"
ordering = ['descripcion']

def __str__(self):
return '%s' % (self.descripcion)

class Autor(models.Model):
tipodoc = models.ForeignKey(TipoDoc, on_delete=models.CASCADE, default=None)
documento = models.CharField('Documento de identidad', max_length=16,
blank=False, null=False, primary_key=True)
nombres = models.CharField('Nombre del Autor', max_length=200, blank=False,
null=False, default=None)
apellidos = models.CharField('Apellidos', max_length=200, blank=False, null=False,
default=None)

def get_foto(self):
if self.image:
return mark_safe(u'<img src="%s" width="60" height="75"/>' %
self.image.url)
else:
return ''
get_foto.short_description = 'Photo'
get_foto.admin_order_field = 'name'

image = models.ImageField(upload_to='images/', blank=False, default=None)

pais = models.ForeignKey(Paises, on_delete=models.CASCADE, default=None)
estado = models.BooleanField('Activo', default=True, blank=False, null=False)
correo = models.EmailField('Correo Electronico', max_length=254, blank=False,
null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}",
message="Correo inválido")])
telefono = models.CharField('Telefono', max_length=20, blank=False, null=False,
default=None)
fecha_creacion = models.DateField('Fecha de creación', default=timezone.now,
blank=False, null=False)

class Meta:
verbose_name = "Autor"
verbose_name_plural = "Autores"
ordering = ['nombres', 'apellidos']

127
 def __str__(self):
return '%s %s %s %s %s' %
(self.tipodoc,self.documento,self.nombres,self.apellidos,self.image)

class Noticia(models.Model):
titulo = models.CharField('Titulo de la noticia', max_length=200, blank=False,
null=False)
descripcion = models.TextField('Descripcion de la noticia', max_length=500,
blank=False, null=False)
fecha = models.DateTimeField('Fecha de creacion', default=timezone.now,
blank=False, null=False)
autor = models.ForeignKey(Autor, to_field='documento',
on_delete=models.CASCADE, default=None)
tipo = models.ForeignKey(TipoNoticia, on_delete=models.CASCADE, default=None)

class Meta:
verbose_name = "Noticia"
verbose_name_plural = "Noticias"
ordering = ['descripcion']

def __str__(self):
return '%s %s %s' % (self.titulo,self.descripcion,self.fecha)

class Contacto(models.Model):
id = models.AutoField(primary_key=True)
nombreu = models.CharField("Nombres", max_length=200, blank=False, null=False)
correo = models.CharField("Correo Electronico", max_length=200, blank=False,
null=False, default=None,
validators=[RegexValidator(regex=r"\S{1,}@\S{2,}\.\S{2,}",
message="Correo inválido")])
mensaje = models.TextField("Mensaje", max_length=400, blank=False, null=False)
fecha_creacion = models.DateField("Fecha de Crecion", auto_now=True, blank=False,
null=False)

class Meta:
verbose_name = "Contacto"
verbose_name_plural = "Contactos"
ordering = ['id']

def __str__(self):
return '%s %s %s %s' % (self.id,self.nombreu,self.correo,self.mensaje)

128
7.1.14 The Django admin site
7.1.14.1 list_display
Podemos personalizar el listado de los modelos mediante el atributo: list_display. A
continuación, modificamos nuestro modelo:

from django.contrib import admin

from .models import TipoNoticia, Paises, TipoDoc, Autor, Noticia, Contacto

class TipoNoticiaAdmin(admin.ModelAdmin):
list_display = ('tipo', 'descripcion')

class PaisesAdmin(admin.ModelAdmin):
list_display = ('codigo', 'Nombre')

class TipoDocAdmin(admin.ModelAdmin):
list_display = ('id','descripcion')

class AutorAdmin(admin.ModelAdmin):
list_display = ('tipodoc', 'documento', 'nombres', 'apellidos', 'image')

class NoticiaAdmin(admin.ModelAdmin):
list_display = ('titulo', 'descripcion', 'fecha')

class ContactoAdmin(admin.ModelAdmin):
list_display = ('id', 'nombreu', 'correo', 'mensaje')

admin.site.register(TipoNoticia, TipoNoticiaAdmin)
admin.site.register(Paises,PaisesAdmin)
admin.site.register(TipoDoc,TipoDocAdmin)
admin.site.register(Autor, AutorAdmin)
admin.site.register(Noticia, NoticiaAdmin)
admin.site.register(Contacto, ContactoAdmin)

129
7.1.14.2 Agregando Filtro (list_filte)
Una vez que tenga muchos elementos en una lista, puede ser útil poder filtrar qué
elementos se muestran. A continuación, modificamos nuestro modelo:

from django.contrib import admin

from .models import TipoNoticia, Paises, TipoDoc, Autor, Noticia, Contacto

class TipoNoticiaAdmin(admin.ModelAdmin):
list_display = ('tipo', 'descripcion')
list_filter = ('tipo', 'descripcion')
class PaisesAdmin(admin.ModelAdmin):
list_display = ('codigo', 'Nombre')
list_filter = ('codigo', 'Nombre')
class TipoDocAdmin(admin.ModelAdmin):
list_display = ('id','descripcion')
list_filter = ('id','descripcion')
class AutorAdmin(admin.ModelAdmin):
list_display = ('tipodoc', 'documento', 'nombres', 'apellidos', 'get_foto')
list_filter = ('documento', 'nombres', 'apellidos')
class NoticiaAdmin(admin.ModelAdmin):
list_display = ('titulo', 'descripcion', 'fecha')
list_filter = ('titulo', 'descripcion')
class ContactoAdmin(admin.ModelAdmin):
list_display = ('id', 'nombreu', 'correo', 'mensaje')
list_display = ('nombreu', 'correo')
admin.site.register(TipoNoticia, TipoNoticiaAdmin)
admin.site.register(Paises,PaisesAdmin)
admin.site.register(TipoDoc,TipoDocAdmin)
admin.site.register(Autor, AutorAdmin)
admin.site.register(Noticia, NoticiaAdmin)
admin.site.register(Contacto, ContactoAdmin)

130
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

Ahora ingresamos al panel de administración a través de la URL:

http://127.0.0.1:8000/admin/

131
Ahora Ingresamos las credenciales:

Usted estará utilizando la interfaz de administración podra verificar

que los datos se almacenan correctamente.

132
Ahora Ingresamos algunos registros en la tabla autor:

133
134
7.1.15 Gestion de Permisos
Django proporciona un sistema de autenticación y autorización ("permisos"), el
cual le permite verificar credenciales de usuario y definir que acciones puede
realizar cada usuario.
Django incluye modelos para Users y Groups (una forma genérica de aplicar
permisos a más de un usuario a la vez), permisos/indicadores (permissions/flags)
que designan si un usuario puede realizar una tarea.
En proyectos reales tenemos muchos usuarios, algunso cuenta con permisos
diversos como: listar, crear, editar o eliminar elementos de la base de datos.
Vamos a crear ingresar a la consola de administración:

Ahora vamos a crear un usuario que solo podrá ver autores, para deberemos
crear el usuario: user_ver_autor:

135
Escribimos el nombre del usuario y su contraseño:

Ahora observamos que el usuario fue agregado correctamente:

136
Ahora complete la información complementaria y active la casilla Es staff:

137
A continuacion definimos los permisos:

138
No se olvide de guardar los cambios:

139
Ahora puede probar acceder con el usuario creado:

Ahora observamos que solo tenemos acceso a ver los autores:

140
141
Capítulo 8 Vistas

142
8.1.1 Que son las Vistas
Una vista es una función que hace una solicitud Web y devuelve una respuesta
en una pagina web, un error 404, o culquier dato.
La vista contiene toda la lógica necesaria para devolver una respuesta, todas
estas respuestas se encuentran en un archivo: views.py, que se encuentra dentro
de cada aplicación de Django.

Las Vistas no tiene nada que ver con el estilo de la

presentación de los datos, solo se encarga de los datos

8.1.2 Modificando la vista : views.py

Hacemos referencia a un método de un modulo que permita atender a

peticiones web:

En nuestra app principal, vamos a crear una vista sencilla. vamos a retornar una
cadena al cliente:
views.py

143
Explicaremos el código anterior línea a línea:

from django.shortcuts import render

importamos la clase HttpResponse, la cual pertenece al módulo django.http.
HttpRequest representa una sola petición HTTP desde algún agente de usuario
from django.http import HttpResponse
importamos la clase HttpResponse, la cual pertenece al módulo django.http

def index(request):

return HttpResponse(“Index Principal”)

El objeto HttpResponse es utilizado para retornar el

contenido de la página solicitada levantar una
excepción como Http404 .

144
8.1.3 Modificando la urls.py del proyecto1 para indicar la vista
Hasta este momento solo hemos construido la vista, ahora para que un usuario
vea la
vista, debe asignar un Localizador Uniforme de Recursos (URL) a la vista.

Para enlazar la vista con la URL abra urls.py ubicado en el directorio de su

proyecto y agregue el siguiente código:

145
En lugar de asignar directamente las URL desde el proyecto a la Apps, podemos
hacer que nuestra app sea más reutilizable al cambiar la forma que llamamos a
la vista:
Urls.py

El objeto HttpResponse es utilizado para retornar el contenido de

la página solicitada levantar una excepción como Http404 .

146
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

147
8.1.4 Vistas Adicionales
Ahora vamos a crear algunas vistas adicionales:

Llamamos a las vistas nuevas:

Urls.py

148
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

149
150
8.1.5 Formato de Cadenas
El formato con str.format() permite fijar la longitud de una cadena, aplicar
formatos numéricos, establecer la alineación, tabular datos y rellenar espacios
con un determinado carácter:
Formato1.py
#programa : Formato1.py
#autor : jorge nolasco valenzuela
#fecha : 01-05-2020
"""
descripcion : este programa muestra
el uso de formatos de cadena
"""
#variables numericas
numero1=8.67676767
numero2=9.00000001
numero3=1200.09001
numero4=90
numero5=100
numero6=110
"""
mostrar variables
con formato decimal
"""
print("{0:.2f}".format(numero1))
print("{0:f}".format(numero1))
print("{0:.2f} {1:.3f} {2:.4f}".format(numero1,numero2,numero3))
"""
mostrar variables
con formato entero
"""
print("{:d}".format(numero4))
print("{:d}".format(numero5))
print("{:d}".format(numero6))
"""
mostrar variables
con formato entero
y espaciados
"""
print("{:10d}".format(numero4))
print("{:9d}".format(numero5))
print("{:8d}".format(numero6))
#variables cadenas
cadena1="hola"
cadena2="amigos"
"""
mostrar cadenas
especificando el orden
"""
print("{1}{0}".format(cadena1,cadena2))
print("{1:8}{0}".format(cadena1,cadena2))
print("{0:8}{1}".format(cadena1,cadena2))
151
"""
mostrar cadenas
rellenando
"""
#derecha
print("{:_<10}".format(cadena1))
#izquierda
print("{:_>10}".format(cadena1))
#izquierda y derecha
print("{:_^10}".format(cadena1))
8.68
8.676768
8.68 9.000 1200.0900
90
100
110
90
100
110
amigoshola
amigos hola
hola amigos
hola______
______hola
___hola___
8.1.6Pasando Argumento
Ahora por ejemplo deseamos pasar n argumento a la Pagina 2 , Modificamos la
vista:
views.py

8.1.7Modifcando archivo urls.py:

Urls.py

152
Capítulo 9 Template y
Plantillas

153
9.1.1 lenguaje de plantilla de Django

Para acelerar el desarrollo de aplicaciones Django posee un lenguaje de plantillas

para lograr flexibilidad, equilibrio y facilidad y con la filosofía de no repetir el
código.
9.1.1.1 Plantillas

Una plantilla es simplemente un archivo de texto. Puede generar cualquier

formato basado en texto (HTML, XML, CSV, etc.).
Una plantilla contiene variables, que se reemplazan con valores cuando se
evalúa la plantilla, y etiquetas, que controlan la lógica de la plantilla.
A continuación, se muestra un ejemplo:
{% extends "base_generic.html" %}

{% block title %}{{ section.title }}{% endblock %}

{% block content %}
<h1>{{ section.title }}</h1>

{% for story in story_list %}

<h2>
<a href="{{ story.get_absolute_url }}">
{{ story.headline|upper }}
</a>
</h2>
<p>{{ story.tease|truncatewords:"100" }}</p>
{% endfor %}
{% endblock %}
154
9.1.1.2 Manejo de Solicitudes
Así es como se maneja una solicitud:
1.Se solicita una URL. - El usuario solicita una página web a través de URL en su
navegador. El servidor web recibe esta solicitud y la pasa a Django.

2.Se llama al middleware. - Django tiene un mecanismo especial llamado

middleware que le permite llamar a funcionas en varios lugares en este ciclo de
solicitud-respuesta.

3.Se evalúa la URL. - El dispatcher de URL de Django compara la URL solicitada

con una lista de patrones (regular expresiones, para ser exactos). Si se encuentra
una coincidencia, Django importa y llama a la vista que está asociado con el
patrón. Este proceso se conoce como resolución de URL.

4.El middleware es llamado nuevamente. - Si tiene funciones de middleware para

ejecutar después de la resolución de URL, pero antes de la vista se ejecuta.

5.La vista es llamada. - La mayoría de las vistas utilizarán la API de la base de

datos para realizar algún tipo de CRUD (crear, recuperar, actualizar y eliminar)
operación, cargar una plantilla, representar el resultado, y enviarlo de vuelta al
usuario.

6.El objeto de plantilla y el archivo de plantilla se cargan. - Se llama al objeto de

plantilla y se obtiene el archivo de plantilla apropiado del archivo sistema en la
ubicación especificada en la vista.

7.Se presenta la plantilla. - Se representa el texto dentro de la plantilla. Los

marcadores de posición se reemplazan con sus datos asociados y declaraciones
de lógica de plantilla.

8.Se llama al middleware (una vez más). - Si tiene funciones de middleware para
ejecutar después de que se genera la respuesta, pero antes se envía de vuelta al
usuario, se les llama en este paso

155
9. La salida se envía al navegador. - La plantilla renderizada es empaqueta con
el formato que necesita el navegador para entender cómo aceptar y mostrar la
página.
9.1.1.3 Variables
Las variables se ven así:
{{variable}}

Cuando el motor de plantillas encuentra una variable, evalúa esa variable y la

reemplaza con el resultado.

Los nombres de las variables consisten en cualquier combinación de caracteres

alfanuméricos y el guión bajo ("_") pero no pueden comenzar con un guión bajo.

Es importante destacar que no puede tener espacios o caracteres de puntuación

en nombres de variables

Use un punto ( .) para acceder a los atributos de una variable.A continuación

mostramos un ejemplo:

9.1.1.4 Filtros
Los filtros pueden formatear la salida de variables en las plantillas de Django.
Se identifican por El uso del símbolo: | inmediatamente después de una variable
de plantilla:
Los filtros se parecen a esto:

{{ name|lower }}

Los filtros se pueden encadenarse:

{{ text|escape|linebreaks }}

Por ejemplo, mostrar los 30 primeros caracteres de ka variable bio:

{{ bio|truncatewords:30 }}

Django proporciona alrededor de sesenta filtros de plantilla incorporados aquí

algunos:

9.1.1.4.1 add
Agrega el argumento al valor.
Por ejemplo:

{{ value|add:"2" }}

Si value es así 4, entonces la salida será 6.

156
9.1.1.4.2 addslashes
Agrega barras diagonales antes de las comillas. Útil para escapar de cadenas en
CSV, por ejemplo.
Por ejemplo:
{{ value|addslashes }}
Si value es ."I'm using Django" la salida será "I\'m using Django"
9.1.1.4.3 capfirst

Capitaliza el primer carácter del valor. Si el primer carácter no es una letra, este
filtro no tiene efecto.

Por ejemplo:

{{ value|capfirst }}
Si value es "django", la salida será "Django".

9.1.1.4.4 center

Centra el valor en un campo de un ancho dado.

Por ejemplo:

"{{ value|center:"15" }}"

Si value es "Django", la salida será ." Django "

9.1.1.4.5 cut

Elimina todos los valores de arg de la cadena dada.

Por ejemplo:

{{ value|cut:" " }}

Si value "String with spaces" la salida sera "Stringwithspaces"

9.1.1.4.6 date

Formatea una fecha de acuerdo con el formato dado.

Utiliza un formato similar a la date()función de PHP ( https://php.net/date ) con

algunas diferencias.

Por ejemplo:

{{ value|date:"D d M Y" }}

Si value es un datetime, la salida será la cadena .'Wed 09 Jan 2008

157
9.1.1.4.7 divisibleby

Devuelve Truesi el valor es divisible por el argumento.

Por ejemplo:

{{ value|divisibleby:"3" }}

Si value es 21, la salida sería True.

9.1.1.4.8 first

Devuelve el primer elemento de una lista.

Por ejemplo:

{{ value|first }}

Si value es la lista ['a', 'b', 'c'], la salida será 'a'

9.1.1.4.9 last

Devuelve el último elemento de una lista.

Por ejemplo:

{{ value|last }}

Si value es la lista .['a', 'b', 'c', 'd'] , la salida será la cadena "d"

9.1.1.4.10 length

Devuelve la longitud del valor. Esto funciona tanto para cadenas como para listas.

Por ejemplo:

{{ value|length }}

Si value es la lista ['a', 'b', 'c', 'd'] la salida será 4

9.1.1.4.11 linenumbers

Muestra texto con números de línea.

Por ejemplo:

{{ value|linenumbers }}

Si value es:

158
one
two
three
la salida será:
1. one
2. two
3. three
9.1.1.4.12 lower

Convierte una cadena en minúsculas.

Por ejemplo:

{{ value|lower }}

Si value es LOVING la salida será loving

9.1.1.4.13random

Devuelve un elemento aleatorio de la lista dada.

Por ejemplo:

{{ value|random }}

Si value es una lista ['a', 'b', 'c', 'd'] , la salida podría ser "b"

9.1.1.4.14 time

Formatea un tiempo de acuerdo con el formato dado.

El formato dado puede ser el predefinido TIME_FORMAT, o un formato

personalizado, igual que el datefiltro. Tenga en cuenta que el formato predefinido
depende de la configuración regional.

Por ejemplo:

{{ value|time:"H:i" }}

Si value es un datetime.datetime.now(), la salida será la cadena "01:23".

Puede consultar Etiquetas y filtros de plantilla incorporados:

https://docs.djangoproject.com/en/3.0/ref/templates/builtins/#ref-templates-builtins-filters

159
9.1.1.5 Valores por defectos
Si una variable posee el valor false o está vacía, use los valores predeterminados
dados:

{{ value|default:"nothing" }}

9.1.1.6 Etiquetas

Son aquellas que crean texto en la salida, algunas controlan el flujo realizando
bucles o lógica, y otras cargan información externa en la plantilla para ser
utilizada por variables posteriores.

{% tag %}

Algunas etiquetas requieren etiquetas iniciales y finales (es

decir ).{% tag %} ... tag contents ... {% endtag %}

Django viene con aproximadamente dos docenas de etiquetas de plantilla

incorporadas. Puede leer todo sobre ellos en la referencia de etiqueta
incorporada . Para darle una idea de lo que está disponible, estas son algunas de
las etiquetas más utilizadas:

Algunas etiquetas requieren etiquetas de inicio y final:

{% tag %} ... tag contents ... {% endtag %}

9.1.1.7 For
Bucle sobre cada elemento en una matriz. Por ejemplo, para mostrar una lista de
atletas:

<ul>
{% for atletas in lista %}
<li>{{ atletas.name }}</li>
{% endfor %}
</ul>
9.1.1.8 if, elif y else

Evalúa una variable, y si esa variable es "verdadera", se muestran los

contenidos del bloque:
{% if lista %}
Numero de atletas: {{ lista|length }}
{% else %}
No atletas.
{% endif %}

160
9.1.2 Configuración de la carpeta Template
Configurando la plantilla para que sea reconocida; abrimos el archivo
proyecto/proyecto/settings.py buscamos la propiedad TEMPLATES y
modificamos:
settings.py

9.1.3 Creacion de Templates

El diseño de páginas dentro de un sitio web es regularmente el mismo, promueve
la organización del sitio web y refuerza su continuidad. Ahora procedemos a crear
una plantilla y configurando página de inicio del sitio web. Dentro de la carpeta
templates y dentro de esta se crean los archivos base.html e index.html (página
inicial).
9.1.4 Añadiendo las Plantillas
Primero deberas crear un directorio templates:

161
9.1.5 Creando base.html

Dentro de templates otra carpeta con el mismo nombre de la Apps:

Ahora en la misma carpeta el archivo base.html:

base.html

162
9.1.6 Usando Plantilla
La parte más poderosa, y por lo tanto la más compleja, del motor de plantillas de
Django es la herencia de plantillas. La herencia de plantillas le permite crear una
plantilla de "esqueleto" base que contiene todos los elementos comunes de su
sitio y define bloques que las plantillas secundarias pueden anular.

Es más fácil comprender la herencia de plantillas comenzando con un

ejemplo:

<!DOCTYPE html>
<html lang="en">
<head>
<link rel="stylesheet" href="style.css">
<title>{% block title %}My amazing site{% endblock %}</title>
</head>

<body>
<div id="sidebar">
{% block sidebar %}
<ul>
<li><a href="/">Home</a></li>
<li><a href="/blog/">Blog</a></li>
</ul>
{% endblock %}
</div>

<div id="content">
{% block content %}{% endblock %}
</div>
</body>
</html>
Fuente:
https://docs.djangoproject.com/en/2.2/ref/templates/language/#template-
inheritance

163
9.1.7 Explicacion de Bloques de la Plantilla

164
9.1.8 Nuestra Plantilla Base

165
9.1.9 Carpeta Static
En algunas oportunidades necesitamos archivos adicionales como imágenes, JavaScript
o CSS. En Django, nos referimos a estos archivos como "archivos estáticos". Para ello
crearemmos la siguiente carpeta:

166
9.1.10 Utilizando la Plantilla
Ahora crearemos la siguiente vista, utilizando render para indicar que un html genera la
vista:

9.1.11 Modificando urls.py de la aplicacion para indicar la vista

En lugar de asignar directamente las URL desde el proyecto a la Apps, podemos

hacer que nuestra app Sea más reutilizable al cambiar la forma que llamamos a
la vista Urls de la app noticias:

167
Ahore escribimos en la Urls del proyecto:

168
169
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

170
9.1.12 Listado de Noticias
Ahora crearemos un listado de las Noticias.

listado.html

<html lang="es">
<head>
<link rel="stylesheet" href="style.css">
<title>{% block title %}Noticias{% endblock %}</title>
</head>

<body>
<div id="sidebar">
{% block sidebar %}
<ul>
<li><a href="">Portada</a></li>
<li><a href="">Noticias</a></li>
<li><a href="">Contactanos</a></li>
</ul>
{% endblock %}
</div>

<div id="content">
<ul>
{% for p in nots %}
<li>
<p>titulo:{{p.titulo}}</p>
<p>descripcion:{{p.descripcion}}</p>
</li>
{% endfor %}

</ul>
</div>
</body>
</html>

171
9.1.13 Creamos la función noticias en la vista

9.1.14 Modificamos el archivo urls de la aplicación noticias

172
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

173
9.1.15 Listado de Noticias en base a una Plantilla
Ahora crearemos un listado de las Noticias en base a base.html.
Creamo el archivo html: noticias_listado.html

Indicamos su nombre:

174
Modificamos el contenido del archivo:
Noticias_listado.html
{% extends 'noticias/base.html' %}
{% block title %}Listado de Noticias{% endblock %}
{% block content %}
<h1>Listado de Noticias</h1>
<ul>
{% for p in nots %}
<li>
<p>Titulo:{{p.titulo}}</p>
<p>Descripcion:{{p.descripcion}}</p>
<p>Fecha:{{p.fecha}}</p>
<p>Autor:{{p.autor.Autores}}</p>
<p>Tipo:{{p.tipo.tipo}}</p>
</li>
<hr>
{% endfor %}
</ul>
{% endblock %}

9.1.16 Modificamos la función noticias

La forma más sencilla de recuperar los registros de la tabla Noticia es utilizar:
Noticia.objects.all()

175
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

176
177
9.1.17 Numero de Registros de Noticia
Ahora queremos mostrar el numero de noticias publicadas, para ello La forma más
sencilla de recuperar el numero de registros de la tabla Noticia es utilizar:
Noticia.objects.count()

Ahora debemos modificar: Noticias_listado.html para añadir el numero de noticias:

178
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

179
9.1.18 Contáctenos en base a una Plantilla
Ahora crearemos un formulario para recibir comentarios y sugerencia base a base.html.
Creamos el archivo html: noticias_contactenos.html

Indicamos su nombre:

180
Modificamos el contenido del archivo:
Noticias_contactenos.html
{% extends 'noticias/base.html' %}
{% block title %}
Contactanos
{% endblock title%}

{% block content %}
<h1>Contactate con nosotros</h1>
<br>
<form method="post">
{% csrf_token %}

{% if error %}
<h2>{{ error }}</h2>
{% else %}
<div>
<strong>Dejanos tu Mensaje</strong>
</div>
<div>
<form action="#" method="post">
<div>
<label>Nombres</label>
<input type="text" name="nombreu">
</div>
<div>
<label>Correo</label>
<input type="text" name="correo">
</div>
<div>
<label>Mensaje</label>
<input type="text" name="mensaje">
</div>

181
 <div>
<button type="submit">Enviar</button>
<button type="reset">Cancelar</button>
</div>
</form>
</div>
</div>

{% endif %}

</form>
{% endblock%}

9.1.19 Creamos la función contactanos en las vistas

182
9.1.20 Portada en base a una Plantilla
Ahora crearemos una pagina para la portada principal en base a base.html.
Creamo el archivo html: noticias_portada.html

Indicamos su nombre:

183
Modificamos el contenido del archivo:
Noticias_portada.html
{% extends 'noticias/base.html' %}
{% block title %}Portada{% endblock %}
{% block content %}
<h1>Pagina Principal</h1>
<h2>Autor : Jorge Santiago Nolasco Valenzuela</h2>
{% endblock %}

9.1.21 Creamos la función contactanos en la vista

184
9.1.22 QuerySet Referencia de API
La API QuerySet de Django proporciona una amplia gama de métodos y funciones para
trabajar con datos. A continuación, describimos los diferentes métodos para el
tratamiento de datos:

Ahora accedemos al Shell:

python manage.py shell

Ahora accedemos al modelo Autor:

from noticias.models import Autor

Ahora accedemos a los registros del modelo Autor:

Autor.objects.all()

185
Ahora recuperamos el registro cuyo documento es 09668210:

x=Autor.objects.get(pk='09668210')

Mostrando valores:

x.doc
x.apellidos

186
Ahora cambiaremos el apellido nolasco por nolasco valenzuela:

Observamos el cambio realizados:

9.1.23 Modificamos la función contactanos en las vistas

from django.shortcuts import render, redirect

# Create your views here.

from noticias.models import Noticia,Contacto

def Home(request):
return render(request,'noticias/base.html')

def Portada(request):
return render(request,'noticias/noticias_portada.html')

def noticias(request):
nots = Noticia.objects.all()
registros=Noticia.objects.count()
return render(request,'noticias/noticias_listado.html',
{'nots':nots,'registros':registros})

187
def contactenos(request):
if request.method == 'POST':
nm = request.POST.get('nombreu')
email = request.POST.get('correo')
txt = request.POST.get('mensaje')
print(nm, email, txt)
contacto = Contacto(nombreu=nm, correo=email, mensaje=txt)
contacto.save()
return redirect('portada')
return render(request,'noticias/noticias_contactenos.html',)

Modificamos el archivo urls del proyecto

188
9.1.24 Modificamos el archivo urls de la aplicación noticias

Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

189
Portada

Noticias

190
Contactenos

9.1.25 Utilizando Template tag {% url %}

Este tag nos permite hacer referencia directamente a una view desde nuestros
templates. Primero observe los names del archivo urls.py:

191
Para ello modificaremos nuestro template base.html:

Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

192
Portada

Noticias

193
Contactenos

194
Capítulo 10 Formularios

195
10.1.1 Formularios

El manejo de formularios es un asunto complejo. Considere al administrador de Django,

donde es posible que se deban preparar numerosos elementos de datos de varios tipos
diferentes para mostrarlos en un formulario, representarlos como HTML, editarlos usando
una interfaz conveniente, devolverlos al servidor, validarlos y limpiarlos, y luego
guardarlos o transmitirlos. para su posterior procesamiento.

La funcionalidad de formulario de Django puede simplificar y automatizar grandes

porciones de este trabajo, y también puede hacerlo de manera más segura de lo que la
mayoría de los programadores podrían hacerlo con el código que ellos mismos
escribieron.

Django maneja tres partes distintas del trabajo involucrado en formularios:

• preparar y reestructurar los datos para que estén listos para la renderización
• creando formularios HTML para los datos
• recibir y procesar formularios y datos enviados por el cliente

10.1.2 The Django Form class

En el corazón de este sistema de componentes está la Formclase de Django . De la

misma manera que un modelo de Django describe la estructura lógica de un objeto, su
comportamiento y la forma en que se nos representan sus partes, una Formclase
describe un formulario y determina cómo funciona y aparece.

De manera similar a como los campos de una clase modelo se asignan a los campos de
la base de datos, los campos de una clase de formulario se asignan a <input>elementos
de formulario HTML . (A ModelForm asigna los campos de una clase modelo
a <input>elementos de formulario HTML a través de a Form; esto es en lo que se basa
el administrador de Django).

Los campos de un formulario son en sí mismos clases; administran los datos del
formulario y realizan la validación cuando se envía un
formulario. A DateFieldy A FileFieldmanejan tipos de datos muy diferentes y tienen que
hacer cosas diferentes con ellos.

Un campo de formulario se representa para un usuario en el navegador como un "widget"

HTML, una pieza de maquinaria de interfaz de usuario. Cada tipo de campo tiene
una clase de widget predeterminada adecuada , pero estos se pueden anular según sea
necesario.

196
10.1.3 Creando nuestro primer Formulario
Primero vamos a crear una pagina HTML para insertar nuevos Tipos de Noticias:
cick derecho en noticias – new – HTML File:

197
Ahora modificamos el HTML:
nuevoTipoNoticia.html
{% extends 'noticias/base.html' %}
{% block title %}Tipo de Noticia{% endblock %}
{% block content %}
<h1>Nuevo Tipo de Noticia</h1>
<form method="post">
{% csrf_token %}
{% if error %}
<h2>{{ error }}</h2>
{% else %}
<div>
<strong>Dejanos tu Mensaje</strong>
</div>
<div>
<form action="#" method="post">
<div>
<label>Tipo de Noticia</label>
<input type="text" name="tipo">
</div>
<div>
<label>Descripcion de la Noticia</label>
<input type="text" name="descripcion">
</div>
<div>
<button type="submit">Enviar</button>
<button type="reset">Cancelar</button>
</div>
</form>
</div>
</div>
{% endif %}
</form>
{% endblock %}

198
Para crear nuestro primer formulario, cick derecho en noticias – new – Python File:

Escribimos el nombre: forms

199
10.1.4 Creamos la función nuevoTipoNoticia en la vista
from django.shortcuts import render, redirect
from noticias.models import Noticia,Contacto
from .forms import forms, TipoNoticiaForm
from .models import TipoNoticia

def Home(request):
return render(request,'noticias/base.html')

def Portada(request):
return render(request,'noticias/noticias_portada.html')

def noticias(request):
nots = Noticia.objects.all()
registros=Noticia.objects.count()
return render(request,'noticias/noticias_listado.html',
{'nots':nots,'registros':registros})

def contactenos(request):
if request.method == 'POST':
nm = request.POST.get('nombreu')
email = request.POST.get('correo')
txt = request.POST.get('mensaje')
print(nm, email, txt)
contacto = Contacto(nombreu=nm, correo=email, mensaje=txt)
contacto.save()
return redirect('portada')
return render(request,'noticias/noticias_contactenos.html',)

def nuevoTipoNoticia(request):
if request.method == 'POST':
tip = request.POST.get('tipo')
des = request.POST.get('descripcion')
print(tip,des)
tipoNoticia = TipoNoticia(tipo=tip, descripcion=des)
tipoNoticia.save()
return redirect('portada')
return render(request,'noticias/nuevoTipoNoticia.html')

200
10.1.5 Modificamos el archivo urls de la aplicación noticias

Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

201
Agregamos un Tipo de Noticia

202
Capítulo 11 Despliegue

203
11.1.1 Heroku
Heroku es un PaaS (Platform as a Service) que nos permite desplegar nuestras
aplicaciones sin preocuparnos por la infraestructura, soportando además múltiples
lenguajes de programación. Todos los servicios que ofrece Heroku están orientados a
startups o pequeñas empresas.
Utiliza contenedores Linux, llamados dynos para alojar las aplicaciones, así mismo
cuenta con la posibilidad de agregar funcionalidades nuevas mediante add-ons.
11.1.2 Crear cuenta Heroku
En este capitulo vamos a realizar el deploy de nuestra aplicación a travez de heroku.
Lo primero es crear una cuenta en Heroku. Tiene una capa gratuita que es suficiente
para hacer pruebas.
Ingrese en la siguiente URL: https://www.heroku.com/

Realizar el registro correspondiente:

204
11.1.3 Git

Llevar un control del código y como se accede a las versiones anteriores era un dolor de
cabeza para los desarrolladores, en conclusión, como controlar el código fuente para ello
se utiliza sistemas de control de versiones como Microsoft SourceSafe, subversión y
ahora Git diseñado por Linus Torvalds, pensando en la eficiencia y la confiabilidad del
mantenimiento de versiones de las aplicaciones
11.2Que es Git y GitHub

Existen varios sistemas de control de versiones como CVS (Current Versions System),
Subversión, mercurial, Bazaar y Git que es en la actualidad es uno de los más populares
utilizados regularmente por: Google, Facebook, Microsoft, twitter, netflix, etc.
Github es una plataforma de desarrollo colaborativo de software para alojar
proyectos usando el sistema de control de versiones Git. El código se almacena de forma
pública, aunque también se puede hacer de forma privada, creando una cuenta de pago.
También se pueden obtener repositorios privados (de pago) si se es estudiante.
Github no sólo ofrece alojamiento del código si no muchas más posibilidades asociadas
a los repos como son, forks, issues, pull requests, diffs, etc.

La diferencia entre Git y los otros Sistema de Control de Versiones ,

la mayoría de los otros almacenan información como una lista de
cambios basados en archivos Git piensa más como un conjunto de
instantáneas de un sistema de archivos. Cada vez que confirma o
guardar el estado de su proyecto en Git, que básicamente toma una
foto de lo que todos sus archivos se parecen en ese momento y
almacena una referencia a esa instantánea.

205
11.3 Mis Primeros Pasos con GitHub
Antes de iniciar es importante descargar git del siguiente link:http://git-
scm.com/downloads

Una vez descargado comenzaremos a instalarlo, presionamos el botón Next

(Siguiente):

206
Carpeta o lugar de Instalación, presionamos el botón Next (Siguiente):

Elegir los componentes a instalar, presionamos el botón Next (Siguiente):

207
presionamos el botón Next (Siguiente):

presionamos el botón Next (Siguiente):

208
Seleccionamos la opción por defecto presionamos el botón Next (Siguiente):

Seleccionamos la opción por defecto presionamos el botón Next (Siguiente):

209
Presionamos el botón Next (Siguiente):

Presionamos el botón Next (Siguiente):

210
Presionamos el botón Next (Siguiente):

Presionamos el botón Next (Siguiente):

211
Presionamos el botón Next (Siguiente):

Presionamos el botón Next (Siguiente):

212
Presionamos el botón Install (Instalar):

213
Presionamos el botón Finish (Finalizar):

11.4 Instalando Heroku Cli

Heroku CLI, nos permite ejecutar Heroku desde nuestra terminal, se puede descargar
desde el siguiente link:https://devcenter.heroku.com/articles/heroku-cli

214
Después de descargarlo, comience la Instalacion:

Presionamos el botón Install (Instalar):

215
11.5 Comprobamos la Version Heroku
En Windows acceder a travez de: Win + R y luego digite CMD y luego clic en aceptar

heroku --version

216
11.6 Loguearse con Heroku

heroku login -i

11.73.9 Variable de Entorno

Las variables de entornos son una serie de valores que normalmente son configuradas
en el sistema operativo y son cargados directamente en memoria.

Ahora debemos instalar la librería Python-desacoplamient:

pip install python-decouple

Ahora verificamos la instalación de Python-desacoplamient:

217
11.83.9 Loguearse con Heroku Login

218
11.9Iniciando Repositorio
Para iniciar un repositorio solo hay que situarse en el directorio de nuestro proyecto (el
que contiene o va a contener los archivos que queremos controlar) y ejecutar la
siguiente orden, a continuación, hacemos un listado de las carpetas:

Ahora ejecutamos el comando: git init

git init

219
11.10 Creacion del archivo .env
Vamos a crear un archivo env para definir las variables de entorno

220
Ahora agregamos el key del archivo settings.py:

221
Ahora quitamos el KEY del archivo settings.py:

Ahora en el archivo settings.py añadimos lo siguiente:

222
Reiniciamos el servidor, Presione en la siguiente URL http: //127.0.0.1:800/ :

223
11.11 Generando las Dependencias
Ahora deberemos crear el archivo requirements.txt para indicarle a Heroku que paquetes
de Python necesitamos que sean instalados en el servidor.

pip freeze > requirements.txt

Observamos el contenido del archivo requirements.txt

224
11.12 Instalacion de gunicorn y otros

pip install dj-database-url gunicorn whitenoise

Ahora verificamos la instalación de las librerías instaladas:

225
11.13 Creacion del Archivo Procfile
Ademas necesitamos el archivo Procfile el cual le dira a Heroku que comandos ejecutar
para iniciar nuestro sitio web. A continuación, procedemos a crear el archivo llamado
Procfile en la carpeta:

226
11.14 Creacion del Archivo runtime.txt
Debemos indicar a Heroku que versión de Python vamos a usar. Esto es hecho creando
un archivo runtime.txt :

227
11.15Creacion del Archivo mysite/local_settings.py(Produccion)
Heroku quiere usar diferentes configuraciones de las que nosotros usamos localmente
(en nuestro computador). Heroku quiere que usar Postgres mientras que nosotros
usamos SQLite, por ejemplo. Por eso necesitamos crear un archivo separado para las
configuraciones que estarán disponibles en nuestro ambiente local.

228
11.16 Settings.py (Desarrollo)
Ahora debemos modificar el archivo de sitio web settings.py. cambiar las siguientes
líneas:

STATIC_ROOT: Es la ruta absoluta a un directorio en el que la herramienta "collectstatic"

de Django reunirá todos los archivos estáticos referenciados en nuestras plantillas. Una
vez recopilados, podrán ser cargados como un grupo a donde hayan de ser alojados.

229
STATICFILES_DIRS: Relaciona directorios adicionales en los que la herramienta
collestatic de Django debería buscar archivos estáticos.

Agregamos Middleware:

230
Creando uan variable para la base de datos:

Observemos el diccionario default:

231
11.17 Desplegando en Heroku
Autentique su cuenta de Heroku ejecutando el siguiente comando en cmd:

Heroku login -i

A continuación, inicie el repositorio:

232
Confirme los cambios:

git status
git add -A .
git commit -m "adicionando archivos"

233
Elija el nombre de su aplicación que se mostrará en el nombre de dominio - [el nombre
de su aplicación] .herokuapp.com y cree la aplicación usando el siguiente comando:

heroku create app-noticias-django

11.18 Probando la Aplicacion

https://app-noticias-django.herokuapp.com/ | https://git.heroku.com/app-noticias-django.git

234
11.19 Configurando Aplicación

235
Ahora colocaremos el SECRET_KEY= de nuestra Aplicación:

Presionar Add:

236
Finalmente, haga un simple git push para implementar nuestra aplicación

237