Configura tu entorno de desarrollo de manera profesional con Python y Django

Configurar tu entorno de desarrollo de manera profesional te ayudará a ahorrarte mucho tiempo, y en esta ocasión veremos como configurar tu entorno de desarrollo para que trabajes con Python y Django desde Visual Studio Code, el editor de texto favorito para muchos.

¿Qué es Django?

Django es un framework de Python para desarrollo web, que nos permite crear y mantener aplicaciones web de una manera rápida, segura y escalable.

Requerimientos

Configura un repositorio de Git en tu proyecto

Git es una herramienta esencial para cualquier proyecto de software, que permite compartir código, participar en un proyecto open source o manejar las versiones de tu aplicación.

Es por ello que te invito a usar Git en tus proyectos, y en este no será la excepción, vamos a inicializar un repositorio de Git, creando primero una carpeta para el proyecto:

  • En tu sistema de archivos, crea una carpeta para tu proyecto, puedes llamarla como tu quieras, en este ejemplo la llamaremos proyecto_django.

  • Abre tu consola desde la ubicación de tu carpeta proyecto_django y ejecuta el siguiente comando para inicializar un repositorio de Git:

git init

El siguiente paso es crear un archivo .gitignore, que permitirá ignorar archivos que no queremos darle un seguimiento a través del sistema control de versiones, estos pueden ser archivos de configuración, que contienen datos sensibles como contraseñas, archivos binarios, como imágenes, ya que suelen ser muy pesados, archivos de compilación de Python (.pyc), etc.

  • Abre la carpeta de tu proyecto desde Visual Studio Code, ya sea ejecutando el comando code . desde tu consola o abriendo Visual Studio Code y en la opción File > Open Folder.

  • Crea el archivo .gitignore en la raíz de la carpeta del proyecto, y no olvides agregar el punto (.) al principio del nombre.

¿Qué contendrá este archivo .gitignore?

El archivo .gitignore contendrá una lista de todos los archivos que vamos a ignorar, y para crear esa lista nos apoyaremos de la página https://gitignore.io que nos facilitará la creación de este archivo pasándole un conjunto de etiquetas de todas las herramientas que utilizaremos.

Para este caso, pasamos las etiquetas VisualStudioCode, Python y Django:

Damos clic al botón Create y enseguida nos aparecerá todo un conjunto de archivos que son utilizados por estas herramientas, pero que no es necesario darles un seguimiento en nuestro repositorio. Copia el contenido y pégalo en tu archivo .gitignore.

Crear un entorno virtual para nuestro proyecto de Django

Un entorno virtual nos permitirá instalar todos los paquetes y librerías necesarias para tu proyecto de manera independiente, es decir, podremos probar distintas versiones de Django sin entrar en conflicto con otros proyectos. Piensa en un entorno virtual como una máquina virtual, capaz de aislar todos los paquetes instalados dentro de ese entorno virtual.

Ahora vayamos a la creación del entorno virtual:

  • Dentro de tu carpeta principal del proyecto, desde la línea de comandos, ejecuta el siguiente comando para crear un entorno virtual llamado venv (asegurate de tener instalado Python): 
# Linux
sudo apt-get install python3-venv # En caso necesario de no contar con python3-venv
python3 -m venv venv

# macOS
python3 -m venv venv

# Windows
python -m venv venv

En Visual Studio Code tenemos que seleccionar el intérprete de Python que se utilizará para ejecutar nuestro proyecto. Ahí es donde entra el entorno virtual que acabamos de crear. Prácticamente le decimos a VS Code, quiero que utilices la versión de Python que tengo dentro de mi entorno virtual junto con todos sus paquetes instalados.

  • Dentro de VS Code, vamos a la opción View > Command Palette y seleccionamos el comando Python: Select Interpreter
  • El comando mostrará una lista de los intérpretes disponibles que VS Code puede localizar automáticamente. Desde la lista, selecciona el entorno virtual que se encuentra dentro de la carpeta del proyecto:

Hasta este momento solamente hemos creado nuestro entorno virtual, pero aún no lo usamos, para ello tenemos que activarlo.

  • Y aquí viene la magia de VS Code, vamos a abrir una línea de comandos desde la opción Terminal > New Terminal, esto abre una consola integrada en nuestro editor y automáticamente activa el entorno virtual ejecutando el script de activación.

  • Del lado izquierdo visualizarás la barra de estado de VS Code indicando que estamos utilizando un entorno virtual.

Actualizando y utilizando pip

Por defecto Python ya cuenta con un conjunto de funcionalidades integradas listas para usar, que se encuentran agrupadas en módulos. De seguro has usado el módulo random para generar números aleatorios, pero que pasa con Django.

Ya que Django es un paquete que no se encuentra directamente dentro de Python tenemos que instalarlo de manera externa.

¿Cómo instalamos Django?

Para instalar Django necesitamos de un gestor de dependencias o en otras palabras de un instalador de paquetes, y el más popular en Python es PIP (Package Installer for Python) ya que viene integrado junto con Python en el momento de la instalación.

Si vienes de JavaScript de seguro conoces npm y se te hará muy familiar los comandos a la hora de instalar paquetes con pip.

  • Un paso adicional antes de empezar a instalar paquetes, es tener actualizado pip en nuestro entorno virtual, que si recuerdas ya se encuentra activado en la consola de VS Code, ejecuta el siguiente comando: 
pip install --upgrade pip
  • Ahora procederemos a instalar Django en el entorno virtual: 
pip install django
  • Puedes verificar que Django fue instalado con el siguiente comando: 
pip freeze

Crear un proyecto de Django

Ahora que ya tenemos instalado Django tenemos disponible el comando django-admin que nos permitirá crear nuestro primer proyecto.

Vamos a la consola de VS Code con tu entorno virtual activado y ejecuta el siguiente comando:

django-admin startproject proyecto_django .

El punto (.) al final del comando indica que el proyecto será creado en la carpeta actual.

Creando archivos de configuración para cada entorno

En un entorno profesional de trabajo es ideal manejar un servidor diferente por cada etapa del proyecto, es decir, cuando realizamos cambios al código del proyecto, usamos un entorno de desarrollo, cuando el cliente prueba funcionalidades nuevas para aprobarlas, se usa un servidor de staging, y finalmente cuando la aplicación es accesible para todos, se usa un servidor de producción.

Es por ello importante manejar archivos de configuración diferentes por cada entorno, ya que esas configuraciones serán diferentes para cada servidor, por lo que sería tedioso manejar un solo archivo y estar cambiando a cada rato cuando nos cambiamos de entorno.

Django por defecto maneja toda la configuración del proyecto en un solo archivo (proyecto_django/settings.py), pero ahora queremos manejar múltiples archivos de configuración por cada entorno manejado.

Para ello vamos a agrupar todos esos archivos de configuración en un sola carpeta llamada settings, creamos la carpeta dentro de la subcarpeta proyecto_django y creamos la siguiente estructura de archivos:

proyecto_django/settings
├── __init__.py
├── base.py
├── local.py
└── production.py

Vamos a describir cada archivo de la carpeta settings:

  • __init__.py: Un archivo vacío que le dice a Python que esta carpeta se trata de un paquete.
  • base.py: Todas las configuraciones en común entre entornos.
  • local.py: Contiene todas las configuraciones de tu entorno local (que incluyen las de base.py).
  • production.py: Configuraciones para el entorno de producción.

¿Qué contenido tendrá base.py?

Todas las configuraciones que no cambien entre los distintos entornos manejados, estará dentro del archivo base.py. Como recomendación copia el contenido del archivo settings.py y pegalo en base.py luego ve identificando que configuraciones son distintas entre tus diferentes entornos.

Identificando configuraciones que cambien entre entornos

La primera configuración que podemos identificar es la siguiente:

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

En un entorno local tener el modo DEBUG activado te facilitará visualizar una página detallada de errores a la hora de codear. En un entorno de producción no queremos mostrarle a nuestros usuarios esos errores detallados, ya que contiene datos sensibles del servidor, por lo que estaríamos expuestos a detalles de seguridad.

La variable de configuración ALLOWED_HOSTS es una lista de hosts/nombres de dominio que nuestro sitio de Django puede servir. Si la variable DEBUG es True y ALLOWED_HOSTS es una lista vacía se proporcionará acceso solamente a ['.localhost', '127.0.0.1', '[::1]'].

Por el momento copiamos esas dos variables de configuración y las pegamos en local.py y production.py, por ahora solamente cambiamos en el archivo production.py la variable DEBUG en False. Ya podemos eliminar esas dos variables de configuración en el archivo base.py.

local.py

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

production.py

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

ALLOWED_HOSTS = []

Ahora tenemos la variable de configuración DATABASES que contiene las configuraciones para todas las bases de datos usadas con Django:

# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

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

En un entorno local nos interesa manejar datos de prueba para verificar el funcionamiento de la aplicación, Django trae por defecto la configuración con una base de datos SQLite, que no es más que un simple archivo donde son guardados los datos.

Para el entorno de producción, Django soporta múltiples motores de base de datos para usar, como MariaDB, MySQL, Oracle o PostgreSQL. El siguiente es un ejemplo para PostgreSQL (Recuerda tener instalado el driver correspondiente con el motor de base de datos):

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Copia la variable de configuración DATABASES y pegalo en tu archivo local.py, para el caso de production.py puedes utilizar por ahora el ejemplo para PostgreSQL. Ya puedes eliminar la configuración para la variable DATABASES en el archivo base.py.

Por último tenemos la variable de configuración STATIC_URL que es la URL a usar para hacer referencia a los archivos estáticos, puede tener diferentes valores dependiendo del entorno, pero por ahora usaremos el mismo valor para los archivos local.py y production.py.

Ya para finalizar tenemos que importar todas las variables de configuración del archivo base.py a local.py y production.py:

from .base import *

Nuestros archivos de configuración se verán de la siguiente manera:

base.py

"""
Django settings for proyecto_django project.

Generated by 'django-admin startproject' using Django 3.2.6.

For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""

from pathlib import Path

# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'my-secret-key'


# Application definition

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

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

ROOT_URLCONF = 'proyecto_django.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',
            ],
        },
    },
]

WSGI_APPLICATION = 'proyecto_django.wsgi.application'


# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators

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


# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

local.py

from .base import *

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

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


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = '/static/'

production.py

from .base import *

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

ALLOWED_HOSTS = []


# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = '/static/'

Modularizando la variable INSTALLED_APPS

Dentro del archivo base.py te encontrarás con la variable de configuración INSTALLED_APPS que es una lista de todas las aplicaciones que están habilitadas para el proyecto. Django maneja el concepto de aplicación como un conjunto de funcionalidades únicas y que se pueden reutilizar en otros proyectos.

Si miras la lista verás que un proyecto de Django trae por defecto todo un conjunto de funcionalidades listas para usar, como el sitio de administración de Django, el sistema de autenticación, el manejo de sesiones, etc.

Todos estos paquetes pertenecen a Django, pero sorpresa, podemos instalar paquetes de terceros, o mejor aún crear nuestros propios paquetes. Una buena práctica es separar estos diferentes tipos de paquetes en distintas variables.

Para los paquetes de Django declaramos la variable DJANGO_APPS, para los paquetes de terceros la variable THIRD_PARTY_APPS y para paquetes propios la variable LOCAL_APPS, las variables se verán de la siguiente manera:

# Application definition

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

THIRD_PARTY_APPS = []

LOCAL_APPS = []

INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS

Actualiza el valor por defecto de DJANGO_SETTINGS_MODULE

Ahora que cambiamos el archivo de configuración settings.py que trae Django por defecto a múltiples archivos de configuración por cada entorno, tenemos que actualizar los archivos asgi.py, wsgi.py y manage.py.

Cambiamos

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'proyecto_django.settings')

por

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'proyecto_django.settings.local')

Esto quiere decir que ahora Django utilizará el archivo de configuración local.py.

Para un entorno de producción tienes que configurar la variable de entorno DJANGO_SETTINGS_MODULE para apuntar hacia el archivo de configuración proyecto_django.settings.production

Creando la base de datos de desarrollo

Ya que se trata de un proyecto inicial de Django, por ahora no tenemos ningún modelo creado, pero tenemos los modelos que trae Django por defecto, ejecuta el siguiente comando para crear una base de datos de desarrollo:

python manage.py migrate

De inmediato visualizarás dentro de la subcarpeta proyecto_django un archivo db.sqlite3 en donde se guardarán los datos para el entorno local.

Mantener algunas configuraciones de manera secreta

En algunas variables de configuración tendrás valores que no vas a querer compartir o subir a tu repositorio por razones de seguridad o porque simplemente solo funcionarán para tu entorno de desarrollo, estas variables pueden ser SECRET_KEY que no debemos usar la misma para producción y para desarrollo, DATABASES si estas manejando de manera local una base de datos PostgreSQL, en donde tendrás que especificar nombre de usuario, contraseña del usuario, nombre de la base de datos, puerto, etc.

Estas son solo algunas variables que pueden cambiar sus valores y necesitas mantenerlas secretas, es decir, no darle seguimiento a través del sistema control de versiones, o en caso de que otras personas están colaborando en el proyecto y van a configurar su propio entorno de desarrollo.

Para ello vamos a instalar una librería con pip llamada Python Decouple que nos ayudará a separar esos valores en un archivo .env, ejecuta el siguiente comando en tu consola:

pip install python-decouple

Ahora crea un archivo .env en la raíz de tu proyecto con el siguiente contenido:

SECRET_KEY=my-secret-key
DB_NAME=django
DB_USER=root
DB_PASSWORD=
DB_HOST=127.0.0.1
DB_PORT=5432

El archivo .env no se agregará al historial de cambios en el sistema control de versiones, ya que en un paso anterior lo hemos agregado en el .gitignore

Necesitamos importar la librería en el archivo base.py:

from decouple import config

Cambia el valor de SECRET_KEY por lo siguiente:

SECRET_KEY = config('SECRET_KEY')

En caso de que quieras manejar un motor de base de datos diferente en tu entorno local, en lugar del archivo de SQLite que maneja Django por defecto, tendrás que configurar las variables correspondientes en tu archivo local.py:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': config('DB_NAME'),
        'USER': config('DB_USER'),
        'PASSWORD': config('DB_PASSWORD'),
        'HOST': config('DB_HOST'),
        'PORT': config('DB_PORT'),
    }
}

Recuerda cambiar a los valores correctos según tu entorno en el archivo .env.

Convirtiendo a otros tipos de datos

Todos los valores que se leen del archivo .env son manejados como una cadena de texto, pero en caso de que quieras configurar una variable como EMAIL_PORT, manejada por Django para el envió de correos, esta debe ser configurada como un entero, por lo que podemos pasarle el argumento cast a la función config() para transformar el valor de cadena como un número entero:

config('EMAIL_PORT', cast=int)

Manejando valores por defecto

Un argumento extra que le podemos pasar a la función config() es default, que definirá un valor por defecto en caso de que la variable de entorno no este definida en el archivo .env:

config('EMAIL_PORT', default=25, cast=int)

Ahora no es necesario que la variable de entorno EMAIL_PORT este definida en el archivo .env

Compartir las variables de entorno definidas para el proyecto

Seguramente te preguntarás porque vamos a compartir algo que al principio mencionamos que mantendríamos en secreto, pues no precisamente vamos a compartir los valores, sino, más bien las variables que necesita el proyecto para funcionar correctamente.

Si una persona se une al proyecto no sabrá como configurar y ejecutar la aplicación de manera correcta, por lo que debemos dejar un ejemplo de las variables que tiene que configurar. Para ello vamos a crear un archivo .env.example en la raíz del proyecto que contendrá datos de ejemplo, esto servirá como referencia para crear el archivo .env con los valores del entorno apropiado.

El archivo .env.example si se agregará al repositorio, ya que solo contendrá datos de ejemplo con las variables de entorno para crear el archivo .env, y recuerda cambiar los valores para que tu entorno funcione correctamente.

Creando nuestra primera app

Recuerdas que te había mencionado que podíamos crear nuestros propios paquetes, pues hemos llegado a ese momento.

Si ejecutamos el siguiente comando, Django va a crear una app en la raíz del proyecto:

python manage.py startapp home

Aunque esto es correcto, si el proyecto va creciendo y se van creando más apps, se tendrá en la raíz del proyecto una lista interminable de carpetas.

Entonces vamos a aplicar desde el inicio del proyecto buenas prácticas. Crea en la raíz del proyecto una carpeta llamada apps, aquí englobaremos todas las apps creadas.

Si ejecutaste el comando anterior recuerda eliminar la carpeta home de la raíz del proyecto.

Desde tu línea de comandos en VS Code y con tu entorno virtual activado, ingresa a la carpeta apps y ejecuta el siguiente comando:

cd apps
django-admin startapp home

Visualizarás que dentro de la carpeta apps se ha creado una subcarpeta home con la siguiente estructura:

apps
└── home
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── tests.py
    └── views.py

Vamos a explicar rápidamente cada archivo:

  • views.py: Contiene la lógica o funcionalidad de la aplicación.
  • models.py: Contiene un conjunto de clases que definen la estructura de datos a utilizar por la aplicación.
  • migrations: Una carpeta que es usada por Django para manejar las versiones de la base de datos.
  • apps.py: Configuraciones propias de la aplicación
  • admin.py: Creación de la interfaz administrativa para el manejo de modelos.
  • tests.py: Creación de pruebas.

Creando nuestra primera vista

Modifica el archivo home/views.py para crear una vista que nos retorne un saludo como respuesta:

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, Django!")

Ahora crea un archivo home/urls.py para definir las diferentes rutas asociadas a las vistas:

from django.urls import path
from . import views

urlpatterns = [
    path("", views.index, name="home"),
]

Dentro de la subcarpeta proyecto_django hay un archivo urls.py que es el encargado de manejar el enrutamiento dentro de la aplicación. Una buena práctica es crear un archivo urls.py dentro de cada app, con la idea de modularizar las rutas de cada aplicación.

En el archivo proyecto_django/urls.py tienen que incluirse las rutas de cada app:

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

urlpatterns = [
    path("", include("apps.home.urls")),
    path('admin/', admin.site.urls)
]

Debugging con Django

Para probar nuestra aplicación simplemente ejecutamos el siguiente comando:

python manage.py runserver

Abre un navegador y visita http://127.0.0.1:8000 para ver una página que renderiza "Hello, Django!".

Seguramente te estarás preguntando si existe una manera más fácil de ejecutar el servidor de desarrollo, y has llegado a la parte indicada.

Vamos a crear algo genial en VS Code que ayudará tanto a correr la aplicación como para realizar debugging.

Cambia el modo Run and Debug en el lado izquierdo de tu barra de actividad y verás el mensaje "To customize Run and Debug create a launch.json file", si das clic en el enlace create a launch.json file esto va a crear un archivo launch.json que contendrá las configuraciones de depuración.

Selecciona el enlace y VS Code te solicitará una configuración para depuración. Selecciona Django y automáticamente VS Code crea el archivo launch.json con las configuraciones para ejecutar la aplicación de Django.

Visualiza la configuración que se genero:

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Django",
            "type": "python",
            "request": "launch",
            "program": "${workspaceFolder}/manage.py",
            "args": [
                "runserver"
            ],
            "django": true
        }
    ]
}

Prácticamente esta configuración dice que ejecute "${workspaceFolder}/manage.py" con los argumentos en la lista args.

Vamos ahora a probar la configuración, selecciona la opción Run > Start Debugging, o selecciona la flecha verde para ejecutar el servidor de desarrollo:

Abre el navegador, visita http://127.0.0.1:8000 y verifica que la aplicación se ejecuta correctamente. De ahora en adelante puedes usar Run > Start Debugging en cualquier momento para probar la aplicación.

Y hemos llegado al final de este post, cuéntame en los comentarios que te ha parecido, si tienes dudas o sugerencias con respecto al contenido, estoy seguro que aprenderemos juntos, ya que la mejor manera de aprender es enseñando.

Por último dime que te gustaría ver en próximos posts y házmelo saber a través de mis redes sociales.

14

Categorías:

PythonDjango

Tags:

PythonDjangoVscode