प्रदर्शन युक्तियाँ¶
अधिकांश मामलों में पाइडेंटिक आपकी समस्या नहीं बनेगी, केवल तभी इसका पालन करें यदि आप सुनिश्चित हैं कि यह आवश्यक है।
सामान्य तौर पर, model_validate_json() उपयोग न करें model_validate(json.loads(...))¶
पर model_validate(json.loads(...)) , JSON को पायथन में पार्स किया जाता है, फिर एक निर्देश में परिवर्तित किया जाता है, फिर इसे आंतरिक रूप से मान्य किया जाता है। दूसरी ओर, model_validate_json() पहले से ही आंतरिक रूप से सत्यापन करता है।
ऐसे कुछ मामले हैं जहां model_validate(json.loads(...)) तेज़ हो सकता है. विशेष रूप से, किसी मॉडल पर 'before' या 'wrap' सत्यापनकर्ता का उपयोग करते समय, दो चरण विधि के साथ सत्यापन तेज हो सकता है। आप इस चर्चा में इन विशेष मामलों के बारे में अधिक पढ़ सकते हैं।
pydantic-core के लिए वर्तमान में कई प्रदर्शन सुधारों पर काम चल रहा है, जैसा कि यहां चर्चा की गई है। एक बार जब ये परिवर्तन विलय हो जाते हैं, तो हमें उस बिंदु पर होना चाहिए जहां model_validate_json() हमेशा से तेज़ होता है model_validate(json.loads(...)) .
TypeAdapter एक बार इंस्टेंट किया गया¶
यहां विचार यह है कि आवश्यकता से अधिक सत्यापनकर्ता और क्रमांकन का निर्माण करने से बचें। हर बार जब TypeAdapter इंस्टेंट किया जाता है, तो यह एक नया सत्यापनकर्ता और क्रमांकन तैयार करेगा। यदि आप किसी फ़ंक्शन में TypeAdapter उपयोग कर रहे हैं, तो हर बार फ़ंक्शन को कॉल करने पर इसे तुरंत चालू किया जाएगा। इसके बजाय, इसे एक बार इंस्टेंटियेट करें, और इसका पुन: उपयोग करें।
\=== "
ख़राब"
```py
from typing import List
from pydantic import TypeAdapter
def my_func():
adapter = TypeAdapter(List[int])
# do something with adapter
```
\=== "
अच्छा"
```py
from typing import List
from pydantic import TypeAdapter
adapter = TypeAdapter(List[int])
def my_func():
...
# do something with adapter
```
Sequence बनाम list या tuple - Mapping बनाम dict¶
Sequence उपयोग करते समय, Pydantic यह जांचने के लिए isinstance(value, Sequence) को कॉल करता है कि मान एक अनुक्रम है या नहीं। साथ ही, पाइडेंटिक विभिन्न प्रकार के अनुक्रमों, जैसे list और tuple विरुद्ध सत्यापन करने का प्रयास करेगा। यदि आप जानते हैं कि मान एक list या tuple है, तो Sequence के बजाय list या tuple उपयोग करें।
यही बात Mapping और dict पर भी लागू होती है। यदि आप जानते हैं कि मान एक dict है, तो Mapping के बजाय dict उपयोग करें।
जब आपको सत्यापन करने की आवश्यकता न हो तो सत्यापन न करें - मान को अपरिवर्तित रखने के लिए Any उपयोग करें¶
यदि आपको किसी मान को सत्यापित करने की आवश्यकता नहीं है, तो मान को अपरिवर्तित रखने के लिए Any उपयोग करें।
from typing import Any
from pydantic import BaseModel
class Model(BaseModel):
a: Any
model = Model(a=1)
आदिमों के उपवर्गों के माध्यम से अतिरिक्त जानकारी से बचें¶
\=== "ऐसा मत करो"
```py
class CompletedStr(str):
def __init__(self, s: str):
self.s = s
self.done = False
```
\=== "ऐसा करो"
```py
from pydantic import BaseModel
class CompletedModel(BaseModel):
s: str
done: bool = False
```
टैग यूनियन का प्रयोग करें, यूनियन का नहीं¶
टैग यूनियन (या भेदभावपूर्ण यूनियन) एक फ़ील्ड वाला यूनियन है जो इंगित करता है कि यह किस प्रकार का है।
from typing import Any
from typing_extensions import Literal
from pydantic import BaseModel, Field
class DivModel(BaseModel):
el_type: Literal['div'] = 'div'
class_name: str | None = None
children: list[Any] | None = None
class SpanModel(BaseModel):
el_type: Literal['span'] = 'span'
class_name: str | None = None
contents: str | None = None
class ButtonModel(BaseModel):
el_type: Literal['button'] = 'button'
class_name: str | None = None
contents: str | None = None
class InputModel(BaseModel):
el_type: Literal['input'] = 'input'
class_name: str | None = None
value: str | None = None
class Html(BaseModel):
contents: DivModel | SpanModel | ButtonModel | InputModel = Field(
discriminator='el_type'
)
अधिक जानकारी के लिए भेदभावपूर्ण यूनियनें देखें।
नेस्टेड मॉडलों पर TypedDict उपयोग करें¶
नेस्टेड मॉडल का उपयोग करने के बजाय, डेटा की संरचना को परिभाषित करने के लिए TypedDict उपयोग करें।
??? जानकारी "प्रदर्शन तुलना" एक साधारण बेंचमार्क के साथ, TypedDict नेस्टेड मॉडल की तुलना में लगभग ~2.5 गुना तेज है:
```py
from timeit import timeit
from typing_extensions import TypedDict
from pydantic import BaseModel, TypeAdapter
class A(TypedDict):
a: str
b: int
class TypedModel(TypedDict):
a: A
class B(BaseModel):
a: str
b: int
class Model(BaseModel):
b: B
ta = TypeAdapter(TypedModel)
result1 = timeit(
lambda: ta.validate_python({'a': {'a': 'a', 'b': 2}}), number=10000
)
result2 = timeit(
lambda: Model.model_validate({'b': {'a': 'a', 'b': 2}}), number=10000
)
print(result2 / result1)
```
यदि आप वास्तव में प्रदर्शन की परवाह करते हैं तो रैप सत्यापनकर्ताओं से बचें¶
रैप सत्यापनकर्ता आम तौर पर अन्य सत्यापनकर्ताओं की तुलना में धीमे होते हैं। ऐसा इसलिए है क्योंकि उन्हें सत्यापन के दौरान डेटा को पायथन में भौतिक रूप से तैयार करने की आवश्यकता होती है। जटिल सत्यापन तर्क के लिए रैप सत्यापनकर्ता अविश्वसनीय रूप से उपयोगी हो सकते हैं, लेकिन यदि आप सर्वोत्तम प्रदर्शन की तलाश में हैं, तो आपको उनसे बचना चाहिए।
FailFast के साथ जल्दी असफल होना¶
v2.8+ से प्रारंभ करके, यदि अनुक्रम में कोई भी आइटम सत्यापन विफल हो जाता है, तो आप अनुक्रम प्रकारों को जल्दी विफल करने के लिए FailFast एनोटेशन लागू कर सकते हैं। यदि आप इस एनोटेशन का उपयोग करते हैं, तो आपको अनुक्रम में शेष आइटमों के लिए सत्यापन त्रुटियां नहीं मिलेंगी यदि कोई विफल रहता है, तो आप प्रभावी रूप से प्रदर्शन के लिए दृश्यता का व्यापार कर रहे हैं।
from typing import List
from typing_extensions import Annotated
from pydantic import FailFast, TypeAdapter, ValidationError
ta = TypeAdapter(Annotated[List[bool], FailFast()])
try:
ta.validate_python([True, 'invalid', False, 'also invalid'])
except ValidationError as exc:
print(exc)
"""
1 validation error for list[bool]
1
Input should be a valid boolean, unable to interpret input [type=bool_parsing, input_value='invalid', input_type=str]
"""
FailFast के बारे में और पढ़ें [यहां][pydantic.types.FairFast]।
本文总阅读量次