Python dan MongoDB:Menghubungkan ke Database NoSQL

MongoDB adalah solusi database berorientasi dokumen dan NoSQL yang memberikan skalabilitas dan fleksibilitas yang hebat bersama dengan sistem kueri yang kuat. Dengan MongoDB dan Python, Anda dapat mengembangkan berbagai jenis aplikasi database dengan cepat. Jadi, jika aplikasi Python Anda membutuhkan database yang sama fleksibelnya dengan bahasa itu sendiri, maka MongoDB adalah untuk Anda.

Dalam tutorial ini, Anda akan mempelajari:

• Apa MongoDB adalah
• Cara memasang dan menjalankan MongoDB
• Cara bekerja dengan basis data MongoDB
• Cara menggunakan driver PyMongo tingkat rendah untuk berinteraksi dengan MongoDB
• Cara menggunakan MongoEngine object-document mapper (ODM) tingkat tinggi

Sepanjang tutorial ini, Anda akan menulis beberapa contoh yang akan menunjukkan fleksibilitas dan kekuatan MongoDB dan dukungan Python yang hebat. Untuk mengunduh kode sumber untuk contoh-contoh tersebut, klik tautan di bawah ini:

Dapatkan Kode Sumber: Klik di sini untuk mendapatkan kode sumber yang akan Anda gunakan untuk mempelajari tentang menggunakan MongoDB dengan Python dalam tutorial ini.

Menggunakan Database SQL vs NoSQL

Selama beberapa dekade, database SQL adalah satu-satunya pilihan bagi pengembang yang ingin membangun sistem database yang besar dan skalabel. Namun, meningkatnya kebutuhan untuk menyimpan struktur data yang kompleks menyebabkan lahirnya NoSQL database. Jenis sistem database baru ini memungkinkan pengembang untuk menyimpan data yang heterogen dan tidak terstruktur secara efisien.

Secara umum, sistem database NoSQL menyimpan dan mengambil data dengan cara yang jauh berbeda dari sistem manajemen database relasional SQL (RDBMS).

Saat memilih dari teknologi database yang tersedia saat ini, Anda mungkin perlu memutuskan antara menggunakan sistem SQL atau NoSQL. Keduanya memiliki fitur khusus yang harus Anda pertimbangkan ketika memilih satu atau yang lain. Berikut adalah beberapa perbedaan mendasar mereka:

Ada banyak perbedaan lain antara kedua jenis database, tetapi yang disebutkan di atas adalah beberapa yang lebih penting untuk diketahui.

Saat memilih database, Anda harus mempertimbangkan kekuatan dan kelemahannya dengan cermat. Anda juga perlu mempertimbangkan bagaimana database cocok dengan skenario spesifik Anda dan persyaratan aplikasi Anda. Terkadang solusi yang tepat adalah menggunakan kombinasi database SQL dan NoSQL untuk menangani berbagai aspek sistem yang lebih luas.

Beberapa contoh umum dari database SQL meliputi:

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

Contoh database NoSQL meliputi:

• DynamoDB
• Kasandra
• Merah
• CouchDB
• Pikirkan KembaliDB
• RavenDB
• MongoDB

Dalam beberapa tahun terakhir, database SQL dan NoSQL bahkan mulai bergabung. Misalnya, sistem database, seperti PostgreSQL, MySQL, dan Microsoft SQL Server sekarang mendukung penyimpanan dan kueri data JSON, seperti halnya database NoSQL. Dengan ini, Anda sekarang dapat mencapai banyak hasil yang sama dengan kedua teknologi. Namun Anda masih belum mendapatkan banyak fitur NoSQL, seperti penskalaan horizontal dan antarmuka yang ramah pengguna.

Dengan latar belakang singkat tentang database SQL dan NoSQL ini, Anda dapat fokus pada topik utama tutorial ini:basis data MongoDB dan cara menggunakannya dengan Python.

Mengelola Database NoSQL Dengan MongoDB

MongoDB adalah berorientasi dokumen database diklasifikasikan sebagai NoSQL. Ini menjadi populer di seluruh industri dalam beberapa tahun terakhir dan terintegrasi dengan sangat baik dengan Python. Tidak seperti RDBMS SQL tradisional, MongoDB menggunakan koleksi dari dokumen bukannya tabel dari baris untuk mengatur dan menyimpan data.

MongoDB menyimpan data dalam dokumen seperti JSON tanpa skema dan fleksibel. Di sini, tanpa skema berarti Anda dapat memiliki dokumen dengan kumpulan bidang yang berbeda dalam koleksi yang sama, tanpa perlu memenuhi skema tabel yang kaku .

Anda dapat mengubah struktur dokumen dan data Anda dari waktu ke waktu, yang menghasilkan sistem fleksibel yang memungkinkan Anda beradaptasi dengan cepat terhadap perubahan persyaratan tanpa memerlukan proses migrasi data yang rumit. Namun, trade-off dalam mengubah struktur dokumen baru adalah bahwa dokumen yang ada menjadi tidak konsisten dengan skema yang diperbarui. Jadi ini adalah topik yang perlu dikelola dengan hati-hati.

Catatan: JSON adalah singkatan dari JavaScript Object Notation . Ini adalah format file dengan struktur yang dapat dibaca manusia yang terdiri dari pasangan nilai kunci yang dapat disarangkan secara sewenang-wenang.

MongoDB ditulis dalam C++ dan dikembangkan secara aktif oleh MongoDB Inc. Ini berjalan di semua platform utama, seperti macOS, Windows, Solaris, dan sebagian besar distribusi Linux. Secara umum, ada tiga tujuan pengembangan utama di balik database MongoDB:

1. Skalakan dengan baik
2. Simpan struktur data yang kaya
3. Menyediakan mekanisme kueri yang canggih

MongoDB adalah didistribusikan database, sehingga ketersediaan tinggi, penskalaan horizontal, dan distribusi geografis dibangun ke dalam sistem. Ini menyimpan data dalam dokumen seperti JSON yang fleksibel. Anda dapat membuat model dokumen ini untuk memetakan objek dalam aplikasi Anda, yang memungkinkan untuk bekerja dengan data Anda secara efektif.

MongoDB menyediakan bahasa kueri yang kuat yang mendukung kueri ad hoc, pengindeksan, agregasi, penelusuran geospasial, penelusuran teks, dan banyak lagi. Ini memberi Anda kit alat yang kuat untuk mengakses dan bekerja dengan data Anda. Terakhir, MongoDB tersedia secara gratis dan memiliki dukungan Python yang hebat.

Meninjau Fitur MongoDB

Sejauh ini, Anda telah mempelajari apa itu MongoDB dan apa tujuan utamanya. Di bagian ini, Anda akan belajar tentang beberapa fitur MongoDB yang lebih penting. Sedangkan untuk sisi manajemen basis data, MongoDB menawarkan fitur-fitur berikut:

• Dukungan kueri: Anda dapat menggunakan banyak jenis kueri standar, seperti pencocokan (== ), perbandingan (< , > ), dan ekspresi reguler.
• Akomodasi data: Anda dapat menyimpan hampir semua jenis data, baik itu terstruktur, terstruktur sebagian, atau bahkan polimorfik.
• Skalabilitas: Ini menangani lebih banyak kueri hanya dengan menambahkan lebih banyak mesin ke cluster server.
• Fleksibilitas dan kelincahan: Anda dapat mengembangkan aplikasi dengannya dengan cepat.
• Orientasi dokumen dan tanpa skema: Anda dapat menyimpan semua informasi mengenai model data dalam satu dokumen.
• Skema yang dapat disesuaikan: Anda dapat mengubah skema database dengan cepat, yang mengurangi waktu yang dibutuhkan untuk menyediakan fitur baru atau memperbaiki masalah yang ada.
• Fungsi basis data relasional: Anda dapat melakukan tindakan umum untuk database relasional, seperti pengindeksan.

Untuk sisi operasi, MongoDB menyediakan beberapa alat dan fitur yang tidak akan Anda temukan di sistem database lain:

• Skalabilitas: Baik Anda memerlukan server yang berdiri sendiri atau cluster server independen yang lengkap, Anda dapat menskalakan MongoDB ke ukuran apa pun yang Anda inginkan.
• Dukungan penyeimbang beban: MongoDB akan secara otomatis memindahkan data di berbagai pecahan.
• Dukungan failover otomatis: Jika server utama Anda mati, maka server utama baru akan aktif dan berjalan secara otomatis.
• Alat manajemen: Anda dapat melacak mesin Anda menggunakan MongoDB Management Service (MMS) berbasis cloud.
• Efisiensi memori: Berkat file yang dipetakan memori, MongoDB seringkali lebih efisien daripada database relasional.

Semua fitur ini cukup berguna. Misalnya, jika Anda memanfaatkan fitur pengindeksan, maka sebagian besar data Anda akan disimpan di memori untuk pengambilan cepat. Bahkan tanpa mengindeks kunci dokumen tertentu, MongoDB menyimpan cukup banyak data menggunakan teknik yang paling jarang digunakan.

Menginstal dan Menjalankan MongoDB

Sekarang setelah Anda terbiasa dengan MongoDB, saatnya untuk mengotori tangan Anda dan mulai menggunakannya. Tetapi pertama-tama, Anda harus menginstalnya di mesin Anda. Situs resmi MongoDB menyediakan dua edisi server database:

1. Edisi komunitas menawarkan model dokumen yang fleksibel bersama dengan kueri ad hoc, pengindeksan, dan agregasi waktu nyata untuk menyediakan cara yang ampuh untuk mengakses dan menganalisis data Anda. Edisi ini tersedia secara gratis.
2. Edisi perusahaan menawarkan fitur yang sama dengan edisi komunitas, ditambah fitur lanjutan lainnya yang terkait dengan keamanan dan pemantauan. Ini adalah edisi komersial, tetapi Anda dapat menggunakannya secara gratis untuk waktu yang tidak terbatas untuk tujuan evaluasi dan pengembangan.

Jika Anda menggunakan Windows, maka Anda dapat membaca tutorial instalasi untuk instruksi lengkap. Secara umum bisa masuk ke halaman download, pilih platform Windows pada kotak Available Downloads, pilih .msi penginstal yang sesuai dengan sistem Anda saat ini, dan klik Unduh .

Jalankan penginstal dan ikuti petunjuk di layar pada wizard penginstalan. Halaman ini juga memberikan informasi tentang cara menjalankan MongoDB sebagai layanan Windows.

Jika Anda menggunakan macOS, Anda dapat menggunakan Homebrew untuk menginstal MongoDB di sistem Anda. Lihat tutorial instalasi untuk mendapatkan panduan lengkapnya. Selain itu, pastikan untuk mengikuti instruksi untuk menjalankan MongoDB sebagai layanan macOS.

Jika Anda menggunakan Linux, maka proses instalasi akan bergantung pada distribusi spesifik Anda. Untuk panduan rinci tentang cara menginstal MongoDB pada sistem Linux yang berbeda, buka halaman tutorial instalasi dan pilih tutorial yang cocok dengan sistem operasi Anda saat ini. Pastikan Anda menjalankan daemon MongoDB, mongod , di akhir penginstalan.

Terakhir, Anda juga dapat menginstal MongoDB menggunakan Docker. Ini berguna jika Anda tidak ingin mengacaukan sistem Anda dengan instalasi lain. Jika Anda lebih suka opsi instalasi ini, Anda dapat membaca tutorial resmi dan mengikuti petunjuknya. Perhatikan bahwa pengetahuan sebelumnya tentang cara menggunakan Docker akan diperlukan dalam kasus ini.

Dengan database MongoDB terinstal dan berjalan di sistem Anda, Anda dapat mulai bekerja dengan database nyata menggunakan mongo cangkang.

Membuat Database MongoDB Dengan mongo Kulit

Jika Anda telah mengikuti petunjuk penginstalan dan menjalankan, maka Anda seharusnya sudah memiliki instance MongoDB yang berjalan di sistem Anda. Sekarang Anda dapat mulai membuat dan menguji database Anda sendiri. Di bagian ini, Anda akan mempelajari cara menggunakan mongo shell untuk membuat, membaca, memperbarui, dan menghapus dokumen pada database.

Menjalankan mongo Kulit

mongo shell adalah antarmuka JavaScript interaktif untuk MongoDB. Anda dapat menggunakan alat ini untuk menanyakan dan memanipulasi data Anda serta untuk melakukan operasi administratif. Karena ini adalah antarmuka JavaScript, Anda tidak akan menggunakan bahasa SQL yang sudah dikenal untuk mengkueri database. Sebagai gantinya, Anda akan menggunakan kode JavaScript.

Untuk meluncurkan mongo shell, buka terminal atau baris perintah Anda dan jalankan perintah berikut:

$ mongo

Perintah ini membawa Anda ke mongo kerang. Pada titik ini, Anda mungkin akan melihat banyak pesan dengan informasi tentang versi shell dan pada alamat dan port server. Terakhir, Anda akan disajikan dengan prompt shell (> ) untuk memasukkan kueri dan perintah.

Anda dapat meneruskan alamat database sebagai argumen ke mongo memerintah. Anda juga dapat menggunakan beberapa opsi, seperti menentukan host dan port untuk mengakses database jarak jauh, dan sebagainya. Untuk detail lebih lanjut tentang cara menggunakan mongo perintah, Anda dapat menjalankan mongo --help .

Membangun Koneksi

Saat Anda menjalankan mongo perintah tanpa argumen, ia meluncurkan shell dan menghubungkan ke server lokal default yang disediakan oleh mongod proses di mongod://127.0.0.1:27017 . Ini berarti Anda terhubung ke host lokal melalui port 27017 .

Secara default, mongo shell memulai sesi dengan membuat koneksi ke test basis data. Anda dapat mengakses database saat ini melalui db objek:

> db
test
>

Dalam hal ini, db memegang referensi ke test , yang merupakan basis data default. Untuk berpindah database, jalankan perintah use , memberikan nama database sebagai argumen.

Misalnya, Anda ingin membuat situs web untuk mempublikasikan konten Python, dan Anda berencana menggunakan MongoDB untuk menyimpan tutorial dan artikel Anda. Dalam hal ini, Anda dapat beralih ke database situs dengan perintah berikut:

> use rptutorials
switched to db rptutorials

Perintah ini mengalihkan koneksi Anda ke rptutorials basis data. MongoDB tidak membuat file database fisik pada sistem file sampai Anda memasukkan data nyata ke dalam database. Jadi dalam hal ini, rptutorials tidak akan muncul di daftar database Anda saat ini:

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

mongo shell menyediakan banyak fitur dan opsi. Ini memungkinkan Anda untuk menanyakan dan memanipulasi data Anda dan juga untuk mengelola server database itu sendiri.

Alih-alih menggunakan bahasa kueri standar seperti SQL, mongo shell menggunakan bahasa pemrograman JavaScript dan API yang mudah digunakan. API ini memungkinkan Anda untuk bermain-main dengan data Anda, yang merupakan topik untuk bagian selanjutnya.

Membuat Koleksi dan Dokumen

Basis data MongoDB adalah wadah fisik untuk kumpulan dokumen. Setiap database mendapatkan kumpulan filenya sendiri di sistem file. File-file ini dikelola oleh server MongoDB, yang dapat menangani beberapa database.

Di MongoDB, sebuah koleksi adalah sekelompok dokumen . Koleksi agak analog dengan tabel dalam RDBMS tradisional, tetapi tanpa memaksakan skema yang kaku. Secara teori, setiap dokumen dalam kumpulan dapat memiliki struktur atau kumpulan bidang yang sama sekali berbeda.

Dalam praktiknya, dokumen dalam kumpulan biasanya memiliki struktur yang serupa untuk memungkinkan proses pengambilan, penyisipan, dan pembaruan yang seragam. Anda dapat menerapkan struktur dokumen yang seragam dengan menggunakan aturan validasi dokumen selama pembaruan dan penyisipan.

Mengizinkan struktur dokumen yang berbeda adalah fitur utama dari koleksi MongoDB. Fitur ini memberikan fleksibilitas dan memungkinkan penambahan bidang baru ke dokumen tanpa perlu memodifikasi skema tabel formal.

Untuk membuat koleksi menggunakan mongo shell, Anda harus menunjuk db ke database target Anda, lalu buat koleksi menggunakan notasi titik :

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

Dalam contoh ini, Anda menggunakan notasi titik untuk membuat tutorial sebagai koleksi di rptutorials , yang merupakan basis data Anda saat ini. Penting untuk dicatat bahwa MongoDB membuat database dan koleksi dengan malas . Dengan kata lain, mereka dibuat secara fisik hanya setelah Anda memasukkan dokumen pertama.

Setelah Anda memiliki database dan koleksi, Anda dapat mulai memasukkan dokumen. Dokumen adalah unit penyimpanan di MongoDB. Dalam RDBMS, ini akan setara dengan baris tabel. Namun, dokumen MongoDB jauh lebih fleksibel daripada baris karena mereka dapat menyimpan informasi yang kompleks, seperti array, dokumen yang disematkan, dan bahkan array dokumen.

MongoDB menyimpan dokumen dalam format yang disebut Binary JSON (BSON), yang merupakan representasi biner dari JSON. Dokumen MongoDB terdiri dari pasangan bidang-dan-nilai dan memiliki struktur berikut:

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

Nilai bidang dapat berupa tipe data BSON apa pun, termasuk dokumen lain, larik, dan larik dokumen. Dalam praktiknya, Anda akan menentukan dokumen Anda menggunakan format JSON.

Saat Anda membangun aplikasi database MongoDB, mungkin keputusan terpenting Anda adalah tentang struktur dokumen. Dengan kata lain, Anda harus memutuskan bidang dan nilai mana yang akan dimiliki dokumen Anda.

Dalam kasus tutorial untuk situs Python Anda, dokumen Anda mungkin terstruktur seperti ini:

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

Dokumen pada dasarnya adalah sekumpulan nama properti dan nilainya. Nilai dapat berupa tipe data sederhana, seperti string dan angka, tetapi juga dapat berupa array seperti contributors dalam contoh di atas.

Model data berorientasi dokumen MongoDB secara alami mewakili data kompleks sebagai objek tunggal. Ini memungkinkan Anda bekerja dengan objek data secara holistik, tanpa perlu melihat beberapa tempat atau tabel.

Jika Anda menggunakan RDBMS tradisional untuk menyimpan tutorial Anda, maka Anda mungkin akan memiliki tabel untuk menyimpan tutorial Anda dan tabel lain untuk menyimpan kontributor Anda. Kemudian Anda harus menyiapkan hubungan antara kedua tabel sehingga Anda dapat mengambil datanya nanti.

Bekerja Dengan Koleksi dan Dokumen

Sejauh ini, Anda mengetahui dasar-dasar cara menjalankan dan menggunakan mongo kerang. Anda juga tahu cara membuat dokumen Anda sendiri menggunakan format JSON. Sekarang saatnya mempelajari cara memasukkan dokumen ke dalam database MongoDB Anda.

Untuk memasukkan dokumen ke dalam database menggunakan mongo shell, pertama Anda harus memilih koleksi dan kemudian memanggil .insertOne() pada koleksi dengan dokumen Anda sebagai argumen:

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

Dengan perintah pertama, Anda beralih ke database yang ingin Anda gunakan. Perintah kedua adalah pemanggilan metode JavaScript yang menyisipkan dokumen sederhana ke dalam koleksi yang dipilih, tutorial . Setelah Anda menekan Enter , Anda mendapatkan pesan di layar yang memberi tahu Anda tentang dokumen yang baru dimasukkan dan insertedId-nya .

Sama seperti database relasional yang memerlukan kunci utama untuk mengidentifikasi setiap baris secara unik dalam tabel, dokumen MongoDB harus memiliki _id bidang yang secara unik mengidentifikasi dokumen. MongoDB memungkinkan Anda memasukkan _id khusus selama Anda menjamin keunikannya. Namun, praktik yang diterima secara luas adalah mengizinkan MongoDB untuk secara otomatis memasukkan _id untukmu.

Demikian pula, Anda dapat menambahkan beberapa dokumen sekaligus menggunakan .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")
    ]
}

Di sini, panggilan ke .insertMany() mengambil daftar tutorial dan memasukkannya ke dalam database. Sekali lagi, output shell menampilkan informasi tentang dokumen yang baru dimasukkan dan _id yang ditambahkan secara otomatis bidang.

mongo shell juga menyediakan metode untuk melakukan operasi baca, perbarui, dan hapus pada database. Misalnya, Anda dapat menggunakan .find() untuk mengambil dokumen dalam koleksi:

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

Panggilan pertama ke .find() mengambil semua dokumen dalam tutorial koleksi. Di sisi lain, panggilan kedua ke .find() mengambil kembali tutorial yang ditulis oleh Joanna.

Dengan latar belakang pengetahuan tentang cara menggunakan MongoDB melalui mongo shell, Anda siap untuk mulai menggunakan MongoDB dengan Python. Beberapa bagian berikutnya akan memandu Anda melalui berbagai opsi untuk menggunakan database MongoDB dalam aplikasi Python Anda.

Menggunakan MongoDB Dengan Python dan PyMongo

Sekarang Anda tahu apa itu MongoDB dan bagaimana membuat dan mengelola database menggunakan mongo shell, Anda dapat mulai menggunakan MongoDB, tetapi kali ini dengan Python. MongoDB menyediakan driver Python resmi yang disebut PyMongo.

Di bagian ini, Anda akan melihat beberapa contoh yang akan membantu Anda memahami cara menggunakan PyMongo untuk membuat aplikasi database Anda sendiri dengan MongoDB dan Python.

Setiap modul dalam PyMongo bertanggung jawab atas serangkaian operasi pada database. Anda akan memiliki modul setidaknya untuk tugas-tugas berikut:

• Membuat koneksi basis data
• Bekerja dengan database
• Bekerja dengan koleksi dan dokumen
• Memanipulasi kursor
• Bekerja dengan enkripsi data

Secara umum, PyMongo menyediakan seperangkat alat yang dapat Anda gunakan untuk berkomunikasi dengan server MongoDB. Ini menyediakan fungsionalitas untuk query, mengambil hasil, menulis dan menghapus data, dan menjalankan perintah database.

Menginstal PyMongo

Untuk mulai menggunakan PyMongo, Anda harus menginstalnya terlebih dahulu di lingkungan Python Anda. Anda dapat menggunakan lingkungan virtual, atau Anda dapat menggunakan instalasi Python di seluruh sistem Anda, meskipun opsi pertama lebih disukai. PyMongo tersedia di PyPI, jadi cara tercepat untuk menginstalnya adalah dengan pip . Jalankan terminal Anda dan jalankan perintah berikut:

$ pip install pymongo==3.11.2

Setelah beberapa unduhan dan langkah terkait lainnya, perintah ini menginstal PyMongo di lingkungan Python Anda. Perhatikan bahwa jika Anda tidak memberikan nomor versi tertentu, maka pip akan menginstal versi terbaru yang tersedia.

Catatan: Untuk panduan lengkap tentang cara menginstal PyMongo, lihat halaman Menginstal/Meningkatkan versi dari dokumentasi resminya.

Setelah selesai menginstal, Anda dapat memulai sesi interaktif Python dan menjalankan impor berikut:

>>> import pymongo

Jika ini berjalan tanpa memunculkan pengecualian di shell Python, maka instalasi Anda berfungsi dengan baik. Jika tidak, lakukan kembali langkah-langkah tersebut dengan hati-hati.

Membangun Koneksi

Untuk membuat koneksi ke database, Anda perlu membuat MongoClient contoh. Kelas ini menyediakan klien untuk instans atau server MongoDB. Setiap objek klien memiliki kumpulan koneksi bawaan, yang secara default menangani hingga seratus koneksi ke server.

Kembali ke sesi interaktif Python Anda dan impor MongoClient dari pymongo . Kemudian buat objek klien untuk berkomunikasi dengan instans MongoDB Anda yang sedang berjalan:

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

Kode di atas membuat koneksi ke host default (localhost ) dan porta (27017 ). MongoClient mengambil satu set argumen yang memungkinkan Anda untuk menentukan host kustom, port, dan parameter koneksi lainnya. Misalnya, untuk menyediakan host dan port khusus, Anda dapat menggunakan kode berikut:

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

Ini berguna ketika Anda perlu memberikan host dan port yang berbeda dari pengaturan default MongoDB. Anda juga dapat menggunakan format URI MongoDB:

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

Semua contoh MongoClient menyediakan pengaturan klien yang sama untuk menghubungkan instans MongoDB Anda saat ini. Yang mana yang harus Anda gunakan hanya bergantung pada seberapa eksplisit Anda ingin berada dalam kode Anda.

Setelah Anda membuat instance MongoClient , Anda dapat menggunakan turunannya untuk merujuk ke koneksi database tertentu, seperti yang Anda lakukan dengan mongo db shell> objek di bagian atas.

Bekerja Dengan Database, Koleksi, dan Dokumen

Setelah Anda memiliki instance MongoClient yang terhubung , Anda dapat mengakses database apa pun yang dikelola oleh server MongoDB yang ditentukan. Untuk menentukan database mana yang ingin Anda gunakan, Anda dapat menggunakan notasi titik seperti yang Anda lakukan di mongo cangkang:

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

Dalam hal ini, rptutorials adalah nama database yang akan Anda kerjakan. Jika database tidak ada, maka MongoDB membuatnya untuk Anda, tetapi hanya saat Anda melakukan operasi pertama pada database.

Anda juga dapat menggunakan akses bergaya kamus jika nama database bukan pengidentifikasi Python yang valid:

>>> db = client["rptutorials"]

Pernyataan ini berguna ketika nama database Anda bukan pengidentifikasi Python yang valid. Misalnya, jika database Anda bernama rp-tutorials , maka Anda perlu menggunakan akses bergaya kamus.

Catatan: Saat Anda menggunakan mongo shell, Anda memiliki akses ke database melalui db objek global. Saat Anda menggunakan PyMongo, Anda dapat menetapkan database ke variabel yang disebut db untuk mendapatkan perilaku serupa.

Menyimpan data di database Anda menggunakan PyMongo mirip dengan yang Anda lakukan dengan mongo cangkang di bagian atas. Tetapi pertama-tama, Anda perlu membuat dokumen Anda. Dengan Python, Anda menggunakan kamus untuk membuat dokumen:

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

Setelah Anda membuat dokumen sebagai kamus, Anda perlu menentukan koleksi mana yang ingin Anda gunakan. Untuk melakukannya, Anda dapat menggunakan notasi titik pada objek database:

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

Dalam hal ini, tutorial adalah turunan dari Collection dan mewakili koleksi fisik dokumen dalam database Anda. Anda dapat memasukkan dokumen ke dalam tutorial dengan memanggil .insert_one() di atasnya dengan dokumen sebagai argumen:

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

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

Di sini, .insert_one() membutuhkan tutorial1 , masukkan ke dalam tutorial koleksi dan mengembalikan InsertOneResult obyek. Objek ini memberikan umpan balik pada dokumen yang disisipkan. Perhatikan bahwa karena MongoDB menghasilkan ObjectId secara dinamis, output Anda tidak akan cocok dengan ObjectId ditunjukkan di atas.

Jika Anda memiliki banyak dokumen untuk ditambahkan ke database, Anda dapat menggunakan .insert_many() untuk memasukkannya sekaligus:

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

Ini lebih cepat dan lebih mudah daripada memanggil .insert_one() beberapa kali. Panggilan ke .insert_many() mengambil dokumen yang dapat diubah dan memasukkannya ke dalam tutorial koleksi di rptutorials . Anda basis data. Metode ini mengembalikan sebuah instance dari InsertManyResult , yang memberikan informasi tentang dokumen yang disisipkan.

Untuk mengambil dokumen dari koleksi, Anda dapat menggunakan .find() . Tanpa argumen, .find() mengembalikan Cursor objek yang menghasilkan dokumen dalam koleksi sesuai permintaan:

>>> 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 penyataan. 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 perintah:

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

Catatan: 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:

Get the Source Code: Click here to get the source code you’ll use to learn about using MongoDB with Python in this tutorial.