मुख्य सामग्री पर जाएँ

Python में Asterisks का उपयोग

कई Python उपयोगकर्ता गुणा और घात ऑपरेटरों के लिए asterisks का उपयोग करते हैं, पर इस ट्यूटोरियल में आप जानेंगे कि asterisk को और किन तरीकों से लागू किया जा सकता है।
· 9 मि॰ पढ़ें

AI के साथ खोजें

हममें से अधिकांश लोग asterisks का उपयोग गुणा और घात ऑपरेटरों के रूप में करते हैं, लेकिन Python में इन्हें प्रिफ़िक्स ऑपरेटर की तरह भी कई प्रकार की क्रियाओं में इस्तेमाल किया जाता है। इस लेख को पढ़ने के बाद, आप asterisks के पूरे उपयोग को जान जाएंगे।

Python में asterisks के कई खास उपयोग के मामले हैं। आम तौर पर हम गुणा और घात ऑपरेटरों से परिचित हैं। अलग-अलग परिस्थितियों में यह अनपैकिंग, आर्ग्युमेंट पासिंग आदि जैसी कुछ और क्रियाएँ भी कर सकते हैं। पहले, asterisks के सामान्य उपयोग को देखते हैं।

* और ** का सामान्य उपयोग

* का उपयोग गुणा ऑपरेटर के रूप में किया जाता है जबकि ** का उपयोग घात ऑपरेटर के रूप में किया जाता है।

## declaring variables
a, b = 2,3

## multiplication
print("Multiplication of 2 and 3 is {}".format(a * b))

## as power operator
print("2 power 3 is {}".format(a ** b))

Multiplication of 2 and 3 is 6
2 power 3 is 8

अब आपने asterisks का सामान्य और सबसे आम उपयोग देख लिया। हालांकि, asterisks के कुछ ऐसे उपयोग भी हैं जिनके बारे में आप शायद नहीं जानते। आइए asterisks के छिपे हुए उपयोगों को खोजते हैं।

1. * का उपयोग करके अनपैकिंग

list/tuple/set से * का उपयोग करके तत्वों को अनपैक करना। हम आगे आने वाले कोड में asterisks की कुछ अन्य विशेषताओं को लागू करने के लिए अनपैकिंग का उपयोग करेंगे। अनपैकिंग ही asterisks को प्रिफ़िक्स ऑपरेटर की तरह उपयोग करने के पीछे की मूल अवधारणा है।

मान लीजिए हम list/tuple/set के पहले तत्व को a में और शेष तत्वों को b में असाइन करना चाहते हैं। सामान्यतः, हम इसे slicing के ज़रिये पूरा करते हैं।

## general approach
nums = [i for i in range(1, 6)]
a = nums[0]
b = nums[1:]
print(a, b)

print("--------------------------")

## hard approach
squares = [i ** 2 for i in range(1, 6)]
a = squares[0]
b = []
for i in range(1, len(squares)):
    b.append(squares[i])
print(a, b)

1 [2, 3, 4, 5]
--------------------------
1 [4, 9, 16, 25]

अब, हम इसे एक ही पंक्ति के कोड में लागू करने के लिए * ऑपरेटर का उपयोग करने जा रहे हैं।

nums = [i for i in range(1, 6)]

## a will be 1 and b will be a list containing remaining elements
a, *b = nums
print(a, b)

1 [2, 3, 4, 5]

यहाँ a उस प्रकार का वेरिएबल है जैसा वह सूची से पाता है और b एक सूची है। अनपैकिंग tuples और sets पर भी वैसे ही काम करती है जैसे यह lists पर करती है। इसके कुछ उदाहरण देखते हैं।

## using tuple
## here first element will assign to a and last element to c
a, *b, c = (1, 2, 3, 4, 5)
print(a, b, c)

print("--------------------------")

## using sets
a, *b, c = {1, 4, 9, 16, 25}
print(a, b, c)

1 [2, 3, 4] 5
--------------------------
1 [4, 9, 16] 25

1.1. अलग-अलग Iterables को जोड़ना

हम अनपैकिंग का उपयोग करके दो अलग-अलग iterables को list/sets/tuples में जोड़ सकते हैं। सामान्यतः, हमें iterables को बदलकर उन्हें एक में संयोजित करना पड़ता। लेकिन यदि हम * का उपयोग करें तो यह आवश्यक नहीं है। एक उदाहरण देखते हैं।

## combining a tuple, list, set
nums = [1, 2, 3]
nums2 = (4, 5, 6)
nums3 = {7, 8, 9}

## we convert the combined elements into any iterable we want
## here i am converting into a list
_list = [*nums, *nums2, *nums3]
_tuple = (*nums, *nums2, *nums3)
_set = {*nums, *nums2, *nums3}

print(type(_list))
print(_list)
print("------------------------")
print(type(_tuple))
print(_tuple)
print("------------------------")
print(type(_set))
print(_set)

<class 'list'>
[1, 2, 3, 4, 5, 6, 8, 9, 7]
------------------------
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 8, 9, 7)
------------------------
<class 'set'>
{1, 2, 3, 4, 5, 6, 7, 8, 9}

1.2. Nested Unpacking

Nested unpacking का अर्थ है पहले स्तर से निकाले गए आइटमों के भीतर से भी तत्वों को निकालना। मैं किस बारे में बात कर रहा हूँ, यह समझने के लिए उदाहरण देखें।

languages = ["Python", "HTML", "CSS", "JS"]

## unpacking
[[first_letter, *remaining], *other] = languages

print(first_letter, remaining, other)

P ['y', 't', 'h', 'o', 'n'] ['HTML', 'CSS', 'JS']

2. ** का उपयोग करके अनपैकिंग

जैसा कि हमने पहले देखा, ** का उपयोग dictionary से तत्वों को अनपैक करने के लिए किया जाता है। अनपैकिंग के दौरान मानों को निकालने के लिए हमें dictionary की keys पता होनी चाहिए। एक उदाहरण देखते हैं।

## sample dictionary
person = {"name":"John", "age":19, "year_of_passing":"2021"}
string = "Name:-{name} Year Of Graduation:-{year_of_passing} Age:-{age}".format(**person)
print(string)

Name:-John Year Of Graduation:-2021 Age:-19

dictionary से तत्व निकालने के लिए ** का उपयोग करना आम नहीं है।

3. Functions में Asterisks

हम functions में asterisks का उपयोग करके आर्ग्युमेंट्स पास और कैप्चर कर सकते हैं, जिससे कोड की पंक्तियाँ कम हो जाती हैं।

3.1. Functions में अनपैकिंग

* ऑपरेटर का उपयोग किसी iterable को अनपैक करके फ़ंक्शन कॉल करने के लिए किया जाता है। मान लीजिए हमारे पास एक list है और हमें उसके सभी तत्वों को print() को अलग-अलग पास करना है। आप क्या करेंगे? शायद आप लूप के बारे में सोच रहे हैं। लेकिन, * यह काम हमारे लिए बहुत आसान बना देता है।

बस iterable को *iterable_name की तरह पास करें। यह iterable को अनपैक कर देता है और सभी तत्वों को अलग-अलग पास करता है।

nums = [i for i in range(1, 6)]
## passsing list using the *
print(*nums)

1 2 3 4 5

nums = (i for i in range(1, 6))
## passsing tuple using the *
print(*nums, sep = ", ")

1, 2, 3, 4, 5

3.2. Elements की पैकिंग

पैकिंग का अर्थ है एक साथ कई तत्वों को कैप्चर करना। हम इस सुविधा का उपयोग फ़ंक्शन कॉल में करते हैं।

def average(*nums):
    return sum(nums) / len(nums)

अब, हम औसत निकालने के लिए किसी भी संख्या में integers पास कर सकते हैं। फ़ंक्शन average सभी आर्ग्युमेंट्स को एक सूची की तरह कैप्चर करता है।

## calling the average with some numbers
print(average(1, 2, 3, 4, 5))

3.0

हमने देखा कि * का उपयोग करके कई तत्वों को एक सूची में कैसे कैप्चर किया जाए। अब, हम सीखेंगे कि ** का उपयोग करके विभिन्न key-value जोड़ों को कैसे कैप्चर करें।

def _object(name, **properties):
    print(name, properties)

_object("Car", color="Red", cost=999999, company="Ferrari")

Car {'ceo': 'Louis', 'color': 'Red', 'cost': 999999, 'company': 'Ferrari'}

4. Positional Arguments के साथ Keyword-Only Arguments

नाम के साथ दिए गए आर्ग्युमेंट्स को keyword arguments कहा जाता है। और अन्य आर्ग्युमेंट्स को positional arguments कहा जाता है। पहले, आपको keyword और positional आर्ग्युमेंट्स के बीच का अंतर समझना होगा। इसका एक उदाहरण देखते हैं।

## name is a positional argument
## color and cost are keyword arguments
def sample(car, color = None, cost = None):
    print("Car:-{} Color:-{}, Cost:-{}".format(car, color, cost))

हम keyword arguments के लिए फ़ंक्शन कॉल करते समय पैरामीटर के नाम का उपयोग करके आर्ग्युमेंट्स पास कर सकते हैं। यदि हम keyword आर्ग्युमेंट्स के लिए कुछ नहीं देते हैं, तो वे फ़ंक्शन परिभाषा में दिए गए डिफ़ॉल्ट मान ले लेंगे।

हम keyword arguments को keywords या आर्ग्युमेंट्स की स्थिति के आधार पर निर्दिष्ट कर सकते हैं।

sample("Ferrari", "Red", 999999)

Car:-Ferrari Color:-Red, Cost:-999999

sample("Ferrari", cost = 999999, color = "Red")

Car:-Ferrari Color:-Red, Cost:-999999

यदि हम उन्हें फ़ंक्शन में परिभाषित नामों का उपयोग करके कॉल करते हैं तो keyword आर्ग्युमेंट्स का क्रम आवश्यक नहीं है।

sample("Ferrari", color = "Green")

Car:-Ferrari Color:-Green, Cost:-None

अब, आपको positional और keyword आर्ग्युमेंट्स के बारे में एक धारणा हो गई है। आइए अपने मुख्य विषय पर आते हैं।

Keyword-Only आर्ग्युमेंट्स केवल keywords द्वारा ही निर्दिष्ट किए जाते हैं। हम उन्हें पहले की तरह स्थितिगत रूप से सेट नहीं कर सकते। keyword-only को कैप्चर करने के लिए हमें * आर्ग्युमेंट्स के बाद keyword आर्ग्युमेंट्स घोषित करने होते हैं।

def keyword_only(*items, _list, default = False):
    print(items)
    print(_list)
    print(default)

हमें *items के बाद _list और default आते हैं, इसलिए फ़ंक्शन कॉल करते समय इनके लिए keywords का उपयोग करना होगा। यदि हम उन्हें कॉल करने के लिए keywords का उपयोग नहीं करते, तो त्रुटि मिलेगी। दोनों स्थितियाँ देखते हैं।

nums = [i ** 2 for i in range(1, 6)]
## calling the function
keyword_only(1, 2, 3, 4, 5, _list = nums, default = True)

(1, 2, 3, 4, 5)
[1, 4, 9, 16, 25]
True

अगर हम फ़ंक्शन keyword_only को positional arguments से कॉल करें तो क्या होगा।

nums = [i ** 2 for i in range(1, 6)]
## calling the function will raise an error
keyword_only(1, 2, 3, 4, 5, nums, False)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-85-bf737d8a8bfc> in <module>()
      1 nums = [i ** 2 for i in range(1, 6)]
----> 2 keyword_only(1, 2, 3, 4, 5, nums, False)


TypeError: keyword_only() missing 1 required keyword-only argument: '_list'

हमें त्रुटि मिलती है जो बताती है कि एक आवश्यक keyword-only आर्ग्युमेंट गायब है। इसलिए, keyword-only आर्ग्युमेंट्स को कॉल करते समय हमें keywords का उपयोग करना होगा। Keyword-Only आर्ग्युमेंट्स फ़ंक्शन्स में केवल * आर्ग्युमेंट्स के बाद ही परिभाषित किए जाते हैं।

5. Positional Arguments के बिना Keyword-Only Arguments

यदि हम किसी भी positional argument के बिना केवल Keyword-Only आर्ग्युमेंट्स स्वीकार करना चाहते हैं, तो Python हमें यह हासिल करने के लिए फ़ंक्शन पैरामीटर्स में * का उपयोग करने की अनुमति देता है। एक उदाहरण देखते हैं।

def _sample(*, name):
    print(name)

ऊपर दिया गया फ़ंक्शन केवल keyword-only आर्ग्युमेंट्स लेता है। हमें आर्ग्युमेंट को keyword के साथ पास करना होगा। अन्यथा, हमें त्रुटि मिलेगी। फ़ंक्शन परिभाषा में * यह सुनिश्चित करने के लिए है कि फ़ंक्शन केवल keywords का उपयोग करके आर्ग्युमेंट्स लेता है। फ़ंक्शन में * पैरामीटर के बाद हम जो भी पैरामीटर्स परिभाषित करेंगे, उन्हें फ़ंक्शन कॉल के दौरान keywords के साथ ही निर्दिष्ट करना होगा।

## calling the function using keyword 'name'
_sample(name = "Datacamp")

Datacamp

## calling the function without using keyword 'name'
## we will get a TypeError
_sample("Datacamp")

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-fe0d3718b56c> in <module>()
      1 ## calling the function without using keyword 'name'
      2 ## we will get a TypeError
----> 3 samp("Datacamp")


TypeError: samp() takes 0 positional arguments but 1 was given

यह स्पष्ट है कि _sample() फ़ंक्शन केवल keyword-only* आर्ग्युमेंट्स लेता है।

निष्कर्ष

Python के हर नए रिलीज़ में डेवलपर्स नई सुविधाएँ जोड़ रहे हैं। Asterisks विशेष हैं और कोड के कुछ हिस्सों को कम कर देते हैं। हम * के बिना कई positional arguments स्वीकार नहीं कर सकते, और keyword-only arguments के लिए भी उस सुविधा को लागू करने हेतु * की आवश्यकता होती है। asterisks के अन्य ऑपरेशन्स को कई पंक्तियों के कोड से भी किया जा सकता है। इन्हें अच्छी तरह समझने के लिए अभ्यास करें। पढ़ने के लिए धन्यवाद!

यदि आप Python के बारे में और सीखना चाहते हैं, तो DataCamp का Python Data Science Toolbox (Part 1) कोर्स देखें।

Happy Coding :)

विषय

Pythonडेटा साइंस