निश्चित आकार के साथ अजगर में एक खाली सूची बनाएं

Question

मैं एक खाली सूची (या जो भी सबसे अच्छा तरीका है) बनाना चाहता हूं जो 10 तत्वों को पकड़ सकता है।

उसके बाद मैं उस सूची में मान निर्दिष्ट करना चाहता हूं, उदाहरण के लिए इसे 0 से 9 प्रदर्शित करना है:

s1 = list();
for i in range(0,9):
   s1[i] = i

print  s1

लेकिन जब मैं इस कोड को चलाता हूं, तो यह एक त्रुटि उत्पन्न करता है या किसी अन्य मामले में यह सिर्फ प्रदर्शित करता है [](खाली)।

कोई समझा सकता है क्यों?

Comments

पायथन में तत्वों की एक ज्ञात संख्या के लिए एक सूची को

— आरम्भ

[]परिभाषा के अनुसार "खाली सूची" ( ) में शून्य तत्व होते हैं। क्या आप जाहिरा तौर पर चाहते हैं की तरह falsy मूल्यों की एक सूची है None, 0या, ''।

— dan04

से एक सूची तैयार करने के 0लिए 9आप वास्तव में उपयोग करना चाहिए for i in range(0, 10)जिसका अर्थ है, for (int i = 0, i < 10, i++)।

— Atcold

Answer 1

lst[i] = somethingजब तक सूची पहले से ही कम से कम i+1तत्वों के साथ आरम्भ नहीं की जाती है, तब तक आप एक सूची को असाइन नहीं कर सकते । आपको सूची के अंत में तत्वों को जोड़ने के लिए परिशिष्ट का उपयोग करने की आवश्यकता है। lst.append(something)।

(यदि आप एक शब्दकोश का उपयोग कर रहे थे तो आप असाइनमेंट नोटेशन का उपयोग कर सकते हैं)।

एक खाली सूची बनाना:

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

उपरोक्त सूची के मौजूदा तत्व के लिए एक मान निर्दिष्ट करना:

>>> l[1] = 5
>>> l
[None, 5, None, None, None, None, None, None, None, None]

ध्यान रखें कि जैसा कुछ l[15] = 5अभी भी विफल होगा, क्योंकि हमारी सूची में केवल 10 तत्व हैं।

रेंज (x) एक सूची बनाता है [0, 1, 2, ... x-1] से

# 2.X only. Use list(range(10)) in 3.X.
>>> l = range(10)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

एक सूची बनाने के लिए एक फ़ंक्शन का उपयोग करना:

>>> def display():
...     s1 = []
...     for i in range(9): # This is just to tell you how to create a list.
...         s1.append(i)
...     return s1
... 
>>> print display()
[0, 1, 2, 3, 4, 5, 6, 7, 8]

सूची समझ (वर्गों का उपयोग करके, क्योंकि सीमा के लिए आपको यह सब करने की आवश्यकता नहीं है, आप बस वापस आ सकते हैं range(0,9))

>>> def display():
...     return [x**2 for x in range(9)]
... 
>>> print display()
[0, 1, 4, 9, 16, 25, 36, 49, 64]

Comments

"आप lst [i] = कुछ" जैसी सूची में निर्दिष्ट नहीं कर सकते हैं, तो आप क्या कर सकते हैं! वर्तमान सूची की लंबाई से परे एक गैर-मौजूद तत्व को असाइन करने के लिए आप क्या नहीं कर सकते

— सर्गेई

"जब तक सूची पहले से ही कम से कम i + 1 तत्वों के साथ प्रारंभ नहीं होती है" ....

— MrR

आप ऐसा कर सकते हैं:a = [0 for _ in range(10)]

— Kamiar

क्या सूची () फ़ंक्शन का उपयोग करके ऐसा करना संभव है?

— राउल चियारेला

Answer 2

इसके बजाय यह प्रयास करें:

lst = [None] * 10

उपरोक्त आकार 10 की एक सूची बनाएगा, जहां प्रत्येक स्थिति को आरंभिक रखा जाएगा None। उसके बाद, आप इसमें तत्व जोड़ सकते हैं:

lst = [None] * 10
for i in range(10):
    lst[i] = i

जाहिर है, कि चीजों को करने का पैथोनिक तरीका नहीं है। बेहतर यह करें:

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

या यहां तक ​​कि सरल , पायथन 2.x में आप 0 से 9 तक मानों के साथ सूची को आरम्भ करने के लिए ऐसा कर सकते हैं:

lst = range(10)

और पायथन 3.x में:

lst = list(range(10))

Comments

इसके बारे में दूसरी बड़ी बात यह है कि आप एक सूची को डिफ़ॉल्ट मानों के साथ आरंभ कर सकते हैं। lst = [''] * 10याlst = [0] * 10

— एंथनी मैनिंग-फ्रैंकलिन

बोध उदाहरण पर एक प्रकार। यदि सरणी के सभी तत्वों को आरंभीकरण के समय खाली होने की आवश्यकता है, तो उपयोग करें arr = [None for _ in range(10)]:।

— डग आर।

Answer 3

varunl का वर्तमान में स्वीकृत उत्तर है

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

संख्या जैसे गैर-संदर्भ प्रकारों के लिए अच्छी तरह से काम करता है। दुर्भाग्य से यदि आप एक सूची बनाना चाहते हैं तो आप संदर्भ त्रुटियों में चलेंगे। पायथन 2.7.6 में उदाहरण:

>>> a = [[]]*10
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
>>> 

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

def init_list_of_objects(size):
    list_of_objects = list()
    for i in range(0,size):
        list_of_objects.append( list() ) #different object reference each time
    return list_of_objects


>>> a = init_list_of_objects(10)
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [], [], [], [], [], [], [], [], []]
>>> 

ऐसा करने की एक डिफ़ॉल्ट, अंतर्निहित अजगर विधि है (एक फ़ंक्शन लिखने के बजाय), लेकिन मुझे यकीन नहीं है कि यह क्या है। सही होने पर खुशी होगी!

संपादित करें: यह है [ [] for _ in range(10)]

उदाहरण :

>>> [ [random.random() for _ in range(2) ] for _ in range(5)]
>>> [[0.7528051908943816, 0.4325669600055032], [0.510983236521753, 0.7789949902294716], [0.09475179523690558, 0.30216475640534635], [0.3996890132468158, 0.6374322093017013], [0.3374204010027543, 0.4514925173253973]]

Comments

मैंने सुना है कि appendबहुत बार उपयोग करने से सूची समझ में हीनता आती है। आप के माध्यम से अपनी सूचियों की सूची बना सकते हैं [ [] for _ in range(10)]।

— M.Herzkamp

इसलिए अपवित्र किया क्योंकि मैं पागल हो रहा था क्योंकि मेरे पास एक ही डेटा के साथ कई बार दोहराए जाने वाले मल्टी-डिमेंशनल एरे थे और यह जवाब खोजने से पहले क्या हो रहा था, यह पता नहीं चल सका। ^ ^ मुझे समझ नहीं आता कि यह यहाँ इतना कम क्यों है।

— ब्रेगलाद

Answer 4

आप .append(element)सूची के लिए कर सकते हैं , जैसे s1.append(i):। वर्तमान में आप जो करने की कोशिश कर रहे हैं वह एक तत्व ( s1[i]) है जो मौजूद नहीं है।

Answer 5

दो "त्वरित" विधियाँ हैं:

x = length_of_your_list
a = [None]*x
# or
a = [None for _ in xrange(x)]

ऐसा प्रतीत होता है कि [None]*xतेज है:

>>> from timeit import timeit
>>> timeit("[None]*100",number=10000)
0.023542165756225586
>>> timeit("[None for _ in xrange(100)]",number=10000)
0.07616496086120605

लेकिन अगर आप एक सीमा (जैसे [0,1,2,3,...,x-1]) के साथ ठीक हैं , तो range(x)सबसे तेज़ हो सकता है:

>>> timeit("range(100)",number=10000)
0.012513160705566406

Comments

ध्यान दें कि Python3 में आपको list(range(n))इसके बजाय उपयोग करना होगा, क्योंकि range()कोई सूची वापस नहीं करता है , लेकिन एक पुनरावृत्तिकर्ता है, और इससे अधिक तेज़ नहीं है [None] * n।

— Skillmon

Answer 6

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

x = [[] for i in range(10)]

Comments

उपरोक्त बनाम करने के बीच सबसे महत्वपूर्ण अंतर x = [[]] * 10यह है कि उत्तरार्द्ध में, सूची में प्रत्येक तत्व एसएएमई सूची ऑब्जेक्ट की ओर इशारा कर रहा है । इसलिए जब तक आप बस एक ही वस्तु की 10 प्रतियां नहीं चाहते हैं, तब तक rangeआधारित संस्करण का उपयोग करें क्योंकि यह 10 नए ऑब्जेक्ट बनाता है । मुझे यह भेद बहुत महत्वपूर्ण लगा।

— मंदीप संधू

Answer 7

(यह प्रश्न के मूल संस्करण पर आधारित था।)

मैं एक खाली सूची बनाना चाहता हूं (या जो भी सबसे अच्छा तरीका है) 10 तत्वों को पकड़ सकता है।

सभी सूचियाँ जितने चाहें उतने तत्व रख सकती हैं, केवल उपलब्ध स्मृति की सीमा के अधीन। सूची का एकमात्र "आकार" जो मायने रखता है वह वर्तमान में इसमें मौजूद तत्वों की संख्या है।

लेकिन जब मैं इसे चलाता हूं, तो परिणाम [] होता है

print display s1मान्य सिंटैक्स नहीं है; आप जो देख रहे हैं, display(s1)उसके विवरण के आधार पर, मेरा मतलब है कि आप और फिर print s1। इसे चलाने के लिए, आपको पहले s1फ़ंक्शन में पास होने के लिए एक वैश्विक परिभाषित किया जाना चाहिए ।

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

यहां एक मूल्य में पारित करने का कोई कारण नहीं है। (फ़ंक्शन बनाने के लिए कोई वास्तविक कारण नहीं है, या तो, लेकिन वह बिंदु के बगल में है।) आप कुछ "बनाना" चाहते हैं, इसलिए यह आपके फ़ंक्शन का आउटपुट है। आपके द्वारा वर्णित चीज़ को बनाने के लिए किसी भी जानकारी की आवश्यकता नहीं है, इसलिए किसी भी जानकारी को पास न करें return।

इससे आपको कुछ ऐसा मिलेगा:

def display():
    s1 = list();
    for i in range(0, 9):
        s1[i] = i
    return s1

आपके द्वारा नोट की जाने वाली अगली समस्या यह है कि आपकी सूची में वास्तव में केवल 9 तत्व होंगे, क्योंकि अंतिम बिंदु rangeफ़ंक्शन द्वारा छोड़ दिया गया है । (साइड नोट्स के रूप में, के []रूप में अच्छी तरह से काम करता हैlist() , , अर्धविराम अनावश्यक है, s1चर के लिए एक खराब नाम है, और rangeयदि आप से शुरू कर रहे हैं , तो केवल एक पैरामीटर की आवश्यकता है 0।) तो आप के साथ समाप्त होता है।

def create_list():
    result = list()
    for i in range(10):
        result[i] = i
    return result

हालाँकि, यह अभी भी निशान गायब है; rangeकुछ जादुई कीवर्ड नहीं है जो भाषा का हिस्सा है forऔर defहैं, लेकिन इसके बजाय यह एक फ़ंक्शन है। और लगता है कि क्या है कि समारोह रिटर्न? यह सही है - उन पूर्णांकों की सूची। तो पूरा समारोह टूट जाता है

def create_list():
    return range(10)

और अब आप देखते हैं कि हमें स्वयं एक फ़ंक्शन लिखने की आवश्यकता क्यों नहीं है; rangeवह कार्य पहले से ही हम देख रहे हैं। हालांकि, फिर से, सूची को "पूर्व-आकार" करने की कोई आवश्यकता या कारण नहीं है।

Answer 8

मैं थोड़ा हैरान हूं कि एक आरंभिक सूची बनाने का सबसे आसान तरीका इनमें से किसी भी उत्तर में नहीं है। listफ़ंक्शन में बस एक जनरेटर का उपयोग करें :

list(range(9))

Comments

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

— AFP_555

यह समस्या यह है कि यह प्रश्न प्रति प्रश्न के अनुसार एक खाली सूची नहीं बनाता है, आप [0, 1, 2, 3, 4, 5, 6, 7, 8] के साथ समाप्त होंगे जो कि सीमा (9) कार्य करता है । तुरंत ही नंबर भरने के बजाय

— नोन्स की

क्यों लपेट range(9)में list()? क्या range(9)पहले से सूची नहीं लौटी है?

— Zyl

@Zyl rangeएक सूची नहीं है, न ही एक जनरेटर। यह एक अंतर्निहित अपरिवर्तनीय उपवर्ग है Sequence।

— नूनो एन्ड्रे

@ AFP_555 मुझे लगता है कि असली सवाल यह है कि इसे अधिक डाउनवोट क्यों नहीं किया गया है, क्योंकि यह वास्तव में सवाल का जवाब नहीं देता है और खराब अनपेक्षित परिणाम हो सकता है।

— एरिक

Answer 9

nनेस्टेड सूची समझ का उपयोग करके आकार का 2 डी मैट्रिक्स बनाने का एक सरल तरीका :

m = [[None for _ in range(n)] for _ in range(n)]

Answer 10

यहाँ अजगर में 2 डी सूची के लिए मेरा कोड है जो कोई भी नहीं पढ़ेगा। इनपुट से पंक्तियाँ:

empty = []
row = int(input())

for i in range(row):
    temp = list(map(int, input().split()))
    empty.append(temp)

for i in empty:
    for j in i:
        print(j, end=' ')
    print('')

Answer 11

मैं इसी तरह की समस्या के लिए खोज करते हुए इस SO प्रश्न पर आया था। मुझे एक 2 डी सरणी का निर्माण करना था और फिर प्रत्येक सूची के कुछ तत्वों (2 डी सरणी में) को एक तानाशाह से तत्वों के साथ बदलना था। मैं तब एसओ के इस सवाल पर आया जिसने मेरी मदद की, शायद इससे अन्य शुरुआती लोगों को इधर-उधर होने में मदद मिलेगी। प्रमुख चाल 2 डी सरणी को एक सुपीरियर सरणी के रूप में आरंभीकृत करना था और फिर array[i,j]इसके बजाय का उपयोग करना थाarray[i][j] ।

संदर्भ के लिए यह कोड का टुकड़ा है जहां मुझे इसका उपयोग करना था:

nd_array = []
for i in range(30):
    nd_array.append(np.zeros(shape = (32,1)))
new_array = []
for i in range(len(lines)):
    new_array.append(nd_array)
new_array = np.asarray(new_array)
for i in range(len(lines)):
    splits = lines[i].split(' ')
    for j in range(len(splits)):
        #print(new_array[i][j])
        new_array[i,j] = final_embeddings[dictionary[str(splits[j])]-1].reshape(32,1)

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

Answer 12

इसे फ़ंक्शन के रूप में अधिक पुन: प्रयोज्य बनाएं।

def createEmptyList(length,fill=None):
    '''
    return a (empty) list of a given length
    Example:
        print createEmptyList(3,-1)
        >> [-1, -1, -1]
        print createEmptyList(4)
        >> [None, None, None, None]
    '''
    return [fill] * length

Answer 13

s1 = []
for i in range(11):
   s1.append(i)

print s1

एक सूची बनाने के लिए, बस इन कोष्ठकों का उपयोग करें: "[]"

किसी सूची में कुछ जोड़ने के लिए, list.append () का उपयोग करें

Answer 14

यह कोड एक सरणी उत्पन्न करता है जिसमें 10 यादृच्छिक संख्याएँ होती हैं।

import random
numrand=[]
for i in range(0,10):
   a = random.randint(1,50)
   numrand.append(a)
   print(a,i)
print(numrand)

Comments

एसओ में आपका स्वागत है। आपका उत्तर वास्तव में विशेष रूप से प्रश्न को संबोधित नहीं करता है। पर एक नज़र डालें stackoverflow.com/help/how-to-answer

— निक