पायथन में फ़िक्स आकार सूची कैसे बनाएं?

Question

सी ++ में, मैं एक सरणी की तरह बना सकते हैं ...

int* a = new int[10]; 

अजगर में

, मैं सिर्फ इतना पता है कि मैं एक सूची घोषित कर सकते हैं, की तुलना में कुछ आइटम जोड़ सकते हैं या जैसे ..

l = [1,2,3,4] 
l = range(10) 

क्या मैं किसी दिए गए आकार से एक सूची शुरू कर सकता हूं, जैसे सी ++, और कोई असाइनमेंट नहीं करता?

Answer 1

(tl; डॉ। अपने प्रश्न का सटीक उत्तर numpy.empty या numpy.empty_like है, लेकिन आप की संभावना परवाह नहीं करते हैं और myList = [None]*10000 उपयोग करने के साथ प्राप्त कर सकते हैं)

सरल तरीकों

आप अपनी सूची को सभी तत्वों में प्रारंभ कर सकते हैं। चाहे यह एक गैर-संख्यात्मक मान का उपयोग करने के लिए अर्थपूर्ण रूप से समझ में आता है (यदि आप इसका उपयोग करते हैं तो यह एक त्रुटि देगा, जो एक अच्छी बात है) या 0 की तरह कुछ (असामान्य? शायद उपयोगी अगर आप एक स्पैर मैट्रिक्स लिख रहे हैं या ' आप भी कर सकते हैं

>>> [None for _ in range(10)] 
[None, None, None, None, None, None, None, None, None, None] 

(यहाँ _ है सिर्फ एक चर नाम, आप i इस्तेमाल किया जा सकता था): डिफ़ॉल्ट 'मान 0 होना चाहिए और आप कीड़े के बारे में चिंतित नहीं हैं) आप पर निर्भर है। ऐसा करें:

>>> [None]*10 
[None, None, None, None, None, None, None, None, None, None] 

आप शायद डॉन इसे अनुकूलित करने की जरूरत नहीं है। सरल तरीके

कौन सा सबसे अच्छा है की

>>> x = [] 
>>> for i in range(10): 
>>> x.append(i) 

---

प्रदर्शन की तुलना: आप सरणी के लिए हर बार जब आप की जरूरत है जोड़ सकते हैं? python2.7 में

>>> def initAndWrite_test(): 
... x = [None]*10000 
... for i in range(10000): 
... x[i] = i 
... 
>>> def initAndWrite2_test(): 
... x = [None for _ in range(10000)] 
... for i in range(10000): 
... x[i] = i 
... 
>>> def appendWrite_test(): 
... x = [] 
... for i in range(10000): 
... x.append(i) 

परिणाम:

अजगर 3.2 में

>>> import timeit 
>>> for f in [initAndWrite_test, initAndWrite2_test, appendWrite_test]: 
... print('{} takes {} usec/loop'.format(f.__name__, timeit.timeit(f, number=1000)*1000)) 
... 
initAndWrite_test takes 714.596033096 usec/loop 
initAndWrite2_test takes 981.526136398 usec/loop 
appendWrite_test takes 908.597946167 usec/loop 

परिणाम:

initAndWrite_test takes 641.3581371307373 usec/loop 
initAndWrite2_test takes 1033.6499214172363 usec/loop 
appendWrite_test takes 895.9040641784668 usec/loop 

हम देख सकते हैं, यह संभावना बेहतर है दोनों को Python2 में मुहावरा [None]*10000 करने के लिए और python3।हालांकि, अगर कोई असाइनमेंट से कुछ अधिक जटिल कर रहा है (जैसे सूची में हर तत्व उत्पन्न करने या संसाधित करने के लिए जटिल कुछ भी), तो ओवरहेड लागत का अर्थहीन रूप से छोटा अंश बन जाता है। यही है, इस तरह के अनुकूलन के बारे में चिंता करने में समय नहीं है कि आप अपनी सूची के तत्वों के साथ कुछ भी उचित कर रहे हैं।

---

शुरू नहीं किए गए स्मृति

ये सभी तथापि अक्षम है क्योंकि वे स्मृति के माध्यम से जाना, इस प्रक्रिया में कुछ लिख रहे हैं। सी में यह अलग है: एक अनियमित सरणी यादृच्छिक कचरा स्मृति से भरा हुआ है (sidenote: जिसे सिस्टम से पुन: आवंटित किया गया है, और security risk हो सकता है जब आप प्रोग्राम को बंद करते समय स्मृति को मिटाने और/या विफल करने में विफल रहते हैं) । यह एक डिज़ाइन विकल्प है, जो स्पीडअप के लिए डिज़ाइन किया गया है: सी भाषा के निर्माताओं ने सोचा था कि स्मृति को स्वचालित रूप से प्रारंभ नहीं करना बेहतर था, और यह सही विकल्प था।

यह एसिम्प्टोटिक स्पीडअप नहीं है (क्योंकि यह O(N) है), लेकिन उदाहरण के लिए आपको पहले अपनी संपूर्ण मेमोरी ब्लॉक को प्रारंभ करने की आवश्यकता नहीं होगी, इससे पहले कि आप वास्तव में उन चीज़ों के साथ ओवरराइट करें। यह, यदि यह संभव था, तो कुछ (छद्म कोड) x = list(size=10000) के बराबर है।

यदि आप पाइथन में कुछ ऐसा चाहते हैं, तो आप numpy संख्यात्मक मैट्रिक्स/एन-आयामी-सरणी मैनिपुलेशन पैकेज का उपयोग कर सकते हैं। विशेष रूप से, numpy.empty या numpy.empty_like

यह आपके प्रश्न का वास्तविक उत्तर है।

Answer 2

यह इस तरह की सूचियों को शुरू करने के लिए वास्तव में पाइथन तरीका नहीं है। वैसे भी, आप इस तरह की एक सूची शुरू कर सकते हैं:

>>> l = [None] * 4 
>>> l 
[None, None, None, None] 

Answer 3

पायथन के पास इसका समर्थन करने के लिए कुछ भी अंतर्निहित नहीं है। क्या आपको वास्तव में इसे अनुकूलित करने की आवश्यकता है क्योंकि मुझे नहीं लगता कि संलग्न करने से अधिक ओवरहेड जोड़ देगा।

हालांकि, आप l = [None] * 1000 जैसे कुछ कर सकते हैं।

वैकल्पिक रूप से, आप जनरेटर का उपयोग कर सकते हैं।

Answer 4

your_list = [None]*size_required 

Answer 5

आप इसका उपयोग कर सकते हैं: [None] * 10। लेकिन यह "निश्चित आकार" नहीं होगा जिसे आप अभी भी जोड़ सकते हैं, हटा सकते हैं ... इस प्रकार सूचियां बनाई जाती हैं।

आप इसे अपनी चौड़ाई को ठीक करने के लिए एक tuple (tuple([None] * 10)) बना सकते हैं, लेकिन फिर से, आप इसे बदलने में सक्षम नहीं होंगे (सभी मामलों में नहीं, केवल तभी संग्रहीत आइटम म्यूटेबल हैं)।

एक और विकल्प, आपकी आवश्यकता के करीब, एक सूची नहीं है, लेकिन अधिकतम लंबाई के साथ collections.deque है। यह अधिकतम आकार है, लेकिन यह छोटा हो सकता है।

import collections 
max_4_items = collections.deque([None] * 4, maxlen=4) 

लेकिन, बस एक सूची का उपयोग करें, और चीजों को करने के "पायथनिक" तरीके से उपयोग करें।

Answer 6

यह भी ध्यान रखें कि जब आप C++ सरणियों इस्तेमाल किया आप कुछ अलग जरूरत है, जो अजगर में अलग अलग तरीकों से हल कर रहे हैं हो सकता था:

1. आप आइटम का सिर्फ एक संग्रह की जरूरत हो सकता है; पायथन सूची पूरी तरह से इस उपयोगकेस के साथ सौदा।
2. आपको समरूप वस्तुओं के उचित सर की आवश्यकता हो सकती है। पायथन सूची सरणी स्टोर करने का एक अच्छा तरीका है।

अजगर द्वारा NumPy सरणियों में की जरूरत है, जो, अन्य बातों के अलावा स्वच्छ, ज्ञात आकार की एक सरणी बनाने के लिए एक तरीका है हल करती है:

from numpy import * 

l = zeros(10) 

Answer 7

fix_array = numpy.empty(n, dtype = object) 

जहां n है आपके सरणी का आकार

हालांकि यह काम करता है, यह सबसे अच्छा विचार नहीं हो सकता है क्योंकि आपको इस उद्देश्य के लिए लाइब्रेरी आयात करना है। उम्मीद है की यह मदद करेगा!