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

NoSQL - MongoDB w dżungli

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

  1. Dokumentowe (MongoDB, CouchDB) - dokumenty JSON-like
  2. Klucz-wartość (Redis, DynamoDB) - proste pary klucz: wartość
  3. Kolumnowe (Cassandra, HBase) - kolumny zamiast wierszy
  4. 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

KoncepcjaSQLMongoDB
Baza danychDatabaseDatabase
TabelaTableCollection
WierszRowDocument
KolumnaColumnField
Klucz głównyPrimary Key_id (automatyczny)
JOINJOINEmbedded docs / $lookup
SchematSztywnyElastyczny

PyMongo - MongoDB w Pythonie

PyMongo to oficjalny driver MongoDB dla Pythona.

Instalacja

pip install pymongo

Uwaga: Potrzebujesz uruchomionego serwera MongoDB:

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. 1. Główna różnica między NoSQL a SQL:

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

  1. PytanieNoSQL vs SQL
  2. PytanieMongoDB
  3. Zadanie z kodemMongoDB insert
  4. Zadanie z kodemMongoDB find
  5. Kliknij w kolejnościBudowanie find_all()
  6. Ułóż w kolejnościREST API pattern
  7. Zadanie z kodemProjekt - API Client
  8. Zadanie z kodemProjekt - Database Manager
  9. Zadanie z kodemProjekt - Safari Data Hub
  10. Ułóż w kolejnościSQLAlchemy workflow
  11. Ułóż w kolejnościPełny cykl danych
  12. PytaniePodsumowanie - JSON
  13. PytaniePodsumowanie - HTTP
  14. Projekt do wysłaniaWyślij Safari Data Hub do mentora
  15. WideoPodsumowanie modułu

Przydatne artykuły