파이썬 BSON 직렬화와 MongoDB datetime 타임존 ObjectId 정밀도까지 한 번에 정리

파이썬 BSON 직렬화와 MongoDB datetime 타임존 ObjectId 정밀도까지 한 번에 정리

🧪 파이썬 pymongo.bson에서 timezone 인식 datetime과 ObjectId가 실제로 어떻게 저장되는지, 그리고 BSON 정밀도에서 흔히 놓치는 함정을 짚어봅니다

MongoDB를 처음 쓰면 한 번쯤 당황하게 되는 부분이 있습니다.
문서를 INSERT 했을 뿐인데 날짜가 내가 넣은 시간과 다르게 바뀌어 버린 것처럼 보이거나, 소수점 숫자가 살짝 달라진 것처럼 느껴지거나, _id 필드에 자동으로 들어간 이상한 24자 문자열(ObjectId)이 사실은 시간 정보를 품고 있다는 사실을 뒤늦게 알게 되는 순간 같은 것들입니다.
이건 단순한 우연이 아니라 MongoDB가 내부적으로 사용하는 BSON(Binary JSON) 포맷의 동작 방식 때문입니다.
BSON은 JSON과 비슷하게 보이지만 실제로는 훨씬 엄격하게 타입을 정의해 둔 이진 직렬화 포맷이고, 파이썬에서는 pymongo 패키지의 bson 모듈이 이 변환을 처리합니다.
그래서 datetime, 숫자, ObjectId 같은 값들이 어떻게 직렬화·역직렬화되는지 이해하지 못하면 시간대(타임존) 문제나 정밀도 손실 문제로 디버깅 시간을 엄청 날릴 수 있습니다.

파이썬 개발자가 실제로 겪는 대표적인 이슈를 기준으로 정리해 보면 핵심은 네 가지입니다.
첫째, MongoDB 문서는 딕셔너리처럼 보이지만 BSON 스펙에 맞춘 엄격한 타입 정보를 갖는 문서형 구조라는 점.
둘째, pymongo.bson이 datetime 값을 다룰 때 모든 시간을 UTC 기준 밀리초 단위 정밀도로 저장하고, 기본적으로 타임존 정보를 잃을 수 있다는 점.
셋째, ObjectId는 단순 랜덤 ID가 아니라 생성 시각(초 단위)까지 들어 있는 12바이트 값이라는 점.
넷째, BSON의 숫자 타입(예: double)은 IEEE 754 64비트 부동소수 형식이라 아주 많은 값을 표현할 수 있지만 반대로 말하면 ‘정확한 소수’를 보장하지 않는다는 점입니다.
이 글은 그 네 가지를 연결해서 설명하면서, 실제로 어떤 실수만 피하면 안정적으로 데이터를 넣고 꺼낼 수 있는지까지 짚습니다.
특히 날짜/시간 필드를 다루는 파트는 운영 환경에서 에러를 가장 많이 만드는 부분이라서 꼭 한 번 정리해 둘 만합니다.

📌 BSON과 MongoDB 문서형 구조 이해

MongoDB는 데이터를 “문서(document)”라고 부르는 구조로 저장합니다.
겉으로 보면 그냥 파이썬 딕셔너리나 JSON 객체랑 비슷해 보이죠.
하지만 실제 저장 단위는 JSON 그 자체가 아니라 BSON(Binary JSON)이라는 이진 형식입니다.
이 BSON이 왜 중요하냐면, 우리가 넣는 각각의 값(문자열, 숫자, 날짜, ObjectId 등)에 대해 타입 정보를 아주 명확하게 들고 있기 때문입니다.
이 말은 곧 “문서형 데이터베이스라 자유롭다” 하고 시작했다가도, 실제로는 타입 호환이나 정밀도에 민감해질 수 있다는 뜻이기도 합니다.

BSON의 큰 특징 하나는 스키마 없는 컬렉션처럼 보이지만 내부적으로는 각 필드가 정확한 바이너리 타입으로 기록된다는 점입니다.
예를 들어 어떤 컬렉션에 price를 100으로 넣고, 다른 문서에는 “100”이라는 문자열로 넣으면, 둘은 같은 값처럼 보여도 실제 타입은 완전히 다릅니다.
그리고 인덱싱, 정렬, 비교 연산에서 이 차이가 그대로 영향을 줍니다.
즉 MongoDB는 문서형 DB라서 유연하긴 하지만, BSON 레벨에서는 “필드마다 정확한 타입”을 기준으로 동작한다는 걸 항상 염두에 둬야 안전합니다.

두 번째로 중요한 부분은 날짜/시간입니다.
BSON에는 “Date” 타입이 따로 있고, 이 값은 유닉스 에포크(1970-01-01 00:00:00 UTC) 이후 경과한 밀리초를 64비트 정수로 저장합니다.
즉 MongoDB는 내부적으로 항상 UTC 기준의 시간을 millisecond(1/1000초) 단위까지 보존합니다.
그래서 “내가 KST(한국 시간)으로 2025-10-28 10:00이라고 넣었는데, 왜 DB에 보면 시간이 다른가요?” 같은 고민이 생기는데요.
사실 시간 자체가 바뀐 게 아니라, 그 시각이 UTC로 변환돼서 저장된 후 다시 조회할 때 드라이버가 어떤 타임존으로 해석하느냐에 따라 다르게 보일 뿐입니다.

이 구조 덕분에 MongoDB는 아주 넓은 시간 범위를 다룰 수 있고(수억 년 단위까지 표현 가능할 정도로 범위가 큼), 밀리초까지 기록되기 때문에 이벤트 로그나 타임시리즈 데이터에도 적합합니다.
하지만 동시에 이 방식은 개발자에게 ‘타임존 인식’이라는 책임을 떠넘깁니다.
파이썬에서 tz 정보가 있는 datetime(aware datetime)과 tz 정보가 없는 naive datetime을 섞어 쓰면 직렬화 과정에서 의도하지 않은 변환이 일어날 수 있기 때문입니다.
이건 뒤에서 PyMongo 관점에서 좀 더 구체적으로 다룹니다.

🗂️ BSON 문서형 저장 방식이 파이썬 직렬화에 미치는 영향

파이썬 쪽에서 MongoDB에 데이터를 넣을 때는 보통 pymongo.bson 모듈(일반적으로는 PyMongo 드라이버 내부의 bson 모듈)을 통해 파이썬 객체가 BSON으로 변환됩니다.
이 변환 과정이 바로 “직렬화(serialization)”입니다.
여기서 핵심은, 우리가 파이썬 dict로 가지고 있는 데이터가 MongoDB로 넘어가는 순간 각 필드는 BSON 스펙에 맞는 타입으로 강제된다는 점입니다.
예:

doc = {
    "price": 199.99,          # 파이썬 float → BSON double (IEEE 754 64비트)
    "created_at": datetime.utcnow(),  # 파이썬 datetime → BSON Date (UTC 밀리초)
    "tags": ["python", "bson", "mongo"],  # list → BSON array
}
collection.insert_one(doc)

위 예시처럼 파이썬에서 float를 넣으면 BSON에서는 IEEE 754 64비트 부동소수(double)로 저장됩니다.
즉 “소수점 있는 금액”을 float로 저장하면 아주 미세한 반올림 차이가 누적될 수 있습니다.
또한 datetime은 밀리초까지만 저장 가능하기 때문에 파이썬 datetime이 마이크로초 단위를 들고 있어도 1/1000초 아래 정밀도는 잘려 나갑니다.
이건 나중에 결과를 다시 불러올 때 “왜 12:00:00.123456이 아니라 12:00:00.123만 남았지?”라는 의문으로 돌아옵니다.

🧩 ObjectId와 _id 필드가 기본으로 따라오는 이유

MongoDB 문서를 넣으면 자동으로 _id 필드가 생기죠.
기본값은 ObjectId라는 BSON 타입입니다.
ObjectId는 단순한 랜덤 문자열이 아니라 12바이트짜리 구조체에 가깝습니다.
구성은 다음과 같습니다.

즉 ObjectId만 봐도 “이 문서가 언제 만들어졌는지”를 유추할 수 있습니다.
이 덕분에 정렬이나 생성 시간 기반 분석이 빠르고, 별도의 auto-increment 시퀀스를 만들 필요가 없습니다.
또한 초 단위 타임스탬프가 맨 앞바이트에 들어가 있기 때문에 ObjectId는 대체로 생성된 순서대로 정렬됩니다.
그 결과 기본 _id 인덱스만으로도 최근 문서를 빠르게 조회하거나, 시간순 페이지네이션 비슷한 작업을 효율적으로 할 수 있습니다.

정리하면, MongoDB의 BSON은 보기에는 JSON처럼 편하지만 실제로는 훨씬 타입 의존적인 이진 포맷이고, PyMongo(pymongo.bson)는 파이썬 객체를 이 BSON 스펙에 맞춰 직렬화합니다.
여기서 datetime은 UTC 밀리초 단위 정밀도로 저장되며(타임존 라벨은 따로 안 들고 감), ObjectId는 12바이트 구조 안에 생성 시각까지 품고 있다는 점이 특히 중요합니다.

📌 pymongo.bson과 ObjectId 다루기

MongoDB를 파이썬에서 다룰 때 핵심 라이브러리는 pymongo입니다.
이 pymongo 내부에는 BSON 처리용 모듈인 pymongo.bson이 들어 있으며, 우리가 insert, find, aggregate 같은 동작을 할 때마다 데이터 직렬화와 역직렬화를 담당합니다.
즉, 파이썬 객체가 MongoDB의 BSON으로 바뀌고 다시 파이썬 객체로 돌아오는 모든 과정을 이 모듈이 맡고 있는 셈이죠.

그중에서도 개발자들이 가장 자주 마주치는 타입이 바로 ObjectId입니다.
ObjectId는 단순한 문자열처럼 보이지만 사실은 고유한 객체 타입이며, ObjectId('654123abcd...') 형태로 표현됩니다.
이 객체를 문자열로 변환하거나 비교하려면 주의해야 할 몇 가지 포인트가 있습니다.

🧱 ObjectId의 기본 생성과 사용법

ObjectId는 보통 MongoDB가 자동으로 생성하지만, 직접 만들어 쓸 수도 있습니다.
PyMongo에서는 다음처럼 간단히 생성할 수 있습니다.

from bson import ObjectId

new_id = ObjectId()
print(new_id)
# 예: 671f2a9d5f8d3e7a4c3b9b10

# 문자열에서 ObjectId 복원
obj = ObjectId("671f2a9d5f8d3e7a4c3b9b10")

# ObjectId 생성 시간 확인
print(obj.generation_time)
# datetime.datetime(2025, 10, 28, 8, 23, 25, tzinfo=datetime.timezone.utc)

위 예제처럼 ObjectId에는 generation_time 속성이 있어, 해당 ID가 생성된 시각(UTC 기준)을 바로 알 수 있습니다.
이 덕분에 MongoDB에서는 별도의 timestamp 필드를 안 써도 간단한 로그 분석을 할 수 있죠.
단, 초 단위까지만 기록된다는 점을 기억해야 합니다.

만약 파이썬에서 ObjectId를 문자열로 저장해야 하는 경우가 있다면, 반드시 다음과 같이 처리해야 합니다.

str_id = str(ObjectId())     # ObjectId → 문자열
obj_id = ObjectId(str_id)    # 문자열 → ObjectId

문자열을 그대로 DB 쿼리에 넣으면 일치 검색이 안 될 수 있기 때문에, 항상 ObjectId 타입으로 변환한 뒤 사용해야 정확히 매칭됩니다.
예를 들어, Flask나 FastAPI로 REST API를 만들 때 _id를 URL 파라미터로 받아서 MongoDB에서 문서를 찾을 경우 아래처럼 변환이 필수입니다.

from bson import ObjectId

@app.get("/user/{user_id}")
def get_user(user_id: str):
    user = db.users.find_one({"_id": ObjectId(user_id)})
    return user

🔍 ObjectId와 datetime의 관계

ObjectId의 첫 4바이트에는 생성 시각(UTC 기준, 초 단위)이 들어있기 때문에, 이를 이용해 문서의 생성 시점을 추적하거나 쿼리를 최적화할 수 있습니다.
예를 들어 “최근 1시간 내 생성된 데이터”를 찾는 쿼리는 다음처럼 작성할 수 있습니다.

from datetime import datetime, timedelta
from bson import ObjectId

one_hour_ago = datetime.utcnow() - timedelta(hours=1)
oid = ObjectId.from_datetime(one_hour_ago)
recent_docs = db.logs.find({"_id": {"$gte": oid}})

이 방식은 별도의 created_at 필드를 인덱싱하지 않아도 빠르게 시간 조건 필터링을 수행할 수 있어 효율적입니다.
다만 ObjectId의 시각 정보는 초 단위까지만 포함되므로, 밀리초 단위로 정밀한 타임라인 분석을 하려면 별도의 datetime 필드를 두는 게 좋습니다.

결론적으로 pymongo.bson은 단순한 직렬화 도구가 아니라, ObjectId와 datetime의 관계를 효율적으로 연결해 주는 중요한 역할을 합니다.
특히 타임존 처리나 문자열 변환, 쿼리 매칭 시 정확한 타입 변환을 잊지 않는 것이 실무에서 오류를 줄이는 핵심입니다.

📌 타임존 인식 datetime 저장 방식

MongoDB의 날짜 데이터(DateTime)는 내부적으로 UTC 기준 밀리초 단위 정수로 저장됩니다.
즉, 타임존(Timezone)에 대한 정보는 BSON 문서 안에 포함되지 않습니다.
이게 바로 파이썬에서 datetime을 MongoDB로 보낼 때 흔히 발생하는 혼란의 원인입니다.
특히 타임존이 없는 naive datetime을 저장하면 PyMongo가 이를 자동으로 UTC로 간주해 변환하는데, 이 동작을 이해하지 못하면 실제 데이터가 ‘시간이 밀려서 저장된 것처럼’ 보이기도 하죠.

🕐 aware datetime과 naive datetime의 차이

파이썬의 datetime 객체는 크게 두 가지로 나뉩니다.
하나는 타임존 정보를 가진 aware datetime, 또 하나는 타임존이 없는 naive datetime입니다.
MongoDB는 둘 중 어느 쪽을 받아도 결국 UTC 기준의 밀리초 단위 숫자로 저장하므로, 원본 타임존 정보는 사라집니다.
즉, 한국에서 KST 기준으로 넣은 시간이더라도 MongoDB에 들어가는 순간 UTC로 환산돼 저장됩니다.
예를 들어 2025-10-28 10:00 KST를 넣으면, DB에는 2025-10-28 01:00 UTC로 기록됩니다.

from datetime import datetime, timezone, timedelta

# KST (UTC+9) 기준 시각 생성
dt_kst = datetime(2025, 10, 28, 10, 0, tzinfo=timezone(timedelta(hours=9)))

# MongoDB에 저장 시 내부적으로 UTC 변환
print(dt_kst.astimezone(timezone.utc))
# 출력: 2025-10-28 01:00:00+00:00

즉, MongoDB는 저장 시점에 타임존을 고려하지 않고 UTC로 통일합니다.
그래서 데이터를 다시 읽어올 때 타임존을 복원하려면 애플리케이션에서 수동 변환을 해야 합니다.
PyMongo는 기본적으로 UTC로 인식하지만, 클라이언트 설정을 바꾸면 자동 변환도 가능합니다.

🌐 PyMongo의 타임존 옵션 사용하기

PyMongo에서 날짜 데이터를 처리할 때 tz_aware 옵션을 True로 주면, MongoDB에서 꺼낸 datetime이 자동으로 timezone-aware 객체로 반환됩니다.
설정 방법은 다음과 같습니다.

from pymongo import MongoClient
from datetime import timezone

client = MongoClient("mongodb://localhost:27017", tz_aware=True, tzinfo=timezone.utc)
db = client.test

doc = {"timestamp": datetime.now(timezone.utc)}
db.logs.insert_one(doc)

# 불러올 때 자동으로 tz-aware datetime 반환
record = db.logs.find_one()
print(record["timestamp"], record["timestamp"].tzinfo)
# 출력: 2025-10-28 01:00:00+00:00 UTC

이처럼 tz_aware=True를 지정하면 PyMongo가 BSON Date를 timezone-aware datetime으로 되돌려 주기 때문에, 추가 변환 없이도 안전하게 타임존을 유지할 수 있습니다.
만약 한국 시간으로 바로 보고 싶다면, 조회 후 다음처럼 변환할 수 있습니다.

from datetime import timedelta

KST = timezone(timedelta(hours=9))
record["timestamp"].astimezone(KST)
# → 2025-10-28 10:00:00+09:00

📏 밀리초 정밀도와 데이터 손실 주의

MongoDB의 BSON Date는 밀리초(1/1000초)까지만 저장합니다.
즉, 파이썬 datetime이 마이크로초(1/1,000,000초) 단위를 포함하더라도 BSON으로 변환되는 과정에서 마지막 세 자리(마이크로초 부분)는 잘려 나갑니다.
예를 들어 2025-10-28 10:00:00.123456을 저장하면, DB에는 2025-10-28 10:00:00.123으로 저장됩니다.
이건 MongoDB의 설계상 한계이며, 정밀한 시계열 분석에서는 반드시 인지하고 있어야 합니다.

요약하자면, MongoDB의 datetime은 UTC 밀리초 단위 정밀도로 저장되고, 타임존 정보는 포함되지 않습니다.
PyMongo에서는 tz_aware 설정을 통해 이를 제어할 수 있으며, 한국 시간과 같은 로컬 타임존은 조회 시점에서 직접 변환해 주는 것이 가장 안전한 방법입니다.

📌 BSON의 정밀도와 부동소수 주의점

MongoDB의 BSON은 숫자 타입에 대해 IEEE 754 64비트 부동소수(double) 규격을 따릅니다.
이는 대부분의 프로그래밍 언어가 사용하는 표준이지만, ‘정확한 소수 표현’에는 한계가 있습니다.
예를 들어, 0.1 + 0.2가 0.30000000000000004로 나오는 문제는 바로 이 부동소수 정밀도 손실 때문입니다.
BSON도 같은 원리로 동작하기 때문에, 돈이나 정밀한 측정값을 저장할 때는 주의가 필요합니다.

💰 부동소수 정밀도 문제 예시

다음은 MongoDB에서 float 값을 다룰 때 발생할 수 있는 실제 정밀도 차이 예시입니다.

doc = {"price": 0.1 + 0.2}
collection.insert_one(doc)
print(doc["price"]) 
# 출력: 0.30000000000000004

이렇게 저장된 데이터는 BSON에서도 그대로 64비트 부동소수로 기록되며, 다시 불러오면 동일한 오차를 가진 값으로 복원됩니다.
금액, 측정 단위, 과학 데이터 등 정확한 소수 표현이 필요한 경우에는 float 대신 Decimal128 타입을 사용하는 것이 안전합니다.

📏 Decimal128 타입 사용법

MongoDB는 BSON 사양에 따라 Decimal128이라는 고정 소수점 타입을 지원합니다.
이 타입은 IEEE 754-2008 Decimal128 표준을 따르며, 금융 계산에서 흔히 쓰이는 34자리 정밀도를 제공합니다.
PyMongo에서는 bson.decimal128 모듈을 사용하면 간단히 적용할 수 있습니다.

from bson.decimal128 import Decimal128
from decimal import Decimal

doc = {"price": Decimal128(Decimal("0.3"))}
collection.insert_one(doc)

result = collection.find_one()
print(result["price"].to_decimal())  # 정확히 0.3 출력

이 방식은 금액 계산이나 세금, 환율처럼 정밀도가 중요한 데이터에 매우 유용합니다.
특히 Python의 decimal.Decimal 타입과 상호 변환이 가능하기 때문에, 회계 시스템이나 분석용 데이터 파이프라인에서도 일관된 결과를 얻을 수 있습니다.

🧮 BSON의 정밀도 제한 정리

• ⚙️float → BSON double로 변환 (64비트 부동소수, 소수점 오차 존재)
• 💡Decimal128 → 정확한 소수 표현 가능 (금융 데이터에 권장)
• 📏datetime → 밀리초 단위까지만 저장 (마이크로초 이하 절삭)
• 🧩ObjectId → 초 단위 생성 시각 포함 (정밀 타임라인용으로 한계 있음)

즉, BSON은 속도와 효율성을 위해 최적화된 포맷이지만, ‘무한 정밀도’를 보장하지는 않습니다.
데이터의 성격에 맞춰 float, Decimal128, ISO 문자열 중 어떤 타입을 사용할지 명확히 결정하는 것이 중요합니다.
이것이 바로 MongoDB를 장기적으로 안정적으로 사용하는 핵심 노하우 중 하나입니다.

📌 직렬화 포맷 선택 가이드와 실무 팁

파이썬에서 데이터를 저장하거나 교환할 때 사용할 수 있는 직렬화 포맷은 여러 가지가 있습니다.
그중 MongoDB의 BSON은 구조화된 문서형 데이터를 효율적으로 다루기 위한 포맷으로, JSON보다 빠르고 타입 정보가 풍부하다는 장점이 있습니다.
하지만 BSON이 만능은 아닙니다.
datetime, float, ObjectId처럼 특수한 타입을 다룰 때는 그 내부 동작을 이해하고 선택적으로 대응해야 합니다.

📦 파이썬 직렬화 포맷 비교

MongoDB는 BSON 기반이라서 파이썬 dict ↔ BSON ↔ JSON 변환이 자연스럽지만, 정밀도나 타임존 관리 같은 세세한 부분에서는 신경 써야 할 점이 많습니다.
실무에서는 JSON과 BSON을 혼용하거나, Decimal128과 ISO 날짜 문자열을 병행해 사용하는 사례가 많습니다.

🔧 실무에서 자주 쓰는 직렬화 팁

• 📆datetime은 UTC 기준으로 변환해 저장하고, 조회 시 애플리케이션에서 로컬 타임존으로 변환.
• 💵금액이나 정밀 계산은 float 대신 Decimal128 사용.
• 🧾로그성 데이터는 ObjectId의 생성 시간으로 정렬 처리 가능.
• 🧩데이터 구조는 JSON 호환성을 고려해 dict/list 중심으로 유지.
• 📡API로 데이터 교환 시 BSON → JSON 변환 시 ObjectId와 datetime을 문자열로 직렬화.

🚀 실무 예시: BSON에서 JSON 응답으로 변환

from flask import jsonify
from bson import json_util

@app.get("/data")
def get_data():
    data = list(db.logs.find().limit(5))
    return jsonify(json_util.loads(json_util.dumps(data)))

이처럼 json_util을 사용하면 ObjectId와 datetime을 문자열 형태로 안전하게 변환할 수 있습니다.
API 응답에서 별도의 변환 로직을 작성할 필요가 없으며, 프론트엔드에서도 쉽게 파싱이 가능합니다.

결국 BSON은 MongoDB의 강력한 구조적 저장 포맷이지만, 그 내부에서 datetime·ObjectId·정밀도 처리 방식은 반드시 이해하고 써야 합니다.
이 부분만 명확히 알고 있으면, 파이썬과 MongoDB를 이용한 데이터 처리 환경에서 타임존 혼선, 정밀도 손실, 타입 불일치 같은 문제를 대부분 예방할 수 있습니다.

❓ 자주 묻는 질문 (FAQ)

🧭 PyMongo BSON과 MongoDB datetime 이해로 데이터 정밀도 지키기

MongoDB의 BSON은 단순한 데이터 포맷을 넘어, 타입 정보와 구조를 정밀하게 표현하기 위한 강력한 직렬화 체계입니다.
파이썬의 pymongo.bson은 이 포맷을 통해 datetime, ObjectId, Decimal128 등 다양한 타입을 안전하게 직렬화합니다.
다만 이 과정에서 UTC 기준 저장, 밀리초 단위 정밀도, float 오차 등 기술적 제약이 존재하기 때문에, 정확한 데이터 처리를 위해서는 이러한 특성을 이해하고 써야 합니다.

요약하자면, BSON은 JSON보다 빠르고 구조적으로 강력하지만 완벽히 동일하지 않습니다.
날짜는 UTC 밀리초 단위까지만 저장되며 타임존 정보는 포함되지 않기 때문에, tz_aware 설정이나 문자열 변환으로 관리해야 합니다.
ObjectId는 문서의 생성 시점을 담고 있으므로 시간 기반 정렬이나 필터링에 유용하지만, 초 단위 정밀도라는 점도 기억해야 합니다.
마지막으로 금액 등 정밀한 계산에는 float 대신 Decimal128을 사용하는 것이 가장 좋은 선택입니다.

결국 MongoDB와 PyMongo를 제대로 다루려면 단순히 문서를 저장하는 수준을 넘어서, BSON의 동작 원리를 이해해야 합니다.
이 글에서 다룬 UTC 변환, 타임존 복원, ObjectId 시간 구조, Decimal128 사용법을 익혀두면, 데이터의 신뢰도를 유지하면서도 복잡한 직렬화 문제를 손쉽게 해결할 수 있습니다.
이것이 바로 파이썬과 MongoDB를 함께 사용할 때 가장 중요한 ‘데이터 정밀도 보존의 기술’입니다.

🏷️ 관련 태그 : 파이썬데이터직렬화, BSON, PyMongo, ObjectId, MongoDB, 타임존, datetime정밀도, Decimal128, 데이터베이스팁, 프로그래밍