Python Language
टपल

परिचय

वाक्य - विन्यास

• (1, ए, "हैलो") # एक चर होना चाहिए

• () # एक खाली टपल

• (1,) # 1-तत्व टपल। (1) टपल नहीं है।

• 1, 2, 3 # 3-तत्व टपल (1, 2, 3)

टिप्पणियों

इंडेक्सिंग ट्यूपल्स

x = (1, 2, 3)
x[0]  # 1
x[1]  # 2
x[2]  # 3
x[3]  # IndexError: tuple index out of range

ऋणात्मक संख्याओं के साथ अनुक्रमण अंतिम तत्व से शुरू होगा -1:

x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range

तत्वों की एक श्रृंखला को अनुक्रमित करना

print(x[:-1])   # (1, 2)
print(x[-1:])   # (3,)
print(x[1:3])   # (2, 3)

टुपल्स अपरिवर्तनीय हैं

पायथन में list एस और tuple एस के बीच मुख्य अंतर यह है कि ट्यूपल्स अपरिवर्तनीय हैं, अर्थात, टपल के आरंभ होने के बाद आइटम को जोड़ या संशोधित नहीं किया जा सकता है। उदाहरण के लिए:

>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

इसी तरह, tuples में .append और .extend विधियाँ नहीं हैं .append कि list है। += का उपयोग करना संभव है, लेकिन यह परिवर्तनशील के बंधन को बदलता है, और न ही स्वयं को बदलता है:

>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)

उत्परिवर्तित वस्तुओं, जैसे lists , टुपल्स के अंदर रखते समय सावधान रहें। इसे बदलने पर बहुत भ्रामक परिणाम हो सकते हैं। उदाहरण के लिए:

>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]

क्या दोनों एक त्रुटि उठाएंगे और टपल के भीतर सूची की सामग्री को बदल देंगे:

TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])

आप टुल्ल के लिए " += एपेंड" करने के लिए += ऑपरेटर का उपयोग कर सकते हैं - यह नए तत्व के साथ एक नया टपल बनाकर काम करता है जिसे आपने "जोड़ा" है और इसे अपने वर्तमान चर पर असाइन करें; पुराने टपल को बदला नहीं गया है, बल्कि बदल दिया गया है!

यह एक सूची में और उससे परिवर्तित करने से बचा जाता है, लेकिन यह धीमा है और एक बुरा अभ्यास है, खासकर यदि आप कई बार एपेंड करने जा रहे हैं।

टपल एलीमेंट-वार हस्सिबल और इक्विटेबल हैं

hash( (1, 2) )  # ok
hash( ([], {"hello"})  # not ok, since lists and sets are not hashabe

इस प्रकार एक टपल को एक set अंदर या एक dict में चाबी के रूप में रखा जा सकता है, यदि इसके प्रत्येक तत्व हो सकते हैं।

{ (1, 2) } #  ok
{ ([], {"hello"}) ) # not ok

टपल

Syntactically, एक tuple मानों की अल्पविराम से अलग की गई सूची है:

t = 'a', 'b', 'c', 'd', 'e'

हालांकि आवश्यक नहीं है, कोष्ठक में tuples संलग्न करना आम है:

t = ('a', 'b', 'c', 'd', 'e')

कोष्ठक के साथ एक खाली टपल बनाएं:

t0 = ()
type(t0)            # <type 'tuple'>

एक एकल तत्व के साथ एक टपल बनाने के लिए, आपको एक अंतिम अल्पविराम शामिल करना होगा:

t1 = 'a',
type(t1)              # <type 'tuple'>

ध्यान दें कि कोष्ठकों में एकल मान टपल नहीं है:

t2 = ('a')
type(t2)              # <type 'str'>

एक सिंगलटन टपल बनाने के लिए एक अनुगामी अल्पविराम का होना आवश्यक है।

t2 = ('a',)
type(t2)              # <type 'tuple'>

ध्यान दें कि कोष्ठक का उपयोग करने के लिए सिंगलटन टुपल्स के लिए इसकी अनुशंसा की जाती है ( PEP8 को ट्रेलिंग कॉमा पर देखें)। इसके अलावा, पीछे आने वाले अल्पविराम के बाद कोई सफेद जगह नहीं है ( व्हॉट्सएप पर PEP8 देखें)

t2 = ('a',)           # PEP8-compliant
t2 = 'a',             # this notation is not recommended by PEP8
t2 = ('a', )          # this notation is not recommended by PEP8

ट्यूपल बनाने का दूसरा तरीका बिल्ट-इन फंक्शन tuple ।

t = tuple('lupins')
print(t)              # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t)              # (0, 1, 2)

ये उदाहरण एलन बी डाउनी की पुस्तक थिंक पाइथन की सामग्री पर आधारित हैं।

पैकिंग और ट्यूपलों को खोलना

पायथन में ट्यूपल्स अल्पविराम द्वारा अलग किए गए मान हैं। ट्यूलिंग इनपुट के लिए कोष्ठक संलग्न करना वैकल्पिक है, इसलिए दो कार्य

a = 1, 2, 3   # a is the tuple (1, 2, 3)

तथा

a = (1, 2, 3) # a is the tuple (1, 2, 3)

समतुल्य हैं। असाइनमेंट a = 1, 2, 3 को पैकिंग भी कहा जाता है क्योंकि यह एक ट्यूपल में मानों को एक साथ पैक करता है।

ध्यान दें कि एक-मूल्य का टुपल भी एक टपल है। पायथन को यह बताने के लिए कि एक चर एक टुपल है और एक भी मूल्य नहीं है जो आप अनुगामी अल्पविराम का उपयोग कर सकते हैं

a = 1  # a is the value 1
a = 1, # a is the tuple (1,)

यदि आपको कोष्ठक का उपयोग करना है तो अल्पविराम की भी आवश्यकता है

a = (1,) # a is the tuple (1,)
a = (1)  # a is the value 1 and not a tuple

एक ट्यूपल से मूल्यों को अनपैक करने के लिए और कई असाइनमेंट का उपयोग करते हैं

# unpacking AKA multiple assignment
x, y, z = (1, 2, 3) 
# x == 1
# y == 2
# z == 3

प्रतीक _ का उपयोग डिस्पोजेबल चर नाम के रूप में किया जा सकता है यदि किसी को केवल एक टपल के कुछ तत्वों की आवश्यकता होती है, जो एक प्लेसहोल्डर के रूप में कार्य करता है:

a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3

एकल तत्व ट्यूपल:

x, = 1,  # x is the value 1
x  = 1,  # x is the tuple (1,)

पायथन 3 में एक * उपसर्ग के साथ एक लक्ष्य चर का उपयोग कैच-ऑल वैरिएबल के रूप में किया जा सकता है ( Iterables को अनपैकेजिंग देखें):

first, *more, last = (1, 2, 3, 4, 5)
# first == 1
# more == [2, 3, 4]
# last == 5

उलटने वाले तत्व

एक ट्यूपल के भीतर तत्वों को उल्टा

colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

या उलट का उपयोग करके (उलट एक पुनरावृत्ति देता है जो एक टुपल में बदल जाता है):

rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

बिल्ट-इन ट्यूपल फ़ंक्शंस

Tuples निम्नलिखित निर्माण कार्यों का समर्थन करता है

तुलना

यदि तत्व एक ही प्रकार के हैं, तो अजगर तुलना करता है और परिणाम देता है। यदि तत्व विभिन्न प्रकार के होते हैं, तो यह जाँचता है कि क्या वे संख्याएँ हैं।

• यदि संख्या, तुलना करें।
• यदि कोई तत्व एक संख्या है, तो दूसरा तत्व वापस आ जाता है।
• अन्यथा, प्रकार वर्णानुक्रम में क्रमबद्ध होते हैं।

यदि हम किसी एक सूची के अंत तक पहुँच गए हैं, तो लंबी सूची "बड़ी" है। यदि दोनों सूची समान हैं तो यह 0 देता है।

tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')

cmp(tuple1, tuple2)
Out: 1

cmp(tuple2, tuple1)
Out: -1

cmp(tuple1, tuple3)
Out: 0

टपल लंबाई

फ़ंक्शन len टपल की कुल लंबाई लौटाता है

len(tuple1)
Out: 5

एक टपल का मैक्स

समारोह max अधिकतम मूल्य के साथ टपल से रिटर्न आइटम

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

एक टपल का मिन

फ़ंक्शन मिनि टपल से आइटम को मिन मान के साथ लौटाता है

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

एक सूची को टुपल में बदलें

अंतर्निहित फ़ंक्शन tuple एक सूची को एक ट्यूपल में परिवर्तित करता है।

list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)

टुपल समतलता

का उपयोग करें + दो ट्यूपलों को समेटने के लिए

tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')