लूप्स के लिए सिंगल लाइन नेस्टेड

Question

एक मैट्रिक्स को स्थानांतरित करने वाले अजगर में इस फ़ंक्शन को लिखा:

def transpose(m):
    height = len(m)
    width = len(m[0])
    return [ [ m[i][j] for i in range(0, height) ] for j in range(0, width) ]

इस प्रक्रिया में मैंने महसूस किया कि मैं पूरी तरह से नहीं जानता कि लूप्स के निष्पादन के लिए सिंगल लाइन नेस्टेड कैसे है। कृपया निम्नलिखित प्रश्नों के उत्तर देकर मुझे समझने में मदद करें:

1. वह कौन सा क्रम है जिसमें यह लूप निष्पादित करता है?
2. अगर मुझे लूप के लिए ट्रिपल नेस्टेड किया गया था, तो यह किस आदेश पर अमल करेगा?
3. लूप के लिए समान अनावश्यक समान क्या होगा?

दिया हुआ,

[ function(i,j) for i,j in object ]

1. लूप संरचना के लिए इसका उपयोग करने के लिए किस प्रकार का ऑब्जेक्ट होना चाहिए?
2. वह कौन सा क्रम है जिसमें i और j को ऑब्जेक्ट में तत्वों को सौंपा गया है?
3. क्या यह लूप संरचना के लिए एक अलग द्वारा अनुकरण किया जा सकता है?
4. क्या लूप के लिए यह लूप के समान या अलग संरचना के साथ नेस्टेड हो सकता है? और कैसा लगेगा?

अतिरिक्त जानकारी की सराहना की जाती है।

Answer 1

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

ट्यूटोरियल से इस लंबी सूची की समझ को देखें ( ifभाग समझ को फ़िल्टर करता है, केवल कुछ अंश जो कथन को पास करते हैं, सूची बोध के अंतिम भाग में यहाँ पारित किए जाते हैं (x,y):

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

यह लूप के लिए नेस्टेड के समान है (और, जैसा कि ट्यूटोरियल कहता है, ध्यान दें कि कैसे और यदि समान है) का क्रम।

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

एक सूची समझ और एक लूप के बीच प्रमुख अंतर यह है कि लूप के लिए अंतिम भाग (जहां आप कुछ करते हैं) शुरुआत में बजाय अंत में आता है।

आपके सवालों पर:

लूप संरचना के लिए इसका उपयोग करने के लिए किस प्रकार का ऑब्जेक्ट होना चाहिए?

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

वह कौन सा क्रम है जिसमें i और j को ऑब्जेक्ट में तत्वों को सौंपा गया है?

उन्हें उसी क्रम में सौंपा गया है जैसा कि वे प्रत्येक सूची से उत्पन्न होते हैं, जैसे कि वे लूप के लिए नेस्टेड थे (आपकी पहली समझ के लिए आपको 1 तत्व i के लिए मिलेगा, फिर j से प्रत्येक मान, दूसरा तत्व i में, तब जम्मू से हर मूल्य, आदि)

क्या यह लूप संरचना के लिए एक अलग द्वारा अनुकरण किया जा सकता है?

हाँ, पहले से ही ऊपर दिखाया गया है।

क्या लूप के लिए यह लूप के समान या अलग संरचना के साथ नेस्टेड हो सकता है? और कैसा लगेगा?

यकीन है, लेकिन यह एक महान विचार नहीं है। यहाँ, उदाहरण के लिए, आपको पात्रों की सूचियों की एक सूची दी गई है:

[[ch for ch in word] for word in ("apple", "banana", "pear", "the", "hello")]

Comments

मुझे आश्चर्य है कि डबल घोंसले के शिकार में उनकी पसंद का क्या निर्देश दिया। मुझे दूसरा रास्ता अधिक स्वाभाविक लगता है (y के लिए तो आपके उदाहरण में x के लिए)। मुझे बस एहसास है कि अजगर करने के 3 साल बाद (बड़े पैमाने पर नहीं, लेकिन अभी भी ...) और उन प्रकार के लूपों का उपयोग करने के लिए !!

— थॉमस

@ थोमस मुझे दूसरा रास्ता अधिक सहज लगता है। मेरा मानना ​​है कि विकल्प विशुद्ध रूप से सुविधा था। इसे और अधिक सहज तरीके से करने का मतलब होगा कि अनसुलझे प्रतीकों से निपटना जब तक कि यह उन्हें बाद में बयान में नहीं मिलेगा। प्रत्येक केले के लिए पार्सिंग का प्रयास करें। प्रत्येक केले के लिए प्रत्येक शहर में एक कागज़। कागज पर प्रत्येक शहर में बब्बनस्तोर। उतना आसान नहीं है। हालांकि, अच्छा और आसान चारों ओर दूसरा रास्ता।

— प्योंगॉन्ग

Answer 2

आपको इसमें रुचि हो सकती है itertools.product, जो आपके द्वारा पास किए जाने वाले सभी पुनरावृत्तियों से मूल्यों की एक चलने योग्य उपज देता है। अर्थात्, itertools.product(A, B)फॉर्म के सभी मूल्यों की पैदावार करता है (a, b), जहां aमूल्य आते हैं Aऔर bमूल्यों से आते हैं B। उदाहरण के लिए:

import itertools

A = [50, 60, 70]
B = [0.1, 0.2, 0.3, 0.4]

print [a + b for a, b in itertools.product(A, B)]

यह प्रिंट:

[50.1, 50.2, 50.3, 50.4, 60.1, 60.2, 60.3, 60.4, 70.1, 70.2, 70.3, 70.4]

ध्यान दें कि अंतिम तर्क किस प्रकार itertools.product"आंतरिक" है। आम तौर पर, के बराबर हैitertools.product(a0, a1, ... an)[(i0, i1, ... in) for in in an for in-1 in an-1 ... for i0 in a0]

Answer 3

सबसे पहले, आपका पहला कोड लूप के लिए प्रति se का उपयोग नहीं करता है, लेकिन एक सूची समझ ।

1. के बराबर होगा

   j के लिए रेंज में (0, चौड़ाई): i के लिए रेंज में (0, ऊंचाई): m [i] [j]

2. बहुत कुछ उसी तरह, यह आम तौर पर छोरों के लिए घोंसला होता है, दाएं से बाएं। लेकिन सूची बोध वाक्यविन्यास अधिक जटिल है।

3. मुझे यकीन नहीं है कि यह सवाल क्या पूछ रहा है

---

1. कोई भी पुनरावृत्ति करने वाली वस्तु जो दो वस्तुओं का उत्पादन करने वाली चलने योग्य वस्तुओं की पैदावार करती है (जो एक कौर - यानी [(1,2),'ab']मान्य होगी)

2. वह क्रम जिसमें वस्तु पुनरावृत्ति पर उपज देती है। iपहली उपज पर जाता है, jदूसरा।

3. हाँ, लेकिन उतना सुंदर नहीं है। मेरा मानना ​​है कि यह कार्यात्मक रूप से इसके बराबर है:

   l = सूची ()
   i, j में ऑब्जेक्ट के लिए:
       l.append (समारोह (i, j))
   

   या इससे भी बेहतर उपयोग मानचित्र :

   map(function, object)

   लेकिन निश्चित रूप से समारोह प्राप्त करना होगा i, jअपने आप में।

4. यह 3 के रूप में एक ही सवाल नहीं है?

Answer 4

आप zipफ़ंक्शन का उपयोग करके एक ही पंक्ति में दो छोरों के लिए उपयोग कर सकते हैं

कोड:

list1 = ['Abbas', 'Ali', 'Usman']
list2 = ['Kamran', 'Asgar', 'Hamza', 'Umer']
list3 = []
for i,j in zip(list1,list2):
    list3.append(i)
    list3.append(j)
print(list3)

आउटपुट:

['Abbas', 'Kamran', 'Ali', 'Asgar', 'Usman', 'Hamza']

तो, ज़िप फ़ंक्शन का उपयोग करके, हम दो छोरों के लिए उपयोग कर सकते हैं या हम एक ही पंक्ति में दो सूचियों को पुनरावृत्त कर सकते हैं।

Answer 5

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

for x in range(1, 10, 1):
     for y in range(1,x):
             print y,
        print
OutPut :
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8