---
title: "Escribiendo su primera aplicación en Django, parte 1"
version: 6.1
locale: es
source: https://docs.djangoproject.com/es/6.1/intro/tutorial01/
canonical: https://djangodocs.dev/es/6.1/intro/tutorial01/
---
# Escribiendo su primera aplicación en Django, parte 1

Aprendamos mediante el ejemplo.

A través de este tutorial le mostraremos cómo crear una aplicación de encuestas básica.

Consistirá de dos partes:

- Un sitio público que le permite a las personas ver sondeos y votar en ellos.
- Un sitio administrativo que le permite añadir, modificar y borrar sondeos.

Asumiremos que ya ha [instalado Django](/es/6.1/intro/install/). Puede ver si Django está instalado, así como su versión, ejecutando el siguiente comando (señalado por el prefijo $):

```console
$ python -m django --version
```

*Windows*

```doscon
...\> py -m django --version
```

Si Django está instalado, debería ver la versión de su instalación. Si no es así, obtendrá un error indicando que «No existe el módulo llamado Django».

This tutorial is written for Django 6.1, which supports Python 3.12 and
later. If the Django version doesn’t match, you can refer to the tutorial for
your version of Django by using the version switcher at the bottom right corner
of this page, or update Django to the newest version. If you’re using an older
version of Python, check [¿Qué versión de Python puedo usar con Django?](/es/6.1/faq/install/#faq-python-version-support) to find a compatible
version of Django.

> **Dónde obtener ayuda:**
>
> Si tiene problemas para seguir este tutorial, diríjase a la sección [Obteniendo ayuda](/es/6.1/faq/help/) del FAQ.

## Creando un proyecto

Si esta es la primera vez que utiliza Django, tendrá que hacerse cargo de ciertas configuraciones iniciales. Concretamente, tendrá que autogenerar un código que establezca un Django [project](/es/6.1/glossary/#term-project) – un conjunto de ajustes para una instancia de Django, incluida la configuración de la base de datos, opciones específicas de Django y configuraciones específicas de la aplicación.

From the command line, `cd` into a directory where you’d like to store your
code and run the following command to bootstrap a new Django project:

```console
$ django-admin startproject mysite djangotutorial
```

*Windows*

```doscon
...\> django-admin startproject mysite djangotutorial
```

This will create a directory `djangotutorial` with a project called
`mysite` inside. The directory name doesn’t matter to Django; you can rename
it to anything you like. If it didn’t work, see
[Problemas ejecutando django-admin](/es/6.1/faq/troubleshooting/#troubleshooting-django-admin).

> **Note**
>
> Tendrá que evitar darle nombres a sus proyectos que sean iguales a los de otros componentes integrados de Python o Django. En particular, esto quiere decir que debe evitar usar nombres como `django` (que entrará en conflicto con Django mismo) o `test` (que entrará en conflicto con un paquete interno de Python).

Veamos lo que el comando [`startproject`](/es/6.1/ref/django-admin/#django-admin-startproject) creó:

```text
djangotutorial/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
```

Estos archivos son:

- `manage.py`: Una utilidad de la línea de comandos que le permite interactuar con este proyecto Django de diferentes formas. Puede leer todos los detalles sobre `manage.py` en [django-admin and manage.py](/es/6.1/ref/django-admin/).
- `mysite/`: A directory that is the actual Python package for your
  project. Its name is the Python package name you’ll need to use to import
  anything inside it (e.g. `mysite.urls`).
- `mysite/__init__.py`: Un archivo vacío que le indica a Python que este directorio debería ser considerado como un paquete Python. Si usted es un principiante lea [más sobre los paquetes](https://docs.python.org/3/tutorial/modules.html#tut-packages) en la documentación oficial de Python.
- `mysite/settings.py`: Settings/configuration for this Django
  project. [Django settings](/es/6.1/topics/settings/) will tell you all about how settings
  work.
- `mysite/urls.py`: Las declaraciones URL para este proyecto Django; una «tabla de contenidos» de su sitio basado en Django. Puede leer más sobre las URLs en [URL dispatcher](/es/6.1/topics/http/urls/).
- `mysite/asgi.py`: An entry-point for ASGI-compatible web servers to
  serve your project. See [How to deploy with ASGI](/es/6.1/howto/deployment/asgi/) for more details.
- `mysite/wsgi.py`: Un punto de entrada para que los servidores web compatibles con WSGI puedan servir su proyecto. Consulte :doc:/howto/deployment/wsgi/index\`para más detalles.

## El servidor de desarrollo

Let’s verify your Django project works. Change into the `djangotutorial`
directory, if you haven’t already, and run the following commands:

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Verá la siguiente salida en la línea de comandos:

```
Performing system checks...

System check identified no issues (0 silenced).

You have unapplied migrations; your app may not work properly until they are
applied. Run 'python manage.py migrate' to apply them.

11 de agosto de 2026 - 15:50:53
Django version 6.1, using settings 'mysite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/6.1/howto/deployment/
```

> **Note**
>
> Ignore por ahora la advertencia sobre las migraciones de bases de datos sin aplicar, nos ocuparemos de la base de datos dentro de poco.

Now that the server’s running, visit <http://127.0.0.1:8000/> with your web
browser. You’ll see a «Congratulations!» page, with a rocket taking off.
It worked!

You’ve started the Django development server, a lightweight web server written
purely in Python. We’ve included this with Django so you can develop things
rapidly, without having to deal with configuring a production server – such as
Apache – until you’re ready for production.

Now’s a good time to note: **don’t** use this server in anything resembling a
production environment. It’s intended only for use while developing. (We’re in
the business of making web frameworks, not web servers.)

(To serve the site on a different port, see the [`runserver`](/es/6.1/ref/django-admin/#django-admin-runserver)
reference.)

> **Recarga automática del comando runserver**
>
> El servidor de desarrollo recarga de forma automática el código Python para cada petición cuando sea necesario. No es necesario reiniciar el servidor para que los cambios de código surtan efecto. Sin embargo, algunas acciones como la adición de archivos no provoca un reinicio, por lo que tendrá que reiniciar el servidor en estos casos.

## Creando la aplicación encuestas

Ahora que su entorno (un «proyecto») se ha configurado, ya está listo para empezar a trabajar.

Cada aplicación que usted escribe en Django consiste en un paquete de Python que sigue una determinada convención. Django tiene una utilidad que genera automáticamente la estructura básica de directorios de una aplicación, por lo que usted puede centrarse en la escritura de código en lugar de crear directorios.

> **Proyectos vs. aplicaciones**
>
> What’s the difference between a project and an app? An app is a web
> application that does something – e.g., a blog system, a database of
> public records or a small poll app. A project is a collection of
> configuration and apps for a particular website. A project can contain
> multiple apps. An app can be in multiple projects.

Your apps can live anywhere in your [Python path](https://docs.python.org/3/tutorial/modules.html#tut-searchpath). In
this tutorial, we’ll create our poll app inside the `djangotutorial` folder.

Para crear su aplicación, asegúrese de que está en el mismo directorio que el archivo `manage.py` y escriba este comando:

```console
$ python manage.py startapp polls
```

*Windows*

```doscon
...\> py manage.py startapp polls
```

Esto creará un directorio `polls`, que se presenta de la siguiente manera:

```text
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```

Esta estructura de directorios almacenará la aplicación encuesta.

## Escriba su primera vista

Vamos a escribir la primera vista. Abra el archivo `polls/views.py` y ponga el siguiente código Python en ella:

*`polls/views.py`*

```python
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")
```

This is the most basic view possible in Django. To access it in a browser, we
need to map it to a URL - and for this we need to define a URL configuration,
or «URLconf» for short. These URL configurations are defined inside each
Django app, and they are Python files named `urls.py`.

To define a URLconf for the `polls` app, create a file `polls/urls.py`
with the following content:

*`polls/urls.py`*

```python
from django.urls import path

from . import views

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

Su directorio de aplicaciones ahora debería verse asi:

```text
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py
```

The next step is to configure the root URLconf in the `mysite` project to
include the URLconf defined in `polls.urls`. To do this, add an import for
`django.urls.include` in `mysite/urls.py` and insert an
[`include()`](/es/6.1/ref/urls/#django.urls.include) in the `urlpatterns` list, so you have:

*`mysite/urls.py`*

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

urlpatterns = [
    path("polls/", include("polls.urls")),
    path("admin/", admin.site.urls),
]
```

The [`path()`](/es/6.1/ref/urls/#django.urls.path) function expects at least two arguments:
`route` and `view`.
The [`include()`](/es/6.1/ref/urls/#django.urls.include) function allows referencing other URLconfs.
Whenever Django encounters [`include()`](/es/6.1/ref/urls/#django.urls.include), it chops off whatever
part of the URL matched up to that point and sends the remaining string to the
included URLconf for further processing.

La idea detrás de [`include()`](/es/6.1/ref/urls/#django.urls.include) es facilitar la conexión y ejecución inmediata de las URLs. Dado que las encuestas están en su propia URLconf (`polls/urls.py`) se pueden ubicar en «/polls/», «/fun\_polls /», «/content/polls/» o en cualquier otra ruta raíz , y la aplicación todavía seguirá funcionando.

> **When to use include()**
>
> You should always use `include()` when you include other URL patterns.
> The only exception is `admin.site.urls`, which is a pre-built URLconf
> provided by Django for the default admin site.

Ahora tiene una vista `index` vinculada en los URLconf. Compruebe su funcionamiento con el siguiente comando:

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Vaya a <http://localhost:8000/polls/> en su navegador, y usted debería ver el texto «*Hello, world. You’re at the polls index.*» el cual definió en la vista `index`.

> **¿Página no encotrada?**
>
> Si usted obtiene aquí una página de error, revisee que usted este llendo a la dirección URL <http://localhost:8000/polls/> y no a la dirección URL <http://localhost:8000/>.

Cuando se familiarice con el flujo básico de solicitud y respuesta, lea [la parte 2 del presente tutorial](/es/6.1/intro/tutorial02/) para empezar a trabajar con la base de datos.