Przewodnik dla początkujących Django: Szybkie tworzenie pierwszej aplikacji internetowej
2/19/2026
5 min read
# Przewodnik dla początkujących Django: Szybkie tworzenie pierwszej aplikacji internetowej
Django to zaawansowany framework internetowy Pythona, którego celem jest szybkie tworzenie i przejrzysta konstrukcja. Działa w oparciu o architekturę Model-Template-View (MTV), zachęcając do ponownego wykorzystania kodu i komponentów. Ten przewodnik poprowadzi Cię krok po kroku przez proces tworzenia prostej aplikacji Django, abyś mógł szybko zacząć.
## 1. Konfiguracja środowiska
Najpierw musisz upewnić się, że masz zainstalowanego Pythona w swoim systemie. Django zaleca używanie Pythona w wersji 3.6 lub nowszej.
### 1.1 Instalacja Pythona
Jeśli nie masz zainstalowanego Pythona w swoim systemie, możesz go pobrać i zainstalować ze [strony internetowej Pythona](https://www.python.org/downloads/).
### 1.2 Tworzenie środowiska wirtualnego (Virtual Environment)
W celu odizolowania zależności między różnymi projektami, zdecydowanie zaleca się używanie środowiska wirtualnego.
1. Otwórz terminal lub wiersz poleceń.
2. Utwórz katalog projektu, na przykład `myproject`:
```bash
mkdir myproject
cd myproject
```
3. Utwórz i aktywuj środowisko wirtualne:
```bash
python3 -m venv venv # Lub python -m venv venv
source venv/bin/activate # Linux/macOS
venv\Scripts\activate # Windows
```
Po aktywacji środowiska wirtualnego, w wierszu poleceń pojawi się `(venv)`, co oznacza, że używasz środowiska wirtualnego.
### 1.3 Instalacja Django
W aktywnym środowisku wirtualnym użyj pip do zainstalowania Django:
```bash
pip install Django
```
Sprawdź, czy instalacja się powiodła:
```bash
python -m django --version
```
Powinieneś zobaczyć numer wersji Django.
## 2. Tworzenie projektu Django
Po zainstalowaniu Django możesz utworzyć nowy projekt Django.
1. Nadal w katalogu projektu (`myproject`), uruchom następujące polecenie:
```bash
django-admin startproject mysite
```
Spowoduje to utworzenie katalogu o nazwie `mysite` w katalogu `myproject`, zawierającego szkieletowe pliki projektu Django.
2. Wejdź do katalogu `mysite`:
```bash
cd mysite
```
3. Struktura katalogów projektu Django jest następująca:
```
mysite/
manage.py
mysite/
__init__.py
settings.py
urls.py
asgi.py
wsgi.py
```
* `manage.py`: Narzędzie wiersza poleceń do zarządzania projektem Django.
* `mysite/`: Pakiet Python zawierający konfigurację projektu.
* `__init__.py`: Pusty plik, który informuje Pythona, że katalog powinien być traktowany jako pakiet Python.
* `settings.py`: Plik konfiguracyjny projektu, na przykład ustawienia bazy danych, tryb debugowania itp.
* `urls.py`: Konfiguracja routingu URL, która mapuje adresy URL na funkcje widoków.
* `asgi.py`: Plik konfiguracyjny ASGI (Asynchronous Server Gateway Interface), używany do wdrażania aplikacji asynchronicznych.
* `wsgi.py`: Plik konfiguracyjny WSGI (Web Server Gateway Interface), używany do wdrażania tradycyjnych aplikacji synchronicznych.
## 3. Uruchomienie serwera deweloperskiego
Django posiada wbudowany lekki serwer deweloperski, który ułatwia lokalne tworzenie i testowanie.
1. W katalogu `mysite` uruchom następujące polecenie:
```bash
python manage.py runserver
```
2. Otwórz przeglądarkę i przejdź do `http://127.0.0.1:8000/`. Powinieneś zobaczyć stronę z napisem "It worked! Congratulations on your first Django-powered page.".
## 4. Tworzenie aplikacji Django
Jeden projekt Django może zawierać wiele aplikacji. Utwórzmy aplikację o nazwie `myapp`.
1. Otwórz nowe okno terminala (pozostaw serwer deweloperski uruchomiony).
2. W katalogu `mysite` uruchom następujące polecenie:
```bash
python manage.py startapp myapp
```
To spowoduje utworzenie katalogu o nazwie `myapp` w katalogu `mysite`, zawierającego szkielet plików aplikacji Django.
3. Struktura katalogu aplikacji Django jest następująca:
```
myapp/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
```
* `__init__.py`: Pusty plik, który informuje Pythona, że katalog powinien być traktowany jako pakiet Pythona.
* `admin.py`: Służy do konfigurowania panelu administracyjnego Django.
* `apps.py`: Konfiguracja aplikacji.
* `migrations/`: Służy do zarządzania migracjami bazy danych.
* `models.py`: Definiuje modele danych (tabele bazy danych).
* `tests.py`: Pisanie przypadków testowych.
* `views.py`: Definiuje funkcje widoków, które obsługują żądania i zwracają odpowiedzi.
4. W pliku `mysite/settings.py` dodaj `myapp` do listy `INSTALLED_APPS`:
```python
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'myapp', # Dodaj myapp
]
```
## 5. Tworzenie prostego widoku
Teraz utworzymy prosty widok, który wyświetli w przeglądarce "Hello, Django!".
1. Edytuj plik `myapp/views.py` i dodaj następujący kod:
```python
from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, Django!")
```
2. Utwórz plik `myapp/urls.py` i zmapuj adres URL do funkcji widoku:
```python
from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='index'),
]
```
3. Dołącz `myapp/urls.py` do `mysite/urls.py`:
```python
from django.urls import include, path
from django.contrib import admin
urlpatterns = [
path('admin/', admin.site.urls),
path('myapp/', include('myapp.urls')), # Dodaj konfigurację URL dla myapp
]
```
4. Odwiedź `http://127.0.0.1:8000/myapp/`. Powinieneś zobaczyć stronę z napisem "Hello, Django!".
## 6. Utwórz model
Stwórzmy prosty model do przechowywania danych.
1. Edytuj plik `myapp/models.py`, dodając następujący kod:
```python
from django.db import models
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
def __str__(self):
return self.question_text
```
To definiuje model o nazwie `Question`, zawierający dwa pola: `question_text` (CharField) i `pub_date` (DateTimeField).
2. Utwórz i zastosuj migracje bazy danych:
```bash
python manage.py makemigrations myapp
python manage.py migrate
```
Komenda `makemigrations` utworzy plik migracji na podstawie twojego modelu, a komenda `migrate` zastosuje migracje do bazy danych.
## 7. Użyj panelu administracyjnego Django
Django udostępnia potężny panel administracyjny, który ułatwia zarządzanie danymi.
1. Utwórz superużytkownika:
```bash
python manage.py createsuperuser
```
Postępuj zgodnie z instrukcjami, aby wprowadzić nazwę użytkownika, adres e-mail i hasło.
2. Edytuj plik `myapp/admin.py`, rejestrując model `Question`:
```python
from django.contrib import admin
from .models import Question
admin.site.register(Question)
```
3. Odwiedź `http://127.0.0.1:8000/admin/`, używając utworzonego superużytkownika do zalogowania się. Powinieneś zobaczyć moduł "Questions", w którym możesz dodawać, edytować i usuwać pytania.
## 8. Użyj szablonów
Używanie szablonów pozwala na bardziej elastyczne generowanie stron HTML.
1. W katalogu `myapp` utwórz katalog o nazwie `templates`, a w katalogu `templates` utwórz katalog o nazwie `myapp` ( `myapp/templates/myapp` ).
2. W katalogu `myapp/templates/myapp` utwórz plik o nazwie `index.html` i dodaj następujący kod:
```html
Hello, Django!
Aktualny czas to: {{ current_time }} ``` 3. Edytuj plik `myapp/views.py`, używając szablonu: ```python from django.shortcuts import render import datetime def index(request): now = datetime.datetime.now() return render(request, 'myapp/index.html', {'current_time': now}) ``` Funkcja `render` załaduje szablon i przekaże dane do szablonu w celu renderowania. 4. Odwiedź ponownie `http://127.0.0.1:8000/myapp/`. Powinieneś zobaczyć stronę zawierającą aktualny czas. ## 9. Wnioski Dzięki temu przewodnikowi poznałeś podstawowe koncepcje i metody używania Django, w tym konfigurację środowiska, tworzenie projektów i aplikacji, definiowanie modeli, tworzenie widoków i używanie szablonów. To dopiero początek, Django oferuje bogate funkcje, możesz kontynuować naukę i eksplorację, aby budować bardziej złożone aplikacje internetowe.Published in Technology
