Python и MongoDB:Свързване с NoSQL бази данни

Що се отнася до операционната страна, MongoDB предоставя няколко инструмента и функции, които няма да намерите в други системи за бази данни:

• Мащабируемост: Независимо дали имате нужда от самостоятелен сървър или пълни клъстери от независими сървъри, можете да мащабирате MongoDB до какъвто размер искате да бъде.
• Поддръжка за балансиране на натоварването: MongoDB автоматично ще премества данни между различни фрагменти.
• Поддръжка за автоматично преминаване при отказ: Ако основният ви сървър се повреди, нов основен ще бъде стартиран и работи автоматично.
• Инструменти за управление: Можете да проследявате вашите машини с помощта на базираната в облак услуга за управление на MongoDB (MMS).
• Ефективност на паметта: Благодарение на картографираните в паметта файлове, MongoDB често е по-ефективен от релационните бази данни.

Всички тези функции са доста полезни. Например, ако се възползвате от функцията за индексиране, тогава голяма част от вашите данни ще се съхраняват в паметта за бързо извличане. Дори без да индексира конкретни ключове за документи, MongoDB кешира доста данни, използвайки най-малко използваната техника.

Инсталиране и стартиране на MongoDB

След като вече сте запознати с MongoDB, е време да си изцапате ръцете и да започнете да го използвате. Но първо трябва да го инсталирате на вашата машина. Официалният сайт на MongoDB предоставя две издания на сървъра на базата данни:

1. Изданието на общността предлага гъвкавия модел на документи заедно със специални заявки, индексиране и агрегиране в реално време, за да предостави мощни начини за достъп и анализ на вашите данни. Това издание е свободно достъпно.
2. Корпоративното издание предлага същите функции като изданието на общността, плюс други разширени функции, свързани със сигурността и наблюдението. Това е комерсиалното издание, но можете да го използвате безплатно за неограничено време за оценка и развитие.

Ако използвате Windows, тогава можете да прочетете инсталационния урок за пълни инструкции. По принцип можете да отидете на страницата за изтегляне, изберете платформата на Windows в полето Налични изтегляния, изберете .msi инсталационна програма, която отговаря на текущата ви система, и щракнете върху Изтегляне .

Стартирайте инсталатора и следвайте инструкциите на екрана на съветника за инсталиране. Тази страница също така предоставя информация как да стартирате MongoDB като услуга на Windows.

Ако сте на macOS, тогава можете да използвате Homebrew, за да инсталирате MongoDB на вашата система. Вижте ръководството за инсталиране, за да получите пълното ръководство. Също така, не забравяйте да следвате инструкциите за стартиране на MongoDB като услуга на macOS.

Ако сте на Linux, тогава процесът на инсталиране ще зависи от вашата конкретна дистрибуция. За подробно ръководство как да инсталирате MongoDB на различни Linux системи, отидете на страницата с инструкции за инсталиране и изберете урока, който съответства на текущата ви операционна система. Уверете се, че стартирате демона MongoDB, mongod , в края на инсталацията.

И накрая, можете също да инсталирате MongoDB с помощта на Docker. Това е удобно, ако не искате да претрупвате системата си с друга инсталация. Ако предпочитате тази опция за инсталиране, тогава можете да прочетете официалния урок и да следвате неговите указания. Имайте предвид, че в този случай ще са необходими предишни познания за това как да използвате Docker.

С инсталираната и работеща база данни MongoDB във вашата система, можете да започнете да работите с реални бази данни, като използвате mongo черупка.

Създаване на бази данни на MongoDB с mongo Черупка

Ако сте следвали инструкциите за инсталиране и стартиране, тогава вече трябва да имате екземпляр на MongoDB, работещ във вашата система. Сега можете да започнете да създавате и тествате свои собствени бази данни. В този раздел ще научите как да използвате mongo shell за създаване, четене, актуализиране и изтриване на документи в база данни.

Изпълнение на mongo Черупка

монго shell е интерактивен JavaScript интерфейс към MongoDB. Можете да използвате този инструмент за запитване и манипулиране на вашите данни, както и за извършване на административни операции. Тъй като това е интерфейс на JavaScript, няма да използвате познатия SQL език, за да направите заявка към базата данни. Вместо това ще използвате JavaScript код.

За да стартирате mongo shell, отворете терминала или командния ред и изпълнете следната команда:

$ mongo

Тази команда ви отвежда до mongo черупка. В този момент вероятно ще видите куп съобщения с информация за версията на обвивката и за адреса и порта на сървъра. Накрая ще ви бъде представена подкана за обвивка (> ), за да въведете заявки и команди.

Можете да предадете адреса на базата данни като аргумент на mongo команда. Можете също да използвате няколко опции, като например задаване на хост и порт за достъп до отдалечена база данни и т.н. За повече подробности как да използвате mongo команда, можете да изпълните mongo --help .

Установяване на връзка

Когато стартирате mongo команда без аргументи, тя стартира обвивката и се свързва с локалния сървър по подразбиране, предоставен от mongod процес на mongod://127.0.0.1:27017 . Това означава, че сте свързани с локалния хост чрез порт 27017 .

По подразбиране mongo shell стартира сесията, като установява връзка с тест база данни. Можете да получите достъп до текущата база данни чрез db обект:

> db
test
>

В този случай db съдържа препратка към test , което е базата данни по подразбиране. За да превключите бази данни, издайте командата use , предоставяйки име на база данни като аргумент.

Например, да речем, че искате да създадете уебсайт за публикуване на съдържание на Python и планирате да използвате MongoDB за съхраняване на вашите уроци и статии. В този случай можете да превключите към базата данни на сайта със следната команда:

> use rptutorials
switched to db rptutorials

Тази команда превключва връзката ви към rptutorials база данни. MongoDB не създава физическия файл на база данни във файловата система, докато не вмъкнете реални данни в базата данни. Така че в този случай rptutorials няма да се покаже в текущия ви списък с база данни:

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

монго shell предоставя много функции и опции. Позволява ви да заявявате и манипулирате вашите данни, както и да управлявате самия сървър на база данни.

Вместо да използвате стандартизиран език за заявки като SQL, mongo shell използва езика за програмиране JavaScript и удобен за потребителя API. Този API ви позволява да си играете с вашите данни, което е тема за следващия раздел.

Създаване на колекции и документи

Базата данни MongoDB е физически контейнер за колекции от документи. Всяка база данни получава свой собствен набор от файлове във файловата система. Тези файлове се управляват от сървъра MongoDB, който може да обработва няколко бази данни.

В MongoDB, колекция е група отдокументи . Колекциите са донякъде аналогични на таблиците в традиционната RDBMS, но без налагане на твърда схема. На теория всеки документ в колекция може да има напълно различна структура или набор от полета.

На практика документите в колекция обикновено споделят подобна структура, за да позволят еднакви процеси на извличане, вмъкване и актуализиране. Можете да наложите еднаква структура на документа, като използвате правила за валидиране на документи по време на актуализации и вмъквания.

Разрешаването на различни структури на документи е ключова характеристика на колекциите на MongoDB. Тази функция осигурява гъвкавост и позволява добавяне на нови полета към документи без нужда от промяна на официална схема на таблица.

За да създадете колекция с помощта на mongo shell, трябва да посочите db към вашата целева база данни и след това създайте колекциите с помощта на точковата нотация :

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

В този пример използвате нотацията с точки, за да създадете урок като колекция в rptutorials , което е текущата ви база данни. Важно е да се отбележи, че MongoDB създава бази данни и колекции мързеливо . С други думи, те се създават физически само след като вмъкнете първия документ.

След като имате база данни и колекция, можете да започнете да вмъквате документи. Документите са единицата за съхранение в MongoDB. В RDBMS това би било еквивалентно на ред на таблица. Документите на MongoDB обаче са много по-гъвкави от редовете, защото могат да съхраняват сложна информация, като масиви, вградени документи и дори масиви от документи.

MongoDB съхранява документи във формат, наречен Binary JSON (BSON), което е двоично представяне на JSON. Документите на MongoDB са съставени от двойки поле и стойност и имат следната структура:

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

Стойността на полето може да бъде всеки тип данни BSON, включително други документи, масиви и масиви от документи. На практика ще посочите документите си, като използвате формата JSON.

Когато създавате приложение за база данни на MongoDB, вероятно най-важното ви решение е относно структурата на документите. С други думи, ще трябва да решите кои полета и стойности ще имат вашите документи.

В случай на уроци за вашия сайт на Python, вашите документи може да са структурирани по следния начин:

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

Документът е по същество набор от имена на свойства и техните стойности. Стойностите могат да бъдат прости типове данни, като низове и числа, но могат да бъдат и масиви като contributors в горния пример.

Документно-ориентираният модел на данни на MongoDB естествено представя сложни данни като един обект. Това ви позволява да работите с обекти с данни цялостно, без да е необходимо да разглеждате няколко места или таблици.

Ако използвате традиционна RDBMS за съхраняване на вашите уроци, тогава вероятно ще имате таблица за съхранение на вашите уроци и друга таблица за съхраняване на вашите сътрудници. След това ще трябва да настроите връзка между двете таблици, за да можете да извлечете данните по-късно.

Работа с колекции и документи

Досега знаете основите как да изпълнявате и използвате mongo черупка. Освен това знаете как да създавате свои собствени документи с помощта на JSON формата. Сега е време да научите как да вмъквате документи във вашата база данни MongoDB.

За да вмъкнете документ в база данни с помощта на mongo shell, първо трябва да изберете колекция и след това да извикате .insertOne() върху колекцията с вашия документ като аргумент:

> 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")
}

С първата команда преминавате към базата данни, която искате да използвате. Втората команда е извикване на метод на JavaScript, което вмъква прост документ в избраната колекция, урок . След като натиснете Enter , получавате съобщение на екрана си, което ви информира за нововмъкнатия документ и неговия insertedId .

Точно както релационните бази данни се нуждаят от първичен ключ за уникално идентифициране на всеки ред в таблица, MongoDB документите трябва да имат _id поле, което уникално идентифицира документа. MongoDB ви позволява да въведете персонализиран _id стига да гарантирате неговата уникалност. Въпреки това, широко приета практика е да се позволи на MongoDB автоматично да вмъкне _id за теб.

По същия начин можете да добавите няколко документа наведнъж, като използвате .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")
    ]
}

Тук извикването на .insertMany() взема списък с уроци и ги вмъква в базата данни. Отново изходът на обвивката показва информация за нововмъкнатите документи и техния автоматично добавен _id полета.

монго shell също така предоставя методи за извършване на операции за четене, актуализиране и изтриване на базата данни. Например, можете да използвате .find() за да извлечете документите в колекция:

> 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/" }

Първото извикване на .find() извлича всички документи в урока колекция. От друга страна, второто извикване на .find() извлича тези уроци, които са автор на Джоана.

С тези основни познания за това как да използвате MongoDB чрез неговия mongo shell, вие сте готови да започнете да използвате MongoDB с Python. Следващите няколко раздела ще ви преведат през различни опции за използване на бази данни MongoDB във вашите Python приложения.

Използване на MongoDB с Python и PyMongo

Сега, когато знаете какво е MongoDB и как да създавате и управлявате бази данни с помощта на mongo shell, можете да започнете да използвате MongoDB, но този път с Python. MongoDB предоставя официален драйвер за Python, наречен PyMongo.

В този раздел ще прегледате някои примери, които ще ви помогнат да усетите как да използвате PyMongo, за да създадете свои собствени приложения за бази данни с MongoDB и Python.

Всеки модул в PyMongo отговаря за набор от операции в базата данни. Ще имате модули за поне следните задачи:

• Установяване на връзки към базата данни
• Работа с бази данни
• Работа с колекции и документи
• Манипулиране на курсора
• Работа с криптиране на данни

Като цяло PyMongo предоставя богат набор от инструменти, които можете да използвате за комуникация със сървър на MongoDB. Той предоставя функционалност за запитване, извличане на резултати, запис и изтриване на данни и изпълнение на команди на базата данни.

Инсталиране на PyMongo

За да започнете да използвате PyMongo, първо трябва да го инсталирате във вашата среда на Python. Можете да използвате виртуална среда или можете да използвате вашата инсталация на Python в цялата система, въпреки че първата опция е за предпочитане. PyMongo се предлага на PyPI, така че най-бързият начин да го инсталирате е с pip . Стартирайте терминала си и изпълнете следната команда:

$ pip install pymongo==3.11.2

След няколко изтегляния и други свързани стъпки, тази команда инсталира PyMongo във вашата среда на Python. Имайте предвид, че ако не предоставите конкретен номер на версията, тогава pip ще инсталира най-новата налична версия.

Забележка: За пълно ръководство как да инсталирате PyMongo, вижте страницата за инсталиране/надграждане на неговата официална документация.

След като приключите с инсталацията, можете да стартирате интерактивна сесия на Python и да изпълните следното импортиране:

>>> import pymongo

Ако това работи без да се повдига изключение в обвивката на Python, тогава вашата инсталация работи добре. Ако не, изпълнете внимателно стъпките отново.

Установяване на връзка

За да установите връзка с база данни, трябва да създадете MongoClient екземпляр. Този клас осигурява клиент за MongoDB екземпляр или сървър. Всеки клиентски обект има вграден пул за връзки, който по подразбиране обработва до сто връзки към сървъра.

Върнете се към вашата интерактивна сесия на Python и импортирайте MongoClient от pymongo . След това създайте клиентски обект, който да комуникира с вашия текущо работещ екземпляр на MongoDB:

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

Кодът по-горе установява връзка с хоста по подразбиране (localhost ) и порт (27017). ). MongoClient приема набор от аргументи, който ви позволява да зададете персонализиран хост, порт и други параметри на връзката. Например, за да предоставите персонализиран хост и порт, можете да използвате следния код:

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

Това е удобно, когато трябва да предоставите хост и порт които се различават от настройката по подразбиране на MongoDB. Можете също да използвате MongoDB URI формата:

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

Всички тези екземпляри на MongoClient осигурете същата настройка на клиента, за да свържете текущия си екземпляр на MongoDB. Кой от тях трябва да използвате зависи само от това колко изрично искате да бъде в кода си.

След като сте инстанцирали MongoClient , можете да използвате неговия екземпляр, за да се позовавате на тази конкретна връзка с база данни, точно както направихте с mongo db на обвивката обект в горния раздел.

Работа с бази данни, колекции и документи

След като имате свързан екземпляр на MongoClient , можете да получите достъп до всяка база данни, управлявана от посочения сървър на MongoDB. За да дефинирате коя база данни искате да използвате, можете да използвате нотацията с точки точно както направихте в mongo обвивка:

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

В този случай rptutorials е името на базата данни, с която ще работите. Ако базата данни не съществува, MongoDB я създава вместо вас, но само когато извършите първата операция с базата данни.

Можете също да използвате достъп в стил речник, ако името на базата данни не е валиден идентификатор на Python:

>>> db = client["rptutorials"]

Това изявление е удобно, когато името на вашата база данни не е валиден идентификатор на Python. Например, ако вашата база данни се нарича rp-tutorials , тогава трябва да използвате достъп в стил речник.

Забележка: Когато използвате mongo shell, имате достъп до базата данни чрез db глобален обект. Когато използвате PyMongo, можете да присвоите базата данни на променлива, наречена db за да получите подобно поведение.

Съхраняването на данни във вашата база данни с помощта на PyMongo е подобно на това, което правихте с mongo обвивка в горните раздели. Но първо трябва да създадете своите документи. В Python използвате речници за създаване на документи:

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

След като създадете документа като речник, трябва да посочите коя колекция искате да използвате. За да направите това, можете да използвате нотацията с точки на обекта на базата данни:

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

В този случай урок е екземпляр на Колекция и представлява физическа колекция от документи във вашата база данни. Можете да вмъквате документи в урок чрез извикване на .insert_one() върху него с документ като аргумент:

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

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

Тук .insert_one() отнема урок1 , го вмъква в урока колекция и връща InsertOneResult обект. Този обект предоставя обратна връзка за вмъкнатия документ. Имайте предвид, че тъй като MongoDB генерира ObjectId динамично, изходът ви няма да съвпада с ObjectId показано по-горе.

Ако имате много документи за добавяне към базата данни, тогава можете да използвате .insert_many() за да ги вмъкнете наведнъж:

>>> 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')
]

Това е по-бързо и по-лесно от извикването на .insert_one() много пъти. Извикването на .insert_many() взема итерация от документи и ги вмъква в урока колекция във вашите rptutorials база данни. Методът връща екземпляр на InsertManyResult , която предоставя информация за въведените документи.

За да извлечете документи от колекция, можете да използвате .find() . Без аргументи, .find() връща Курсор обект, който извежда документите в колекцията при поискване:

>>> 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 изявление. 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 команда:

$ 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.

Забележка: 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:

Вземете изходния код: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.