Kurs Python · Moduł 4: Dane, API i bazy danych

HTTP - protokół wymiany danych

9 min czytania ·
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:

  1. Klient (np. przeglądarka, aplikacja Python) wysyła zapytanie (request)
  2. Serwer (np. strona, API) przetwarza zapytanie
  3. 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ć:

MetodaPrzeznaczenieAnalogia Safari
GETPobierz dane"Pokaż mi listę gatunków"
POSTUtwórz nowy zasób"Dodaj nową obserwację słonia"
PUTZaktualizuj cały zasób"Zastąp cały profil lwa nowymi danymi"
PATCHZaktualizuj część zasobu"Zmień tylko populację goryla"
DELETEUsuń 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.com

Cechy:

  • 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 requests

Podstawowe 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 URL

Nagłó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 klienta
  • Accept - oczekiwany format odpowiedzi
  • Content-Type - format wysyłanych danych
  • Authorization - 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 danych

Podsumowanie

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. 1. Która metoda HTTP służy do pobierania danych?

  2. 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)

  1. PytanieMetody HTTP
  2. PytanieBiblioteka requests
  3. PytanieKody HTTP
  4. Ułóż w kolejnościRequests GET
  5. PytanieKod 404
  6. Kliknij w kolejnościBudowanie import json, csv
  7. Zadanie z kodemRequest GET
  8. Zadanie z kodemParsowanie JSON z response
  9. Kliknij w kolejnościRequest GET

Przydatne artykuły