Kurs Python · Moduł 4: Dane, API i bazy danych
HTTP - protokół wymiany danych
W tej lekcji14
Witaj ponownie! Darwin tutaj.
W poprzedniej lekcji nauczyłeś/aś się formatów danych - jak przechowywać informacje (JSON, CSV, XML, YAML). Teraz czas na HTTP - protokół, który pozwala przesyłać te dane przez internet!
Analogia Safari: Formaty danych to język, w którym zapisujesz obserwacje. HTTP to system kurierski - sposób, w jaki wysyłasz te obserwacje między stacjami badawczymi w różnych częściach Afryki!
Czym jest HTTP?
HTTP (HyperText Transfer Protocol) to protokół komunikacyjny - zbiór zasad, według których komputery wymieniają się danymi przez internet.
Jak to działa:
- Klient (np. przeglądarka, aplikacja Python) wysyła zapytanie (request)
- Serwer (np. strona, API) przetwarza zapytanie
- Serwer odsyła odpowiedź (response) z danymi lub informacją o błędzie
[KLIENT] ---(HTTP REQUEST)---> [SERWER]
↓ ↓
↓ Przetwarza
↓ ↓
↓ <---(HTTP RESPONSE)--- [SERWER]Przykład Safari: Wysyłasz prośbę do centralnej bazy danych w Nairobi: "Podaj mi dane o lwach w Serengeti". Serwer odpowiada: "Oto 120 lwów w formie JSON"!
Metody HTTP - rodzaje zapytań
HTTP ma różne metody (czasem nazywane "czasownikami") - określają CO chcesz zrobić:
| Metoda | Przeznaczenie | Analogia Safari |
|---|---|---|
| GET | Pobierz dane | "Pokaż mi listę gatunków" |
| POST | Utwórz nowy zasób | "Dodaj nową obserwację słonia" |
| PUT | Zaktualizuj cały zasób | "Zastąp cały profil lwa nowymi danymi" |
| PATCH | Zaktualizuj część zasobu | "Zmień tylko populację goryla" |
| DELETE | Usuń zasób | "Usuń błędną obserwację" |
Najważniejsze: GET i POST - używane w 90% przypadków!
GET - pobieranie danych
GET /api/species/lion HTTP/1.1
Host: safari-api.comCechy:
- Nie modyfikuje danych na serwerze
- Parametry w URL (
?name=lion&habitat=savanna) - Można zapisać w zakładkach
- Bezpieczna do wielokrotnego wywołania
POST - tworzenie/wysyłanie danych
POST /api/observations HTTP/1.1
Host: safari-api.com
Content-Type: application/json
{
"species": "Panthera leo",
"count": 12,
"location": "Serengeti"
}Cechy:
- Wysyła dane w ciele zapytania (body), nie w URL
- Może modyfikować dane na serwerze
- Nie zapisuje się w historii przeglądarki
- Może tworzyć nowe zasoby
Kody statusu HTTP - odpowiedzi serwera
Serwer zawsze odpowiada kodem statusu - liczbą mówiącą czy operacja się powiodła:
2xx - Sukces
- 200 OK - zapytanie udane, oto dane
- 201 Created - zasób został utworzony
- 204 No Content - sukces, ale brak danych do zwrócenia
3xx - Przekierowanie
- 301 Moved Permanently - zasób przeniesiony na stałe
- 302 Found - tymczasowe przekierowanie
4xx - Błąd klienta
- 400 Bad Request - błędne zapytanie (np. zły JSON)
- 401 Unauthorized - wymagane uwierzytelnienie
- 403 Forbidden - brak dostępu
- 404 Not Found - zasób nie istnieje
- 429 Too Many Requests - zbyt wiele zapytań
5xx - Błąd serwera
- 500 Internal Server Error - błąd serwera
- 502 Bad Gateway - problem z serwerem pośredniczącym
- 503 Service Unavailable - serwer niedostępny
Analogia Safari: Kod 200 = "Znalazłem lwa!", 404 = "Nie ma tu żadnego lwa", 500 = "Mój radiotelefon się zepsuł"
Python requests - biblioteka HTTP
requests to najpopularniejsza biblioteka Python do HTTP - prosta, elegancka, potężna!
Instalacja
pip install requestsPodstawowe użycie - GET request
import requests
# Pobierz dane
response = requests.get("https://api.github.com/users/octocat")
# Status code
print(response.status_code) # 200
# Dane jako JSON
data = response.json()
print(data["login"]) # "octocat"
print(data["name"]) # "The Octocat"
# Dane jako tekst
print(response.text) # Surowy JSON jako string
# Nagłówki odpowiedzi
print(response.headers["Content-Type"]) # "application/json"Sprawdzanie sukcesu
import requests
response = requests.get("https://api.github.com/users/nonexistent")
# Metoda 1: Sprawdź status code
if response.status_code == 200:
print("Sukces!")
elif response.status_code == 404:
print("Nie znaleziono")
# Metoda 2: Użyj response.ok (True dla 2xx)
if response.ok:
data = response.json()
print(data)
else:
print(f"Błąd: {response.status_code}")
# Metoda 3: Rzuć wyjątek przy błędzie
try:
response.raise_for_status() # Rzuca HTTPError dla 4xx/5xx
data = response.json()
except requests.HTTPError as e:
print(f"HTTP Error: {e}")Parametry URL - query parameters
GET requests często używają parametrów w URL:
import requests
# Ręcznie w URL
response = requests.get("https://api.example.com/species?habitat=savanna&endangered=true")
# Lepiej: słownik params (automatyczne kodowanie)
params = {
"habitat": "savanna",
"endangered": "true",
"min_population": 100
}
response = requests.get("https://api.example.com/species", params=params)
# URL: https://api.example.com/species?habitat=savanna&endangered=true&min_population=100
print(response.url) # Zobacz wygenerowany URLNagłówki (Headers)
Nagłówki to metadane zapytania - informacje o kliencie, oczekiwanym formacie, autoryzacji:
import requests
# Własne nagłówki
headers = {
"User-Agent": "Safari-Data-Collector/1.0",
"Accept": "application/json",
"Authorization": "Bearer YOUR_API_KEY_HERE"
}
response = requests.get("https://api.example.com/species", headers=headers)
# Sprawdź nagłówki odpowiedzi
print(response.headers["Content-Type"])
print(response.headers["Date"])Popularne nagłówki:
User-Agent- identyfikacja klientaAccept- oczekiwany format odpowiedziContent-Type- format wysyłanych danychAuthorization- token/klucz API
POST request - wysyłanie danych
JSON payload
import requests
# Dane do wysłania
new_observation = {
"species": "Panthera leo",
"location": "Serengeti",
"count": 12,
"date": "2024-01-15",
"observer": "Darwin"
}
# POST z JSON
response = requests.post(
"https://api.safari.com/observations",
json=new_observation # Automatycznie: Content-Type: application/json
)
if response.status_code == 201: # Created
created_data = response.json()
print(f"Utworzono obserwację ID: {created_data['id']}")
else:
print(f"Błąd: {response.status_code}")Form data (application/x-www-form-urlencoded)
import requests
# Dane formularza
form_data = {
"species": "Loxodonta africana",
"count": "35"
}
response = requests.post(
"https://api.safari.com/quick-report",
data=form_data # Content-Type: application/x-www-form-urlencoded
)PUT, PATCH, DELETE
import requests
# PUT - zastąp cały zasób
updated_species = {
"scientific_name": "Panthera leo",
"population": 125, # Zaktualizowana
"habitat": "sawanna"
}
response = requests.put(
"https://api.safari.com/species/lion",
json=updated_species
)
# PATCH - zmień tylko część
partial_update = {
"population": 125 # Tylko populacja
}
response = requests.patch(
"https://api.safari.com/species/lion",
json=partial_update
)
# DELETE - usuń zasób
response = requests.delete("https://api.safari.com/observations/12345")
if response.status_code == 204: # No Content
print("Usunięto pomyślnie")Obsługa błędów
import requests
from requests.exceptions import RequestException, Timeout, ConnectionError
def fetch_species_data(species_id: str):
"""Pobierz dane gatunku z obsługą błędów"""
try:
response = requests.get(
f"https://api.safari.com/species/{species_id}",
timeout=5 # Timeout po 5 sekundach
)
# Sprawdź status
response.raise_for_status()
# Przetwórz dane
return response.json()
except Timeout:
print("⏱Timeout - serwer nie odpowiedział w czasie")
return None
except ConnectionError:
print("Błąd połączenia - sprawdź internet")
return None
except requests.HTTPError as e:
print(f"HTTP Error {response.status_code}: {e}")
return None
except RequestException as e:
print(f"Błąd zapytania: {e}")
return None
# Użycie
data = fetch_species_data("lion")
if data:
print(f"Gatunek: {data['name']}")Safari przykład - API klient do zarządzania obserwacjami
import requests
from typing import List, Dict, Optional
from datetime import datetime
class SafariAPIClient:
"""Klient API do systemu obserwacji Safari"""
def __init__(self, base_url: str, api_key: str):
self.base_url = base_url.rstrip("/")
self.api_key = api_key
self.session = requests.Session() # Reużywalne połączenie
# Domyślne nagłówki dla wszystkich zapytań
self.session.headers.update({
"User-Agent": "Safari-Data-Collector/2.0",
"Authorization": f"Bearer {self.api_key}",
"Accept": "application/json"
})
def get_species(self, species_id: str) -> Optional[Dict]:
"""Pobierz dane gatunku"""
try:
response = self.session.get(
f"{self.base_url}/species/{species_id}",
timeout=10
)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Błąd pobierania gatunku: {e}")
return None
def search_species(self, habitat: Optional[str] = None,
endangered: Optional[bool] = None,
min_population: Optional[int] = None) -> List[Dict]:
"""Wyszukaj gatunki z filtrami"""
params = {}
if habitat:
params["habitat"] = habitat
if endangered is not None:
params["endangered"] = str(endangered).lower()
if min_population:
params["min_population"] = min_population
try:
response = self.session.get(
f"{self.base_url}/species",
params=params,
timeout=10
)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Błąd wyszukiwania: {e}")
return []
def create_observation(self, species: str, location: str,
count: int, notes: str = "") -> Optional[Dict]:
"""Utwórz nową obserwację"""
observation_data = {
"species": species,
"location": location,
"count": count,
"date": datetime.now().isoformat(),
"notes": notes
}
try:
response = self.session.post(
f"{self.base_url}/observations",
json=observation_data,
timeout=10
)
response.raise_for_status()
if response.status_code == 201:
created = response.json()
print(f"Utworzono obserwację ID: {created.get('id')}")
return created
else:
return response.json()
except requests.RequestException as e:
print(f"Błąd tworzenia obserwacji: {e}")
return None
def update_species_population(self, species_id: str,
new_population: int) -> bool:
"""Zaktualizuj populację gatunku (PATCH)"""
try:
response = self.session.patch(
f"{self.base_url}/species/{species_id}",
json={"population": new_population},
timeout=10
)
response.raise_for_status()
print(f"Zaktualizowano populację {species_id} → {new_population}")
return True
except requests.RequestException as e:
print(f"Błąd aktualizacji: {e}")
return False
def delete_observation(self, observation_id: str) -> bool:
"""Usuń obserwację"""
try:
response = self.session.delete(
f"{self.base_url}/observations/{observation_id}",
timeout=10
)
response.raise_for_status()
if response.status_code == 204:
print(f"Usunięto obserwację {observation_id}")
return True
return False
except requests.RequestException as e:
print(f"Błąd usuwania: {e}")
return False
def get_statistics(self) -> Optional[Dict]:
"""Pobierz statystyki (z parametrami query)"""
params = {
"include_endangered": "true",
"group_by": "habitat"
}
try:
response = self.session.get(
f"{self.base_url}/statistics",
params=params,
timeout=15
)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Błąd pobierania statystyk: {e}")
return None
def close(self):
"""Zamknij sesję"""
self.session.close()
# === DEMONSTRACJA ===
print("=== SAFARI API CLIENT ===\n")
# Inicjalizacja klienta
client = SafariAPIClient(
base_url="https://api.safari-data.org/v1",
api_key="demo_key_12345"
)
# GET - pobierz gatunek
print("1. Pobieranie danych lwa...")
lion_data = client.get_species("lion")
if lion_data:
print(f" Gatunek: {lion_data.get('common_name')}")
print(f" Populacja: {lion_data.get('population')}")
# GET z parametrami - wyszukiwanie
print("\n2. Wyszukiwanie zagrożonych gatunków w sawannie...")
endangered = client.search_species(habitat="savanna", endangered=True)
print(f" Znaleziono {len(endangered)} gatunków")
# POST - tworzenie obserwacji
print("\n3. Tworzenie nowej obserwacji...")
new_obs = client.create_observation(
species="Panthera leo",
location="Serengeti North",
count=8,
notes="Pride with 2 cubs"
)
# PATCH - aktualizacja
print("\n4. Aktualizacja populacji...")
client.update_species_population("lion", 125)
# DELETE - usuwanie
print("\n5. Usuwanie błędnej obserwacji...")
client.delete_observation("obs_12345")
# GET ze statystykami
print("\n6. Pobieranie statystyk...")
stats = client.get_statistics()
if stats:
print(f" Łączna liczba gatunków: {stats.get('total_species')}")
# Zamknij sesję
client.close()
print("\nSesja zakończona")Session - wydajność dla wielu zapytań
Jeśli robisz wiele zapytań do tego samego API, użyj Session - reużywa połączenie TCP:
import requests
# BEZ Session - każde zapytanie = nowe połączenie
for i in range(100):
response = requests.get("https://api.example.com/data")
# Z Session - jedno połączenie, szybsze!
session = requests.Session()
session.headers.update({"Authorization": "Bearer token123"})
for i in range(100):
response = session.get("https://api.example.com/data")
session.close()Timeouty - nie czekaj w nieskończoność
Zawsze używaj timeout, aby zapytanie nie wisiało w nieskończoność:
import requests
# Timeout 5 sekund
response = requests.get("https://slow-api.com/data", timeout=5)
# Różne timeouty: (connect_timeout, read_timeout)
response = requests.get("https://api.com/data", timeout=(3, 10))
# 3s na połączenie, 10s na odczyt danychPodsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym jest HTTP i jak działa (klient → serwer → odpowiedź)
- Metody HTTP: GET, POST, PUT, PATCH, DELETE
- Kody statusu: 200 OK, 404 Not Found, 500 Server Error
- Biblioteka
requests:requests.get(),requests.post() - Parametry URL (
params=), nagłówki (headers=) - Wysyłanie JSON (
json=) i form data (data=) - Obsługa błędów:
response.raise_for_status(), try/except - Session dla wydajności
- Timeouty dla bezpieczeństwa
Checkpoint
Przed przejściem dalej:
- Rozumiesz różnicę między GET a POST
- Potrafisz wysłać zapytanie GET z parametrami
- Potrafisz wysłać POST z JSON
- Wiesz jak obsłużyć błędy HTTP
- Rozumiesz kody statusu (2xx, 4xx, 5xx)
Analogia Safari: HTTP to system kurierski między stacjami badawczymi. GET = "wyślij mi dane", POST = "zapisz te nowe obserwacje", kody statusu = potwierdzenia dostawy!
W następnej lekcji Darwin pokaże Ci REST API - standardy architektury API, które pozwalają budować profesjonalne systemy wymiany danych!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Która metoda HTTP służy do pobierania danych?
2. Jak wykonać request GET w bibliotece requests?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy w prawidłowej kolejności:
- Klikanie w kolejności
Kliknij elementy w prawidłowej kolejności:
- Edytor kodu
Pobierz dane z URL 'https://api.example.com/animals' używając requests
- Edytor kodu
Wykonaj GET i sparsuj odpowiedź jako JSON
- Klikanie w kolejności
Kliknij w kolejności: response = requests.get(url)