किसी सूची में तत्व की प्रत्येक जोड़ी पर ऑपरेशन

Question 1

अजगर का उपयोग करना, मैं एक सूची में हर संभव जोड़ी की तुलना करना चाहूंगा।

मान लो मेरे पास है

my_list = [1,2,3,4]

मैं सूची से 2 तत्वों के हर संयोजन पर एक ऑपरेशन (इसे फू कहूं) करना चाहता हूं।

अंतिम परिणाम समान होना चाहिए

foo(1,1)
foo(1,2)
...
foo(4,3)
foo(4,4)

मेरा पहला विचार मैन्युअल रूप से सूची के माध्यम से दो बार पुनरावृति करना था, लेकिन यह बहुत ही आकर्षक नहीं लगता है।

Question 2

की जाँच करें product()में itertoolsमॉड्यूल। यह वही करता है जो आप वर्णन करते हैं।

import itertools

my_list = [1,2,3,4]
for pair in itertools.product(my_list, repeat=2):
    foo(*pair)

यह इसके बराबर है:

my_list = [1,2,3,4]
for x in my_list:
    for y in my_list:
        foo(x, y)

संपादित करें: दो समान कार्य भी हैं, permutations()और combinations()। यह बताने के लिए कि वे कैसे भिन्न हैं:

product() सभी डुप्लिकेट सहित तत्वों की हर संभव जोड़ी बनाता है:

1,1  1,2  1,3  1,4
2,1  2,2  2,3  2,4
3,1  3,2  3,3  3,4
4,1  4,2  4,3  4,4

permutations()x,xडुप्लिकेट को समाप्त करने वाले तत्वों की प्रत्येक अनूठी जोड़ी के सभी अनूठे ऑर्डर उत्पन्न करता है :

 .   1,2  1,3  1,4
2,1   .   2,3  2,4
3,1  3,2   .   3,4
4,1  4,2  4,3   .

अंत में, combinations()केवल लेक्सिकोग्राफ़िक क्रम में, तत्वों की प्रत्येक अद्वितीय जोड़ी बनाता है:

 .   1,2  1,3  1,4
 .    .   2,3  2,4
 .    .    .   3,4
 .    .    .    .

इन तीनों कार्यों को पायथन 2.6 में पेश किया गया था।

Question 3

मुझे इसी तरह की समस्या थी और इसका समाधान यहां मिला । यह किसी भी मॉड्यूल को आयात किए बिना काम करता है।

एक सूची की तरह:

people = ["Lisa","Pam","Phil","John"]

एक सरलीकृत एक-पंक्ति समाधान इस तरह दिखेगा।

डुप्लिकेट सहित सभी संभावित जोड़े :

result = [foo(p1, p2) for p1 in people for p2 in people]

डुप्लिकेट को छोड़कर सभी संभावित जोड़े :

result = [foo(p1, p2) for p1 in people for p2 in people if p1 != p2]

अद्वितीय जोड़े , जहां आदेश अप्रासंगिक है:

result = [foo(people[p1], people[p2]) for p1 in range(len(people)) for p2 in range(p1+1,len(people))]

यदि आप संचालन नहीं करना चाहते हैं, लेकिन केवल जोड़े प्राप्त करना चाहते हैं, तो फ़ंक्शन को हटा दें fooऔर सिर्फ एक ट्यूपल का उपयोग करना पर्याप्त होगा।

डुप्लिकेट सहित सभी संभावित जोड़े :

list_of_pairs = [(p1, p2) for p1 in people for p2 in people]

परिणाम:

('Lisa', 'Lisa')
('Lisa', 'Pam')
('Lisa', 'Phil')
('Lisa', 'John')
('Pam', 'Lisa')
('Pam', 'Pam')
('Pam', 'Phil')
('Pam', 'John')
('Phil', 'Lisa')
('Phil', 'Pam')
('Phil', 'Phil')
('Phil', 'John')
('John', 'Lisa')
('John', 'Pam')
('John', 'Phil')
('John', 'John')

डुप्लिकेट को छोड़कर सभी संभावित जोड़े :

list_of_pairs = [(p1, p2) for p1 in people for p2 in people if p1 != p2]

परिणाम:

('Lisa', 'Pam')
('Lisa', 'Phil')
('Lisa', 'John')
('Pam', 'Lisa')
('Pam', 'Phil')
('Pam', 'John')
('Phil', 'Lisa')
('Phil', 'Pam')
('Phil', 'John')
('John', 'Lisa')
('John', 'Pam')
('John', 'Phil')

अद्वितीय जोड़े , जहां आदेश अप्रासंगिक है:

list_of_pairs = [(people[p1], people[p2]) for p1 in range(len(people)) for p2 in range(p1+1,len(people))]

परिणाम:

('Lisa', 'Pam')
('Lisa', 'Phil')
('Lisa', 'John')
('Pam', 'Phil')
('Pam', 'John')
('Phil', 'John')

संपादित करें: इस समाधान को सरल बनाने के लिए कार्य करने के बाद, मैंने महसूस किया कि यह एडम रोसेनफील्ड की तुलना में एक ही दृष्टिकोण है। मुझे उम्मीद है कि बड़ा विवरण इसे बेहतर समझने में कुछ मदद करता है।

Question 4

यदि आप किसी फ़ंक्शन को कॉल कर रहे हैं, तो आप वास्तव में इससे बेहतर नहीं कर सकते:

for i in my_list:
    for j in my_list:
        foo(i, j)

यदि आप फ़ंक्शन को कॉल करने के परिणामों की एक सूची एकत्र करना चाहते हैं, तो आप कर सकते हैं:

[foo(i, j) for i in my_list for j in my_list]

जो आपको foo(i, j)प्रत्येक संभावित जोड़ी में आवेदन करने के परिणाम की एक सूची लौटाएगा (i, j)।

Question 5

my_list = [1,2,3,4]

pairs=[[x,y] for x in my_list for y in my_list]
print (pairs)