Python Data Structures ट्यूटोरियल

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

इस ट्यूटोरियल में, आप विभिन्न Python डेटा स्ट्रक्चर्स के बारे में जानेंगे और देखेंगे कि उन्हें कैसे लागू किया जाता है:

• एब्स्ट्रैक्ट डेटा टाइप और डेटा स्ट्रक्चर्स
• प्रिमिटिव डेटा स्ट्रक्चर्स
  • Integers
  • Float
  • Strings
  • Boolean
• नॉन-प्रिमिटिव डेटा स्ट्रक्चर्स
  • Arrays
  • Lists
  • Tuples
  • Dictionary
  • Sets
  • Files

हमारे मुफ्त Intro to Python for Data Science कोर्स में, आप डेटा साइंस संदर्भ में विशेष रूप से Python का उपयोग करना सीख सकते हैं। यह कोर्स Python की बुनियादी अवधारणाओं का परिचय देता है। इसके साथ, आप मेथड्स, फ़ंक्शंस और NumPy पैकेज खोजेंगे।

एब्स्ट्रैक्ट डेटा टाइप और डेटा स्ट्रक्चर्स

जैसा कि आपने परिचय में पढ़ा, डेटा स्ट्रक्चर्स आपको बारीकियों में खोने के बजाय बड़ी तस्वीर पर ध्यान केंद्रित करने में मदद करते हैं। इसे डेटा एब्स्ट्रैक्शन कहा जाता है।

अब, डेटा स्ट्रक्चर्स वास्तव में एब्स्ट्रैक्ट डेटा टाइप्स या ADT का इम्प्लीमेंटेशन हैं। इस इम्प्लीमेंटेशन के लिए कुछ प्रोग्रामिंग कंस्ट्रक्ट्स और बेसिक डेटा टाइप्स का उपयोग करके डेटा का फिजिकल व्यू चाहिए होता है।

आम तौर पर, कंप्यूटर विज्ञान में डेटा स्ट्रक्चर्स को दो श्रेणियों में बांटा जा सकता है: प्रिमिटिव और नॉन-प्रिमिटिव डेटा स्ट्रक्चर्स। पहले वाले डेटा को दर्शाने के सबसे सरल रूप हैं, जबकि दूसरे अधिक उन्नत हैं: वे विशेष प्रयोजनों के लिए जटिल डेटा स्ट्रक्चर्स के भीतर प्रिमिटिव डेटा स्ट्रक्चर्स को समाहित करते हैं।

प्रिमिटिव डेटा स्ट्रक्चर्स

ये सबसे प्राचीन या बुनियादी डेटा स्ट्रक्चर्स हैं। ये डेटा मैनिपुलेशन के बिल्डिंग ब्लॉक्स हैं और इनमें डेटा के शुद्ध, सरल मान होते हैं। Python में चार प्रिमिटिव वैरिएबल टाइप्स होते हैं:

• Integers
• Float
• Strings
• Boolean

अगले सेक्शंस में, आप इनके बारे में और जानेंगे!

Integers

आप एक integer का उपयोग संख्यात्मक डेटा का प्रतिनिधित्व करने के लिए कर सकते हैं, और विशेष रूप से, ऋणात्मक अनंत से अनंत तक के पूर्णांक, जैसे 4, 5, या -1।

Float

"Float" का अर्थ 'फ्लोटिंग प्वाइंट नंबर' है। आप इसका उपयोग परिमेय संख्याओं के लिए कर सकते हैं, जो आमतौर पर दशमलव अंक के साथ समाप्त होती हैं, जैसे 1.11 या 3.14।

निम्नलिखित DataCamp Light Chunk पर नज़र डालें और कुछ integer और float ऑपरेशंस आज़माएं!

# Floats
x = 4.0
y = 2.0

# Addition
print(x + y)

# Subtraction
print(x - y)

# Multiplication
print(x * y)

# Returns the quotient
print(x / y)

# Returns the remainder
print(x % y) 

# Absolute value
print(abs(x))

# x to the power y
print(x ** y)

नोट कि Python में, आपको वैरिएबल या अपने डेटा के प्रकार को स्पष्ट रूप से बताने की आवश्यकता नहीं है। ऐसा इसलिए है क्योंकि यह डायनामिकली टाइप्ड भाषा है। डायनामिकली टाइप्ड भाषाएं वे हैं जहां किसी ऑब्जेक्ट में स्टोर किए जा सकने वाले डेटा का प्रकार परिवर्तनशील होता है।

String

स्ट्रिंग्स अक्षरों, शब्दों या अन्य कैरेक्टर्स का संग्रह होती हैं। Python में, आप एकल या डबल कोट्स की जोड़ी के भीतर कैरेक्टर्स के अनुक्रम को रखकर स्ट्रिंग्स बना सकते हैं। उदाहरण के लिए: 'cake', "cookie", आदि।

आप दो या अधिक स्ट्रिंग्स पर + ऑपरेशन लागू करके उन्हें जोड़ भी सकते हैं, ठीक नीचे दिए उदाहरण की तरह:

x = 'Cake'
y = 'Cookie'
x + ' & ' + yसंचालित द्वारा

'Cake & Cookie'संचालित द्वारा

यहाँ कुछ अन्य बुनियादी ऑपरेशंस हैं जो आप स्ट्रिंग्स के साथ कर सकते हैं; उदाहरण के लिए, आप किसी स्ट्रिंग को निश्चित संख्या में दोहराने के लिए * का उपयोग कर सकते हैं:

# Repeat
x * 2संचालित द्वारा

'CakeCake'संचालित द्वारा

आप स्ट्रिंग्स को slice भी कर सकते हैं, यानी स्ट्रिंग्स के कुछ हिस्से चुन सकते हैं:

# Range Slicing
z1 = x[2:]  संचालित द्वारा

print(z1)संचालित द्वारा

# Slicing
z2 = y[0] + y[1]संचालित द्वारा

ke
Coसंचालित द्वारा

नोट कि स्ट्रिंग्स अल्फ़ा-न्यूमेरिक कैरेक्टर्स भी हो सकती हैं, लेकिन + ऑपरेशन अभी भी स्ट्रिंग्स को जोड़ने के लिए ही उपयोग होता है।

x = '4'
y = '2'संचालित द्वारा

x + yसंचालित द्वारा

'42'संचालित द्वारा

Python में स्ट्रिंग्स को मैनिपुलेट करने के लिए कई बिल्ट-इन मेथड्स या हेल्पर फ़ंक्शंस हैं। किसी सबस्ट्रिंग को बदलना, किसी पैराग्राफ़ में कुछ शब्दों को कैपिटलाइज़ करना, किसी स्ट्रिंग के भीतर दूसरी स्ट्रिंग की पोजीशन खोजना—ये कुछ आम स्ट्रिंग मैनिपुलेशंस हैं। इनमें से कुछ पर नज़र डालें:

स्ट्रिंग्स को कैपिटलाइज़ करें

str.capitalize('cookie')

'Cookie'संचालित द्वारा

किसी स्ट्रिंग की लंबाई कैरेक्टर्स में प्राप्त करें। ध्यान दें कि स्पेसेस भी अंतिम परिणाम में गिने जाते हैं:

str1 = "Cake 4 U"
str2 = "404"
len(str1)
संचालित द्वारा

8
संचालित द्वारा

जांचें कि क्या कोई स्ट्रिंग केवल अंकों से बनी है

str1.isdigit()
संचालित द्वारा

False
संचालित द्वारा

str2.isdigit()
संचालित द्वारा

True
संचालित द्वारा

स्ट्रिंग्स के हिस्सों को अन्य स्ट्रिंग्स से बदलें

str1.replace('4 U', str2)
संचालित द्वारा

'Cake 404'
संचालित द्वारा

अन्य स्ट्रिंग्स में सबस्ट्रिंग्स खोजें; वह स्ट्रिंग के भीतर सबसे कम इंडेक्स या पोजीशन लौटाता है जहां सबस्ट्रिंग मिलती है:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)
संचालित द्वारा

0
संचालित द्वारा

सबस्ट्रिंग

'cook'

की खोज

'cookie'

की शुरुआत में होती है। नतीजतन, आप उस पोजीशन का संदर्भ देते हैं

'cookie'

के भीतर जहां आपको वह सबस्ट्रिंग मिलती है। इस मामले में,

0

लौटाया जाता है क्योंकि आप पोजीशन्स की गिनती 0 से शुरू करते हैं!

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)
संचालित द्वारा

12
संचालित द्वारा

इसी तरह, सबस्ट्रिंग

'cook'

की खोज

'I got you a cookie'

में पोजीशन 12 पर होती है। याद रखें कि आप 0 से गिनना शुरू करते हैं और स्पेसेस भी पोजीशन्स में गिने जाते हैं!

Python में स्ट्रिंग मेथड्स की एक विस्तृत सूची आपको यहाँ मिल सकती है।

Boolean

यह बिल्ट-इन डेटा टाइप मान True और False ले सकता है, जो अक्सर 1 और 0 इंटीजर्स के साथ अदला-बदली योग्य बनाते हैं। बूलियन्स कंडीशनल और तुलना अभिव्यक्तियों में उपयोगी होते हैं, ठीक निम्नलिखित उदाहरणों की तरह:

x = 4
y = 2
x == y
संचालित द्वारा

False
संचालित द्वारा

x > y
संचालित द्वारा

True
संचालित द्वारा

x = 4
y = 2
z = (x==y) # Comparison expression (Evaluates to false)
if z: # Conditional on truth/false value of 'z'
    print("Cookie")
else: print("No Cookie")
संचालित द्वारा

No Cookie
संचालित द्वारा

डेटा टाइप कन्वर्ज़न

कभी-कभी, आप खुद को किसी और के कोड पर काम करते हुए पाएंगे, और आपको, उदाहरण के लिए, किसी integer को float में या इसके विपरीत कन्वर्ट करना होगा। या हो सकता है कि आपको पता चले कि आप integer का उपयोग कर रहे थे जबकि वास्तव में आपको float की आवश्यकता थी। ऐसे मामलों में, आप वैरिएबल्स के डेटा टाइप को बदल सकते हैं!

Python में किसी ऑब्जेक्ट का टाइप जांचने के लिए, बिल्ट-इन type() फ़ंक्शन का उपयोग करें, ठीक नीचे दी गई लाइनों की तरह:

i = 4.0
type(i)
संचालित द्वारा

float
संचालित द्वारा

जब आप किसी एंटिटी के प्रकार को एक डेटा टाइप से दूसरे में बदलते हैं, तो इसे "टाइपकास्टिंग" कहा जाता है। दो तरह के डेटा कन्वर्ज़न संभव हो सकते हैं: इनप्लिसिट जिसे कॉएर्सन कहा जाता है और एक्सप्लिसिट, जिसे अक्सर कास्टिंग कहा जाता है।

इनप्लिसिट डेटा टाइप कन्वर्ज़न

यह एक स्वचालित डेटा कन्वर्ज़न है, और कम्पाइलर इसे आपके लिए संभालता है। निम्नलिखित उदाहरण देखें:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)
संचालित द्वारा

float
संचालित द्वारा

ऊपर के उदाहरण में, आपको float वैल्यू डिविजन करने के लिए y के डेटा टाइप को स्पष्ट रूप से बदलने की आवश्यकता नहीं थी। कम्पाइलर ने इसे आपके लिए इनप्लिसिटली किया।

यह आसान है!

एक्सप्लिसिट डेटा टाइप कन्वर्ज़न

इस प्रकार का डेटा टाइप कन्वर्ज़न उपयोगकर्ता-परिभाषित होता है, यानी आपको कम्पाइलर को स्पष्ट रूप से बताना होगा कि कुछ एंटिटीज़ के डेटा टाइप को बदलना है। इसे पूरी तरह समझने के लिए नीचे दिए कोड चंक पर विचार करें:

x = 2
y = "The Godfather: Part "
fav_movie = y + x
संचालित द्वारा

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

TypeError                                 Traceback (most recent call last)

<ipython-input-51-b8fe90df9e0e> in <module>()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly
संचालित द्वारा

उपरोक्त उदाहरण ने आपको एक त्रुटि दी क्योंकि कम्पाइलर यह नहीं समझता कि आप मिश्रित डेटा टाइप्स के कारण संयोजन या जोड़ करने की कोशिश कर रहे हैं। आप एक integer और एक string को एक साथ जोड़ने की कोशिश कर रहे हैं।

यह स्पष्ट बेमेल है।

इसे हल करने के लिए, आपको पहले int को string में कन्वर्ट करना होगा ताकि आप संयोजन कर सकें।

नोट कि हमेशा एक डेटा टाइप को दूसरे में कन्वर्ट करना संभव नहीं होता। कुछ बिल्ट-इन डेटा कन्वर्ज़न फ़ंक्शंस जिन्हें आप यहां उपयोग कर सकते हैं: int(), float(), और str()।

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)
संचालित द्वारा

The Godfather: Part 2
संचालित द्वारा

नॉन-प्रिमिटिव डेटा स्ट्रक्चर्स

नॉन-प्रिमिटिव प्रकार डेटा स्ट्रक्चर परिवार के उन्नत सदस्य हैं। ये केवल एक मान स्टोर नहीं करते, बल्कि विभिन्न फ़ॉर्मैट्स में मानों का एक संग्रह स्टोर करते हैं।

पारंपरिक कंप्यूटर विज्ञान की दुनिया में, नॉन-प्रिमिटिव डेटा स्ट्रक्चर्स को इस प्रकार विभाजित किया जाता है:

• Arrays
• Lists
• Files

Array

सबसे पहले, Python में एरेज़ बेसिक डेटा टाइप्स को इकट्ठा करने का एक कॉम्पैक्ट तरीका हैं, एरे में सभी एंट्रीज़ का डेटा टाइप एक जैसा होना चाहिए। हालांकि, C++ या Java जैसी अन्य भाषाओं के विपरीत, Python में एरेज़ इतने लोकप्रिय नहीं हैं।

आम तौर पर, जब लोग Python में एरेज़ की बात करते हैं, तो वे वास्तव में लिस्ट्स का संदर्भ देते हैं। हालांकि, इनके बीच एक मौलिक अंतर है, और आप इसे थोड़ी देर में देखेंगे। Python के लिए, एरेज़ एक निश्चित प्रकार की लिस्ट को स्टोर करने का अधिक कुशल तरीका माना जा सकता है। हालांकि, इस प्रकार की लिस्ट में एक ही डेटा टाइप के एलिमेंट्स होते हैं।

Python में, एरेज़ array मॉड्यूल द्वारा समर्थित हैं और उन्हें इनिशियलाइज़ और उपयोग करने से पहले इम्पोर्ट करना आवश्यक है। एरे में स्टोर किए गए एलिमेंट्स उनके डेटा टाइप में बाधित होते हैं। डेटा टाइप एरे क्रिएशन के समय निर्दिष्ट किया जाता है और टाइप कोड का उपयोग करके निर्दिष्ट किया जाता है, जो एक सिंगल कैरेक्टर होता है, जैसे कि नीचे दिए उदाहरण में आप I देखते हैं:

import array as arr
a = arr.array("I",[3,6,9])
type(a)
संचालित द्वारा

array.array
संचालित द्वारा

Python Array डाक्यूमेंटेशन पेज array मॉड्यूल द्वारा उपलब्ध विभिन्न टाइप कोड्स और फ़ंक्शनैलिटीज़ के बारे में अधिक जानकारी प्रदान करता है।

List

Python में लिस्ट्स का उपयोग विषम (heterogeneous) आइटम्स के कलेक्शन को स्टोर करने के लिए किया जाता है। ये म्यूटेबल होती हैं, यानी आप उनकी पहचान बदले बिना उनकी सामग्री बदल सकते हैं। आप लिस्ट्स को उनके स्क्वेयर ब्रैकेट्स [ और ] से पहचानते हैं, जो कॉमा , से अलग किए एलिमेंट्स को होल्ड करते हैं। लिस्ट्स Python में बिल्ट-इन हैं: आपको उन्हें अलग से इनवोक करने की आवश्यकता नहीं है।

x = [] # Empty list
type(x)
संचालित द्वारा

list
संचालित द्वारा

x1 = [1,2,3]
type(x1)
संचालित द्वारा

list
संचालित द्वारा

x2 = list([1,'apple',3])
type(x2)
संचालित द्वारा

list
संचालित द्वारा

print(x2[1])
संचालित द्वारा

apple
संचालित द्वारा

x2[1] = 'orange'
print(x2)
संचालित द्वारा

[1, 'orange', 3]
संचालित द्वारा

नोट: जैसा कि आपने ऊपर x1 के उदाहरण में देखा, लिस्ट्स एकरूप (homogeneous) आइटम्स भी होल्ड कर सकती हैं और इस प्रकार एरे की स्टोरेज फ़ंक्शनैलिटी को संतुष्ट करती हैं। यह तब तक ठीक है जब तक कि आप इस कलेक्शन पर कुछ विशिष्ट ऑपरेशंस लागू करना न चाहें।

Python लिस्ट्स को मैनिपुलेट करने और उनके साथ काम करने के लिए कई मेथड्स प्रदान करता है। किसी लिस्ट में नए आइटम जोड़ना, किसी लिस्ट से कुछ आइटम हटाना, और किसी लिस्ट को sort या reverse करना सामान्य लिस्ट मैनिपुलेशंस हैं। आइए उनमें से कुछ को क्रिया में देखें:

• append() के साथ list_num लिस्ट में 11 जोड़ें। डिफ़ॉल्ट रूप से, यह संख्या लिस्ट के अंत में जोड़ी जाएगी।

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)
संचालित द्वारा

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]
संचालित द्वारा

• insert() का उपयोग करके list_num लिस्ट में इंडेक्स या पोजीशन 0 पर 11 जोड़ें

list_num.insert(0, 11)
print(list_num)
संचालित द्वारा

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]
संचालित द्वारा

• remove() की मदद से list_char से 'o' की पहली उपस्थिति हटाएँ

list_char.remove('o') 
print(list_char)
संचालित द्वारा

['c', 'o', 'k', 'i', 'e']
संचालित द्वारा

• list_char से इंडेक्स -2 पर मौजूद आइटम हटाएँ

list_char.pop(-2) # Removes the item at the specified position
print(list_char)
संचालित द्वारा

['c', 'o', 'k', 'e']
संचालित द्वारा

list_num.sort() # In-place sorting
print(list_num)
संचालित द्वारा

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]
संचालित द्वारा

list.reverse(list_num)
print(list_num)
संचालित द्वारा

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]
संचालित द्वारा

यदि आप Python लिस्ट्स के बारे में और जानना चाहते हैं, तो आप आसानी से 18 Most Common Python List Questions ट्यूटोरियल पढ़ सकते हैं!

एरे बनाम लिस्ट्स

अब जब आपने Python में लिस्ट्स देख ली हैं, तो आप सोच रहे होंगे कि फिर एरेज़ की क्या ज़रूरत है। कारण यह है कि वे उन ऑपरेशंस के संदर्भ में मौलिक रूप से अलग हैं जो उन पर किए जा सकते हैं। एरेज़ के साथ, आप उसके सभी आइटम्स पर आसानी से ऑपरेशन कर सकते हैं, जो लिस्ट्स के साथ हमेशा संभव नहीं होता। यहाँ एक उदाहरण है:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)
संचालित द्वारा

array('u', 'cats')
संचालित द्वारा

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

जब हम एरेज़ की बात कर रहे हैं, तो NumPy एरे का उल्लेख करना भी सार्थक है। मल्टीडायमेंशनल एरेज़ के साथ काम करने के लिए डेटा साइंस की दुनिया में NumPy एरेज़ का बहुत अधिक उपयोग होता है। वे सामान्य तौर पर array मॉड्यूल और Python लिस्ट्स की तुलना में अधिक कुशल हैं। NumPy एरे में एलिमेंट्स को पढ़ना और लिखना तेज़ है, और वे "वेक्टराइज़्ड" ऑपरेशंस जैसे एलिमेंट-वाइज़ ऐडिशन को सपोर्ट करते हैं। साथ ही, NumPy एरेज़ बड़े sparse डेटासेट्स के साथ कुशलता से काम करते हैं। अधिक जानने के लिए, DataCamp का Python Numpy Array Tutorial देखें।

यहाँ NumPy एरे शुरू करने के लिए कुछ कोड है:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)
संचालित द्वारा

[ 1.  2.  3.]
संचालित द्वारा

arr_ones = np.ones(4)
print(arr_ones)
संचालित द्वारा

[ 1.  1.  1.  1.]
संचालित द्वारा

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)
संचालित द्वारा

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]
संचालित द्वारा

पारंपरिक रूप से, लिस्ट डेटा स्ट्रक्चर को आगे रैखिक (linear) और गैर-रैखिक (non-linear) डेटा स्ट्रक्चर्स में वर्गीकृत किया जा सकता है। Stacks और Queues को "रैखिक डेटा स्ट्रक्चर्स" कहा जाता है, जबकि Graphs और Trees "गैर-रैखिक डेटा स्ट्रक्चर्स" हैं। ये स्ट्रक्चर्स और उनके कॉन्सेप्ट्स अपेक्षाकृत जटिल हो सकते हैं लेकिन वास्तविक दुनिया के मॉडलों से उनकी समानता के कारण व्यापक रूप से उपयोग किए जाते हैं। आपको इस ट्यूटोरियल में इन विषयों की एक झलक मिलेगी।

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

Stacks

स्टैक ऑब्जेक्ट्स का एक कंटेनर है जिसमें ऑब्जेक्ट्स को Last-In-First-Out (LIFO) कॉन्सेप्ट के अनुसार डाला और हटाया जाता है। डिनर पार्टी के एक परिदृश्य की कल्पना करें जहां प्लेटों का एक ढेर है—प्लेटें हमेशा ढेर के ऊपर से जोड़ी या हटाई जाती हैं। कंप्यूटर विज्ञान में, इस कॉन्सेप्ट का उपयोग अभिव्यक्तियों का मूल्यांकन और सिंटैक्स पार्सिंग, शेड्यूलिंग एल्गोरिद्म/रूटीन आदि में किया जाता है।

Python में स्टैक्स को लिस्ट्स का उपयोग करके इम्प्लीमेंट किया जा सकता है। जब आप किसी स्टैक में एलिमेंट्स जोड़ते हैं, तो इसे push ऑपरेशन कहा जाता है, जबकि जब आप किसी एलिमेंट को हटाते या डिलीट करते हैं तो इसे pop ऑपरेशन कहा जाता है। नोट कि Python में स्टैक्स के साथ काम करते समय आपके पास pop() मेथड उपलब्ध होता है:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)
संचालित द्वारा

[1, 2, 3, 4, 5, 6]
संचालित द्वारा

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)
संचालित द्वारा

[1, 2, 3, 4]
संचालित द्वारा

Queue

क्यू ऑब्जेक्ट्स का एक कंटेनर है जिसमें ऑब्जेक्ट्स को First-In-First-Out (FIFO) सिद्धांत के अनुसार डाला और हटाया जाता है। वास्तविक दुनिया में क्यू का एक बढ़िया उदाहरण टिकट काउंटर पर लगी कतार है जहां लोगों को उनके आगमन क्रम के अनुसार सेवा दी जाती है, और इसलिए जो व्यक्ति पहले आता है वही पहले जाता है। क्यूज़ कई अलग-अलग प्रकार की हो सकती हैं।

क्यू को इम्प्लीमेंट करने के लिए लिस्ट्स कुशल नहीं हैं, क्योंकि किसी लिस्ट के अंत से append() और pop() तेज़ नहीं है और इससे मेमोरी मूवमेंट लागत आती है। साथ ही, अंत में इन्सर्शन और शुरुआत से डिलीशन इतना तेज़ नहीं है क्योंकि इसमें एलिमेंट पोजीशन्स में शिफ्ट की आवश्यकता होती है।

Graphs

गणित और कंप्यूटर विज्ञान में एक ग्राफ़ नोड्स से बने नेटवर्क होते हैं, जिन्हें वर्टिसेस भी कहा जाता है, जो एक-दूसरे से जुड़े हो भी सकते हैं और नहीं भी। जो रेखाएं या पथ दो नोड्स को जोड़ते हैं उन्हें एज कहा जाता है। यदि एज का कोई विशेष दिशा प्रवाह है, तो यह निर्देशित ग्राफ़ होता है, जिसमें दिशा एज को आर्क कहा जाता है। अन्यथा, यदि कोई दिशा निर्दिष्ट नहीं है, तो ग्राफ़ अनडायरेक्टेड कहलाता है।

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

यहाँ, आपको शुरू करने में मदद के लिए Python Dictionary का उपयोग करके एक सरल ग्राफ़ इम्प्लीमेंटेशन मिलेगा:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))
संचालित द्वारा

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]
संचालित द्वारा

आप ग्राफ़्स के साथ कुछ बढ़िया चीजें कर सकते हैं, जैसे यह खोजना कि क्या दो नोड्स के बीच कोई पथ मौजूद है या दो नोड्स के बीच सबसे छोटा पथ खोजना, ग्राफ़ में साइकिल्स का निर्धारण करना।

प्रसिद्ध "ट्रैवलिंग सेल्समैन समस्या" वास्तव में उस सबसे छोटे संभव मार्ग को खोजने के बारे में है जो हर नोड पर ठीक एक बार जाता है और शुरुआती बिंदु पर वापस आता है। कभी-कभी ग्राफ़ के नोड्स या आर्क्स को वेट्स या कॉस्ट्स दिए गए होते हैं, आप इसे चलने में कठिनाई स्तर निर्दिष्ट करने के रूप में सोच सकते हैं, और आप सबसे सस्ता या सबसे आसान पथ खोजने में रुचि रखते हैं।

Trees

वास्तविक दुनिया में एक पेड़ एक जीवित प्राणी है जिसकी जड़ें जमीन में होती हैं और शाखाएँ पत्तियों और फलों को थामे रहती हैं। पेड़ की शाखाएँ कुछ हद तक व्यवस्थित तरीके से फैलती हैं। कंप्यूटर विज्ञान में, पेड़ों का उपयोग यह बताने के लिए किया जाता है कि डेटा कभी-कभी कैसे व्यवस्थित होता है, बस इतना अंतर है कि जड़ ऊपर होती है और शाखाएँ, पत्तियाँ नीचे की ओर फैलती हैं और पेड़ वास्तविक पेड़ की तुलना में उल्टा खींचा जाता है।

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

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

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

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)
संचालित द्वारा

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None
संचालित द्वारा

आपने एरेज़ के बारे में सीखा और लिस्ट डेटा स्ट्रक्चर भी देखा। हालांकि, Python डेटा कलेक्शन के कई अलग-अलग प्रकार के मैकेनिज़्म प्रदान करता है, और भले ही वे कंप्यूटर विज्ञान में पारंपरिक डेटा स्ट्रक्चर विषयों में शामिल न हों, वे जानने योग्य हैं, खासकर Python प्रोग्रामिंग भाषा के संदर्भ में:

• Tuples
• Dictionary
• Sets

Tuples

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

आइए देखें कि ट्यूपल्स कैसे इम्प्लीमेंट किए जाते हैं:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]
संचालित द्वारा

1
संचालित द्वारा

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple
संचालित द्वारा

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

TypeError                                 Traceback (most recent call last)

<ipython-input-74-b5d6da8c1297> in <module>()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment
संचालित द्वारा

Dictionary

यदि आप कुछ ऐसा इम्प्लीमेंट करना चाहते हैं जो टेलीफोन बुक के समान हो, तो डायक्सनरीज़ बिल्कुल वही हैं जिसकी आपको आवश्यकता है। आपने जो डेटा स्ट्रक्चर्स पहले देखे हैं, उनमें से कोई भी टेलीफोन बुक के लिए उपयुक्त नहीं है।

यहीं पर डायक्सनरी काम आती है। डायक्सनरीज़ key-value जोड़ों से बनी होती हैं। key का उपयोग आइटम की पहचान करने के लिए किया जाता है और value नाम के अनुसार, आइटम का मान रखता है।

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict
संचालित द्वारा

{'Edward': 1, 'Jorge': 2, 'Prem': 3}
संचालित द्वारा

x_dict['Edward'] # Prints the value stored with the key 'Edward'.
संचालित द्वारा

1
संचालित द्वारा

आप डायक्सनरीज़ पर कई अन्य इनबिल्ट फ़ंक्शनैलिटीज़ लागू कर सकते हैं:

len(x_dict)
संचालित द्वारा

3
संचालित द्वारा

x_dict.keys()
संचालित द्वारा

dict_keys(['Prem', 'Edward', 'Jorge'])
संचालित द्वारा

x_dict.values()
संचालित द्वारा

dict_values([3, 1, 2])

यह कोड key-value जोड़ों को स्टोर और एक्सेस करने के लिए Python डायक्सनरी का उपयोग करने का एक उदाहरण दिखाता है।

पहले, कोड x_dict को आर्ग्युमेंट के रूप में लेकर len() फ़ंक्शन कॉल करता है। यह डायक्सनरी में key-value जोड़ों की संख्या लौटाता है, जो 3 है।

अगला, कोड x_dict पर keys() मेथड कॉल करता है। यह डायक्सनरी में मौजूद कीज़ वाला एक व्यू ऑब्जेक्ट लौटाता है। इस मामले में, कीज़ 'Prem', 'Edward' और 'Jorge' हैं, जैसा कि आउटपुट में दिखाया गया है।

फिर, कोड x_dict पर values() मेथड कॉल करता है। यह डायक्सनरी में मौजूद वैल्यूज़ वाला एक व्यू ऑब्जेक्ट लौटाता है। इस मामले में, वैल्यूज़ क्रमशः 3, 1 और 2 हैं, जैसा कि आउटपुट में दिखाया गया है।

Sets

सेट्स विशिष्ट (यूनिक) ऑब्जेक्ट्स का कलेक्शन हैं। ये ऐसे लिस्ट्स बनाने में उपयोगी हैं जो डाटासेट में केवल यूनिक वैल्यूज़ रखती हैं। यह एक अनऑर्डर्ड कलेक्शन है लेकिन म्यूटेबल है, जो बड़े डाटासेट से गुजरते समय बहुत सहायक होता है।

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)
संचालित द्वारा

{'A', '&', 'O', 'E', 'C', 'K'}
संचालित द्वारा

print(y_set) # Single unique 'o'
संचालित द्वारा

{'I', 'O', 'E', 'C', 'K'}
संचालित द्वारा

print(x - y) # All the elements in x_set but not in y_set
संचालित द्वारा

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

NameError                                 Traceback (most recent call last)

<ipython-input-3-31abf5d98454> in <module>()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined
संचालित द्वारा

print(x_set|y_set) # Unique elements in x_set or y_set or both
संचालित द्वारा

{'C', '&', 'E', 'A', 'O', 'K', 'I'}
संचालित द्वारा

print(x_set & y_set) # Elements in both x_set and y_set
संचालित द्वारा

{'O', 'E', 'K', 'C'}

कोड दो सेट बनाता है: x_set और y_set। प्रत्येक सेट को set() फ़ंक्शन को कैरेक्टर्स की स्ट्रिंग पास करके बनाया जाता है। इस मामले में, x_set स्ट्रिंग 'CAKE&COKE' से बनाया जाता है, जबकि y_set स्ट्रिंग 'COOKIE' से बनाया जाता है।

इसके बाद, कोड print() फ़ंक्शन का उपयोग करके प्रत्येक सेट को प्रिंट करता है। पहला print() स्टेटमेंट x_set को प्रिंट करता है, जिसमें स्ट्रिंग 'CAKE&COKE' के यूनिक कैरेक्टर्स होते हैं। आउटपुट दिखाता है कि x_set में 'A', '&', 'O', 'E', 'C' और 'K' कैरेक्टर्स होते हैं। इसी तरह, दूसरा print() स्टेटमेंट y_set को प्रिंट करता है, जिसमें स्ट्रिंग 'COOKIE' के यूनिक कैरेक्टर्स होते हैं। आउटपुट दिखाता है कि y_set में 'I', 'O', 'E', 'C' और 'K' कैरेक्टर्स होते हैं।

तीसरा print() स्टेटमेंट x_set में मौजूद लेकिन y_set में न मौजूद सभी एलिमेंट्स का सेट प्रिंट करने का प्रयास करता है। हालांकि, यह कोड लाइन NameError का परिणाम देती है क्योंकि वैरिएबल x परिभाषित नहीं किया गया है। संभवतः, यह लाइन print(x_set - y_set) होनी चाहिए।

चौथा print() स्टेटमेंट x_set या y_set या दोनों में मौजूद यूनिक एलिमेंट्स का सेट प्रिंट करता है। आउटपुट दिखाता है कि परिणामी सेट में x_set और y_set दोनों के सभी यूनिक कैरेक्टर्स शामिल हैं।

अंत में, पाँचवाँ print() स्टेटमेंट उन एलिमेंट्स का सेट प्रिंट करता है जो दोनों x_set और y_set में हैं। आउटपुट दिखाता है कि इस सेट में 'O', 'E', 'K' और 'C' कैरेक्टर्स होते हैं।

Files

फाइल्स पारंपरिक रूप से डेटा स्ट्रक्चर्स का हिस्सा हैं। और यद्यपि डेटा साइंस उद्योग में बिग डेटा आम बात है, फिर भी कोई प्रोग्रामिंग भाषा जो पहले से स्टोर की गई जानकारी को स्टोर और पुनः प्राप्‍त करने में सक्षम न हो, शायद ही उपयोगी होगी। आपको अब भी डेटाबेस में फैली फाइल्स में बैठे सारे डेटा का उपयोग करना पड़ता है और आप सीखेंगे कि यह कैसे करना है।

Python में फाइल्स को पढ़ने और लिखने का सिंटैक्स अन्य प्रोग्रामिंग भाषाओं के समान है, लेकिन हैंडल करना कहीं आसान है। यहाँ कुछ बुनियादी फ़ंक्शंस हैं जो Python का उपयोग करके फाइल्स के साथ काम करने में आपकी मदद करेंगे:

• open() आपके सिस्टम में फाइल्स खोलने के लिए, filename वह फाइल का नाम है जिसे खोला जाना है;

• read() पूरी फाइल पढ़ने के लिए;

• readline() एक समय में एक लाइन पढ़ने के लिए;

• write() किसी स्ट्रिंग को फाइल में लिखने और लिखे गए कैरेक्टर्स की संख्या लौटाने के लिए; और

• close() फाइल को बंद करने के लिए।

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()
संचालित द्वारा

open() फ़ंक्शन में दूसरा आर्ग्युमेंट फाइल मोड है। यह आपको यह निर्दिष्ट करने की अनुमति देता है कि आप पढ़ना (r), लिखना (w), जोड़ना (a) या दोनों पढ़ना और लिखना (r+) चाहते हैं।

Python में फाइल हैंडलिंग के बारे में और जानने के लिए, सुनिश्चित करें कि आप इस पेज को देखें।

निष्कर्ष

इस ट्यूटोरियल के अंत तक पहुँचने पर बधाई! यह आपको डेटा साइंस की दुनिया पर विजय पाने के अपने सपनों के एक विषय और करीब ले आता है।

यदि आपकी रुचि हो, तो हमारा दो-भाग वाला Python Data Science Toolbox functions, iterators, lists, आदि में और गहराई से जाता है।