फ़ील्ड्स

??? एपीआई "एपीआई दस्तावेज़ीकरण" pydantic.fields.Field

Field फ़ंक्शन का उपयोग मॉडल के फ़ील्ड में मेटाडेटा को अनुकूलित करने और जोड़ने के लिए किया जाता है।

डिफॉल्ट मान¶

default पैरामीटर का उपयोग किसी फ़ील्ड के लिए डिफ़ॉल्ट मान परिभाषित करने के लिए किया जाता है।

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(default='John Doe')


user = User()
print(user)
#> name='John Doe'

आप कॉल करने योग्य को परिभाषित करने के लिए default_factory भी उपयोग कर सकते हैं जिसे डिफ़ॉल्ट मान उत्पन्न करने के लिए कॉल किया जाएगा।

from uuid import uuid4

from pydantic import BaseModel, Field


class User(BaseModel):
    id: str = Field(default_factory=lambda: uuid4().hex)

!!! जानकारी default और default_factory पैरामीटर परस्पर अनन्य हैं।

!!! ध्यान दें यदि आप typing.Optional उपयोग करते हैं, तो इसका मतलब यह नहीं है कि फ़ील्ड का डिफ़ॉल्ट मान None है!

`Annotated` उपयोग करना¶

Field फ़ंक्शन का उपयोग Annotated के साथ भी किया जा सकता है।

from uuid import uuid4

from typing_extensions import Annotated

from pydantic import BaseModel, Field


class User(BaseModel):
    id: Annotated[str, Field(default_factory=lambda: uuid4().hex)]

!!! नोट डिफॉल्ट्स को Annotated बाहर निर्दिष्ट मान के रूप में या Annotated के अंदर Field.default_factory के साथ सेट किया जा सकता है। Annotated के अंदर Field.default तर्क समर्थित नहीं है।

फ़ील्ड उपनाम¶

सत्यापन और क्रमांकन के लिए, आप किसी फ़ील्ड के लिए उपनाम परिभाषित कर सकते हैं।

उपनाम को परिभाषित करने के तीन तरीके हैं:

Field(..., alias='foo')
Field(..., validation_alias='foo')
Field(..., serialization_alias='foo')

alias पैरामीटर का उपयोग सत्यापन और क्रमबद्धता दोनों के लिए किया जाता है। यदि आप क्रमशः सत्यापन और क्रमांकन के लिए अलग-अलग उपनामों का उपयोग करना चाहते हैं, तो आप validation_alias और serialization_alias पैरामीटर का उपयोग कर सकते हैं, जो केवल उनके संबंधित उपयोग के मामलों में लागू होंगे।

यहां alias पैरामीटर का उपयोग करने का एक उदाहरण दिया गया है:

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(..., alias='username')


user = User(username='johndoe')  # (1)!
print(user)
#> name='johndoe'
print(user.model_dump(by_alias=True))  # (2)!
#> {'username': 'johndoe'}

उपनाम 'username' उपयोग उदाहरण निर्माण और सत्यापन के लिए किया जाता है।
हम मॉडल को क्रमबद्ध प्रारूप में बदलने के लिए model_dump उपयोग कर रहे हैं।

आप एपीआई संदर्भ में model_dump के बारे में अधिक विवरण देख सकते हैं।

ध्यान दें कि by_alias कीवर्ड तर्क डिफ़ॉल्ट रूप से False है, और फ़ील्ड (क्रमबद्धता) उपनामों का उपयोग करके मॉडल को डंप करने के लिए स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए।

जब by_alias=True , उपनाम 'username' उपयोग क्रमबद्धता के दौरान भी किया जाता है।

यदि आप केवल सत्यापन के लिए उपनाम का उपयोग करना चाहते हैं, तो आप validation_alias पैरामीटर का उपयोग कर सकते हैं:

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(..., validation_alias='username')


user = User(username='johndoe')  # (1)!
print(user)
#> name='johndoe'
print(user.model_dump(by_alias=True))  # (2)!
#> {'name': 'johndoe'}

सत्यापन के दौरान सत्यापन उपनाम 'username' उपयोग किया जाता है।
क्रमांकन के दौरान फ़ील्ड नाम 'name' उपयोग किया जाता है।

यदि आप केवल क्रमांकन के लिए उपनाम परिभाषित करना चाहते हैं, तो आप serialization_alias पैरामीटर का उपयोग कर सकते हैं:

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(..., serialization_alias='username')


user = User(name='johndoe')  # (1)!
print(user)
#> name='johndoe'
print(user.model_dump(by_alias=True))  # (2)!
#> {'username': 'johndoe'}

सत्यापन के लिए फ़ील्ड नाम 'name' उपयोग किया जाता है।
क्रमबद्धता उपनाम 'username' उपयोग क्रमबद्धता के लिए किया जाता है।

!!! ध्यान दें "उपनाम पूर्वता और प्राथमिकता" यदि आप एक ही समय में validation_alias या serialization_alias साथ alias उपयोग करते हैं, तो सत्यापन के लिए validation_alias alias पर प्राथमिकता दी जाएगी, और क्रमबद्धता के लिए serialization_alias alias पर प्राथमिकता दी जाएगी।

If you use an `alias_generator` in the [Model Config][pydantic.config.ConfigDict.alias_generator], you can control
the order of precedence for specified field vs generated aliases via the `alias_priority` setting. You can read more about alias precedence [here](../concepts/alias.md#alias-precedence).

??? टिप "VSCode और Pyright उपयोगकर्ता" VSCode में, यदि आप पाइलेंस एक्सटेंशन का उपयोग करते हैं, तो फ़ील्ड के उपनाम का उपयोग करके किसी मॉडल को इंस्टेंट करते समय आपको कोई चेतावनी नहीं दिखाई देगी:

```py
from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(..., alias='username')


user = User(username='johndoe')  # (1)!
```

1. VSCode will NOT show a warning here.

When the `'alias'` keyword argument is specified, even if you set `populate_by_name` to `True` in the
[Model Config][pydantic.config.ConfigDict.populate_by_name], VSCode will show a warning when instantiating
a model using the field name (though it will work at runtime) — in this case, `'name'`:

```py
from pydantic import BaseModel, ConfigDict, Field


class User(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    name: str = Field(..., alias='username')


user = User(name='johndoe')  # (1)!
```

1. VSCode will show a warning here.

To "trick" VSCode into preferring the field name, you can use the `str` function to wrap the alias value.
With this approach, though, a warning is shown when instantiating a model using the alias for the field:

```py
from pydantic import BaseModel, ConfigDict, Field


class User(BaseModel):
    model_config = ConfigDict(populate_by_name=True)

    name: str = Field(..., alias=str('username'))  # noqa: UP018


user = User(name='johndoe')  # (1)!
user = User(username='johndoe')  # (2)!
```

1. Now VSCode will NOT show a warning
2. VSCode will show a warning here, though

This is discussed in more detail in [this issue](https://github.com/pydantic/pydantic/issues/5893).

### Validation Alias

Even though Pydantic treats `alias` and `validation_alias` the same when creating model instances, VSCode will not
use the `validation_alias` in the class initializer signature. If you want VSCode to use the `validation_alias`
in the class initializer, you can instead specify both an `alias` and `serialization_alias`, as the
`serialization_alias` will override the `alias` during serialization:

```py
from pydantic import BaseModel, Field


class MyModel(BaseModel):
    my_field: int = Field(..., validation_alias='myValidationAlias')
```
with:
```py
from pydantic import BaseModel, Field


class MyModel(BaseModel):
    my_field: int = Field(
        ...,
        alias='myValidationAlias',
        serialization_alias='my_serialization_alias',
    )


m = MyModel(myValidationAlias=1)
print(m.model_dump(by_alias=True))
#> {'my_serialization_alias': 1}
```

All of the above will likely also apply to other tools that respect the
[`@typing.dataclass_transform`](https://docs.python.org/3/library/typing.html#typing.dataclass_transform)
decorator, such as Pyright.

उपनाम के उपयोग के बारे में अधिक जानकारी के लिए, उपनाम अवधारणा पृष्ठ देखें।

संख्यात्मक बाधाएँ¶

कुछ कीवर्ड तर्क हैं जिनका उपयोग संख्यात्मक मानों को बाधित करने के लिए किया जा सकता है:

gt - इससे भी बड़ा
lt - से कम
ge - इससे बड़ा या इसके बराबर
le - से कम या बराबर
multiple_of - दी गई संख्या का गुणज
allow_inf_nan - 'inf' , '-inf' , 'nan' मानों को अनुमति दें

यहाँ एक उदाहरण है:

from pydantic import BaseModel, Field


class Foo(BaseModel):
    positive: int = Field(gt=0)
    non_negative: int = Field(ge=0)
    negative: int = Field(lt=0)
    non_positive: int = Field(le=0)
    even: int = Field(multiple_of=2)
    love_for_pydantic: float = Field(allow_inf_nan=True)


foo = Foo(
    positive=1,
    non_negative=0,
    negative=-1,
    non_positive=0,
    even=2,
    love_for_pydantic=float('inf'),
)
print(foo)
"""
positive=1 non_negative=0 negative=-1 non_positive=0 even=2 love_for_pydantic=inf
"""

??? जानकारी "JSON स्कीमा" उत्पन्न JSON स्कीमा में:

- `gt` and `lt` constraints will be translated to `exclusiveMinimum` and `exclusiveMaximum`.
- `ge` and `le` constraints will be translated to `minimum` and `maximum`.
- `multiple_of` constraint will be translated to `multipleOf`.

The above snippet will generate the following JSON Schema:

```json
{
  "title": "Foo",
  "type": "object",
  "properties": {
    "positive": {
      "title": "Positive",
      "type": "integer",
      "exclusiveMinimum": 0
    },
    "non_negative": {
      "title": "Non Negative",
      "type": "integer",
      "minimum": 0
    },
    "negative": {
      "title": "Negative",
      "type": "integer",
      "exclusiveMaximum": 0
    },
    "non_positive": {
      "title": "Non Positive",
      "type": "integer",
      "maximum": 0
    },
    "even": {
      "title": "Even",
      "type": "integer",
      "multipleOf": 2
    },
    "love_for_pydantic": {
      "title": "Love For Pydantic",
      "type": "number"
    }
  },
  "required": [
    "positive",
    "non_negative",
    "negative",
    "non_positive",
    "even",
    "love_for_pydantic"
  ]
}
```

See the [JSON Schema Draft 2020-12] for more details.

!!! चेतावनी "यौगिक प्रकारों पर बाधाएँ" यदि आप मिश्रित प्रकारों के साथ फ़ील्ड बाधाओं का उपयोग करते हैं, तो कुछ मामलों में त्रुटि हो सकती है। संभावित समस्याओं से बचने के लिए, आप Annotated उपयोग कर सकते हैं:

```py
from typing import Optional

from typing_extensions import Annotated

from pydantic import BaseModel, Field


class Foo(BaseModel):
    positive: Optional[Annotated[int, Field(gt=0)]]
    # Can error in some cases, not recommended:
    non_negative: Optional[int] = Field(ge=0)
```

स्ट्रिंग बाधाएँ¶

??? एपीआई "एपीआई दस्तावेज़ीकरण" pydantic.types.StringConstraints

ऐसे फ़ील्ड हैं जिनका उपयोग स्ट्रिंग्स को बाधित करने के लिए किया जा सकता है:

min_length : स्ट्रिंग की न्यूनतम लंबाई.
max_length : स्ट्रिंग की अधिकतम लंबाई.
pattern : एक नियमित अभिव्यक्ति जिसका स्ट्रिंग से मिलान होना चाहिए।

यहाँ एक उदाहरण है:

from pydantic import BaseModel, Field


class Foo(BaseModel):
    short: str = Field(min_length=3)
    long: str = Field(max_length=10)
    regex: str = Field(pattern=r'^\d*$')  # (1)!


foo = Foo(short='foo', long='foobarbaz', regex='123')
print(foo)
#> short='foo' long='foobarbaz' regex='123'
```

1. Only digits are allowed.

??? info "JSON Schema"
    In the generated JSON schema:

    - `min_length` constraint will be translated to `minLength`.
    - `max_length` constraint will be translated to `maxLength`.
    - `pattern` constraint will be translated to `pattern`.

    The above snippet will generate the following JSON Schema:

    ```json
    {
      "title": "Foo",
      "type": "object",
      "properties": {
        "short": {
          "title": "Short",
          "type": "string",
          "minLength": 3
        },
        "long": {
          "title": "Long",
          "type": "string",
          "maxLength": 10
        },
        "regex": {
          "title": "Regex",
          "type": "string",
          "pattern": "^\\d*$"
        }
      },
      "required": [
        "short",
        "long",
        "regex"
      ]
    }
    ```

## Decimal Constraints

There are fields that can be used to constrain decimals:

* `max_digits`: Maximum number of digits within the `Decimal`. It does not include a zero before the decimal point or
  trailing decimal zeroes.
* `decimal_places`: Maximum number of decimal places allowed. It does not include trailing decimal zeroes.

Here's an example:

```py
from decimal import Decimal

from pydantic import BaseModel, Field


class Foo(BaseModel):
    precise: Decimal = Field(max_digits=5, decimal_places=2)


foo = Foo(precise=Decimal('123.45'))
print(foo)
#> precise=Decimal('123.45')

डेटाक्लास बाधाएँ¶

ऐसे फ़ील्ड हैं जिनका उपयोग डेटाक्लास को बाधित करने के लिए किया जा सकता है:

init : क्या फ़ील्ड को डेटाक्लास के __init__ में शामिल किया जाना चाहिए।
init_var : क्या फ़ील्ड को डेटाक्लास में केवल init फ़ील्ड के रूप में देखा जाना चाहिए।
kw_only : डेटाक्लास के कंस्ट्रक्टर में फ़ील्ड केवल कीवर्ड तर्क होना चाहिए या नहीं।

यहाँ एक उदाहरण है:

from pydantic import BaseModel, Field
from pydantic.dataclasses import dataclass


@dataclass
class Foo:
    bar: str
    baz: str = Field(init_var=True)
    qux: str = Field(kw_only=True)


class Model(BaseModel):
    foo: Foo


model = Model(foo=Foo('bar', baz='baz', qux='qux'))
print(model.model_dump())  # (1)!
#> {'foo': {'bar': 'bar', 'qux': 'qux'}}

baz फ़ील्ड model_dump() आउटपुट में शामिल नहीं है, क्योंकि यह केवल init फ़ील्ड है।

डिफ़ॉल्ट मान मान्य करें¶

पैरामीटर validate_default उपयोग यह नियंत्रित करने के लिए किया जा सकता है कि फ़ील्ड का डिफ़ॉल्ट मान मान्य किया जाना चाहिए या नहीं।

डिफ़ॉल्ट रूप से, फ़ील्ड का डिफ़ॉल्ट मान मान्य नहीं है।

from pydantic import BaseModel, Field, ValidationError


class User(BaseModel):
    age: int = Field(default='twelve', validate_default=True)


try:
    user = User()
except ValidationError as e:
    print(e)
    """
    1 validation error for User
    age
      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='twelve', input_type=str]
    """

क्षेत्र प्रतिनिधित्व¶

पैरामीटर repr उपयोग यह नियंत्रित करने के लिए किया जा सकता है कि फ़ील्ड को मॉडल के स्ट्रिंग प्रतिनिधित्व में शामिल किया जाना चाहिए या नहीं।

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(repr=True)  # (1)!
    age: int = Field(repr=False)


user = User(name='John', age=42)
print(user)
#> name='John'

यह व्यतिक्रम मूल्य है।

Discriminator¶

पैरामीटर discriminator उपयोग उस क्षेत्र को नियंत्रित करने के लिए किया जा सकता है जिसका उपयोग एक संघ में विभिन्न मॉडलों के बीच भेदभाव करने के लिए किया जाएगा। यह या तो किसी फ़ील्ड का नाम या Discriminator इंस्टेंस लेता है। Discriminator दृष्टिकोण तब उपयोगी हो सकता है जब विवेचक क्षेत्र Union के सभी मॉडलों के लिए समान न हों।

निम्नलिखित उदाहरण दिखाता है कि फ़ील्ड नाम के साथ discriminator उपयोग कैसे करें:

from typing import Literal, Union

from pydantic import BaseModel, Field


class Cat(BaseModel):
    pet_type: Literal['cat']
    age: int


class Dog(BaseModel):
    pet_type: Literal['dog']
    age: int


class Model(BaseModel):
    pet: Union[Cat, Dog] = Field(discriminator='pet_type')


print(Model.model_validate({'pet': {'pet_type': 'cat', 'age': 12}}))  # (1)!
#> pet=Cat(pet_type='cat', age=12)

मॉडल पेज में हेल्पर फ़ंक्शंस के बारे में और देखें।

निम्नलिखित उदाहरण दिखाता है कि Discriminator उदाहरण के साथ discriminator कीवर्ड तर्क का उपयोग कैसे करें:

from typing import Literal, Union

from typing_extensions import Annotated

from pydantic import BaseModel, Discriminator, Field, Tag


class Cat(BaseModel):
    pet_type: Literal['cat']
    age: int


class Dog(BaseModel):
    pet_kind: Literal['dog']
    age: int


def pet_discriminator(v):
    if isinstance(v, dict):
        return v.get('pet_type', v.get('pet_kind'))
    return getattr(v, 'pet_type', getattr(v, 'pet_kind', None))


class Model(BaseModel):
    pet: Union[Annotated[Cat, Tag('cat')], Annotated[Dog, Tag('dog')]] = Field(
        discriminator=Discriminator(pet_discriminator)
    )


print(repr(Model.model_validate({'pet': {'pet_type': 'cat', 'age': 12}})))
#> Model(pet=Cat(pet_type='cat', age=12))

print(repr(Model.model_validate({'pet': {'pet_kind': 'dog', 'age': 12}})))
#> Model(pet=Dog(pet_kind='dog', age=12))

आप अपनी भेदभावपूर्ण यूनियनों को परिभाषित करने के लिए Annotated का भी लाभ उठा सकते हैं। अधिक विवरण के लिए डिस्क्रिमिनेटेड यूनियन दस्तावेज़ देखें।

सख्त मोड¶

Field पर strict पैरामीटर निर्दिष्ट करता है कि फ़ील्ड को "सख्त मोड" में मान्य किया जाना चाहिए या नहीं। स्ट्रिक्ट मोड में, पाइडेंटिक उस फ़ील्ड पर डेटा को ज़बरदस्ती करने के बजाय सत्यापन के दौरान एक त्रुटि फेंकता है जहां strict=True ।

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str = Field(strict=True)  # (1)!
    age: int = Field(strict=False)


user = User(name='John', age='42')  # (2)!
print(user)
#> name='John' age=42

यह व्यतिक्रम मूल्य है।
age फ़ील्ड को सख्त मोड में मान्य नहीं किया गया है। इसलिए, इसे एक स्ट्रिंग असाइन किया जा सकता है।

अधिक जानकारी के लिए स्ट्रिक्ट मोड देखें।

पाइडेंटिक सख्त और ढीले दोनों मोड में डेटा को कैसे परिवर्तित करता है, इसके बारे में अधिक जानकारी के लिए रूपांतरण तालिका देखें।

अचल स्थिति¶

frozen पैरामीटर का उपयोग जमे हुए डेटाक्लास व्यवहार का अनुकरण करने के लिए किया जाता है। इसका उपयोग मॉडल बनने (अपरिवर्तनीयता) के बाद फ़ील्ड को एक नया मान निर्दिष्ट करने से रोकने के लिए किया जाता है।

अधिक विवरण के लिए जमे हुए डेटाक्लास दस्तावेज़ देखें।

from pydantic import BaseModel, Field, ValidationError


class User(BaseModel):
    name: str = Field(frozen=True)
    age: int


user = User(name='John', age=42)

try:
    user.name = 'Jane'  # (1)!
except ValidationError as e:
    print(e)
    """
    1 validation error for User
    name
      Field is frozen [type=frozen_field, input_value='Jane', input_type=str]
    """

चूँकि name फ़ील्ड फ़्रीज़ हो गई है, इसलिए असाइनमेंट की अनुमति नहीं है।

बहिष्कृत करें¶

exclude पैरामीटर का उपयोग यह नियंत्रित करने के लिए किया जा सकता है कि मॉडल को निर्यात करते समय किन फ़ील्ड को मॉडल से बाहर रखा जाना चाहिए।

निम्नलिखित उदाहरण देखें:

from pydantic import BaseModel, Field


class User(BaseModel):
    name: str
    age: int = Field(exclude=True)


user = User(name='John', age=42)
print(user.model_dump())  # (1)!
#> {'name': 'John'}

age फ़ील्ड को model_dump() आउटपुट में शामिल नहीं किया गया है, क्योंकि इसे बाहर रखा गया है।

अधिक विवरण के लिए क्रमांकन अनुभाग देखें।

बहिष्कृत फ़ील्ड¶

deprecated पैरामीटर का उपयोग किसी फ़ील्ड को बहिष्कृत के रूप में चिह्नित करने के लिए किया जा सकता है। ऐसा करने का परिणाम यह होगा:

फ़ील्ड तक पहुँचने पर रनटाइम बहिष्करण चेतावनी उत्सर्जित होती है।
"deprecated": true सेट किया जा रहा है।

आप deprecated पैरामीटर को इनमें से किसी एक के रूप में सेट कर सकते हैं:

एक स्ट्रिंग, जिसका उपयोग बहिष्करण संदेश के रूप में किया जाएगा।
warnings.deprecated का एक उदाहरण। पदावनत डेकोरेटर (या typing_extensions बैकपोर्ट)।
एक बूलियन, जिसका उपयोग डिफ़ॉल्ट 'deprecated' पदावनत संदेश के साथ फ़ील्ड को बहिष्कृत के रूप में चिह्नित करने के लिए किया जाएगा।

एक स्ट्रिंग के रूप में `deprecated`¶

from typing_extensions import Annotated

from pydantic import BaseModel, Field


class Model(BaseModel):
    deprecated_field: Annotated[int, Field(deprecated='This is deprecated')]


print(Model.model_json_schema()['properties']['deprecated_field'])
#> {'deprecated': True, 'title': 'Deprecated Field', 'type': 'integer'}

`warnings.deprecated` के माध्यम से `deprecated` डेकोरेटर¶

!!! नोट आप इस तरह से deprecated डेकोरेटर का उपयोग केवल तभी कर सकते हैं जब आपके पास typing_extensions >= 4.9.0 स्थापित हो।

import importlib.metadata

from packaging.version import Version
from typing_extensions import Annotated, deprecated

from pydantic import BaseModel, Field

if Version(importlib.metadata.version('typing_extensions')) >= Version('4.9'):

    class Model(BaseModel):
        deprecated_field: Annotated[int, deprecated('This is deprecated')]

        # Or explicitly using `Field`:
        alt_form: Annotated[
            int, Field(deprecated=deprecated('This is deprecated'))
        ]

बूलियन के रूप में `deprecated`¶

from typing_extensions import Annotated

from pydantic import BaseModel, Field


class Model(BaseModel):
    deprecated_field: Annotated[int, Field(deprecated=True)]


print(Model.model_json_schema()['properties']['deprecated_field'])
#> {'deprecated': True, 'title': 'Deprecated Field', 'type': 'integer'}

!!! नोट " category और stacklevel के लिए समर्थन" इस सुविधा का वर्तमान कार्यान्वयन deprecated डेकोरेटर के लिए category और stacklevel तर्कों को ध्यान में नहीं रखता है। यह पाइडेंटिक के भविष्य के संस्करण में आ सकता है।

!!! चेतावनी "सत्यापनकर्ताओं में एक बहिष्कृत फ़ील्ड तक पहुँचना" एक सत्यापनकर्ता के अंदर एक बहिष्कृत फ़ील्ड तक पहुँचने पर, बहिष्करण चेतावनी उत्सर्जित होगी। आप इसे स्पष्ट रूप से अनदेखा करने के लिए catch_warnings का उपयोग कर सकते हैं:

```py
import warnings

from typing_extensions import Self

from pydantic import BaseModel, Field, model_validator


class Model(BaseModel):
    deprecated_field: int = Field(deprecated='This is deprecated')

    @model_validator(mode='after')
    def validate_model(self) -> Self:
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', DeprecationWarning)
            self.deprecated_field = self.deprecated_field * 2
```

JSON स्कीमा को अनुकूलित करना¶

कुछ फ़ील्ड पैरामीटर विशेष रूप से जेनरेट किए गए JSON स्कीमा को अनुकूलित करने के लिए उपयोग किए जाते हैं। विचाराधीन पैरामीटर हैं:

title
description
examples
json_schema_extra

JSON स्कीमा डॉक्स के कस्टमाइज़िंग JSON स्कीमा अनुभाग में फ़ील्ड के साथ JSON स्कीमा अनुकूलन/संशोधन के बारे में और पढ़ें।

`computed_field` डेकोरेटर¶

??? एपीआई "एपीआई दस्तावेज़ीकरण" pydantic.fields.computed_field

किसी मॉडल या डेटाक्लास को क्रमबद्ध करते समय computed_field डेकोरेटर का उपयोग property या cached_property विशेषताओं को शामिल करने के लिए किया जा सकता है। यह उन फ़ील्ड के लिए उपयोगी हो सकता है जिनकी गणना अन्य फ़ील्ड से की जाती है, या उन फ़ील्ड के लिए जिनकी गणना करना महंगा है (और इस प्रकार, कैश्ड हैं)।

यहाँ एक उदाहरण है:

from pydantic import BaseModel, computed_field


class Box(BaseModel):
    width: float
    height: float
    depth: float

    @computed_field
    def volume(self) -> float:
        return self.width * self.height * self.depth


b = Box(width=1, height=2, depth=3)
print(b.model_dump())
#> {'width': 1.0, 'height': 2.0, 'depth': 3.0, 'volume': 6.0}

नियमित फ़ील्ड की तरह, परिकलित फ़ील्ड को बहिष्कृत के रूप में चिह्नित किया जा सकता है:

from typing_extensions import deprecated

from pydantic import BaseModel, computed_field


class Box(BaseModel):
    width: float
    height: float
    depth: float

    @computed_field
    @deprecated("'volume' is deprecated")
    def volume(self) -> float:
        return self.width * self.height * self.depth

本文总阅读量次

फ़ील्ड्स

डिफॉल्ट मान¶

Annotated उपयोग करना¶

फ़ील्ड उपनाम¶

संख्यात्मक बाधाएँ¶

स्ट्रिंग बाधाएँ¶

डेटाक्लास बाधाएँ¶

डिफ़ॉल्ट मान मान्य करें¶

क्षेत्र प्रतिनिधित्व¶

Discriminator¶

सख्त मोड¶

अचल स्थिति¶

बहिष्कृत करें¶

बहिष्कृत फ़ील्ड¶

एक स्ट्रिंग के रूप में deprecated¶

warnings.deprecated के माध्यम से deprecated डेकोरेटर¶

बूलियन के रूप में deprecated¶

JSON स्कीमा को अनुकूलित करना¶

computed_field डेकोरेटर¶

`Annotated` उपयोग करना¶

एक स्ट्रिंग के रूप में `deprecated`¶

`warnings.deprecated` के माध्यम से `deprecated` डेकोरेटर¶

बूलियन के रूप में `deprecated`¶

`computed_field` डेकोरेटर¶