Python MongoDB-빠른 가이드
Pymongo는 MongoDB와 함께 작동하는 도구를 제공하는 Python 배포판으로, Python에서 MongoDB 데이터베이스와 통신하는 데 가장 선호되는 방법입니다.
설치
pymongo를 먼저 설치하려면 python3 (PIP와 함께) 및 MongoDB를 올바르게 설치했는지 확인하십시오. 그런 다음 다음 명령을 실행하십시오.
C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0
확인
pymongo를 설치했으면 새 텍스트 문서를 열고 다음 행을 붙여넣고 test.py로 저장하십시오.
import pymongo
pymongo를 제대로 설치했다면 아래와 같이 test.py를 실행하면 아무런 문제가 없을 것입니다.
D:\Python_MongoDB>test.py
D:\Python_MongoDB>
다른 데이터베이스와 달리 MongoDB는 데이터베이스를 생성하는 별도의 명령을 제공하지 않습니다.
일반적으로 use 명령은 특정 데이터베이스를 선택 / 전환하는 데 사용됩니다. 이 명령은 처음에 우리가 지정한 데이터베이스가 있는지 여부를 확인합니다. 존재하는 경우 연결합니다. 데이터베이스가 존재하지 않는 경우 use 명령으로 지정하면 새 데이터베이스가 생성됩니다.
따라서 MongoDB에서 다음을 사용하여 데이터베이스를 만들 수 있습니다. Use 명령.
통사론
기본 구문 use DATABASE 진술은 다음과 같습니다-
use DATABASE_NAME
예
다음 명령은 mydb라는 이름의 데이터베이스를 만듭니다.
>use mydb
switched to db mydb
db 명령 을 사용하여 생성을 확인할 수 있습니다 . 그러면 현재 데이터베이스가 표시됩니다.
>db
mydb
Python을 사용하여 데이터베이스 생성
pymongo를 사용하여 MongoDB에 연결하려면 MongoClient를 가져 와서 생성 한 다음 속성 열정에서 생성해야하는 데이터베이스에 직접 액세스 할 수 있습니다.
예
다음 예제는 MangoDB에 데이터베이스를 만듭니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
print("Database created........")
#Verification
print("List of databases after creating new one")
print(client.list_database_names())
산출
Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']
MongoClient를 생성하는 동안 포트 및 호스트 이름을 지정할 수도 있으며 사전 스타일로 데이터베이스에 액세스 할 수 있습니다.
예
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
print("Database created........")
산출
Database created........
MongoDB의 컬렉션은 일련의 문서를 보유하며 관계형 데이터베이스의 테이블과 유사합니다.
다음을 사용하여 컬렉션을 만들 수 있습니다. createCollection()방법. 이 메서드는 만들 컬렉션의 이름을 나타내는 문자열 값과 옵션 (선택 사항) 매개 변수를받습니다.
이것을 사용하여 다음을 지정할 수 있습니다-
컬렉션 의 크기 입니다.
최대 캐핑 컬렉션 허용 문서 수.
우리가 생성하는 컬렉션이 제한 컬렉션 (고정 크기 컬렉션)이어야하는지 여부.
우리가 생성하는 컬렉션이 자동 인덱싱되어야하는지 여부.
통사론
다음은 MongoDB에서 컬렉션을 만드는 구문입니다.
db.createCollection("CollectionName")
예
다음 메서드는 ExampleCollection이라는 컬렉션을 만듭니다.
> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>
마찬가지로 다음은 createCollection () 메서드의 옵션을 사용하여 컬렉션을 만드는 쿼리입니다.
>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>
Python을 사용하여 컬렉션 만들기
다음 파이썬 예제는 MongoDB (mydb)의 데이터베이스에 연결하고 그 안에 컬렉션을 만듭니다.
예
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
#Creating a collection
collection = db['example']
print("Collection created........")
산출
Collection created........
insert () 메서드를 사용하여 MongoDB에 문서를 저장할 수 있습니다 . 이 메소드는 JSON 문서를 매개 변수로 허용합니다.
통사론
다음은 삽입 메소드의 구문입니다.
>db.COLLECTION_NAME.insert(DOCUMENT_NAME)
예
> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>
마찬가지로 다음을 사용하여 여러 문서를 삽입 할 수도 있습니다. insert() 방법.
> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
{"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
{"_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad"},
{"_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore"},
{"_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 3,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
>
Python을 사용하여 컬렉션 만들기
Pymongo는 MangoDB에 문서를 삽입하기 위해 insert_one ()이라는 메서드를 제공합니다. 이 방법을 사용하려면 사전 형식으로 문서를 전달해야합니다.
예
다음 예제는 example이라는 컬렉션에 문서를 삽입합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
#Creating a collection
coll = db['example']
#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())
산출
{'_id': ObjectId('5d63ad6ce043e2a93885858b'), 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
pymongo를 사용하여 MongoDB에 여러 문서를 삽입하려면 insert_many () 메서드를 호출해야합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydb']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)
산출
Data inserted ......
['101', '102', '103']
MongoDB에서 저장된 문서를 읽고 검색 할 수 있습니다. find()방법. 이 메서드는 MongoDB의 모든 문서를 구조화되지 않은 방식으로 검색하고 표시합니다.
통사론
다음은 find() 방법.
>db.COLLECTION_NAME.find()
예
다음 쿼리를 사용하여 sample이라는 컬렉션의 testDB라는 데이터베이스에 3 개의 문서를 삽입했다고 가정합니다.
> use testDB
> db.createCollection("sample")
> data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
{"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)
다음과 같이 find () 메소드를 사용하여 삽입 된 문서를 검색 할 수 있습니다.
> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>
findOne () 메소드를 사용하여 컬렉션의 첫 번째 문서를 검색 할 수도 있습니다.
> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
Python을 사용하여 데이터 검색 (찾기)
그만큼 find_One() pymongo의 메서드는 쿼리를 기반으로 단일 문서를 검색하는 데 사용됩니다. 일치하는 항목이없는 경우이 메서드는 아무것도 반환하지 않으며 쿼리를 사용하지 않으면 컬렉션의 첫 번째 문서를 반환합니다.
이 메서드는 결과의 문서를 하나만 검색해야하거나 쿼리가 하나의 문서 만 반환한다고 확신 할 때 유용합니다.
예
다음 파이썬 예제는 컬렉션의 첫 번째 문서를 검색합니다-
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mydatabase']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)
#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())
#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))
산출
Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
단일 쿼리 (단일 호출 또는 찾기 방법)에서 여러 문서를 가져 오려면 다음을 사용할 수 있습니다. find()pymongo의 방법. 쿼리를 전달하지 않은 경우 컬렉션의 모든 문서를 반환하고이 메서드에 쿼리를 전달한 경우 일치하는 모든 문서를 반환합니다.
예
#Getting the database instance
db = client['myDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)
#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)
산출
Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
사용하여 검색하는 동안 find()방법을 사용하면 쿼리 개체를 사용하여 문서를 필터링 할 수 있습니다. 필수 문서의 조건을 지정하는 쿼리를이 메서드에 대한 매개 변수로 전달할 수 있습니다.
연산자
다음은 MongoDB의 쿼리에 사용되는 연산자 목록입니다.
조작 | 통사론 | 예 |
---|---|---|
평등 | {"핵심 가치"} | db.mycol.find ({ "by": "튜토리얼 포인트"}) |
보다 작음 | { "키": {$ lt : "값"}} | db.mycol.find ({ "좋아요": {$ lt : 50}}) |
보다 작음 | { "key": {$ lte : "value"}} | db.mycol.find ({ "좋아요": {$ lte : 50}}) |
보다 큰 | { "키": {$ gt : "값"}} | db.mycol.find ({ "좋아요": {$ gt : 50}}) |
같음보다 큼 | { "키"{$ gte : "value"}} | db.mycol.find ({ "좋아요": {$ gte : 50}}) |
같지 않음 | { "key": {$ ne : "값"}} | db.mycol.find ({ "likes": {$ ne : 50}}) |
예 1
다음 예제는 이름이 sarmista 인 컬렉션에서 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['sdsegf']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving data
print("Documents in the collection: ")
for doc1 in coll.find({"name":"Sarmista"}):
print(doc1)
산출
Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
예 2
다음 예제는 컬렉션에서 연령 값이 26보다 큰 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['ghhj']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving data
print("Documents in the collection: ")
for doc in coll.find({"age":{"$gt":"26"}}):
print(doc)
산출
Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
컬렉션의 내용을 검색하는 동안 다음을 사용하여 오름차순 또는 내림차순으로 정렬하고 정렬 할 수 있습니다. sort() 방법.
이 방법으로 필드와 정렬 순서 (1 또는 -1)를 전달할 수 있습니다. 여기서 1은 오름차순이고 -1은 내림차순입니다.
통사론
다음은 sort () 메서드 의 구문입니다 .
>db.COLLECTION_NAME.find().sort({KEY:1})
예
아래와 같이 컬렉션을 만들고 5 개의 문서를 삽입했다고 가정합니다.
> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 6,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
다음 줄은 연령에 따라 오름차순으로 정렬 된 컬렉션의 모든 문서를 검색합니다.
> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
Python을 사용하여 문서 정렬
쿼리 결과를 오름차순 또는 내림차순으로 정렬하기 위해 pymongo는 sort()방법. 이 메서드에는 결과에 필요한 문서 수를 나타내는 숫자 값을 전달합니다.
기본적으로이 방법은 지정된 필드를 기준으로 문서를 오름차순으로 정렬합니다. 내림차순으로 정렬해야하는 경우 필드 이름과 함께 -1을 전달합니다.
coll.find().sort("age",-1)
예
다음 예제는 오름차순으로 연령 값에 따라 정렬 된 컬렉션의 모든 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['b_mydb']
#Creating a collection
coll = db['myColl']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")
for doc1 in coll.find().sort("age"):
print(doc1)
산출
Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
컬렉션에서 문서를 삭제할 수 있습니다. remove()MongoDB의 방법. 이 방법은 두 가지 선택적 매개 변수를 허용합니다.
문서 삭제 조건을 지정하는 삭제 기준입니다.
하나만 true 또는 1을 두 번째 매개 변수로 전달하면 하나의 문서 만 삭제됩니다.
통사론
다음은 remove () 메서드의 구문입니다.
>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)
예
아래와 같이 컬렉션을 만들고 5 개의 문서를 삽입했다고 가정합니다.
> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 6,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
다음 쿼리는 이름 값이 Sarmista 인 컬렉션의 문서를 삭제합니다.
> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
호출하면 remove() 삭제 기준을 통과하지 않고 메서드를 사용하면 컬렉션의 모든 문서가 삭제됩니다.
> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()
Python을 사용하여 문서 삭제
MangoDB 컬렉션에서 문서를 삭제하려면 메서드를 사용하여 컬렉션에서 문서를 삭제할 수 있습니다. delete_one() 과 delete_many() 행동 양식.
이러한 메서드는 문서 삭제 조건을 지정하는 쿼리 개체를받습니다.
detele_one () 메서드는 일치하는 경우 단일 문서를 삭제합니다. 쿼리를 지정하지 않으면이 메서드는 컬렉션의 첫 번째 문서를 삭제합니다.
예
다음 파이썬 예제는 ID 값이 1006 인 컬렉션의 문서를 삭제합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['lpaksgf']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Deleting one document
coll.delete_one({"_id" : "1006"})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)
산출
Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
마찬가지로 delete_many() pymongo의 메소드는 지정된 조건을 만족하는 모든 문서를 삭제합니다.
예
다음 예제는 컬렉션에서 나이 값이 26보다 큰 모든 문서를 삭제합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['sampleDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)
산출
Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}
쿼리를 전달하지 않고 delete_many () 메서드를 호출하면이 메서드는 컬렉션의 모든 문서를 삭제합니다.
coll.delete_many({})
다음을 사용하여 컬렉션을 삭제할 수 있습니다. drop() MongoDB의 방법.
통사론
다음은 drop () 메서드의 구문입니다.
db.COLLECTION_NAME.drop()
예
다음 예제는 샘플 이름으로 컬렉션을 삭제합니다-
> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl
Python을 사용하여 컬렉션 삭제
drop () 메서드를 호출하여 현재 컬렉션에서 컬렉션을 삭제 / 삭제할 수 있습니다.
예
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['example2']
#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})
#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)
#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")
#List of collections
collections = db.list_collection_names()
for coll in collections:
print(coll)
산출
List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl
다음을 사용하여 기존 문서의 내용을 업데이트 할 수 있습니다. update() 방법 또는 save() 방법.
업데이트 메소드는 기존 문서를 수정하는 반면 저장 메소드는 기존 문서를 새 문서로 대체합니다.
통사론
다음은 MangoDB의 update () 및 save () 메소드의 구문입니다.
>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})
예
데이터베이스에 컬렉션을 만들고 아래와 같이 3 개의 레코드를 삽입했다고 가정합니다.
> use testdatabase
switched to db testdatabase
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
{"_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad"},
{"_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore"},
{"_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai"}
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)
다음 메소드는 ID가 1002 인 문서의 도시 값을 업데이트합니다.
>db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
마찬가지로 save () 메서드를 사용하여 동일한 ID로 저장하여 문서를 새 데이터로 바꿀 수 있습니다.
> db.sample.save({ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" })
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
Python을 사용하여 문서 업데이트
단일 문서를 검색하는 find_one () 메소드와 유사하게, pymongo의 update_one () 메소드는 단일 문서를 업데이트합니다.
이 메서드는 업데이트 할 문서와 업데이트 작업을 지정하는 쿼리를받습니다.
예
다음 파이썬 예제는 컬렉션에서 문서의 위치 값을 업데이트합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['myDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)
산출
Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
마찬가지로 update_many() pymongo 메소드는 지정된 조건을 충족하는 모든 문서를 업데이트합니다.
예
다음 예제는 컬렉션의 모든 문서에서 위치 값을 업데이트합니다 (빈 상태)-
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['myDB']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})
#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")
for doc2 in coll.find():
print(doc2)
산출
Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}
컬렉션의 내용을 검색하는 동안 limit () 메서드를 사용하여 결과의 문서 수를 제한 할 수 있습니다. 이 메서드는 결과에서 원하는 문서 수를 나타내는 숫자 값을받습니다.
통사론
다음은 limit () 메서드의 구문입니다.
>db.COLLECTION_NAME.find().limit(NUMBER)
예
아래와 같이 컬렉션을 만들고 5 개의 문서를 삽입했다고 가정합니다.
> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 6,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
다음 줄은 컬렉션의 처음 3 개 문서를 검색합니다.
> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
Python을 사용하여 문서 제한
쿼리 결과를 특정 문서 수로 제한하기 위해 pymongo는 limit()방법. 이 메서드에는 결과에 필요한 문서 수를 나타내는 숫자 값을 전달합니다.
예
다음 예제는 컬렉션의 처음 세 문서를 검색합니다.
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['l']
#Creating a collection
coll = db['myColl']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
{"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
{"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")
for doc1 in coll.find().limit(3):
print(doc1)
산출
Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}