Curso de django

Este es un índice de los diferentes apartados del curso.

1. Comenzando con django
2. Estructura del proyecto django
3. Creación de Apps en django
4. Estructura de una app en django
5. Hello World en django
6. Organizar mejor las URLs en django usando el método include
7. Django database models
8. Django Shell

Django Shell

Veamos lo que se puede hacer desde la Shell de Python para crear datos en la base de datos, consultarlos y manejarlos. Esto nos dará idea de cómo luego lo haremos desde django.

python manage.py shell
>>> from myapp.models import Project, Task
>>> p = Project(name="aplicacion movil")
>>> p
<Project: Project object (None)>
>>> p.save()  # guardamos en la base de datos el nuevo dato
>>> 

Hemos accedido al shell de Python usando python manage.py shell

Hemos importado las dos clases que previamente habíamos creado. Para hacer la importación escribimos from myapp.models import Project, Task

Creamos nuestro primer dato en la tabla Project y en el campo name. El datos es "aplicacion movil" y una vez creado se lo asignamos a una variable que hemos llamado, por ejemplo, p, así:

  p = Project(name="aplicacion movil")

Si imprimimos p no da error y nos muestra lo siguiente:

<Project: Project object (None)>

Usando p.save() lo que hacemos es grabar el dato en la base de datos.

Podemos actualizar con F5 la aplicación DB Browser for SQLite y así veremos que se ha creado el nuevo campo de Id 1 cuyo campo name es "aplicacion movil".

Vamos a crear ahora un segundo campo.

>>> p = Project(name="aplicacion web usando Django")
>>> p.save()

Actualizamos con F5 para ver el nuevo campo.

Django database models

La base de datos incluida por defecto en django es db.sqlite3.

Al lanzar el servidor es habitual ver un mensaje similar a este "You have 18 unapplied migration(s)".

Las migraciones son una forma de actualizar nuestra base de datos desde código Python.
Desde código Python interaccionaremos con la base de datos creando las tablas, las relaciones, los usuarios, ...

Las migraciones nos permiten ahorrar trabajo ya que nos ayudan a crear las tablas y relaciones de la base de datos.

DB Browser for SWLite

Descargar este programa.

Está disponible para varios sistemas operativos, incluso para macOS (Apple Silicon).

Para actualizar la base de datos, detenemos el servidor y ejecutamos el comando:

python manage.py makemigrations
python manage.py migrate

Observamos la estructura que aparece con una serie de tablas e índices. Si aparecen cero tablas y cero índices lo que tenemos que hacer es abrir la base de datos con Archivo/Abrir base de datos. Navegamos hasta nuestro archivo que en mi caso está en:

/Users/apa/Documents/github/djangoproject/db.sqlite3 

Estando dentro de la aplicación BD Browser for SQLite, pulsamos F5 para actualizar y ahora deberíamos observamos la estructura que aparece con una serie de tablas e índices ya creados por defecto. 

Sobre la tabla de usuarios pedimos con el botón derecho del ratón Mostrar datos, en inglés aparece como Browse Table.

Esto nos permitirá ver los campos de la tabla de usuarios.

Unamos la aplicación myapp con la configuración del proyecto en mysite.

Django nos da unas tablas por defecto pero posteriormente nosotros desearemos hacer nuestras propias tablas para nuestro proyecto. Para hacer esto nosotros tenemos que poder crear lo que se llama un MODELO. Este modelo es código de Python que se va a transformar en una tabla de SQL. Ahora estamos trabajando en SQLite pero este script de Python se podrá ejecutar en otras base de datos, por ejemplo en postgreSQL, siempre y cuando le hayamos dado la conexión correcta.

Mi aplicación myapp va a tener una serie de modelos específicos para esta aplicación. Para ello nos vamos al archivo models.py que está dentro de la carpeta myapp.

Estando en myapp/models.py voy a crear un modelo específico.

from django.db import models

# Create your models here.
class Project(models.Model):
    # los atributos de la clase serán los campos de la tabla
    name = models.CharField(max_length=200)

Conectar la APP con el proyecto

Para que nuestra aplicación de django conozca nuestros modelos tenemos que conectar el modelo creado, para lo cual vamos a la carpeta principal del proyecto (mysite) y vamos al archivo settings.py y buscamos la sección que contiene la variable INSTALLED_APPS que ya trae, por defecto una serie de conexiones.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',
]

Hemos añadido al final de la lista 'myapp' y esto ya permite conectar el modelo creado en mi aplicación myapp con el proyecto django.

Ejecutamos las migraciones:

Ahora lanzamos nuevamente el servidor y en otra terminal ejecutamos:

python manage.py makemigrations
python manage.py migrate myapp

Añadir myapp después de migrate es optativo y se hace en caso de querer ejecutar únicamente las migraciones de esa APP.

Se ha generado un archivo myapp/migrations/0001_initial.py. Este archivo no debemos tocarle y contiene el código necesario para que django consiga hacer los cambios necesarios en la base de datos sin nuestra intervención. Este archivo crea por nosotros la tabla con sus campos. Pero no debemos tocarlo.

Si volvemos a consultar ahora la aplicación "DB Browser for SQlite" veremos que se ha agregado una nueva tabla.

Si ya tenías abierta esta aplicación puedes refrescar la tablas pulsando F5.

La nueva tabla que se ha creado se llama myapp_project que tiene el nombre de la aplicación (myapp) y el nombre del modelo, ya que nosotros le habíamos llamado Project, recordemos que habíamos llamado así a la clase (Class Project). 

Con botón derecho del ratón y Browse Table o Mostrar Datos veremos los campos creados Id y name. El Id se crea automáticamente de forma auto-incremental si no se pone otra cosa. El name se crea debido a que nosotros habíamos creado ese atributo en la clase Project.

Creamos otra clase

Vamos a crear otra clase en myapp/models.py:

from django.db import models

# Create your models here.
class Project(models.Model):
    name = models.CharField(max_length=200)

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    project =  models.ForeignKey(Project, on_delete=models.CASCADE)

El atributo project indicamos que está relacionado con otro proyecto denominado Project, por eso ponemos que se necesita una clave foránea: models.ForeignKey(Project). 

Se añade on_delete=models.CASCADE para que cuando se elimine el objeto al que se hace referencia, elimine también los objetos que tengan referencias con él.

En Django, una foreign key (clave foránea) es un campo utilizado para establecer una relación entre dos modelos en una base de datos relacional. Este campo sirve para crear una relación uno a muchos entre dos modelos, donde un modelo tiene una clave que apunta a otro modelo.

Ahora volvemos a ejecutar los comandos para hacer las migraciones.

python manage.py makemigrations
python manage.py migrate

Veremos que se ha creado un nuevo archivo denominado myapp/migrations/0002_initial.py que contiene las nuevas migraciones y que tampoco debemos tocar.

Al refrescar la estructura de la base de datos con F5 en el programa DB Browser for SQLite podemos ver que se ha creado una nueva tabla para las tareas Task.

La nueva tabla se llama myapp_task y si punsamos con el botón derecho del ratón y elegimos Browse Table o Mostrar datos veremos los campos que se corresponden con los atributos creados en la clase Task que hemos creado previamente.

Vemos que aparece project_id ya que cuando se creó el atributo project lo hicimos relacionándolo con otro proyecto (con el que denominamos Project).

Sección DATABASES en settings.py

Ya tenemos, por defecto esta sección en el archivo settings.py que está en mysite.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Ahora no lo voy a hacer, pero en el futuro podré modificar esta configuración con otra que me permita utilizar otra base de datos, por ejemplo postgreSQL.

Organizar mejor las URLs en django usando el método include

Anteriormente hemos ido incluyendo las rutas en el archivo urls.py de la carpeta principal donde esta nuestro proyecto que es mysite. Pero sucede que cuando aumente el número de APPs que tengamos y no solo esté myapp, se irán acumulando muchas rutas o URLs a las que queramos ir, por lo que es mejor que cada APP tenga su propio archivo conteniendo las URLs propias de esa APP.

Ahora tendremos un archivo urls.py en cada APP que tengamos, más el archivo urls.py de la carpeta principal del proyecto que es mysite. Veamos cómo quedan ambos ficheros.

mysite/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

Además de importar el método path importamos también el método include que es el que nos permite luego incluir las rutas que se indiquen include('myapp.urls')

Cuando colocamos un string vacío ('') en la línea path('', include('myapp.urls')) indica que antes de las urls a las que estamos haciendo referencia no va nada.

Si en lugar de poner un string vacío pusiera algo, por ejemplo 'home/' lo que sucedería es que ahora sería necesario poner esto para visitar las rutas que se referencian en myapp. Si hicieramos esto las rutas raiz y about serían así:

• http://127.0.0.1:8000/home/
• http://127.0.0.1:8000/home/about

En ese caso, si hubiéramos puesto 'home/' diríamos que esto es un prefijo y se debería añadir antes de las urls que importemos.

Nosotros en nuestro ejemplo, dejaremos el string vacío. Si bien, conviene entender que este prefijo puede ser útil para preceder la ruta de cada aplicación que tengamos para distinguirlas, por ejemplo, 'blog/' o 'tasks/' o 'store/', etc.

myapp/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.hello),
    path('about/', views.about),
]

Escribimos el punto después de from para indicar que views está en el mismo directorio que en el que estamos que es myapp.

Podemos reestablecer el servidor y ver que las rutas raiz y about funcionan bien, igual que antes.

Hello World en django

Creación de las vistas

Las vistas se crean mediante la creación de unas funciones.

Iremos a la carpeta de nuestra aplicación que se llama myapp y dentro de ella encontraremos el archivo views.py.

En el archivo views.py crearemos nuestra primera función que retornará un mensaje al cliente (al navegador).

La función puede llamarse como queramos, en nuestro caso se llamará hello.

La función recibirá un parámetro que nos lo pasará django y se llamará request.

La función retornará una respuesta al cliente de tipo HTTP. Será un texto que el navegador va a recibir.

Para enviar la respuesta de tipo HTTP tendremos que importar de la librería django.http el método HttpResponse.

De momento quitaremos la otra linéa que por defecto nos muestra django que es from django.shortcuts import render que posteriormente ya utizaremos, pero que ahora quitamos.

El código quedaría así:

from django.http import HttpResponse

# Create your views here.
def hello(request):
    return HttpResponse("Hello World")

La ruta

Ahora necesitamos indicar en que ruta se ha de mostrar el resultado de nuestra función. Las rutas están en el archivo urls.py de la carpeta del proyecto mysite

Por defecto, al inicial django el archivo urls.py viene así:

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

Inicialmente ya aparece la ruta admin/ y ahora añadiremos la nuestra.

Nuestra ruta se añadirá indicando el paht como vacío (comillas comillas) '' lo que indica que se trata de la ruta principal o raiz del proyecto.

Luego pondremos la función hello, pero para que funcione tenemos que importarla con la línea from myapp.views import hello que indica dónde se encuentra esa función y cómo se llama. La función se llama hello y está situada en myapp.views

Finalmente el código queda así:

from django.contrib import admin
from django.urls import path
from myapp.views import hello

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', hello),
]

Grabamos archivos y lanzamos el servidos o actualizamos la página localhost si ya estaba lanzado el servidor.

También es posible escribir en código HTML dentro de la respuesta. Por ejemplo, poniendo una etiqueta h1 y en cursiva.

from django.http import HttpResponse

# Create your views here.
def hello(request):
    return HttpResponse("<h1><i>Hello World</i></h1>")

Recargamos la página y vemos el resultado.

Otra forma de importar la vista que proporciona la función hello consiste en importar todas las vistas con from myapp import views y luego indicar que la función hello pertenece a views poniéndolo así views.hello

El código en el archivo urls.py quedaría así.

from django.contrib import admin
from django.urls import path
from myapp import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.hello),
]

Añadiendo una nueva ruta

Vamos a añadir una nueva ruta denominada about. Para ello necesitamos modificar los archivos myapp/views.py y mysite/urls.py

Veamos estos archivos.

myapp/views.py

from django.http import HttpResponse

# Create your views here.
def hello(request):
    return HttpResponse("<h1>Hello World</h1>")

def about(request):
    return HttpResponse("Esta es la página de about")

mysite/urls.py

from django.contrib import admin
from django.urls import path
from myapp import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.hello),
    path('about/', views.about),

La ruta la hemos llamado "about/" y esta ruta se visita desde "http://127.0.0.1:8000/about/".

Actualizamos la página y pulsamos en el navegador Chrome F12. Así, en "Elementos" veremos el código de nuestra página.

Estructura de una app en django

 Hemos creado una app en django que se llama myapp, que queda recogida en una carpeta con el mismo nombre. Esta carpeta contiene una serie de archivos que vamos a describir.

views.py

Podemos considerarle el archivo principal de nuestra app ya que aquí podemos definir lo que vamos a ejecutar o lo que queremos enviar al cliente (al navegador) para que se pueda ver en pantalla. Aquí podemos enviar archivos HTML.

__init__.py

Se genera vacío y sirve para que esta carpeta sea considerada como un módulo de Python.

migrations

Carpeta que de entrada solo tiene un archivo __init__.py y que posteriormente se ira llenando cuando modifiquemos la base de datos.

En django no tenemos que estar escribiendo consultas SQL sino que ya viene con un módulo de ORM (Object Relational Mapping). Esto permite abstraer la base de datos y posibilita que las consultas a la base de datos se realicen en el lenguaje en el que trabaja el framework, en nuestro caso Python. De esta forma se facilita la tarea del programador que no tiene que estar escribiendo código SQL, aunque si se desea para realizar una consulta compleja también se puede utilizar código SQL.

admin.py

Permite añadir a nuestras aplicaciones un panel de administrador, que permite administrar nuestras aplicaciones. Permite administrar datos, crear usuarios, crear roles para los usuarios, podemos decir si a un usuario le pertenece un dato. Todo ello con un panel que ya está creado por parte del framework. Para poder integrarlo es para lo que tendremos que usar este archivo ademin.py.

apps.py

Permite configurar esta aplicación. Es similar al settings.py que tenemos en la carpeta mysite.

models.py

Aquí podemos crear clases que finalmente se convertirán en tablas SQL. Contamos con la ventaja de que django ya tiene ese ORM que se encargará de crear esas tablas. Cuando modifiquemos ese código, django también se encargará de modicar esas tablas. Para ello django creará unos archivos que se llaman migraciones, que creará en la carpeta migrations, que sirve para actualizar código de la base de datos.

tests.py

Archivo que nos permite realizar testing de las vistas que enviaremos al navegador y poder comprobar lógica. Para ver si hemos consultado bien un dato, si hemos ejecutado correctamente una función.

Creación de Apps en django

Los proyectos en django están conformados por aplicaciones que son partes del proyecto que se ocupan de tareas específicas. Por ejemplo, podemos tener en nuestro proyecto:

• un blog
• una sección para autenticar usuarios
• una sección para poder hacer pagos
• una sección para poder tener artículos
• etc.

De esta forma podemos dividir el proyecto grande es múltiples partes. Esas partes se llaman aplicaciones.

Las apps que integran un proyecto las determino yo, y al ser modulares se pueden integrar al proyecto o desacoplar de él. De esta forma tendremos un proyecto dividido en partes y personalizado.

Vamos a crear una app que se llame myapp:

python manage.py startapp myapp

La estructura del proyecto se verá ahora así.

Observamos que se ha creado una carpeta que se llama myapp, que es el nombre que hemos elegido, y dentro de ella se encuentran ya múltiples archivos para el correcto funcionamiento de la aplicación.

Podríamos haber creado muchas otras aplicaciones y el procedimiento para todas ellas sería el mismo.

Por ejemplo, aplicaciones de blog, de encuestas (polls), tienda (store), tareas (tasks), ...

python manage.py startapp blog
python manage.py startapp polls
python manage.py startapp store
python manage.py startapp tasks

De momento solo crearemos una app que hemos denominado myapp dentro de mi proyecto que he llamado mysite.

myapp es una parte del proyecto y mysite contiene las configuraciones globales del proyecto.

Estructura del proyecto django

Archivos y carpetas

Esta es la estructura del proyecto de django nada más crearlo.

Archivo manage.py

El archivo manage.py nos ayuda a ejecutar comandos administrativos. Por ejemplo, podemos ejecutar un help.

python manage.py --help

Archivo db.sqlite3

Es la base de datos de nuestra aplicación. sqlite3 es una base de datos de tipo SQL.

Es una base de datos simple que se usa habitualmente para pruebas, pero no para desarrollo.

django oficialmente soporta las siguientes bases de datos:

• PostgreSQL
• MariaDB
• MySQL
• Oracle
• SQLite

Carpeta mysite

Contiene el código fuente de nuestra aplicación.

Archivo __pycache__

Este archivo solo sirve para guardar código que ya compiló Python

Archivo __init__py©

Este archivo es imprescindible que exista aunque esté vacío.

Este archivo solo sirve para decirle a Python que la carpeta mysite es un módulo de python.

Este archivo está más relacionado con el funcionamiento de Python que con el de Django.

Archivo settings.py

Este archivo permite configurar nuestro proyecto.

Este archivo solo sirve para decirle a Python que la carpeta mysite es un módulo de python.

Veamos algún ejemplo de instrucciones de configuración.

Variable ALLOWED_HOSTS = []

Le indica al servidor qué direcciones tiene permitido consultar.

Propiedad DEBUG = True

Le indica si estamos en modo desarrollo o en modo producción.

Cuando esté como DEBUG = True nos permite obtener más información cuando estemos desarrollando.

Propiedad SECRET_KEY

Permite mejorar la encriptación de los usuarios o permite mejorar la seguridad de los datos compartidos entre el navegador y el servidor.

Contiene valores generados aleatoriamente.

SECRET_KEY = 'django-insecure-xe-ryt5i.../...87cek$'

Variable BASE_DIR = Path(__file__).resolve().parent.parent

Indica los directorios que contiene el proyecto.

Contiene valores generados aleatoriamente.

Variable INSTALLED_APPS

Es una variable en forma de lista que contiene las aplicaciones que contiene nuestro proyecto.

django permite dividir un proyecto en diferentes partes que aquí se llaman aplicaciones.

La lista contiene las aplicaciones que se instalan por defecto.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Variable MIDDLEWARE

Es una variable en forma de lista que indica a Django si va a procesar algún tipo de datos de alguna forma específica.

Esta es la lista que se ha instalado inicialmente.

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',
]

Variable TEMPLATES

Aquí podremos establecer nuestros Templates.

Variable WSGI_APPLICATION

Aquí podremos indicar módulos extra cuando estemos en modo de producción.

WSGI_APPLICATION = 'mysite.wsgi.application'

Variable DATABASES

Es una variable en forma de diccionario que contiene las bases de datos a las que está conectado nuestro proyecto.

Por defecto la base de datos es SQLITE3.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Variable AUTH_PASSWORD_VALIDATORS

Es una variable en forma de lista que contiene las formas de validar contraseñas al autenticar usuarios.

Por defecto la base de datos es SQLITE3.

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

Variable STATIC_URL

Aquí podremos establecer en que directorio se encuentran los archivos estáticos, por defecto se establece que esta carpeta será 'static'.

La carpeta 'static' no viene creada por defecto, pero lo habitual es que nosotros la creemos y en ella guardemos los llamados archivos estáticos.

El contenido estático es cualquier archivo que se almacena en un servidor y es el mismo cada vez que se entrega a los usuarios. Se consideran estáticos los archivos HTML, CSS, JS, las imágenes, mp3, mp4, ico y otros elementos que no cambian dinámicamente en función de las interacciones del usuario..

STATIC_URL = 'static/'

Archivo urls.py

Aquí se indican las URLs que los clientes pueden visitar.

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]code>

Por defecto, solo viene la ruta "admin/' pero posteriormente iremos añadiendo otras.

Archivos asgi.py y wsgi.py

Estos archivos están más relacionados con la forma de servir nuestro proyecto en producción.

django se ocupa de crear el proyecto pero no del despliegue, para lo cual tendremos que tocar estos archivos.

Comenzando con django

Veamos django desde cero. Seguiremos algunos vídeos y páginas y tomaremos nota de lo principal.

• Curso de Django para Principiantes 

Instalación de django en Ubuntu

Sigue estos pasos en la terminal:

Paso 1. Actualiza tu sistema

sudo apt update -y

sudo apt upgrade -y

Paso 2. Actualiza Python3

Actualiza a la última versión disponible de Python 3.

Este paso puedes hacerlo ahora y así Python 3 quedará actualizado para todo tu sistema operativo o bien puedes hacerlo dentro del entorno virtual que crearemos más adelante y una vez que lo tengas activado, de esta forma la última versión de Python 3, quedará establecida en ese entorno virtual concreto, sin interferir con la versión que tiene el sistema operativo.

Primero

Descarga de la página oficial (https://www.python.org/downloads) la última versión disponible para Linux, por ejemplo Python-3.12.2.tar.xz

Segundo

Instala las dependencias necesarias para compilar Python desde la fuente:

sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev wget

Tercero

Extrae el archivo tar.xz descargado

tar -xf Python-3.12.2.tar.xz

Cuarto

Accede al directorio Python-3.12.2

cd Python-3.12.2

Quinto

Configura la compilación

./configure --enable-optimizations

Sexto

Compila e instala Python

sudo make altinstall

Séptimo

Verifica la instalación:

python3.12 --version

Octavo

Es posible que al hacer python3 --version se continúe mostrando una versión anterior a la 3.12 que es la que has instalado como versión más reciente. En ese caso se puede conseguir que Ubuntu muestre la versión última que acabas de instalar. Para ello vamos a crear manualmente un enlace simbólico para python3.12 que apunte a python3.

Vamos a conseguirlo siguiendo estos dos puntos:

Octavo. Punto 1

Primero, identifica la ruta completa del intérprete de Python 3.12.2 que instalaste. Puedes hacerlo con el siguiente comando:

which python3.12

Esto te mostrará la ruta completa del intérprete de Python 3.12.2.

Octavo. Punto 2

Luego, crea un enlace simbólico para python3.12 que apunte a python3 con el siguiente comando (reemplaza /ruta/a/python3.12 con la ruta que obtuviste en el paso anterior):

sudo ln -sf /ruta/a/python3.12 /usr/bin/python3

Este comando crea un enlace simbólico llamado python3 que apunta al intérprete de Python 3.12.2.

Una vez completados estos pasos, al ejecutar python3 --version deberías obtener la versión 3.12.2.

Paso 3. Crea un nuevo directorio para tu proyecto

Sitúate en la carpeta que quieras, en Documents o en una carpeta llamada github si la tienes creada, y alli podrás crear el nuevo directorio.

Después de crear el directorio, muévete hacia él en la terminal.

mkdir djangoproject

cd djangoproject

Paso 4. Comprueba la versión de Python 3 que tienes instalada en tu sistema.

python3 --version

Paso 5. Crea un entorno virtual

Dentro del directorio del proyecto crearemos un entorno virtual.

python3 -m venv venv

Paso 6. Activa el entorno virtual

Estando en el directorio del proyecto activa tu entorno virtual. Si tu entorno virtual no se llama venv sustituye en la siguiente línea venv por el nombre que tenta tu entorno virtual.

source venv/bin/activate

Cuando el entorno virtual queda activado verás a la izquierda del prompt en la terminal que pone (venv) o el nombre que hubieras dado a tu entorno virtual.

La forma de activarlo en Windows es bastante diferente (.\venv\Scripts\activate).

Paso 7. Actualiza a la última versión de Python3

Si no lo hiciste en el Paso 2, ahora dentro del entorno virtual, vamos a instalar o actualizar a la última versión de Python 3.

python3 -m venv venv

Paso 8. Ver la versión de Python dentro del entorno virtual

Si tenemos activado el entorno virtual podemos ver la versión de Python que tenemos en este entorno virtual escribiendo en la terminal lo siguiente

python --version

Observe que ahora no es necesario poner el número 3 después de la palabra python.

Puedes comprobar también la versión del gestor de paquetes pip.

pip --version

Paso 9. Desactivar el entorno virtual

Estando con el entorno virtual activado escribimos:

deactivate

Al desactivarse el entorno virtual ya no aparece a la izquierda del promt (venv) o el nombre que hubiéramos dado a nuestro entorno virtual.

Usar Visual Studio Code

Extensiones

Instalar la extensión de Python más habitual que es la de Microsoft.

Seleccionar el intérprete de Python

Estamos dentro de VSC, tenemos abierta una terminal dentro de VSC y estamos con el entorno virtual activado.

Pulsamos F1 y buscamos Python Select Interpreter. Al pulsar sobre esa opción nos saldrán varias opciones de Python, elegiremos la del entorno virtual y no la denominada Global.

En mi caso elijo la que pone:

Python 3.12.2 ('venv'; venv) ./venv/bin/python     Recomended

Instalar django

Instalación

Estando en VSC, con una terminal abierta en VSC y con el entorno virtual activado, escribimos:

pip install django

Comprobar si está instalado

Podemos comprobar la versión instalada de django por alguno de estos tres métodos.

Método 1

django-admin --version

Método 2

python -m django --version

Método 3

Entramos en Python.

python

Ya estamos dentro del Shell de Python y aquí escribimos:

import django

django.get_version()

Con esto ya hemos obtenido la versión de django y ahora salimos del Shell de Python:

exit()

Crear un proyecto con django

El proyecto se llamará mysite. No usar nombres de proyecto como django, python, test.

Estamos en VSC, y tenemos abirta una terminal en VSC con el entorno virtual activado y estamos en el directorio djangoproject que se creó anteriormente.

django-admin startproject mysite .

Observe que la línea anterior termina es espacio punto. Ese punto hace referencia a la carpeta actual, que es en la que estoy djangoproject, para que cree el proyecto en ella. Si todo va bien habrá creado la carpeta mysite dentro de la carpeta djangoproject.

El archivo manage.py sirve para establecer los archivos de configuración de nuestro proyecto. Vamos a ejecutar ese archivo con Python y le pasamos un parámetro (runserver) para arrancar el servidor.

python manage.py runserver

En nuestro navegador web, en la siguiente ruta podremos ver corriendo la página inicial de nuestro proyecto.

http://127.0.0.1:8000/

Esto es lo que veremos.

Cambiar el puerto del servidor

Podemos terminar el servidor pulsando Control + C.

Lanzamos nuevamente el servidor, en esta ocasión en el puerto 3000:

python manage.py runserver 3000

Luego pulsamos son Control + Click sobre el enlace que aparece en la terminal: http://127.0.0.1:3000/

También se puede conseguir la página web en local pidiendo en nuestro navegador la página cuya URL es: localhost:3000