भ्रमित [...] पायथन में सूची: यह क्या है?

Question

तो मैं पाइथन में एक साधारण बाइनरी पेड़ लिख रहा था और [...]

मुझे यह विश्वास नहीं है कि यह एलिप्सिस ऑब्जेक्ट से संबंधित है, और ऐसा लगता है कि इसमें अनंतता के साथ कुछ करना है लूप (पायथन की उथली प्रतिलिपि के कारण?)। इस अनंत लूप के स्रोत और क्यों यह जबकि जब तक पहुँचा के विस्तार कुछ मैं पूरी तरह से करने के लिए खो दिया हूँ, ए + बी

def Keys(x,y=[]): 
    if len(x):y+=[x[2]]+Keys(x[0],y)+Keys(x[1],y)#Though it seems I was using y=y[:]+, this actually outputs an ugly mess 
    return y 

संस्करण का उपयोग कर का उपयोग कर

>>> a 
[[[[[], [], 8, 3], [[], [], 3, 2], 6, 3], [], 1, 4], [[], [], -4, 2], 0, 0] 
>>> Keys(a)#With a+b 
[0, 1, 6, 8, 3, -4] 
>>> Keys(a)#With [a,b] 
[8, [...], [...], 3, [...], [...], 6, [...], [...], 1, [...], [...], -4, [...], [...], 0, [...], [...]] 
>>> Keys(a)[1]#?? 
[8, [...], [...], 3, [...], [...], 6, [...], [...], 1, [...], [...], -4, [...], [...], 0, [...], [...], 8, [...], [...], 3, [...], [...], 6, [...], [...], 1, [...], [...], -4, [...], [...], 0, [...], [...]] 

संस्करण है, लेकिन विस्तार नहीं प्राप्त करता है [एक , बी]

def Keys(x,y=[]): 
    if len(x):y+=[x[2],Keys(x[0],y),Keys(x[1],y)] 
    return y 

तो वास्तव में क्या है [...]?

Answer 1

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

---

पायथन में एलिप्सिस ऑब्जेक्ट का विस्तार विस्तारित टुकड़ा नोटेशन के लिए किया जाता है। इसका उपयोग वर्तमान पायथन कोर पुस्तकालयों में नहीं किया जाता है, लेकिन डेवलपर्स के लिए अपने पुस्तकालयों में परिभाषित करने के लिए उपलब्ध है। उदाहरण के लिए, NumPy (या SciPy) इसे अपने सरणी ऑब्जेक्ट के हिस्से के रूप में उपयोग करते हैं। आपको इस वस्तु में इलिप्सिस कैसे व्यवहार करता है, यह जानने के लिए आपको पेड़() के लिए प्रलेखन को देखने की आवश्यकता होगी।

Python documentation से

:

3.11.8 अंडाकार वस्तु

इस वस्तु बढ़ाया टुकड़ा अंकन द्वारा किया जाता है (देखें अजगर संदर्भ मैनुअल)। यह कोई विशेष संचालन का समर्थन करता है। इलिप्सिस नामक एक इलिप्सिस ऑब्जेक्ट है ( अंतर्निहित नाम)।

यह इलिप्सिस के रूप में लिखा गया है।

Answer 2

यह भी दिखाई दे सकता है कि आपके पास एक सूची के साथ एक परिपत्र संरचना है या नहीं। इस तरह:

>>> a = [1,2] 
>>> a.append(a) 
>>> a 
[1, 2, [...]] 
>>> 

के बाद से अजगर संरचना बाहर मुद्रित नहीं कर सकते (यह एक अनंत लूप होगा) यह अंडाकार का उपयोग करता है संरचना में प्रत्यावर्तन है कि वहाँ दिखाने के लिए।

---

मैं काफी यकीन है कि अगर सवाल क्या क्या हो रहा है या इसे ठीक करने के लिए, लेकिन मैं ऊपर कार्यों को सही करने की कोशिश करेंगे था नहीं हूँ।

उनमें से दोनों में, आप पहले दो रिकर्सिव कॉल करते हैं, जो y सूची में डेटा जोड़ते हैं, और उसके बाद लौटा डेटा y पर जोड़ देते हैं। इसका मतलब है कि परिणाम में एक ही डेटा कई बार उपस्थित होगा।

या तो सिर्फ

return [x[2]]+keys(x[0])+keys(x[1]) 

की तरह कुछ के साथ, किसी भी y को जोड़ने के बिना सभी डेटा एकत्र या बस की तरह

y += [x[2]] 
keys(x[0], y) #Add left children to y... 
keys(x[1], y) #Add right children to y... 
return y 

(बेशक, दोनों कुछ के साथ, कॉल में appending करना इन स्निपेटों को खाली सूचियों आदि के लिए हैंडलिंग की आवश्यकता है)

@Abgan ने यह भी नोट किया कि आप वास्तव में प्रारंभकर्ता में y=[] नहीं चाहते हैं ।

Answer 3

मुझे उपरोक्त कोड नहीं पता है, लेकिन [...] मुझे लगता है कि पाइथन दुभाषिया अनंत डेटा संरचनाओं को छोड़ रहा है। उदाहरण के लिए:

>>> a = [0, 1] 
>>> a[0] = a 
>>> a 
[[...], 1] 

ऐसा लगता है कि आपकी पेड़ की संरचना लूप हो रही है।

स्लाइस ऑब्जेक्ट्स के बारे में उत्तर बिंदु के बगल में हैं।

Answer 4

मेरा मानना ​​है कि आपके 'पेड़' में स्वयं शामिल है, इसलिए इसमें चक्र होते हैं।

 
    [1,2,3,4, [...]] 

कारण

 
def Keys(x,y=[]): 

उपयोग कर रहा है यह गलत और बुराई है:

 
    a = [1,2,3,4] 
    print a 
    a.append(a) 
    print a 

पहले प्रिंट आउटपुट:

 
    [1,2,3,4] 

जबकि दूसरा

इस कोड का प्रयास करें। सूची एक म्यूटेबल ऑब्जेक्ट है, और जब डिफ़ॉल्ट पैरामीटर के रूप में उपयोग किया जाता है, तो यह फ़ंक्शन कॉल के बीच संरक्षित होता है। इसलिए प्रत्येक y + = "कुछ भी" ऑपरेशन (सभी फ़ंक्शन कॉल में, और के बाद से समारोह पुनरावर्ती है ...) एक ही सूची में जोड़ता है

---

Effbot या Devshed पारित कर दिया परिवर्तनशील वस्तुओं पर अधिक जानकारी के लिए देखें कार्यों के लिए डिफ़ॉल्ट मान के रूप में।

Answer 5

मुझे यह विश्वास नहीं है कि यह एलिप्सिस ऑब्जेक्ट से संबंधित है, और ऐसा लगता है कि इसमें अनंतता लूप (पायथन की उथली प्रतिलिपि के कारण) के साथ कुछ करना है।

>>> a = [0] 
>>> a.append(a) 
>>> print a 
[0, [...]] 

अजगर कैसे है: यह अनंत लूप के स्रोत और क्यों यह जबकि जब तक पहुँचा विस्तार हो रहा है, कुछ मैं पूरी तरह से करने के लिए खो दिया है कर रहा हूँ है, लेकिन

निम्नलिखित कोड पर देखो विस्तारित किए जाते हैं नहीं है एक प्रिंट करना चाहिए? यह एक ऐसी सूची है जिसमें शून्य और स्वयं का संदर्भ शामिल है।इसलिए यह एक सूची है कि एक शून्य और जो बारी में एक शून्य और जो बारी में एक शून्य और एक संदर्भ है एक सूची

[0, [0, [...]]] 

का संदर्भ होता है एक सूची

[0, [...]] 

का संदर्भ होता है है एक सूची, और इतने पर, रिकर्सिवली रहे हैं:

[0, [0, [0, [...]]]] 
[0, [0, [0, [0, [...]]]]] 
[0, [0, [0, [0, [0, [...]]]]]] 
... 

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

Answer 6

ठीक है, इसलिए में अंक:

1. आप अनंत डेटा बना रहे हैं संरचना:

   def Keys(x,y=[])

   प्रत्येक कॉल में एक ही 'y' का प्रयोग करेंगे। यह सिर्फ सही नहीं है।

2. print बयान, हालांकि, काफी चालाक एक अनंत डेटा मुद्रित करने के लिए नहीं है, लेकिन साथ एक [...] (ज्ञात के रूप में अंडाकार)

3. अजगर आप की अनुमति देगा स्वयं संदर्भ चिह्नित करने के लिए है ऐसी संरचना को सही ढंग से संबोधित करने के लिए, ताकि आप

   a.keys()[1][1][1]

   लिख सकें और इसी तरह। आपको क्यों नहीं चाहिए
4. y = y[:] कथन बस सूची वाई की प्रतिलिपि बनाता है। y = list(y)

के साथ और अधिक सुख से किया जा सकता है निम्नलिखित कोड का उपयोग कर प्रयास करें:

 
def Keys(x,y=None): 
    if y is None: 
     y = [] 
    if len(x): 
     y += [x[2], Keys(x[0],y), Keys(x[1],y)] 
    return y 

लेकिन फिर भी मुझे लगता है कि यह है कि यह आपको काट कर सकते हैं। तुम अब भी एक अभिव्यक्ति में तीन स्थानों पर एक ही चर y (मैं एक ही वस्तु मतलब) का उपयोग कर रहे हैं:

 y += [x[2], Keys(x[0], y), Keys(x[1], y)]

है कि आप वास्तव में क्या हासिल करना चाहते हैं? या शायद आप की कोशिश करनी चाहिए:

 
def mKeys(x,y=None): 
    if y is None: 
     y = [] 
    if len(x): 
     z = [x[2], mKeys(x[0], y), mKeys(x[1],y)] 
     return z 
    return [] 

Answer 7

समारोह कुंजी के दो संस्करणों के बीच अंतर के लिए, निम्नलिखित पर ध्यान दें अंतर:

y+=[x[2]]+Keys(x[0],y)+Keys(x[1],y) 

इस बयान में दाईं ओर मूल्य एक सूची है जो होता है एक्स [2], प्लस कुंजी के तत्वों (एक्स [0], वाई) और कुंजी के तत्वों (एक्स [1], वाई)

y+=[x[2],Keys(x[0],y),Keys(x[1],y)] 

इस बयान में दाईं ओर मूल्य एक सूची है जो होता है एक्स [2], प्लस लिस्ट कीज (एक्स [2], वाई) और लिस्ट कीज (एक्स [1], वाई)।

तो [ए, बी] का उपयोग करने वाला संस्करण वाई को अपने तत्वों के रूप में स्वयं बना देगा।

कुछ अन्य नोट्स:

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

   यह मेरी मशीन पर पाइथन 2.5.2 के साथ फ़ंक्शन चलाकर पुष्टि की जाती है।

2. इसके अलावा क्योंकि डिफ़ॉल्ट मान फ़ंक्शन परिभाषा समय पर केवल एक बार परिभाषित किया जाता है, यहां तक ​​कि फ़ंक्शन पहली बार सही काम करता है, यह एक अलग से कॉल करते समय काम नहीं करेगा, क्योंकि पहले बाइनरी पेड़ की चाबियाँ बनी रहेंगी वाई में

   आप इसे कुंजी (ए) दो बार कॉल करके या दो अलग-अलग सूचियों पर कॉल करके देख सकते हैं।

3. इस समस्या के लिए दूसरा पैरामीटर आवश्यक नहीं है। समारोह इस तरह हो सकता है:

   डीईएफ़ कुंजी (क): अगर एक = []: वापसी [] किसी और : वापसी [एक [2]] कुंजी (एक [0]) + कुंजी (एक [1])

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

Answer 8

आप एक PrettyPrinter का इस्तेमाल किया है चाहते हैं, तो उत्पादन आत्म व्याख्यात्मक किया गया था होगा

>>> l = [1,2,3,4] 
>>> l[0]=l 
>>> l 
[[...], 2, 3, 4] 
>>> pp = pprint.PrettyPrinter(indent = 4) 
>>> pp.pprint(l) 
[<Recursion on list with id=70327632>, 2, 3, 4] 
>>> id(l) 
70327632 

दूसरे शब्दों में

Answer 9

मुद्दे की तरह अपने कुछ की वजह से एक है सूची तत्व सूची का संदर्भ दे रहा है। तो यदि सभी तत्वों को मुद्रित करने का प्रयास किया जाता है तो यह कभी खत्म नहीं होगा।

उदाहरण:

x = range(3) 
x.append(x) 
x[3][3][3][3][3][0] = 5 
print x 

आउटपुट:

[5, 1, 2, [...]] 

x[3] एक ही x की चर्चा करते हुए है। x[3][3] के लिए भी चला जाता है।

यह बेहतर देखे जा सकते हैं [यहां] (http://pythontutor.com/visualize.html#code=x+%3D+range(3%29%0Ax.append(x%29%0Ax%5B3%5D%5B3%5D%5B3%5D%5B3%5D%5B3%5D%5B0%5D+%3D+5%0Aprint+x&mode=display&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=2&rawInputLstJSON=%5B%5D&curInstr=4)