Python og MongoDB:Opretter forbindelse til NoSQL-databaser

Dette er hurtigere og mere ligetil end at kalde .insert_one() flere gange. Kaldet til .insert_many() tager en gentagelse af dokumenter og indsætter dem i tutorial samling i dine rptutorials database. Metoden returnerer en forekomst af InsertManyResult , som giver oplysninger om de indsatte dokumenter.

For at hente dokumenter fra en samling kan du bruge .find() . Uden argumenter, .find() returnerer en Markør genstand, der leverer dokumenterne i samlingen efter anmodning:

>>> importer pprint>>> til doc i tutorial.find():... pprint.pprint(doc)...{'_id':ObjectId('600747355e6ea8d224f754ba'), 'author':'Jon', 'contributors':['Aldren', 'Geir Arne', 'Joanna', 'Jason'], 'title':'Læsning og skrivning af CSV-filer i 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 udmelding. 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 kommando:

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

Bemærk: 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 

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 PythonHow to Iterate Through a Dictionary in PythonPython 3's f-Strings:An Improved String Formatting Syntax (Guide)Working With JSON Data in PythonPython's Requests Library (Guide)Object-Oriented Programming (OOP) in Python 3Beautiful 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:

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