---
title: "Escrevendo seu primeiro app Django, parte 1"
version: 6.0
locale: pt-br
source: https://docs.djangoproject.com/pt-br/6.0/intro/tutorial01/
canonical: https://djangodocs.dev/pt-br/6.0/intro/tutorial01/
---
# Escrevendo seu primeiro app Django, parte 1

Vamos aprender por um exemplo.

Através deste tutorial, nós vamos caminhar através da criação de uma aplicação básica de enquetes.

Ela irá consistir de duas partes:

- Uma página pública que permitirá que pessoas vejam as enquetes e votem nelas.
- Um site de administração que permite adicionar, alterar e deletar enquetes.

Assumiremos que você já tem o [Django instalado](/pt-br/6.0/intro/install/). Você pode verificar se o Django está instalado e em qual versão rodando o seguinte comando em um prompt shell (indicado pelo prefixo $):

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

*Windows*

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

Se o Django estiver instalado, você verá a versão de sua instalação. Se não estiver, você receberá uma mensagem de erro dizendo “No module named django”.

This tutorial is written for Django 6.0, 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 [Qual versão do Python eu posso usar com Django?](/pt-br/6.0/faq/install/#faq-python-version-support) to find a compatible
version of Django.

> **Onde obter ajuda:**
>
> Se tiver problemas enquanto caminha por este tutorial, por favor consulte a seção [Obtendo ajuda](/pt-br/6.0/faq/help/) da FAQ.

## Criando um projeto

Se esta é a primeira vez em que você está utilizando o Django, você terá que preocupar-se com algumas configurações iniciais. Isto é, você precisará auto-gerar um código para iniciar um [projeto](/pt-br/6.0/glossary/#term-project) Django – uma coleção de configurações para uma instância do Django, incluindo configuração do banco de dados, opções específicas do Django e configurações específicas da aplicação.

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 ao rodar o django-admin](/pt-br/6.0/faq/troubleshooting/#troubleshooting-django-admin).

> **Note**
>
> Você precisará evitar dar nomes a projetos que remetam a componentes internos do Python ou do Django. Particularmente, isso significa que você deve evitar usar nomes como `django` (que irá conflitar com o próprio Django) ou `test` (que irá conflitar com um pacote interno do Python).

Veja a estrutura de diretório criada com o comando [`startproject`](/pt-br/6.0/ref/django-admin/#django-admin-startproject):

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

Esses arquivos são:

- `manage.py`: um utilitário de linha de comando que permite a você interagir com esse projeto Django de várias maneiras. Você pode ler todos os detalhes sobre o `manage.py` em [django-admin and manage.py](/pt-br/6.0/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`: um arquivo vazio que diz ao Python que este diretório deve ser considerado um pacote Python. Se você é um iniciante Python, leia [mais sobre pacotes](https://docs.python.org/3/tutorial/modules.html#tut-packages) na documentação oficial do Python.
- `mysite/settings.py`: Settings/configuration for this Django
  project. [Configurações do Django](/pt-br/6.0/topics/settings/) will tell you all about how settings
  work.
- `mysite/urls.py`: as declarações de URLs para este projeto Django; um “índice” de seu site movido a Django. Você pode ler mais sobre URLs em [Despachante de URL](/pt-br/6.0/topics/http/urls/).
- `mysite/asgi.py`: um ponto de integração para servidores web compatíveis com ASGI usado para servir seu projeto. Veja [Como fazer o deploy com ASGI](/pt-br/6.0/howto/deployment/asgi/) para mais detalhes.
- `mysite/wsgi.py`: um ponto de integração para servidores web compatíveis com WSGI usado para servir seu projeto. Veja [Como implementar com WSGI](/pt-br/6.0/howto/deployment/wsgi/) para mais detalhes.

## O servidor de desenvolvimento

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
```

Você verá a seguinte saída na sua linha de comando:

```
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.

09 ago. 2026 - 15:50:53
Django version 6.0, 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.0/howto/deployment/
```

> **Note**
>
> Por hora, ignore os avisos sobre as migrações do banco de dados não aplicadas; lidaremos com o banco de dados brevemente.

Agora que o servidor está funcionando, visite <http://127.0.0.1:8000/> no seu navegador web. Você verá uma página de “Congratulations!”, com um foguete decolando. Funcionou!

Você iniciou o servidor de desenvolvimento do Django, um servidor web leve escrito exclusivamente em Python. Incluímos isso no Django para que você possa desenvolver coisas rapidamente, sem ter que lidar com a configuração de um servidor de produção – como o Apache – até que esteja pronto para a produção.

Agora, uma boa recomendação: **não** use esse servidor em ambiente de produção. Porque ele foi planejado apenas para desenvolvimento. (Nosso objetivo é criar um framework web e não um servidor web).

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

> **Recarregamento automático do runserver**
>
> O servidor de desenvolvimento recarrega o código Python para cada solicitação, conforme necessário. Você não precisa reiniciar o servidor para que alterações de código tenham efeito. No entanto, algumas ações como a adição de arquivos não disparam uma reinicialização, então você terá que reiniciar o servidor nestes casos.

## Criando a aplicação de enquetes: Polls

Agora que seu ambiente – um “projeto” – está configurado, você está pronto para começar o trabalho.

Cada aplicação que você escreve no Django consiste de um pacote Python que segue uma certa convenção. O Django vem com um utilitário que gera automaticamente a estrutura básica de diretório de uma aplicação, então você pode se concentrar apenas em escrever código em vez de ficar criando diretórios.

> **Projetos versus aplicações**
>
> Qual a diferença entre um projeto e um app? Um app é uma aplicação web que executa algo, por exemplo: um sistema de blog, uma base de dados de registros públicos ou uma pequena aplicação de enquete. Um projeto é uma coleção de configurações e apps para um website específico. Um projeto pode conter múltiplos apps. Um app pode estar em múltiplos projetos.

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 criar sua aplicação, certifique-se de que esteja no mesmo diretório que `manage.py` e digite o seguinte comando:

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

*Windows*

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

Isto criará um diretório `polls`, com a seguinte estrutura:

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

Esta estrutura de diretório irá abrigar a aplicação de enquete.

## Escreva sua primeira view

Hora de criar a primeira view. Abra o arquivo `polls/views.py` e ponha o seguinte código em Python dentro dele:

*`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"),
]
```

Your app directory should now look like:

```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()`](/pt-br/6.0/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()`](/pt-br/6.0/ref/urls/#django.urls.path) function expects at least two arguments:
`route` and `view`.
The [`include()`](/pt-br/6.0/ref/urls/#django.urls.include) function allows referencing other URLconfs.
Whenever Django encounters [`include()`](/pt-br/6.0/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.

A idéia por trás do [`include()`](/pt-br/6.0/ref/urls/#django.urls.include) é facilitar plugar URLs. Uma vez que polls está em sua própria URLconf (`polls/urls.py`), ele pode ser colocado depois de  “/polls/”, ou depois de “/fun\_polls/”, u depois de “/content/polls/”, ou qualquer outro início de caminho, e a aplicação ainda irá funcionar

> **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.

Agora você amarrou uma view `index` no seu URLconf. Verique se funciona com o seguinte comando:

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

*Windows*

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

Acesse <http://localhost:8000/polls/> no seu navegador, e deverá ver o texto “*Hello, world. You’re at the polls index.*”, o qual foi definido na view “index”.

> **Página não encontrada?**
>
> Se retornar uma página de erro, verifique se está acessando <http://localhost:8000/polls/> e não  <http://localhost:8000/>.

Quando estiver confortável com o básico da sequência de requisição e resposta, leia a [parte 2 desse tutorial](/pt-br/6.0/intro/tutorial02/)  para começar a trabalhar com banco de dados.