(पायथन) सरणियाँ। मूल बातें

डेटा स्टोरेज

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

सूचियां (सरणी)

बड़ी मात्रा में डेटा के साथ काम करना सुविधाजनक बनाने के लिए, कोशिकाओं के एक समूह को एक सामान्य नाम दिया जाता है। कोशिकाओं के ऐसे समूह को सरणी कहा जाता है।
 
सरणियों के साथ काम करते समय, आपको जानना होगा कि कैसे हल करना है तीन कार्य:
एक्स सरणी के लिए आवश्यक आकार की मेमोरी आवंटित करें;
एक्स वांछित सेल में डेटा लिखें;
एक्स एक सेल से डेटा पढ़ें।

 

पायथन में ऐरे

पायथन में ऐसी कोई सरणियाँ नहीं हैं। इसके बजाय, सूचियों का उपयोग एक ही प्रकार की वस्तुओं के समूह को संग्रहीत करने के लिए किया जाता है (लेकिन केवल एक ही प्रकार के नहीं) - सूची प्रकार की वस्तुओं। सूचियों और सरणियों के बीच का अंतर यह है कि एक सूची एक गतिशील संरचना है, जिसका आकार स्मृति प्रबंधन संचालन के बारे में सोचे बिना प्रोग्राम निष्पादन (हटाना, तत्वों को जोड़ना) के दौरान बदला जा सकता है (यह संकलक द्वारा किया जाता है)।
भविष्य में, सूचियों के साथ काम का विश्लेषण करते समय, हम "सरणी" शब्द का उपयोग करेंगे, क्योंकि अक्सर सूचियों का उपयोग सरणी की भूमिका में सटीक रूप से किया जाता है (वे उसी प्रकार के डेटा को संग्रहीत करते हैं)।
 

एक सरणी बनाना

जब एक सरणी बनाई जाती है, तो स्मृति में स्थान आवंटित किया जाता है (कोशिकाओं की एक निश्चित संख्या)। 1) सरणियों को केवल तत्वों की गणना करके बनाया जा सकता है: ए = [1, 4, 7, 12, 5] प्रिंट (प्रकार (ए)) प्रोग्राम आउटपुट करेगा
<कक्षा 'सूची'>
अर्थात, एक सरणी प्रकार सूची (अंग्रेज़ी सूची से अनुवादित) का एक ऑब्जेक्ट है।

2) सारणियों को किसी भी प्रकार के डेटा से बनाया जा सकता है - पूर्णांक या वास्तविक संख्याएं, वर्ण स्ट्रिंग  ए = ["वस्या", "पेट्या", "फेड्या"]

सरणियों के साथ काम करने के कुछ तरीके

3) सारणियों को "जोड़ा" जा सकता है। ए = [1, 5] + [25, 7]
4) समान सरणियों के जोड़ को गुणन से बदला जा सकता है। इसलिए समान मानों से भरी एक सरणी बनाना आसान है, जैसे: A = [0]*10 # ने 10 तत्वों की एक सरणी बनाई और इसे शून्य से भर दिया
5) एक सरणी हमेशा "जानती है" आपका आकार।  len() फ़ंक्शन का उपयोग सरणी के आकार को निर्धारित करने के लिए किया जाता है। अक्सर ऐरे के आकार को एक अलग वेरिएबल में स्टोर किया जाता है ताकि प्रोग्राम को एक अलग एरे आकार के साथ काम करने के लिए आसानी से बदला जा सके।

उदाहरण

N = 10 # सरणी के आकार को वेरिएबल N में स्टोर करें ए = [0] * एन # आकार एन की एक सरणी बनाएँ प्रिंट (लेन (ए)) # सरणी के आकार को प्रिंट करें एक सरणी का आकार कीबोर्ड से सेट किया जा सकता है।

सरणी तत्वों के साथ कार्य करना

सरणियों की अधिकांश उपयोगिता इस तथ्य से आती है कि इसके तत्वों को व्यक्तिगत रूप से एक्सेस किया जा सकता है।
ऐसा करने का तरीका तत्वों को क्रमांकित करने के लिए एक अनुक्रमणिका का उपयोग करना है।
 

किसी सरणी के किसी तत्व को संदर्भित करने के लिए, आपको वर्ग कोष्ठक में सरणी के नाम के बाद उसके सूचकांक को निर्दिष्ट करना होगा। उदाहरण के लिए, आप अनुक्रमणिका 1 पर सरणी तत्व में मान 100 इस तरह लिख सकते हैं: A[1] = 100।

आपको याद रखना होगा!

पायथन में क्रमांकन शून्य से शुरू होता है!
(यह एक पूर्वापेक्षा है - आपको बिल्कुल नए सिरे से शुरुआत करनी चाहिए। यह याद रखना विशेष रूप से महत्वपूर्ण है।)
 

उदाहरण

एक्स = (ए [3] + 5) * ए [1] # ए [3] और ए [1] के मान पढ़ें ए [0] = एक्स + 6 # ए [0] के लिए नया मान लिखें
आइए सरणी तत्वों के साथ काम करने के लिए कार्यक्रम का विश्लेषण करें। <पूर्व> मैं = 1 ए = [0] * 5 # 5 तत्वों की एक सरणी बनाएँ ए [0] = 23 # प्रत्येक 5 सरणी तत्वों में (इंडेक्स 0 से 4) ए [1] = 12 # एक विशिष्ट मूल्य लिखें ए [2] = 7 ए [3] = 43 ए [4] = 51 A[2] = A[i] + 2*A[i-1] + A[2*i] # अभिव्यक्ति के परिणाम के लिए सूचकांक 2 के साथ तत्व का मान बदलें # चूंकि i = 1, फिर चर i के मान को अभिव्यक्ति में प्रतिस्थापित करना जो हमें मिलता है # निम्नलिखित अभिव्यक्ति ए [2] = ए [1] + 2 * ए [0] + ए [2]; प्रिंट (ए [2] + ए [4])
दौड़ने के परिणामस्वरूप इस कार्यक्रम में अनुक्रमणिका 2 के साथ सरणी के तत्वों के योग का मान और अनुक्रमणिका 4 के बराबर 116 स्क्रीन पर दिखाई देगा। जैसा कि आप उदाहरण से देख सकते हैं, हम सरणी के किसी भी तत्व तक पहुंच सकते हैं . और विभिन्न फ़ार्मुलों का उपयोग करके आवश्यक तत्व संख्या की गणना भी करें (उदाहरण के लिए, जैसा कि प्रोग्राम A[i-1] या A[2*i]) में है। इन मामलों में, तत्वों की अनुक्रमणिका की गणना की जाएगी और i के मान पर निर्भर करेगी।

पायथन में, आप सरणियों के लिए नकारात्मक सूचकांक मानों का उपयोग कर सकते हैं और सरणी के अंत से गिनती कर सकते हैं। उदाहरण के लिए: A[-1] - सरणी का अंतिम तत्व A[-2] - अंतिम तत्व आदि

आइए कार्यक्रम का विश्लेषण करें। एन = 5 ए = [0] * एन  एक्स = 1 प्रिंट (ए [एक्स - 3])   # ऐक्सेसिंग एलिमेंट ए [-2] प्रिंट (ए [एक्स - 3 + लेन (ए)]) # एक्सेस एलिमेंट ए [3]                       # यह वही तत्व है जो  ए[-2] A[x + 4] = A[x] + A[2 * (x + 1)]  # एक्सप्रेशन और गणना में x को प्रतिस्थापित करने के बाद                            # अगली पंक्ति प्राप्त करें A[5] = A[1] + A[4]                           # ए [5] ऐसा कोई तत्व मौजूद नहीं है                           # त्रुटि - सीमा सीमा से बाहर चूंकि सरणी को 5 तत्वों के साथ घोषित किया गया है, इसलिए तत्वों को -5 से 4 तक क्रमांकित किया जाएगा। हम देखते हैं कि छठी पंक्ति में प्रोग्राम एक गैर-मौजूद तत्व को संदर्भित करता है: A[5]।
यह पता चला है कि कार्यक्रम सरणी की सीमा से परे चला गया है।
 

सरणी तत्वों पर पुनरावृति

सरणियों के साथ काम करते समय, आपको आमतौर पर सरणी के सभी तत्वों के साथ एक साथ काम करना पड़ता है।
 
इसके लिए, एक चर के साथ एक लूप का सबसे अधिक उपयोग किया जाता है, जो 0 से N-1 में बदलता है, जहां N सरणी की संख्या है तत्व।
N के अंतर्गत हम सरणी के वर्तमान आकार पर विचार करेंगे, अर्थात  N = len(A)। ... मैं सीमा में (एन) के लिए: # यहां हम ए [i] के साथ काम करते हैं ... निर्दिष्ट लूप में, वेरिएबल i मान 0, 1, 2, ..., N-1 लेगा।  इस प्रकार, लूप के प्रत्येक चरण में, हम संख्या i के साथ सरणी के एक विशिष्ट तत्व तक पहुंचते हैं।
इस प्रकार, यह वर्णन करने के लिए पर्याप्त है कि A[i] सरणी के एक तत्व के साथ क्या किया जाना चाहिए और इन क्रियाओं को ऐसे लूप के अंदर रखें।

आइए एक प्रोग्राम लिखते हैं जो सरणी को पहले N प्राकृतिक संख्याओं से भरता है, यानी प्रोग्राम के अंत में, सरणी के तत्व बराबर हो जाने चाहिए ए [0] = 1 ए [1] = 2 ए [2] = 3 ... ए[एन - 1] = एन पैटर्न को देखना आसान है: किसी सरणी तत्व का मान तत्व के सूचकांक से 1 अधिक होना चाहिए।

लूप इस तरह दिखेगा मैं सीमा में (एन) के लिए: ए [i] = आई + 1

सूची जनरेटर

पायथन भाषा आपको कई समस्याओं को संक्षिप्त और विश्वसनीय रूप से हल करने की अनुमति देती है। आइए सरणी भरने की मुख्य संभावनाओं को सूचीबद्ध करते हैं। 1) एक सरणी बनाना और भरना इस तरह लिखा जा सकता है: A = [i for i in range(N)] # with N = 5, array A = [0,1,2,3,4] A = [i*i for i in range(N)] # N = 5 के साथ, array A = [0,1,4,9,16] for i in range(N) - सभी i मानों को 0 से N-1 तक लूप करता है।

सरणी के अगले तत्व में वह मान होगा जो for शब्द से पहले आता है, पहले मामले में i, दूसरे में - i*i >।

हम निम्नलिखित संकेतन का उपयोग करके समान परिणाम प्राप्त करते हैं: <पूर्व> ए = सूची (श्रेणी (एन)) # एन = 5 के साथ, सरणी ए = [0,1,2,3,4]
2) आप सरणी में सभी मान नहीं लिख सकते हैं, लेकिन केवल वे जो एक निश्चित शर्त को पूरा करते हैं।
 

उदाहरण

सरणी को 0 से 9 की श्रेणी में सभी सम संख्याओं से भरना। ए = [मैं रेंज में मैं के लिए (10) अगर मैं% 2 == 0] प्रिंट (* ए) # सरणी ए = [0,2,4,6,8] इस मामले में, आपको यह समझने की आवश्यकता है कि सरणी की लंबाई 10 से कम होगी। 

3) कीबोर्ड से एक ऐरे को ऐसे तत्वों से भरना जो प्रति पंक्ति एक स्थित हैं, दो तरीकों से किया जा सकता है।
  <तालिका संरेखण = "केंद्र" सीमा = "1" सेलपैडिंग = "1" सेलस्पेसिंग = "1" शैली = "चौड़ाई: 85%"> <शरीर>