Kurs Python · Moduł 4: Dane, API i bazy danych
NoSQL - MongoDB w dżungli
W tej lekcji7
Gratulacje! To ostatnia lekcja Modułu 4. Darwin tutaj po raz ostatni w tym module!
Poznałeś/aś SQL - relacyjne bazy z tabelami, wierszami, kolumnami i sztywnymi schematami. Teraz czas na NoSQL - elastyczne bazy dokumentowe bez sztywnej struktury!
Analogia Safari: SQL to jak katalog z szufladkami i kartotekami - wszystko ma swoje miejsce. MongoDB to notatnik terenowy - zapisujesz obserwacje w dowolnej formie, bez sztywnego formatu!
Czym jest NoSQL?
NoSQL (Not Only SQL) to rodzina baz danych, które nie używają relacyjnego modelu tabel.
Typy baz NoSQL:
- Dokumentowe (MongoDB, CouchDB) - dokumenty JSON-like
- Klucz-wartość (Redis, DynamoDB) - proste pary klucz: wartość
- Kolumnowe (Cassandra, HBase) - kolumny zamiast wierszy
- Grafowe (Neo4j, ArangoDB) - węzły i relacje
W tej lekcji: MongoDB - najpopularniejsza baza dokumentowa!
MongoDB - baza dokumentowa
MongoDB przechowuje dane jako dokumenty BSON (Binary JSON):
{
"_id": ObjectId("507f1f77bcf86cd799439011"),
"scientific_name": "Panthera leo",
"common_name": "Lew",
"population": 120,
"habitat": "sawanna",
"endangered": true,
"observations": [
{"date": "2024-01-15", "location": "Serengeti", "count": 12},
{"date": "2024-01-20", "location": "Masai Mara", "count": 8}
],
"tags": ["carnivore", "big cat", "africa"]
}Cechy:
- Elastyczny schemat - każdy dokument może mieć inne pola
- Zagnieżdżone struktury - obiekty i tablice
- Skalowanie horyzontalne
- Szybkie dla niektórych zastosowań
MongoDB vs SQL
| Koncepcja | SQL | MongoDB |
|---|---|---|
| Baza danych | Database | Database |
| Tabela | Table | Collection |
| Wiersz | Row | Document |
| Kolumna | Column | Field |
| Klucz główny | Primary Key | _id (automatyczny) |
| JOIN | JOIN | Embedded docs / $lookup |
| Schemat | Sztywny | Elastyczny |
PyMongo - MongoDB w Pythonie
PyMongo to oficjalny driver MongoDB dla Pythona.
Instalacja
pip install pymongoUwaga: Potrzebujesz uruchomionego serwera MongoDB:
- Zainstaluj MongoDB Community: https://www.mongodb.com/try/download/community
- Lub użyj MongoDB Atlas (cloud, darmowy tier): https://www.mongodb.com/cloud/atlas
Połączenie z MongoDB
from pymongo import MongoClient
# Połączenie lokalne
client = MongoClient("mongodb://localhost:27017/")
# Lub MongoDB Atlas (cloud)
# client = MongoClient("mongodb+srv://username:password@cluster.mongodb.net/")
# Wybierz bazę danych
db = client["safari_database"]
# Wybierz kolekcję (jak tabela w SQL)
species_collection = db["species"]CRUD w MongoDB
CREATE - dodawanie dokumentów
from pymongo import MongoClient
from datetime import datetime
client = MongoClient("mongodb://localhost:27017/")
db = client["safari_database"]
species = db["species"]
# Dodaj jeden dokument
lion = {
"scientific_name": "Panthera leo",
"common_name": "Lew",
"population": 120,
"habitat": "sawanna",
"endangered": True,
"created_at": datetime.utcnow(),
"observations": [
{"date": "2024-01-15", "location": "Serengeti", "count": 12},
{"date": "2024-01-20", "location": "Masai Mara", "count": 8}
],
"tags": ["carnivore", "big cat", "africa"]
}
result = species.insert_one(lion)
print(f"Dodano dokument ID: {result.inserted_id}")
# Dodaj wiele dokumentów
many_species = [
{
"scientific_name": "Loxodonta africana",
"common_name": "Słoń",
"population": 450,
"endangered": True
},
{
"scientific_name": "Gorilla gorilla",
"common_name": "Goryl",
"population": 230,
"endangered": True
}
]
result = species.insert_many(many_species)
print(f"Dodano {len(result.inserted_ids)} dokumentów")READ - pobieranie dokumentów
# Wszystkie dokumenty
all_species = species.find()
for doc in all_species:
print(doc["common_name"], doc["population"])
# Jeden dokument
lion = species.find_one({"common_name": "Lew"})
print(lion)
# Filtrowanie - WHERE
endangered = species.find({"endangered": True})
savanna = species.find({"habitat": "sawanna"})
# Wiele warunków (AND)
results = species.find({
"endangered": True,
"population": {"$gt": 100} # $gt = greater than (>)
})
# OR
results = species.find({
"$or": [
{"habitat": "sawanna"},
{"habitat": "las"}
]
})
# Operatory porównania
# $gt - greater than (>)
# $gte - greater than or equal (>=)
# $lt - less than (<)
# $lte - less than or equal (<=)
# $ne - not equal (!=)
# $in - in list
large_population = species.find({"population": {"$gte": 200}})
specific_habitats = species.find({"habitat": {"$in": ["sawanna", "las"]}})
# Sortowanie
sorted_species = species.find().sort("population", -1) # -1 = descending
# Limit
top_5 = species.find().limit(5)
# Projekcja - wybierz tylko niektóre pola
names_only = species.find({}, {"common_name": 1, "population": 1, "_id": 0})
# Count
count = species.count_documents({})
endangered_count = species.count_documents({"endangered": True})UPDATE - aktualizacja dokumentów
# Zaktualizuj jeden dokument
species.update_one(
{"common_name": "Lew"}, # Filtr
{"$set": {"population": 125}} # Aktualizacja
)
# Zaktualizuj wiele dokumentów
species.update_many(
{"habitat": "sawanna"},
{"$set": {"endangered": True}}
)
# Operatory aktualizacji:
# $set - ustaw wartość
# $inc - inkrementuj
# $push - dodaj do tablicy
# $pull - usuń z tablicy
# Przykłady
species.update_one(
{"common_name": "Lew"},
{
"$inc": {"population": 5}, # Zwiększ o 5
"$push": { # Dodaj obserwację
"observations": {
"date": "2024-01-25",
"location": "Ngorongoro",
"count": 10
}
}
}
)DELETE - usuwanie dokumentów
# Usuń jeden dokument
species.delete_one({"common_name": "Test Species"})
# Usuń wiele dokumentów
species.delete_many({"population": 0})
# Usuń wszystkie (OSTROŻNIE!)
# species.delete_many({})Safari przykład - kompletny system MongoDB
from pymongo import MongoClient
from datetime import datetime
from typing import List, Dict, Optional
class SafariMongoDB:
"""Zarządzanie bazą danych Safari w MongoDB"""
def __init__(self, connection_string: str = "mongodb://localhost:27017/"):
self.client = MongoClient(connection_string)
self.db = self.client["safari_database"]
self.species = self.db["species"]
# === SPECIES ===
def create_species(self, scientific_name: str, common_name: str,
population: int = 0, habitat: str = "",
endangered: bool = False, tags: List[str] = None) -> str:
"""Dodaj gatunek"""
species_doc = {
"scientific_name": scientific_name,
"common_name": common_name,
"population": population,
"habitat": habitat,
"endangered": endangered,
"tags": tags or [],
"observations": [],
"created_at": datetime.utcnow(),
"updated_at": datetime.utcnow()
}
result = self.species.insert_one(species_doc)
return str(result.inserted_id)
def get_species(self, species_id: str) -> Optional[Dict]:
"""Pobierz gatunek po ID"""
from bson import ObjectId
return self.species.find_one({"_id": ObjectId(species_id)})
def get_species_by_name(self, common_name: str) -> Optional[Dict]:
"""Pobierz gatunek po nazwie"""
return self.species.find_one({"common_name": common_name})
def list_species(self, endangered: Optional[bool] = None,
habitat: Optional[str] = None,
min_population: int = 0) -> List[Dict]:
"""Lista gatunków z filtrami"""
query = {"population": {"$gte": min_population}}
if endangered is not None:
query["endangered"] = endangered
if habitat:
query["habitat"] = habitat
return list(self.species.find(query).sort("common_name", 1))
def update_species(self, common_name: str, **kwargs) -> bool:
"""Zaktualizuj gatunek"""
if not kwargs:
return False
kwargs["updated_at"] = datetime.utcnow()
result = self.species.update_one(
{"common_name": common_name},
{"$set": kwargs}
)
return result.modified_count > 0
def delete_species(self, common_name: str) -> bool:
"""Usuń gatunek"""
result = self.species.delete_one({"common_name": common_name})
return result.deleted_count > 0
# === OBSERVATIONS ===
def add_observation(self, common_name: str, observation_date: str,
location: str, count: int, notes: str = "") -> bool:
"""Dodaj obserwację do gatunku"""
observation = {
"date": observation_date,
"location": location,
"count": count,
"notes": notes,
"recorded_at": datetime.utcnow()
}
result = self.species.update_one(
{"common_name": common_name},
{"$push": {"observations": observation}}
)
return result.modified_count > 0
def get_observations(self, common_name: str) -> List[Dict]:
"""Pobierz obserwacje gatunku"""
species = self.species.find_one(
{"common_name": common_name},
{"observations": 1, "_id": 0}
)
return species.get("observations", []) if species else []
# === STATISTICS ===
def get_statistics(self) -> Dict:
"""Statystyki bazy"""
pipeline = [
{
"$group": {
"_id": "$habitat",
"count": {"$sum": 1},
"total_population": {"$sum": "$population"}
}
},
{"$sort": {"count": -1}}
]
by_habitat = list(self.species.aggregate(pipeline))
return {
"total_species": self.species.count_documents({}),
"endangered_count": self.species.count_documents({"endangered": True}),
"by_habitat": by_habitat
}
def close(self):
"""Zamknij połączenie"""
self.client.close()
# === DEMONSTRACJA ===
print("=== SAFARI MONGODB SYSTEM ===\n")
db = SafariMongoDB()
# 1. Dodaj gatunki
print("1. Dodawanie gatunków...")
lion_id = db.create_species(
"Panthera leo", "Lew", 120, "sawanna", True,
tags=["carnivore", "big cat", "africa"]
)
elephant_id = db.create_species("Loxodonta africana", "Słoń", 450, "sawanna", True)
gorilla_id = db.create_species("Gorilla gorilla", "Goryl", 230, "las", True)
print(f" Dodano 3 gatunki")
# 2. Pobierz gatunek
print("\n2. Pobieranie gatunku...")
lion = db.get_species_by_name("Lew")
print(f" {lion['common_name']}: {lion['population']} osobników")
print(f" Tagi: {', '.join(lion.get('tags', []))}")
# 3. Lista zagrożonych
print("\n3. Lista zagrożonych gatunków...")
endangered = db.list_species(endangered=True)
for species in endangered:
print(f" - {species['common_name']}: {species['population']}")
# 4. Aktualizacja
print("\n4. Aktualizacja populacji...")
db.update_species("Lew", population=125)
lion = db.get_species_by_name("Lew")
print(f" Nowa populacja: {lion['population']}")
# 5. Dodaj obserwacje (zagnieżdżone w dokumencie!)
print("\n5. Dodawanie obserwacji...")
db.add_observation("Lew", "2024-01-15", "Serengeti", 12, "Pride with 2 cubs")
db.add_observation("Lew", "2024-01-20", "Masai Mara", 8, "Male coalition")
# 6. Pobierz obserwacje
print("\n6. Obserwacje lwa...")
observations = db.get_observations("Lew")
for obs in observations:
print(f" - {obs['date']}: {obs['count']}x @ {obs['location']}")
# 7. Statystyki
print("\n7. Statystyki bazy...")
stats = db.get_statistics()
print(f" Łącznie gatunków: {stats['total_species']}")
print(f" Zagrożone: {stats['endangered_count']}")
print(" Według siedliska:")
for habitat_stat in stats['by_habitat']:
print(f" - {habitat_stat['_id']}: {habitat_stat['count']} gatunków")
db.close()
print("\nDemonstracja zakończona")Kiedy używać MongoDB vs SQL?
Użyj MongoDB gdy:
- Elastyczny schemat (dane różnią się między rekordami)
- Zagnieżdżone struktury (JSON-like dane)
- Szybki prototyp (brak migracji schematu)
- Skalowanie horyzontalne
- Dane nierelacyjne
Użyj SQL gdy:
- Sztywny schemat (dane strukturalne)
- Skomplikowane relacje (wiele JOIN-ów)
- Transakcje ACID krytyczne
- Raportowanie i analityka
- Tradycyjne aplikacje biznesowe
Często: Używa się obu - SQL do danych transakcyjnych, MongoDB do logów, cache, sesji!
Podsumowanie - Moduł 4 zakończony!
Gratulacje! Ukończyłeś/aś Moduł 4: Przepływ Danych!
W tym module nauczyłeś/aś się:
Lekcja 1: Formaty danych
- JSON, CSV, XML, YAML
- Serializacja i deserializacja
- Konwersja między formatami
Lekcja 2: HTTP i requests
- Protokół HTTP (GET, POST, PUT, DELETE)
- Kody statusu (200, 404, 500)
- Biblioteka requests
- Obsługa błędów, timeouty, sesje
Lekcja 3: REST API
- Zasady REST (zasoby, metody, stateless)
- RESTful endpoints
- Paginacja, filtrowanie, sortowanie
- Best practices API
Lekcja 4: Web scraping
- BeautifulSoup4 (find, select)
- Ekstrakcja danych z HTML
- Selenium dla JavaScript
- Etyka scrapingu
Lekcja 5: SQL i SQLite
- Relacyjne bazy danych
- SQL: CREATE, INSERT, SELECT, UPDATE, DELETE
- JOIN, WHERE, ORDER BY
- Python sqlite3
Lekcja 6: SQLAlchemy ORM
- Modele i klasy Python
- CRUD z ORM
- Relacje (One-to-Many)
- Query API
Lekcja 7: NoSQL MongoDB
- Dokumentowa baza danych
- PyMongo
- Elastyczny schemat
- MongoDB vs SQL
Analogia Safari finalna: Teraz potrafisz zbierać dane (scraping), przesyłać je (HTTP), przechowywać (SQL/MongoDB) i udostępniać (REST API) - kompletny cykl życia danych w aplikacji Safari!
Jesteś gotowy/a na Moduł 5 i dalsze przygody z Darwinem! Do zobaczenia wkrótce!
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. Główna różnica między NoSQL a SQL:
2. W MongoDB dane przechowywane są jako:
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Wstaw dokument animal = {'name': 'Tygrys', 'weight': 200} do kolekcji 'animals'
- Edytor kodu
Znajdź wszystkie dokumenty gdzie weight > 100
- Klikanie w kolejności
Kliknij elementy w prawidłowej kolejności:
- Układanie w pionie
Uporządkuj budowanie klienta REST API:
- Edytor kodu
Stwórz klasę SafariAPIClient z metodami: get_animals(), get_animal_by_id()
- Edytor kodu
Stwórz klasę DatabaseManager z metodami: save_animal(), get_all_animals(), search()
- Edytor kodu
Stwórz kompletny Safari Data Hub z menu, pobieraniem z API, zapisem do bazy, wyszukiwaniem
- Układanie w pionie
Uporządkuj kroki pracy z SQLAlchemy:
- Układanie w pionie
Uporządkuj kroki pełnego cyklu pracy z danymi:
Zadania po tej lekcji
- PytanieNoSQL vs SQL
- PytanieMongoDB
- Zadanie z kodemMongoDB insert
- Zadanie z kodemMongoDB find
- Kliknij w kolejnościBudowanie find_all()
- Ułóż w kolejnościREST API pattern
- Zadanie z kodemProjekt - API Client
- Zadanie z kodemProjekt - Database Manager
- Zadanie z kodemProjekt - Safari Data Hub
- Ułóż w kolejnościSQLAlchemy workflow
- Ułóż w kolejnościPełny cykl danych
- PytaniePodsumowanie - JSON
- PytaniePodsumowanie - HTTP
- Projekt do wysłaniaWyślij Safari Data Hub do mentora
- WideoPodsumowanie modułu