टपल में

टपल के बारे में

एक टपल क्रम में रखी गई चीज़ों का एक अपरिवर्तनीय कलेक्शन है।

ज़्यादातर कलेक्शन की तरह (बिल्ट-इन list, dict और set देखिए), tuples किसी भी (या कई) डेटा टाइप को रख सकते हैं, जिनमें दूसरे tuples भी शामिल हैं। टपल के एलिमेंट पर for item in <tuple> रचना का इस्तेमाल करके इटरेशन किया जा सकता है। अगर एलिमेंट का इंडेक्स और वैल्यू दोनों चाहिए, तो for index, item in enumerate(<tuple>) का इस्तेमाल किया जा सकता है।

किसी भी सीक्वेंस की तरह, tuples के अंदर के एलिमेंट तक ब्रैकेट नोटेशन से पहुँचा जा सकता है, बाईं ओर से 0-based index संख्या का या दाईं ओर से -1-based index संख्या का इस्तेमाल करके। टपल को पूरा या आंशिक रूप से स्लाइस नोटेशन से या <tuple>.copy() से कॉपी किया जा सकता है, और ये सभी सामान्य सीक्वेंस ऑपरेशन का समर्थन करते हैं। अपरिवर्तनीय होने के कारण, tuples परिवर्तनीय सीक्वेंस ऑपरेशन का समर्थन नहीं करते।

टपल दूसरे कलेक्शन टाइप की तुलना में बहुत कम मेमोरी लेते हैं और इंडेक्स इस्तेमाल करने पर इनका एक्सेस समय स्थिर (O(1)) होता है। लेकिन एक बार बन जाने के बाद इनका आकार नहीं बदला जा सकता, इन्हें क्रमबद्ध नहीं किया जा सकता और इनमें बदलाव नहीं किया जा सकता, इसलिए जब डेटा में बार-बार बदलाव या अपडेट की ज़रूरत हो, तब ये कम लचीले होते हैं। अगर बार-बार अपडेट या विस्तार की ज़रूरत हो, तो list, collections.deque, या array.array बेहतर डेटा स्ट्रक्चर हो सकते हैं।

टपल बनाना

टपल कई तरीकों से बनाए जा सकते हैं, या तो tuple क्लास कंस्ट्रक्टर से या (<element_1>, <element_2>) (tuple लिटरल) घोषणा से।

tuple() कंस्ट्रक्टर को खाली या किसी इटरेबल के साथ इस्तेमाल करना:

>>> no_elements = tuple()
()

# The constructor *requires* an iterable, so single elements must be passed in a list or another tuple.
>>> one_element = tuple([16])
(16,)

स्ट्रिंग इटरेबल होती हैं, इसलिए tuple() कंस्ट्रक्टर को आर्गुमेंट के रूप में एक अकेली str देना चौंकाने वाले नतीजे दे सकता है:

# String elements (characters) are iterated through and added to the tuple
>>> multiple_elements_string = tuple("Timbuktu")
('T', 'i', 'm', 'b', 'u', 'k', 't', 'u')

दूसरे इटरेबल के भी एलिमेंट एक-एक करके जोड़े जाते हैं:

>>> multiple_elements_list = tuple(["Parrot", "Bird", 334782])
("Parrot", "Bird", 334782)

>>> multiple_elements_set = tuple({2, 3, 5, 7, 11})
(2,3,5,7,11)

dict में इटरेशन डिफ़ॉल्ट रूप से कीज़ पर होता है। किसी डिक्शनरी से बनाए गए टपल में की और वैल्यू दोनों शामिल करने के लिए <dict>.items() इस्तेमाल कीजिए, जो (key, value) tuples का एक इटरेटर लौटाता है।

>>> source_data = {"fish": "gold", "monkey": "brown"}

>>> multiple_elements_dict_1 = tuple(source_data)
('fish', 'monkey')

>>> multiple_elements_dict_2 = tuple(source_data.items())
(('fish', 'gold'), ('monkey', 'brown'))

टपल को लिटरल के रूप में घोषित करना:

चूँकि tuple() कंस्ट्रक्टर आर्गुमेंट के रूप में सिर्फ इटरेबल (या कुछ नहीं) लेता है, लिटरल तरीके से एक-एलिमेंट वाला टपल बनाना कहीं ज़्यादा आसान है।

>>> no_elements = ()
()

>>> one_element = ("Guava",)
("Guava",)

ध्यान दीजिए कि आम तौर पर tuple लिटरल बनाने के लिए कोष्ठक नहीं चाहिए, सिर्फ अल्पविराम चाहिए। लेकिन ज़्यादातर मामलों में (<element_1>, <element_2>) को ज़्यादा पढ़ने लायक माना जाता है। कोष्ठक उन मामलों में भी चाहिए जहाँ अस्पष्टता हो, जैसे खाली टपल या एक-एलिमेंट वाला टपल, या जहाँ कोई फंक्शन आर्गुमेंट के रूप में टपल लेता है।

>>> elements_separated_with_commas = "Parrot", "Bird", 334782
("Parrot", "Bird", 334782)

>>> elements_with_commas_and_parentheses = ("Triangle", 60, 60, 60)
("Triangle", 60, 60, 60)

दूसरे डेटा स्ट्रक्चर को tuple के एलिमेंट के रूप में शामिल किया जा सकता है, जिनमें दूसरे tuples भी शामिल हैं।

>>> nested_data_structures = ({"fish": "gold", "monkey": "brown", "parrot" : "grey"}, ("fish", "mammal", "bird"))
({"fish": "gold", "monkey": "brown", "parrot" : "grey"}, ("fish", "mammal", "bird"))

>>> nested_data_structures_1 = (["fish", "gold", "monkey", "brown", "parrot", "grey"], ("fish", "mammal", "bird"))
(["fish", "gold", "monkey", "brown", "parrot", "grey"], ("fish", "mammal", "bird"))

टपल को प्लस + ऑपरेटर से जोड़ा जा सकता है, जो हर tuple को खोलता है और एक नया, संयुक्त tuple बनाता है।

>>> new_via_concatenate = ("George", 5) + ("cat", "Tabby")
("George", 5, "cat", "Tabby")

#likewise, using the multiplication operator * is the equivalent of using + n times
>>> first_group = ("cat", "dog", "elephant")

>>> multiplied_group = first_group * 3
('cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant')

डेटा तक पहुँचना

टपल के अंदर के एलिमेंट तक (दूसरे सीक्वेंस टाइप str और list की तरह) ब्रैकेट नोटेशन से पहुँचा जा सकता है। इंडेक्स left --> right (शून्य से शुरू) या right --> left (-1 से शुरू) हो सकते हैं। टपल को पूरा या आंशिक रूप से स्लाइस नोटेशन से या <tuple>.copy() इस्तेमाल करके भी कॉपी किया जा सकता है।

>>> student_info = ("Alyssa", "grade 3", "female", 8)

#name is at index 0 or index -4
>>> student_name = student_info[0]
Alyssa

>>> student_name = student_info[-4]
Alyssa

#age is at index 3 or index -1
>>> student_age_1 = student_info[3]
8

>>> student_age_2 = student_info[-1]
8

एलिमेंट पर इटरेशन

टपल के अंदर के एलिमेंट पर for item in <tuple> सिंटैक्स का इस्तेमाल करके लूप में इटरेशन किया जा सकता है। अगर इंडेक्स और वैल्यू दोनों चाहिए, तो for index, item in enumerate(<tuple>) का इस्तेमाल किया जा सकता है।

>>> student_info = ("Alyssa", "grade 3", "female", 8)
>>> for item in student_info:
...   print(item)
...
Alyssa
grade 3
female
8

>>> for index, item in enumerate(student_info):
...  print("Index is: " + str(index) + ", value is: " + str(item) + ".")
...
Index is: 0, value is: Alyssa.
Index is: 1, value is: grade 3.
Index is: 2, value is: female.
Index is: 3, value is: 8.

समरूप जानकारी के रूप में टपल

टपल अक्सर रिकॉर्ड के रूप में इस्तेमाल होते हैं, जिनमें ऐसा डेटा होता है जो संगठनात्मक या अवधारणात्मक रूप से समरूप होता है और जिसे जानकारी की एक इकाई माना जाता है, भले ही अलग-अलग एलिमेंट विषमरूप डेटा टाइप के हों।

>>> student_info = ("Alyssa", "grade 3", "female", 8)

टपल तब भी इस्तेमाल होते हैं जब डेटा के समरूप अपरिवर्तनीय सीक्वेंस की ज़रूरत hashability के लिए, किसी set में संग्रहीत करने के लिए, या डिक्शनरी में की बनाने के लिए होती है।

ध्यान दीजिए कि ज़्यादातर मामलों में tuples अपरिवर्तनीय होते हैं, लेकिन चूँकि इनमें कोई भी डेटा स्ट्रक्चर या ऑब्जेक्ट हो सकता है, अगर इनका कोई भी एलिमेंट किसी परिवर्तनीय टाइप का हो, तो ये परिवर्तनीय हो सकते हैं। किसी tuple के अंदर परिवर्तनीय डेटा टाइप इस्तेमाल करने से वह पूरा tuple हैश करने लायक नहीं रह जाता है।

>>> cmyk_color_map = {
        (.69, .3, .48, .1) : ("Teal 700", (59, 178, 146), 0x3BB292),
        (0, .5, 1, 0) : ("Pantone 151", (247, 127, 1), 0xF77F01),
        (.37, .89, 0, .44) : ("Pantone 267", (89, 16, 142), 0x59108E),
        (0, 1, .46, .45) : ("Pantone 228", (140, 0, 76), 0x8C004C)
    }

>>> unique_rgb_colors = {
        (59, 178, 146),
        (247, 127, 1),
        (89, 16, 142),
        (140, 0, 76),
        (76, 0, 140)
     }

>>> teal_700 = hash((59, 178, 146))

>>> teal_700 = hash(("Pantone 228", [(140, 0, 76), 0x8C004C]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

विस्तारित टपल और संबंधित डेटा टाइप

टपल अक्सर रिकॉर्ड के रूप में इस्तेमाल होते हैं, लेकिन इनके अंदर के डेटा तक सिर्फ स्थान/इंडेक्स से पहुँचा जा सकता है। collections मॉड्यूल में namedtuple() क्लास बेसिक टपल की कार्यक्षमता को बढ़ाता है, जिससे एलिमेंट तक नाम से पहुँचा जा सकता है। इसके अलावा, उपयोगकर्ता dataclass को ढालकर भी नामित एट्रिब्यूट की ऐसी ही सुविधा पा सकते हैं, जिसके कुछ फायदे और नुकसान हैं।