Python a MongoDB:Připojení k NoSQL databázím

MongoDB je dokumentově orientované a NoSQL databázové řešení, které poskytuje skvělou škálovatelnost a flexibilitu spolu s výkonným dotazovacím systémem. S MongoDB a Python můžete rychle vyvíjet mnoho různých typů databázových aplikací. Pokud tedy vaše aplikace Python potřebuje databázi, která je stejně flexibilní jako samotný jazyk, pak je MongoDB pro vás.

V tomto kurzu se naučíte:

• Co MongoDB je
• Jak instalovat a spustit MongoDB
• Jak pracovat s databázemi MongoDB
• Jak používat nízkoúrovňový ovladač PyMongo pro rozhraní s MongoDB
• Jak používat vysokoúrovňový mapovač objektů a dokumentů (ODM) MongoEngine

V tomto tutoriálu napíšete několik příkladů, které demonstrují flexibilitu a sílu MongoDB a jeho skvělou podporu Pythonu. Chcete-li stáhnout zdrojový kód těchto příkladů, klikněte na odkaz níže:

Získejte zdrojový kód: Kliknutím sem získáte zdrojový kód, pomocí kterého se v tomto tutoriálu dozvíte o používání MongoDB s Pythonem.

Používání databází SQL vs NoSQL

Po desetiletí byly databáze SQL jednou z mála možností pro vývojáře, kteří chtěli budovat velké a škálovatelné databázové systémy. Rostoucí potřeba ukládání složitých datových struktur však vedla ke zrodu NoSQL databází. Tento nový druh databázového systému umožňuje vývojářům efektivně ukládat heterogenní a nestrukturovaná data.

Obecně platí, že databázové systémy NoSQL ukládají a načítají data mnohem jiným způsobem než systémy správy relačních databází SQL (RDBMS).

Pokud jde o výběr z aktuálně dostupných databázových technologií, možná se budete muset rozhodnout mezi použitím systémů SQL nebo NoSQL. Oba mají specifické vlastnosti, které byste měli zvážit při výběru jednoho nebo druhého. Zde jsou některé z jejich podstatnějších rozdílů:

Mezi těmito dvěma typy databází existuje mnoho dalších rozdílů, ale výše uvedené jsou některé z nejdůležitějších, o kterých je třeba vědět.

Při výběru databáze byste měli pečlivě zvážit její silné a slabé stránky. Musíte také zvážit, jak databáze zapadá do vašeho konkrétního scénáře a požadavků vaší aplikace. Někdy je správným řešením použití kombinace SQL a NoSQL databází ke zpracování různých aspektů širšího systému.

Mezi běžné příklady databází SQL patří:

• SQLite
• MySQL
• Oracle
• PostgreSQL
• Microsoft SQL Server

Příklady databáze NoSQL zahrnují:

• DynamoDB
• Cassandra
• Redis
• CouchDB
• Přehodnoťte DB
• RavenDB
• MongoDB

V posledních letech se dokonce začaly slučovat databáze SQL a NoSQL. Například databázové systémy jako PostgreSQL, MySQL a Microsoft SQL Server nyní podporují ukládání a dotazování JSON dat, podobně jako databáze NoSQL. Díky tomu nyní můžete dosáhnout mnoha stejných výsledků s oběma technologiemi. Stále však nezískáte mnoho funkcí NoSQL, jako je horizontální škálování a uživatelsky přívětivé rozhraní.

Díky tomuto krátkému pozadí databází SQL a NoSQL se můžete zaměřit na hlavní téma tohoto tutoriálu:databáze MongoDB a jak jej používat v Pythonu.

Správa databází NoSQL pomocí MongoDB

MongoDB je orientovaný na dokumenty databáze klasifikovaná jako NoSQL. V posledních letech se stal populární v celém odvětví a velmi dobře se integruje s Pythonem. Na rozdíl od tradičních SQL RDBMS používá MongoDB kolekce z dokumentů místo tabulek z řádků organizovat a ukládat data.

MongoDB ukládá data do bezschematických a flexibilních dokumentů podobných JSON. Zde bez schématu znamená, že můžete mít dokumenty s odlišnou sadou polí ve stejné kolekci, aniž byste museli splňovat pevné schéma tabulky .

Strukturu svých dokumentů a dat můžete v průběhu času měnit, výsledkem čehož je flexibilní systém, který vám umožní rychle se přizpůsobit změnám požadavků bez nutnosti složitého procesu migrace dat. Kompromisem při změně struktury nových dokumentů je však to, že opouštějící dokumenty se stanou nekonzistentní s aktualizovaným schématem. Toto je tedy téma, které je třeba řídit opatrně.

Poznámka: JSON je zkratka pro JavaScript Object Notation . Jde o souborový formát s lidsky čitelnou strukturou sestávající z párů klíč–hodnota, které lze vnořovat libovolně hluboko.

MongoDB je napsán v C++ a aktivně vyvíjen společností MongoDB Inc. Běží na všech hlavních platformách, jako jsou macOS, Windows, Solaris a většina distribucí Linuxu. Obecně jsou za databází MongoDB tři hlavní vývojové cíle:

1. Dobré měřítko
2. Ukládání struktur bohatých dat
3. Poskytněte sofistikovaný mechanismus dotazů

MongoDB je distribuovaný databáze, takže vysoká dostupnost, horizontální škálování a geografická distribuce jsou zabudovány do systému. Ukládá data do flexibilních dokumentů podobných JSON. Tyto dokumenty můžete modelovat a mapovat objekty ve vašich aplikacích, což umožňuje efektivně pracovat s vašimi daty.

MongoDB poskytuje výkonný dotazovací jazyk, který podporuje ad hoc dotazy, indexování, agregaci, geoprostorové vyhledávání, textové vyhledávání a mnoho dalšího. To vám nabízí výkonnou sadu nástrojů pro přístup a práci s vašimi daty. Konečně, MongoDB je volně dostupný a má skvělou podporu Pythonu.

Kontrola funkcí MongoDB

Zatím jste se dozvěděli, co je MongoDB a jaké jsou jeho hlavní cíle. V této části se dozvíte o některých důležitějších funkcích MongoDB. Co se týče správy databází, MongoDB nabízí následující funkce:

• Podpora dotazů: Můžete použít mnoho standardních typů dotazů, jako je shoda (== ), srovnání (< , > ) a regulární výrazy.
• Umístění dat: Můžete ukládat prakticky jakýkoli druh dat, ať už strukturovaná, částečně strukturovaná nebo dokonce polymorfní.
• Škálovatelnost: Zvládá více dotazů pouhým přidáním více počítačů do serverového clusteru.
• Flexibilita a agilita: Můžete s ním rychle vyvíjet aplikace.
• Orientace dokumentu a neschématost: Všechny informace týkající se datového modelu můžete uložit do jediného dokumentu.
• Nastavitelné schéma: Schéma databáze můžete měnit za chodu, což zkracuje čas potřebný k poskytování nových funkcí nebo opravě stávajících problémů.
• Funkce relační databáze: Můžete provádět akce běžné pro relační databáze, jako je indexování.

Pokud jde o provozní stránku, MongoDB poskytuje několik nástrojů a funkcí, které v jiných databázových systémech nenajdete:

• Škálovatelnost: Ať už potřebujete samostatný server nebo kompletní clustery nezávislých serverů, můžete škálovat MongoDB na jakoukoli velikost, kterou potřebujete.
• Podpora vyrovnávání zátěže: MongoDB bude automaticky přesouvat data přes různé fragmenty.
• Automatická podpora převzetí služeb při selhání: Pokud selže váš primární server, automaticky se spustí a spustí nový primární server.
• Nástroje pro správu: Své počítače můžete sledovat pomocí cloudové služby MongoDB Management Service (MMS).
• Účinnost paměti: Díky souborům mapovaným do paměti je MongoDB často efektivnější než relační databáze.

Všechny tyto funkce jsou docela užitečné. Pokud například využijete funkci indexování, bude velká část vašich dat uložena v paměti pro rychlé načtení. I bez indexování konkrétních klíčů dokumentu ukládá MongoDB do mezipaměti poměrně dost dat pomocí nejméně nedávno používané techniky.

Instalace a spuštění MongoDB

Nyní, když jste obeznámeni s MongoDB, je čas ušpinit si ruce a začít jej používat. Nejprve jej však musíte nainstalovat do počítače. Oficiální stránka MongoDB poskytuje dvě edice databázového serveru:

1. Vydání pro komunitu nabízí flexibilní model dokumentu spolu s ad hoc dotazy, indexováním a agregací v reálném čase, které poskytují účinné způsoby přístupu a analýzy vašich dat. Toto vydání je volně dostupné.
2. Edice Enterprise nabízí stejné funkce jako edice pro komunitu a navíc další pokročilé funkce související se zabezpečením a monitorováním. Toto je komerční vydání, ale můžete jej používat zdarma po neomezenou dobu pro účely hodnocení a vývoje.

Pokud používáte Windows, můžete si přečíst instalační návod, kde najdete úplné pokyny. Obecně můžete přejít na stránku stahování, vybrat platformu Windows v poli Dostupné soubory ke stažení a vybrat .msi instalační program, který odpovídá vašemu aktuálnímu systému, a klikněte na Stáhnout .

Spusťte instalační program a postupujte podle pokynů na obrazovce průvodce instalací. Tato stránka také poskytuje informace o tom, jak spustit MongoDB jako službu Windows.

Pokud používáte macOS, můžete použít Homebrew k instalaci MongoDB do vašeho systému. Kompletní průvodce získáte v instalačním tutoriálu. Také se ujistěte, že dodržujete pokyny pro spuštění MongoDB jako služby macOS.

Pokud používáte Linux, bude proces instalace záviset na vaší konkrétní distribuci. Chcete-li získat podrobný návod, jak nainstalovat MongoDB na různé systémy Linux, přejděte na stránku instalačního kurzu a vyberte si kurz, který odpovídá vašemu aktuálnímu operačnímu systému. Ujistěte se, že spouštíte démona MongoDB, mongod , na konci instalace.

Nakonec můžete také nainstalovat MongoDB pomocí Dockeru. To je užitečné, pokud nechcete svůj systém zahltit další instalací. Pokud dáváte přednost této možnosti instalace, můžete si přečíst oficiální návod a postupovat podle jeho pokynů. Všimněte si, že v tomto případě budou vyžadovány předchozí znalosti o používání Dockeru.

S nainstalovanou a spuštěnou databází MongoDB ve vašem systému můžete začít pracovat se skutečnými databázemi pomocí mongo shell.

Vytváření databází MongoDB pomocí mongo Shell

Pokud jste postupovali podle pokynů k instalaci a spuštění, pak byste již měli mít na svém systému spuštěnou instanci MongoDB. Nyní můžete začít vytvářet a testovat své vlastní databáze. V této části se dozvíte, jak používat mongo shell k vytváření, čtení, aktualizaci a odstraňování dokumentů v databázi.

Spuštění mongo Shell

mongo shell je interaktivní JavaScriptové rozhraní pro MongoDB. Tento nástroj můžete použít k dotazování a manipulaci s daty a také k provádění administrativních operací. Vzhledem k tomu, že se jedná o rozhraní JavaScript, nebudete k dotazování databáze používat známý jazyk SQL. Místo toho použijete kód JavaScript.

Chcete-li spustit mongo shell, otevřete terminál nebo příkazový řádek a spusťte následující příkaz:

$ mongo

Tento příkaz vás přenese do mongo skořápka. V tomto okamžiku pravděpodobně uvidíte spoustu zpráv s informacemi o verzi shellu a o adrese a portu serveru. Nakonec se vám zobrazí výzva shellu (> ) pro zadávání dotazů a příkazů.

Adresu databáze můžete předat jako argument do mongo příkaz. Můžete také použít několik možností, jako je zadání hostitele a portu pro přístup ke vzdálené databázi a tak dále. Další podrobnosti o tom, jak používat mongo můžete spustit mongo --help .

Navázání připojení

Když spustíte mongo příkaz bez argumentů, spustí shell a připojí se k výchozímu místnímu serveru poskytovanému mongod zpracovat na mongod://127.0.0.1:27017 . To znamená, že jste připojeni k místnímu hostiteli přes port 27017 .

Ve výchozím nastavení mongo shell zahájí relaci navázáním spojení s test databáze. K aktuální databázi můžete přistupovat prostřednictvím db objekt:

> db
test
>

V tomto případě db obsahuje odkaz na test , což je výchozí databáze. Chcete-li přepnout databáze, zadejte příkaz use , poskytující název databáze jako argument.

Řekněme například, že chcete vytvořit webovou stránku pro publikování obsahu Pythonu a plánujete používat MongoDB k ukládání výukových programů a článků. V takovém případě se můžete přepnout do databáze webu pomocí následujícího příkazu:

> use rptutorials
switched to db rptutorials

Tento příkaz přepne vaše připojení k rptutorials databáze. MongoDB nevytvoří fyzický databázový soubor v systému souborů, dokud do databáze nevložíte skutečná data. Takže v tomto případě rptutorials se nezobrazí ve vašem aktuálním seznamu databází:

> show dbs
admin          0.000GB
config         0.000GB
local          0.000GB
>

mongo shell poskytuje mnoho funkcí a možností. Umožňuje vám dotazovat se a manipulovat s vašimi daty a také spravovat samotný databázový server.

Místo použití standardizovaného dotazovacího jazyka, jako je SQL, mongo shell používá programovací jazyk JavaScript a uživatelsky přívětivé API. Toto API vám umožňuje hrát si s vašimi daty, což je téma pro další sekci.

Vytváření sbírek a dokumentů

Databáze MongoDB je fyzický kontejner pro kolekce dokumentů. Každá databáze získá svou vlastní sadu souborů v systému souborů. Tyto soubory jsou spravovány serverem MongoDB, který zvládne několik databází.

V MongoDB, kolekce je skupina dokumentů . Kolekce jsou poněkud analogické tabulkám v tradičním RDBMS, ale bez zavedení rigidního schématu. Teoreticky může mít každý dokument v kolekci zcela odlišnou strukturu nebo sadu polí.

V praxi dokumenty ve sbírce běžně sdílejí podobnou strukturu, která umožňuje jednotné procesy vyhledávání, vkládání a aktualizace. Jednotnou strukturu dokumentu můžete vynutit pomocí pravidel ověřování dokumentů během aktualizací a vkládání.

Povolení různých struktur dokumentů je klíčovou vlastností sbírek MongoDB. Tato funkce poskytuje flexibilitu a umožňuje přidávat nová pole do dokumentů bez nutnosti upravovat formální schéma tabulky.

Chcete-li vytvořit kolekci pomocí mongo shell, musíte ukázat db do vaší cílové databáze a poté vytvořte kolekce pomocí tečkové notace :

> use rptutorials
switched to db rptutorials
> db
rptutorials
> db.tutorial
rptutorials.tutorial

V tomto příkladu použijete tečkovou notaci k vytvoření tutorial jako kolekce v rptutorials , což je vaše aktuální databáze. Je důležité si uvědomit, že MongoDB vytváří databáze a kolekce líně . Jinými slovy, jsou fyzicky vytvořeny až po vložení prvního dokumentu.

Jakmile máte databázi a kolekci, můžete začít vkládat dokumenty. Dokumenty jsou jednotkou úložiště v MongoDB. V RDBMS by to bylo ekvivalentní řádku tabulky. Dokumenty MongoDB jsou však mnohem univerzálnější než řádky, protože mohou ukládat složité informace, jako jsou pole, vložené dokumenty a dokonce pole dokumentů.

MongoDB ukládá dokumenty ve formátu zvaném Binary JSON (BSON), což je binární reprezentace JSON. Dokumenty MongoDB se skládají z párů pole-a-hodnota a mají následující strukturu:

{
   field1 → value1,
   field2 → value2,
   field3 → value3,
   ...
   fieldN → valueN
}

Hodnota pole může být libovolný datový typ BSON, včetně jiných dokumentů, polí a polí dokumentů. V praxi budete dokumenty specifikovat pomocí formátu JSON.

Když vytváříte databázovou aplikaci MongoDB, pravděpodobně nejdůležitějším rozhodnutím je struktura dokumentů. Jinými slovy, budete se muset rozhodnout, která pole a hodnoty budou mít vaše dokumenty.

V případě výukových programů pro váš web Python mohou být vaše dokumenty strukturovány takto:

{
    "title": "Reading and Writing CSV Files in Python",
    "author": "Jon",
    "contributors": [
        "Aldren",
        "Geir Arne",
        "Joanna",
        "Jason"
    ],
    "url": "https://realpython.com/python-csv/"
}

Dokument je v podstatě souborem názvů vlastností a jejich hodnot. Hodnoty mohou být jednoduché datové typy, jako jsou řetězce a čísla, ale mohou to být také pole, jako jsou contributors ve výše uvedeném příkladu.

Dokumentově orientovaný datový model MongoDB přirozeně představuje komplexní data jako jeden objekt. To vám umožňuje pracovat s datovými objekty holisticky, aniž byste se museli dívat na několik míst nebo tabulek.

Pokud byste k ukládání výukových programů používali tradiční RDBMS, pravděpodobně byste měli tabulku pro ukládání výukových programů a další tabulku pro ukládání přispěvatelů. Pak byste museli nastavit vztah mezi oběma tabulkami, abyste mohli později načíst data.

Práce se sbírkami a dokumenty

Zatím znáte základy toho, jak spustit a používat mongo skořápka. Víte také, jak vytvářet vlastní dokumenty pomocí formátu JSON. Nyní je čas naučit se vkládat dokumenty do databáze MongoDB.

Vložení dokumentu do databáze pomocí mongo shell, musíte nejprve vybrat kolekci a poté zavolat .insertOne() na kolekci s vaším dokumentem jako argument:

> use rptutorials
switched to db rptutorials

> db.tutorial.insertOne({
...     "title": "Reading and Writing CSV Files in Python",
...     "author": "Jon",
...     "contributors": [
...         "Aldren",
...         "Geir Arne",
...         "Joanna",
...         "Jason"
...     ],
...     "url": "https://realpython.com/python-csv/"
... })
{
    "acknowledged" : true,
    "insertedId" : ObjectId("600747355e6ea8d224f754ba")
}

Prvním příkazem se přepnete do databáze, kterou chcete použít. Druhý příkaz je volání metody JavaScript, které vloží jednoduchý dokument do vybrané kolekce, tutorial . Jakmile stisknete Enter , zobrazí se na obrazovce zpráva, která vás informuje o nově vloženém dokumentu a jeho insertedId .

Stejně jako relační databáze potřebují primární klíč k jedinečné identifikaci každého řádku v tabulce, dokumenty MongoDB musí mít _id pole, které dokument jednoznačně identifikuje. MongoDB vám umožňuje zadat vlastní _id pokud zaručíte jeho jedinečnost. Nicméně široce přijímanou praxí je umožnit MongoDB automaticky vložit _id pro vás.

Podobně můžete přidat několik dokumentů najednou pomocí .insertMany() :

> tutorial1 = {
...     "title": "How to Iterate Through a Dictionary in Python",
...     "author": "Leodanis",
...     "contributors": [
...         "Aldren",
...         "Jim",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/iterate-through-dictionary-python/"
... }

> tutorial2 = {
...      "title": "Python 3's f-Strings: An Improved String Formatting Syntax",
...      "author": "Joanna",
...      "contributors": [
...          "Adriana",
...          "David",
...          "Dan",
...          "Jim",
...          "Pavel"
...      ],
...      "url": "https://realpython.com/python-f-strings/"
... }

> db.tutorial.insertMany([tutorial1, tutorial2])
{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("60074ff05e6ea8d224f754bb"),
        ObjectId("60074ff05e6ea8d224f754bc")
    ]
}

Zde je volání .insertMany() vezme seznam výukových programů a vloží je do databáze. Výstup shellu opět zobrazuje informace o nově vložených dokumentech a jejich automaticky přidané _id pole.

mongo shell také poskytuje metody pro provádění operací čtení, aktualizace a mazání v databázi. Můžete například použít .find() k načtení dokumentů ve sbírce:

> db.tutorial.find()
{ "_id" : ObjectId("600747355e6ea8d224f754ba"),
"title" : "Reading and Writing CSV Files in Python",
"author" : "Jon",
"contributors" : [ "Aldren", "Geir Arne", "Joanna", "Jason" ],
"url" : "https://realpython.com/python-csv/" }
    ...

> db.tutorial.find({author: "Joanna"})
{ "_id" : ObjectId("60074ff05e6ea8d224f754bc"),
"title" : "Python 3's f-Strings: An Improved String Formatting Syntax (Guide)",
"author" : "Joanna",
"contributors" : [ "Adriana", "David", "Dan", "Jim", "Pavel" ],
"url" : "https://realpython.com/python-f-strings/" }

První volání .find() načte všechny dokumenty v tutorial sbírka. Na druhé straně druhé volání .find() načte výukové programy, jejichž autorem je Joanna.

S těmito znalostmi o tom, jak používat MongoDB prostřednictvím jeho mongo shell, jste připraveni začít používat MongoDB s Pythonem. Několik následujících sekcí vás provede různými možnostmi použití databází MongoDB ve vašich aplikacích Python.

Používání MongoDB s Pythonem a PyMongem

Nyní, když víte, co je MongoDB a jak vytvářet a spravovat databáze pomocí mongo shell, můžete začít používat MongoDB, ale tentokrát s Pythonem. MongoDB poskytuje oficiální ovladač Pythonu s názvem PyMongo.

V této části si projdete několik příkladů, které vám pomohou získat představu o tom, jak používat PyMongo k vytváření vlastních databázových aplikací s MongoDB a Python.

Každý modul v PyMongu je zodpovědný za sadu operací s databází. Budete mít moduly alespoň pro následující úkoly:

• Nastavování databázových připojení
• Práce s databázemi
• Práce se sbírkami a dokumenty
• Manipulace s kurzorem
• Práce se šifrováním dat

Obecně PyMongo poskytuje bohatou sadu nástrojů, které můžete použít ke komunikaci se serverem MongoDB. Poskytuje funkce pro dotazování, načítání výsledků, zápis a mazání dat a spouštění databázových příkazů.

Instalace PyMongo

Chcete-li začít používat PyMongo, musíte jej nejprve nainstalovat do prostředí Pythonu. Můžete použít virtuální prostředí nebo můžete použít svou systémovou instalaci Pythonu, i když je preferována první možnost. PyMongo je k dispozici na PyPI, takže nejrychlejší způsob instalace je pomocí pip . Spusťte terminál a spusťte následující příkaz:

$ pip install pymongo==3.11.2

Po několika staženích a dalších souvisejících krocích tento příkaz nainstaluje PyMongo do vašeho prostředí Pythonu. Všimněte si, že pokud nezadáte konkrétní číslo verze, pak pip nainstaluje nejnovější dostupnou verzi.

Poznámka: Úplný návod, jak nainstalovat PyMongo, najdete na stránce Instalace/Upgrade v jeho oficiální dokumentaci.

Po dokončení instalace můžete spustit interaktivní relaci Pythonu a spustit následující import:

>>> import pymongo

Pokud to běží bez vyvolání výjimky v prostředí Pythonu, pak vaše instalace funguje dobře. Pokud ne, proveďte opatrně kroky znovu.

Navázání připojení

Chcete-li navázat připojení k databázi, musíte vytvořit MongoClient instance. Tato třída poskytuje klienta pro instanci nebo server MongoDB. Každý klientský objekt má vestavěný fond připojení, který ve výchozím nastavení zpracovává až sto připojení k serveru.

Vraťte se do interaktivní relace Pythonu a importujte MongoClient z pymongo . Poté vytvořte klientský objekt pro komunikaci s aktuálně spuštěnou instancí MongoDB:

>>> from pymongo import MongoClient
>>> client = MongoClient()
>>> client
MongoClient(host=['localhost:27017'], ..., connect=True)

Výše uvedený kód naváže připojení k výchozímu hostiteli (localhost ) a port (27017 ). MongoClient přebírá sadu argumentů, která vám umožňuje určit vlastního hostitele, port a další parametry připojení. Chcete-li například poskytnout vlastního hostitele a port, můžete použít následující kód:

>>> client = MongoClient(host="localhost", port=27017)

To je užitečné, když potřebujete poskytnout host a port které se liší od výchozího nastavení MongoDB. Můžete také použít formát MongoDB URI:

>>> client = MongoClient("mongodb://localhost:27017")

Všechny tyto instance MongoClient poskytněte stejné nastavení klienta pro připojení vaší aktuální instance MongoDB. Který z nich byste měli použít, závisí na tom, jak explicitní chcete být ve svém kódu.

Jakmile vytvoříte instanci MongoClient , můžete jeho instanci použít k odkazování na toto konkrétní připojení k databázi, stejně jako jste to udělali s mongo db shellu objekt ve výše uvedené sekci.

Práce s databázemi, kolekcemi a dokumenty

Jakmile budete mít připojenou instanci MongoClient , můžete přistupovat k jakékoli databázi spravované zadaným serverem MongoDB. Chcete-li definovat, kterou databázi chcete použít, můžete použít tečkovou notaci stejně jako v mongo shell:

>>> db = client.rptutorials
>>> db
Database(MongoClient(host=['localhost:27017'], ..., connect=True), 'rptutorials')

V tomto případě rptutorials je název databáze, se kterou budete pracovat. Pokud databáze neexistuje, MongoDB ji vytvoří za vás, ale pouze tehdy, když s databází provedete první operaci.

Pokud název databáze není platným identifikátorem Pythonu, můžete také použít přístup ve stylu slovníku:

>>> db = client["rptutorials"]

Toto prohlášení je užitečné, když název vaší databáze není platným identifikátorem Pythonu. Pokud se například vaše databáze nazývá rp-tutorials , pak musíte použít přístup ve stylu slovníku.

Poznámka: Když použijete mongo shell, máte přístup k databázi přes db globální objekt. Když používáte PyMongo, můžete databázi přiřadit proměnné nazvané db získat podobné chování.

Ukládání dat do databáze pomocí PyMongo je podobné tomu, co jste dělali s mongo shell ve výše uvedených částech. Nejprve však musíte vytvořit své dokumenty. V Pythonu používáte k vytváření dokumentů slovníky:

>>> tutorial1 = {
...     "title": "Working With JSON Data in Python",
...     "author": "Lucas",
...     "contributors": [
...         "Aldren",
...         "Dan",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-json/"
... }

Jakmile vytvoříte dokument jako slovník, musíte určit, kterou kolekci chcete použít. K tomu můžete použít tečkovou notaci na databázovém objektu:

>>> tutorial = db.tutorial
>>> tutorial
Collection(Database(..., connect=True), 'rptutorials'), 'tutorial')

V tomto případě tutorial je instancí Collection a představuje fyzickou sbírku dokumentů ve vaší databázi. Dokumenty můžete vkládat do tutorial voláním .insert_one() na něm s dokumentem jako argumentem:

>>> result = tutorial.insert_one(tutorial1)
>>> result
<pymongo.results.InsertOneResult object at 0x7fa854f506c0>

>>> print(f"One tutorial: {result.inserted_id}")
One tutorial: 60084b7d87eb0fbf73dbf71d

Zde .insert_one() trvá tutorial1 , vloží jej do tutorial kolekce a vrátí InsertOneResult objekt. Tento objekt poskytuje zpětnou vazbu na vložený dokument. Všimněte si, že protože MongoDB generuje ObjectId dynamicky se váš výstup nebude shodovat s ObjectId zobrazeno výše.

Pokud chcete do databáze přidat mnoho dokumentů, můžete použít .insert_many() vložíte je najednou:

>>> tutorial2 = {
...     "title": "Python's Requests Library (Guide)",
...     "author": "Alex",
...     "contributors": [
...         "Aldren",
...         "Brad",
...         "Joanna"
...     ],
...     "url": "https://realpython.com/python-requests/"
... }

>>> tutorial3 = {
...     "title": "Object-Oriented Programming (OOP) in Python 3",
...     "author": "David",
...     "contributors": [
...         "Aldren",
...         "Joanna",
...         "Jacob"
...     ],
...     "url": "https://realpython.com/python3-object-oriented-programming/"
... }

>>> new_result = tutorial.insert_many([tutorial2, tutorial3])

>>> print(f"Multiple tutorials: {new_result.inserted_ids}")
Multiple tutorials: [
   ObjectId('6008511c87eb0fbf73dbf71e'),
   ObjectId('6008511c87eb0fbf73dbf71f')
]

Je to rychlejší a přímočařejší než volání .insert_one() vícekrát. Volání .insert_many() vezme iterační soubor dokumentů a vloží je do tutorial kolekce ve vašich rptutorials databáze. Metoda vrací instanci InsertManyResult , který poskytuje informace o vložených dokumentech.

Chcete-li načíst dokumenty z kolekce, můžete použít .find() . Bez argumentů, .find() vrátí Cursor objekt, který na požádání vydá dokumenty ve sbírce:

>>> import pprint

>>> for doc in tutorial.find():
...     pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

Here, you run a loop on the object that .find() returns and print successive results, using pprint.pprint() to provide a user-friendly output format.

You can also use .find_one() to retrieve a single document. In this case, you can use a dictionary that contains fields to match. For example, if you want to retrieve the first tutorial by Jon, then you can do something like this:

>>> import pprint

>>> jon_tutorial = tutorial.find_one({"author": "Jon"})

>>> pprint.pprint(jon_tutorial)
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}

Note that the tutorial’s ObjectId is set under the _id key, which is the unique document identifier that MongoDB automatically adds when you insert a document into your database.

PyMongo also provides methods to replace, update, and delete documents from a database. If you want to dive deeper into these features, then take a look at the documentation for Collection .

Closing Connections

Establishing a connection to a MongoDB database is typically an expensive operation. If you have an application that constantly retrieves and manipulates data in a MongoDB database, then you probably don’t want to be opening and closing the connection all the time since this might affect your application’s performance.

In this kind of situation, you should keep your connection alive and only close it before exiting the application to clear all the acquired resources. You can close the connection by calling .close() on the MongoClient instance:

>>> client.close()

Another situation is when you have an application that occasionally uses a MongoDB database. In this case, you might want to open the connection when needed and close it immediately after use for freeing the acquired resources. A consistent approach to this problem would be to use the with prohlášení. Yes, MongoClient implements the context manager protocol:

>>> import pprint
>>> from pymongo import MongoClient

>>> with MongoClient() as client:
...     db = client.rptutorials
...     for doc in db.tutorial.find():
...         pprint.pprint(doc)
...
{'_id': ObjectId('600747355e6ea8d224f754ba'),
 'author': 'Jon',
 'contributors': ['Aldren', 'Geir Arne', 'Joanna', 'Jason'],
 'title': 'Reading and Writing CSV Files in Python',
 'url': 'https://realpython.com/python-csv/'}
    ...
{'_id': ObjectId('6008511c87eb0fbf73dbf71f'),
 'author': 'David',
 'contributors': ['Aldren', 'Joanna', 'Jacob'],
 'title': 'Object-Oriented Programming (OOP) in Python 3',
 'url': 'https://realpython.com/python3-object-oriented-programming/'}

If you use the with statement to handle your MongoDB client, then at the end of the with code block, the client’s .__exit__() method gets called, which at the same time closes the connection by calling .close() .

Using MongoDB With Python and MongoEngine

While PyMongo is a great and powerful Python driver for interfacing with MongoDB, it’s probably a bit too low-level for many of your projects. With PyMongo, you’ll have to write a lot of code to consistently insert, retrieve, update, and delete documents.

One library that provides a higher abstraction on top of PyMongo is MongoEngine. MongoEngine is an object-document mapper (ODM), which is roughly equivalent to an SQL-based object-relational mapper (ORM). MongoEngine provides a class-based abstraction, so all the models you create are classes.

Installing MongoEngine

There are a handful of Python libraries to help you work with MongoDB. MongoEngine, however, is a popular one that provides a nice set of features, flexibility, and community support. MongoEngine is available on PyPI. You can install it using the following pip příkaz:

$ pip install mongoengine==0.22.1

Once you’ve installed MongoEngine into your Python environment, you’re ready to start working with MongoDB databases using Python’s object-oriented features. The next step is to connect to your running MongoDB instance.

Establishing a Connection

To establish a connection with your database, you need to use mongoengine.connect() . This function takes several arguments. However, in this tutorial, you’ll use only three of them. Within your Python interactive session, type the following code:

>>> from mongoengine import connect
>>> connect(db="rptutorials", host="localhost", port=27017)
MongoClient(host=['localhost:27017'], ..., read_preference=Primary())

Here, you first set the database name db to "rptutorials" , which is the name of the database you want to work in. Then you provide a host and a port to connect to your current MongoDB instance. Since you’re using the default host and port , you can omit these two parameters and just use connect("rptutorials") .

Working With Collections and Documents

To create documents with MongoEngine, you first need to define what data you want the documents to have. In other words, you need to define a document schema. MongoEngine encourages you to define a document schema to help you reduce coding errors and to allow you to define utility or helper methods.

Similar to ORMs, ODMs like MongoEngine provide a base or model class for you to define a document schema. In ORMs, that class is equivalent to a table, and its instances are equivalent to rows. In MongoEngine, the class is equivalent to a collection, and its instances are equivalent to documents.

To create a model, you need to subclass Document and provide the required fields as class attributes. To continue with the blog example, here’s how you can create a model for your tutorials:

>>> from mongoengine import Document, ListField, StringField, URLField

>>> class Tutorial(Document):
...     title = StringField(required=True, max_length=70)
...     author = StringField(required=True, max_length=20)
...     contributors = ListField(StringField(max_length=20))
...     url = URLField(required=True)

With this model, you tell MongoEngine that you expect a Tutorial document to have a .title , an .author , a list of .contributors , and a .url . The base class, Document , uses that information along with the field types to validate the input data for you.

Poznámka: One of the more difficult tasks with database models is data validation . How do you make sure that the input data conforms to your format requirements? That’s one of the reasons for you to have a coherent and uniform document schema.

MongoDB is said to be a schemaless database, but that doesn’t mean it’s schema free. Having documents with a different schema within the same collection can lead to processing errors and inconsistent behavior.

For example, if you try to save a Tutorial object without a .title , then your model throws an exception and lets you know. You can take this even further and add more restrictions, such as the length of the .title , and so on.

There are a few general parameters that you can use to validate fields. Here are some of the more commonly used parameters:

• db_field specifies a different field name.
• required ensures that the field is provided.
• default provides a default value for a given field if no value is given.
• unique ensures that no other document in the collection has the same value for this field.

Each specific field type also has its own set of parameters. You can check the documentation for a complete guide to the available field types.

To save a document to your database, you need to call .save() on a document object. If the document already exists, then all the changes will be applied to the existing document. If the document doesn’t exist, then it’ll be created.

Here’s an example of creating and saving a tutorial into your sample tutorials database:

>>> tutorial1 = Tutorial(
...     title="Beautiful Soup: Build a Web Scraper With Python",
...     author="Martin",
...     contributors=["Aldren", "Geir Arne", "Jaya", "Joanna", "Mike"],
...     url="https://realpython.com/beautiful-soup-web-scraper-python/"
... )

>>> tutorial1.save()  # Insert the new tutorial
<Tutorial: Tutorial object>

By default, .save() inserts the new document into a collection named after the model class, Tutorial , except using lowercase letters. In this case, the collection name is tutorial , which matches the collection you’ve been using to save your tutorials.

PyMongo performs data validation when you call .save() . This means that it checks the input data against the schema you declared in the Tutorial model class. If the input data violates the schema or any of its constraints, then you get an exception, and the data isn’t saved into the database.

For example, here’s what happens if you try to save a tutorial without providing a .title :

>>> tutorial2 = Tutorial()
>>> tutorial2.author = "Alex"
>>> tutorial2.contributors = ["Aldren", "Jon", "Joanna"]
>>> tutorial2.url = "https://realpython.com/convert-python-string-to-int/"
>>> tutorial2.save()
Traceback (most recent call last):
  ...
mongoengine.errors.ValidationError: ... (Field is required: ['title'])

In this example, first note that you can also build a Tutorial object by assigning values to its attributes. Second, since you don’t provide a .title for the new tutorial, .save() raises a ValidationError telling you that the .title field is required. Having automatic data validation is a great feature that will save you some headaches.

Each Document subclass has an .objects attribute that you can use to access the documents in the associated collection. For example, here’s how you can print the .title of all your current tutorials:

>>> for doc in Tutorial.objects:
...     print(doc.title)
...
Reading and Writing CSV Files in Python
How to Iterate Through a Dictionary in Python
Python 3's f-Strings: An Improved String Formatting Syntax (Guide)
Working With JSON Data in Python
Python's Requests Library (Guide)
Object-Oriented Programming (OOP) in Python 3
Beautiful Soup: Build a Web Scraper With Python

The for loop iterates over all your tutorials and prints their .title data to the screen. You can also use .objects to filter your documents. For example, say you want to retrieve the tutorials authored by Alex. In that case, you can do something like this:

>>> for doc in Tutorial.objects(author="Alex"):
...     print(doc.title)
...
Python's Requests Library (Guide)

MongoEngine is well suited to manage your MongoDB databases for just about any type of application. Its features make it ideal for creating efficient and scalable programs using a high-level approach. If you’re looking for more information about MongoEngine, be sure to check out its user guide.

Conclusion

If you need a robust, scalable, and flexible database solution, then MongoDB might be a good option for you. MongoDB is a mature and popular NoSQL database with great Python support. With a good understanding of how to access MongoDB with Python, you’ll be ready to create database applications that scale well and provide excellent performance.

With MongoDB, you also have the benefit of a human-readable and highly-flexible data model, so you can adapt to requirement changes quickly.

In this tutorial, you learned:

• What MongoDB and NoSQL databases are
• How to install and run MongoDB on your system
• How to create and work with MongoDB databases
• How to interface with MongoDB in Python using the PyMongo driver
• How to use the MongoEngine object-document mapper to work with MongoDB

The examples you coded in this tutorial are available for download. To get their source code, click the link below:

Získejte zdrojový kód: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.