पायथन में बिल्ट-इन डेटा स्ट्रक्चर

पायथन में कुछ सरल बिल्ट-इन प्रकार हैं, जैसे int, float, complex, str, bool। इसमें कुछ जटिल बिल्ट-इन प्रकार भी हैं, जैसे List, Dict, Tuple, Set।

List - List पायथन में डेटा प्रकारों में से एक है। List ऑब्जेक्ट्स का एक संग्रह है, यह क्रमबद्ध और परिवर्तनीय है। पायथन में यह वर्गाकार कोष्ठक [] के भीतर लिखा जाता है।

List कैसे बनाएं

my_list = ["car", "bus", "truck"]
print(my_list)

List आइटम कैसे एक्सेस करें

हम इंडेक्स नंबर का संदर्भ देकर सूची आइटम एक्सेस कर सकते हैं:

पोजीशन 1 पर आइटम लौटाता है।

my_list = ["car", "bus", "truck"]
print(my_list[1])

List मान कैसे बदलें

इंडेक्स नंबर का उपयोग करके, हम आइटम मान बदल सकते हैं।

my_list = ["car", "bus", "truck"]
my_list[2] = "van"  # मान परिवर्तनीय हैं
print(my_list)

List के माध्यम से लूप कैसे लागू करें

हम for लूप का उपयोग करके सूची आइटम के माध्यम से लूप कर सकते हैं।

my_list = ["car", "bus", "truck"]
for x in my_list:
    print(x)

List पर कुछ मेथड

List मेथड्स

पायथन में कुछ बिल्ट-इन मेथड हैं, हम इन मेथड्स का उपयोग सूचियों पर कर सकते हैं।

Dict - डिक्शनरी तत्वों के अनक्रमित सेट हैं और डिक्शनरी का उपयोग उनकी कुंजियों के साथ किया जाता है न कि उनकी स्थिति के साथ। डिक्शनरी पायथन में अमूर्त डेटा प्रकार हैं। डिक्शनरी में दो पैरामीटर होते हैं एक कुंजी और दूसरा मान। प्रत्येक कुंजी मान से जुड़ी होती है, इसलिए हम कह सकते हैं कि डिक्शनरी एसोसिएटिव ऐरे हैं।

उदाहरण

>>> student = {"Aadrika": 001, "Adwaita": 009, "Sakya": 011, "Sanj": 022}

यहाँ हम छात्र रिकॉर्ड का उपयोग करते हैं, हमें बस छात्र के नाम को इंडेक्स के रूप में उपयोग करना है।

>>> student = {"Aadrika": 001, "Adwaita": 009, "Sakya": 011, "Sanj": 022}
>>> student["Adwaita"]
009

इन उदाहरणों में, हमारी डिक्शनरी student है और हमारी डिक्शनरी में एक क्रम है। जैसे पहला तत्व "Aadrika" है, दूसरा तत्व "Adwaita" है और इसी तरह। लेकिन डिक्शनरी में कोई क्रम नहीं है। यही कारण है कि student डिक्शनरी का आउटपुट "मूल क्रम" को प्रतिबिंबित नहीं करता है।

यदि हम तत्व जोड़ना चाहते हैं।

>>> student["Krishna"] = 111
>>> student
student = {"Aadrika": 001, "Adwaita": 009, "Sakya": 011, "Sanj": 022, "Krishna": 111}

तो, प्रारंभ में डिक्शनरी खाली होती है फिर यह मान को एक-एक करके वृद्धिशील प्रक्रिया में लेती है।

Tuples - टपल पायथन में ऑब्जेक्ट्स का एक समूह है। यह कॉमा (",") से अलग होता है। इंडेक्सिंग के संदर्भ में, टपल सूची के समान है। मुख्य रूप से टपल अपरिवर्तनीय है। ये तुलनीय और हैशेबल भी हैं इसलिए हम आसानी से उनकी सूची सॉर्ट कर सकते हैं और पायथन डिक्शनरी में टपल्स को कुंजी मान के रूप में उपयोग किया जाता है।

टपल कैसे बनाएं

my_tuple = ("car", "bus", "truck")
print(my_tuple)

टपल आइटम कैसे एक्सेस करें

हम इंडेक्स नंबर का संदर्भ देकर टपल आइटम एक्सेस कर सकते हैं।

पोजीशन 1 में आइटम लौटाता है।

my_tuple = ("car", "bus", "truck")
print(my_tuple[1])

टपल मान कैसे बदलें

एक बार टपल बन जाने के बाद, हम इसके मान नहीं बदल सकते। टपल अपरिवर्तनीय हैं।

हम टपल में मान नहीं बदल सकते।

my_tuple = ("car", "bus", "truck")
my_tuple[3] = "van"  # मान अपरिवर्तनीय हैं
print(my_tuple)

टपल के माध्यम से लूप कैसे लागू करें

हम for लूप का उपयोग करके टपल आइटम के माध्यम से लूप कर सकते हैं।

my_tuple = ("car", "bus", "truck")
for x in my_tuple:
    print(x)

टपल मेथड्स

पायथन में दो बिल्ट-इन मेथड count() और index() हैं। हम इन मेथड्स का उपयोग टपल्स में कर सकते हैं।

Set - गणित में, एक सेट अलग-अलग ऑब्जेक्ट्स का संग्रह है। उदाहरण के लिए, यहाँ मान लें 3 संख्याएँ, संख्याएँ 2, 4, और 6 अलग-अलग ऑब्जेक्ट हैं जब हम उन्हें अलग-अलग मानते हैं, लेकिन जब उन्हें सामूहिक रूप से माना जाता है तो वे आकार तीन के एक सेट बनाते हैं, जिसे {2,4,6} लिखा जाता है।

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

सेट पर विभिन्न ऑपरेशन

सेट के लिए मेथड्स

1. add(x) मेथड: यदि तत्व सूची में मौजूद नहीं है तो इसे सूची में जोड़ता है।

   A = {"AA", "BB", "CC"}
   A.add("DD") -> DD को A सेट में जोड़ें।

2. union(s) मेथड: यह मेथड दो सेटों का यूनियन लौटाता है। यूनियन ऑपरेशन के लिए '|' ऑपरेटर का उपयोग करें।

   A = {"AA", "BB", "CC"}
   B = {"MM", "NN"}
   Z = A.union(B) OR Z = A|B -> सेट Z में A और B दोनों के तत्व होंगे

3. intersect(s) मेथड: यह मेथड दो सेटों का इंटरसेक्शन लौटाता है। ' &' ऑपरेटर का उपयोग भी इस मामले में किया जा सकता है।

   S = A.intersection(B) -> सेट S में A और B के सामान्य तत्व होंगे

4. difference(s) मेथड: यह मेथड उन सेट तत्वों को लौटाता है जो पहले सेट से संबंधित हैं लेकिन दूसरे सेट से नहीं। हम यहाँ '- ' ऑपरेटर का उपयोग कर सकते हैं।

   S = A.difference(B) OR S = A - B -> सेट S में वे सभी तत्व होंगे जो A में हैं लेकिन B में नहीं

5. clear() मेथड: पूरे सेट को साफ़ करता है।

   B.clear() -> B सेट को साफ़ करता है

सेट के लिए ऑपरेटर्स

सेट और फ्रोजन सेट निम्नलिखित ऑपरेटर्स का समर्थन करते हैं

key in s	# समावेश जांच
key not in s	# गैर-समावेश जांच
s1 == s2	# दो सेट समान हैं
s1 != s2	# दो सेट समान नहीं हैं
s1 <= s2	# s1, s2 का सबसेट है, s1 < s2 # पहला सेट दूसरे का सबसेट है, s1 >= s2 # पहला सेट दूसरे का सुपरसेट है
s1 > s2	# पहला सेट दूसरे का सुपरसेट है
s1 | s2	# दो सेटों का यूनियन
s1 & s2	# दो सेटों का इंटरसेक्शन
s1 - s2	# पहले सेट में तत्वों का सेट लेकिन दूसरे में नहीं
s1 ^ s2	# पहले सेट या दूसरे सेट में से केवल एक में तत्वों का सेट