पायथन में ** ऑपरेटर प्रासंगिक है या इस पर निर्भर है कि इसका उपयोग किसके साथ किया जाता है; जब इसे संख्याओं (आमतौर पर दो संख्याओं के बीच) के साथ प्रयोग किया जाता है, तो यह एक घातक ऑपरेटर के रूप में कार्य करता है। हालाँकि इस लेख में हम एक अन्य संदर्भ को देखेंगे जिसमें इसका उपयोग किया जाता है। हम इसके उपयोग को अनपैकिंग ऑपरेटर के रूप में देखेंगे, जिसका उपयोग पायथन शब्दकोशों को अनपैक करने के लिए किया जाता है।

जिस किसी ने भी पायथन में कोड किया है, उसने **क्वार्ग्स अवश्य देखा होगा। कीवर्ड तर्कों के लिए संक्षिप्त। वे कुंजी = मान सिंटैक्स में फ़ंक्शन के लिए दिए गए तर्क हैं। kwargs का उपयोग तब किया जाता है जब हमें यह नहीं पता होता है कि हमारे फ़ंक्शन में कितने कीवर्ड तर्क पारित किए जाएंगे। **kwargs एक शब्दकोश प्रकार है और किसी शब्दकोश को किसी फ़ंक्शन में पास करने जितना ही अच्छा है। इस शब्दकोश में शामिल हैं:

• तर्क नामों के अनुरूप कुंजियाँ।
• तर्क मानों के अनुरूप मान।

इस तर्क के आधार पर, इस लेख में, हम पायथॉन में इसके उपयोग के मामलों से लेकर पाइडेंटिक कक्षाओं के साथ फास्टएपीआई में इसके उपयोग के मामलों को देखेंगे।

निम्नलिखित बिंदुओं पर ध्यान दिया जाएगा।

• पायथन फ़ंक्शंस के साथ उपयोग करें।
• पायथन कक्षाओं के साथ प्रयोग करें।
• FastAPI Pydantic कक्षाओं के साथ उपयोग करें।
• उपयोग के लाभ।

नोट: क्वार्ग्स का उपयोग करना अनिवार्य नहीं है, आप किसी अन्य नामकरण परंपरा का उपयोग कर सकते हैं जैसे। **मायआर्ग्स, **कुछ भी इत्यादि।

आवश्यक शर्तें

• पायथन कक्षाओं और कार्यों का ज्ञान।
• FastAPI का कुछ बुनियादी ज्ञान।

पायथन फ़ंक्शंस के साथ प्रयोग करें

इस उदाहरण में, हमारे पास **kwargs के रूप में एक फ़ंक्शन में पास किए गए कई कीवर्ड तर्क होंगे और चूंकि **kwargs एक शब्दकोश है, हम इस पर शब्दकोश विधि .items() का उपयोग करेंगे। .items() विधि एक दृश्य ऑब्जेक्ट लौटाती है जो शब्दकोश के कुंजी-मूल्य टपल जोड़े की एक सूची प्रदर्शित करती है।

def print_details(**kwargs):
    # kwargs is a dictionary containing all keyword arguments
    print(type(kwargs))  # Output: 
    print(kwargs.items())  # Displays the dictionary items (key-value pairs)

    # Iterate over the key-value pairs in kwargs
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# Calling the function with multiple keyword arguments
print_details(name="Stephen", age=30, profession="Software Developer")

आउटपुट

dict_items([('name', 'Stephen'), ('age', 30), ('profession', 'Software Developer')])

name: Stephen
age: 30
profession: Software Developer

पायथन क्लासेस के साथ प्रयोग करें

जैसा कि हमने देखा होगा, पायथन कक्षाएं कॉल करने योग्य हैं; इसका मतलब यह है कि हम क्लास को उसी तरह कॉल कर सकते हैं जैसे हम किसी फ़ंक्शन को कॉल करते हैं। किसी क्लास को कॉल करने से उस क्लास का एक इंस्टेंस (एक ऑब्जेक्ट) बनता है।

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design
# Call class to create an instance
tech = Tech(dev, devops, design)                

तर्क मूल्यों के साथ टेक को कॉल करने से इंस्टेंस तकनीक वापस आ जाएगी।

कक्षाओं में, ** ऑपरेटर शब्दकोश को अनपैक करता है जिससे प्रत्येक कुंजी-मूल्य जोड़ी को क्लास कंस्ट्रक्टर के लिए नामित तर्क के रूप में पारित किया जा सकता है।

इस अनुभाग के उदाहरण में, हम एक वर्ग को परिभाषित करते हैं। हम वर्ग मापदंडों से मेल खाने वाले गुणों के साथ एक शब्दकोश को परिभाषित करते हैं। फिर हम शब्दकोश को अनपैक करने के लिए ** का उपयोग करके कक्षा का एक उदाहरण बनाते हैं।

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design

# Define a dictionary with properties matching the class's parameters
tech_team = {
    'dev': 'Stephen',
    'devops': ['Jenny', 'Rakeem', 'Stanley'],
    'design': 'Carlos'
}

# Create an instance of the class using ** to unpack the dictionary

tech = Tech(**tech_team)
print(tech.dev)
print(tech.devops)
print(tech.design)

उपरोक्त कोड इसके बराबर है:

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design


# Define a dictionary with properties matching the class's parameters
tech_team = {
    'dev': 'Stephen',
    'devops': ['Jenny', 'Rakeem', 'Stanley'],
    'design': 'Carlos'
}

# Create an instance of the class 
tech = Tech(
    dev = tech_team["dev"],
   devops = tech_team["devops"],
  design = tech_team["design"]
)

print(tech.dev)
print(tech.devops)
print(tech.design)

यह है क्योंकि:

tech = Tech(**Tech_team)

जैसा ही है:

tech = Tech(
    dev = tech_team["dev"],
   devops = tech_team["devops"],
  design = tech_team["design"]
)

फास्टएपीआई पाइडेंटिक क्लासेस के साथ प्रयोग करें

Pydantic एक Python लाइब्रेरी है जिसका उपयोग डेटा सत्यापन के लिए किया जाता है, इसे Python3 के टाइप हिंटिंग सिस्टम का उपयोग करके Python के लिए सबसे व्यापक रूप से उपयोग की जाने वाली डेटा सत्यापन लाइब्रेरी के रूप में भी जाना जाता है। फास्टएपीआई में नियोजित यह पायडेंटिक हमें डेटा मॉडल को परिभाषित करने में मदद करता है जो सरल शब्दों में कक्षाएं हैं।

हमारी कक्षाओं में, हम अपनी विशेषताओं या फ़ील्ड के लिए प्रकार निर्दिष्ट कर सकते हैं जैसे कि str, int, फ़्लोट, सूची। जब डेटा प्रदान किया जाता है, तो पाइडेंटिक यह सुनिश्चित करने के लिए जांच करता है कि यह मेल खाता है।

इसके अलावा पाइडेंटिक पार्सिंग और क्रमबद्धता में मदद करता है। क्रमांकन डेटा ऑब्जेक्ट को आसानी से प्रसारित होने वाले प्रारूप में प्रसारित करने की प्रक्रिया है; उदाहरण के लिए किसी ऑब्जेक्ट या सरणी को उसकी सरलता और पार्सिंग में आसानी के लिए JSON प्रारूप में।

पाइडेंटिक में एक बेसमॉडल क्लास है जो परिभाषित कक्षाओं को विरासत में मिलती है। नीचे पाइडेंटिक मॉडल का एक उदाहरण दिया गया है:

from pydantic import BaseModel, EmailStr
# We import the BaseModel and Emailstr type from Pydantic

class UserInDB(BaseModel):
    username: str
    hashed_password: str
    email: EmailStr
    full_name: Union[str, None] = None

मान लीजिए हमारे पास:

class Item(BaseModel):
   name:str
   price:float

app = FastAPI()
@app.post("/items/")
async def create_item(item:Item):
   return item

उपरोक्त कोड में, आइटम जो अनुरोध बॉडी पैरामीटर है, आइटम मॉडल का एक उदाहरण है। इसका उपयोग आने वाले JSON अनुरोध निकाय को मान्य और क्रमबद्ध करने के लिए किया जाता है ताकि यह सुनिश्चित किया जा सके कि यह वें आइटम मॉडल में परिभाषित संरचना से मेल खाता है।

पाइडेंटिक की .dict() विधि

पाइडेंटिक मॉडल में एक .dict() विधि होती है जो मॉडल के डेटा के साथ एक शब्दकोश लौटाती है।

यदि हम एक पाइडेंटिक मॉडल उदाहरण बनाते हैं:

item = Item(name="sample item", price=5.99)

फिर हम इसके साथ dict() को कॉल करते हैं:

itemDict = item.dict()
print(itemDict)

अब हमारे पास एक शब्दकोश है और हमारा आउटपुट होगा:

{
"name": "sample item",
"price":5.99
}

ध्यान दें कि:

Item(name="sample item", price=5.99)

के बराबर है

# Using the unpacking operator
Item(**itemDict)

# Or 

Item(
  name=itemDict["name"], price=itemDict["price" 
)

उपयोग के लाभ

अब हम कुछ स्थितियों पर गौर करेंगे जहां अनपैकिंग ऑपरेटर का उपयोग करना फायदेमंद है।

• प्रविष्टियों को जोड़कर या संशोधित करके पहले से मौजूद शब्दकोश से नए शब्दकोश बनाना।

original_dict = {"name": "Stephen", "age": 30, "profession": "Software Developer"}

# Creating a new dictionary with additional or modified entries
new_dict = {**original_dict, "age": 31, "location": "New York"}
print(new_dict)

• शब्दकोशों को एक में जोड़ना। अनपैकिंग ऑपरेटर के साथ हम कई शब्दकोशों को मर्ज कर सकते हैं।

default_config = {"theme": "light", "notifications": True}
user_config = {"theme": "dark"}

# Merging dictionaries using unpacking
final_config = {**default_config, **user_config}
print(final_config)

• कार्यों में तर्कों को गतिशील तरीके से संभालना। इसे हमारे शुरुआती उदाहरणों में देखा जा सकता है।

निष्कर्ष

फ़ंक्शंस और कक्षाओं में तर्कों को संभालने की अपनी गतिशील प्रकृति और नए शब्दकोशों के विलय और निर्माण के कारण डिक्शनरी अनपैकिंग ऑपरेटर ** का उपयोग करने पर विचार किया जाना चाहिए। इन सभी को एक साथ रखने से कम कोड और कोड का बेहतर रखरखाव होता है।