टपल के बजाय सूची आउटपुट के साथ ज़िप

Question 1

दो सूचियों से सूचियों की सूची बनाने का सबसे तेज़ और सबसे सुंदर तरीका क्या है?

मेरे पास है

In [1]: a=[1,2,3,4,5,6]

In [2]: b=[7,8,9,10,11,12]

In [3]: zip(a,b)
Out[3]: [(1, 7), (2, 8), (3, 9), (4, 10), (5, 11), (6, 12)]

और मैं करना चाहूंगा

In [3]: some_method(a,b)
Out[3]: [[1, 7], [2, 8], [3, 9], [4, 10], [5, 11], [6, 12]]

मैं ज़िप के बजाय मानचित्र का उपयोग करने के बारे में सोच रहा था, लेकिन मुझे नहीं पता कि पहले तर्क के रूप में कुछ मानक पुस्तकालय पद्धति है या नहीं।

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

Question 2

यदि आप 2 से अधिक सूचियों (या केवल 2 के लिए, उस मामले के लिए) को ज़िप कर रहे हैं, तो एक पठनीय तरीका होगा:

[list(a) for a in zip([1,2,3], [4,5,6], [7,8,9])]

यह सूची समझ का उपयोग करता है और सूची में प्रत्येक तत्व (टुपल्स) को सूचियों में परिवर्तित करता है।

Question 3

आपके पास लगभग खुद ही जवाब था। के mapबजाय का उपयोग न करें zip। का उपयोग करें map और zip ।

आप सुरुचिपूर्ण, कार्यात्मक दृष्टिकोण के लिए ज़िप के साथ मानचित्र का उपयोग कर सकते हैं:

list(map(list, zip(a, b)))

ziptuples की सूची देता है। सूची में प्रत्येक टपल पर map(list, [...])कॉल listकरता है। list(map([...])मैप ऑब्जेक्ट को पठनीय सूची में बदल देता है।

Question 4

मुझे जिप फ़ंक्शन की लालित्य बहुत पसंद है, लेकिन ऑपरेटर मॉड्यूल में आइटमगेटर () फ़ंक्शन का उपयोग करना बहुत तेज़ प्रतीत होता है। मैंने इसे जांचने के लिए एक सरल स्क्रिप्ट लिखी:

import time
from operator import itemgetter

list1 = list()
list2 = list()
origlist = list()
for i in range (1,5000000):
        t = (i, 2*i)
        origlist.append(t)

print "Using zip"
starttime = time.time()
list1, list2 = map(list, zip(*origlist))
elapsed = time.time()-starttime
print elapsed

print "Using itemgetter"
starttime = time.time()
list1 = map(itemgetter(0),origlist)
list2 = map(itemgetter(1),origlist)
elapsed = time.time()-starttime
print elapsed

मुझे उम्मीद थी कि जिप और तेज होगी, लेकिन एक लंबे शॉट से आइटमगेटर का तरीका जीत जाएगा:

Using zip
6.1550450325
Using itemgetter
0.768098831177

Question 5

मुझे आमतौर पर लैंबडा का उपयोग करना पसंद नहीं है, लेकिन ...

>>> a = [1, 2, 3, 4, 5]
>>> b = [6, 7, 8, 9, 10]
>>> c = lambda a, b: [list(c) for c in zip(a, b)]
>>> c(a, b)
[[1, 6], [2, 7], [3, 8], [4, 9], [5, 10]]

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

>>> d = lambda a, b: map(list, zip(a, b))
>>> d(a, b)
[[1, 6], [2, 7], [3, 8], [4, 9], [5, 10]]

हालांकि, मानचित्र को अनैफोनिक माना जाता है और इसे केवल प्रदर्शन ट्यूनिंग के लिए उपयोग किया जाना चाहिए।

Question 6

इस बारे में कैसा है?

>>> def list_(*args): return list(args)

>>> map(list_, range(5), range(9,4,-1))
[[0, 9], [1, 8], [2, 7], [3, 6], [4, 5]]

या इससे भी बेहतर:

>>> def zip_(*args): return map(list_, *args)
>>> zip_(range(5), range(9,4,-1))
[[0, 9], [1, 8], [2, 7], [3, 6], [4, 5]]

Question 7

सुन्न का उपयोग करना

लालित्य की परिभाषा काफी संदेहास्पद हो सकती है लेकिन अगर आप numpyकिसी सरणी के निर्माण और सूची में इसके रूपांतरण (यदि आवश्यक हो तो ...) के साथ काम कर रहे हैं, भले ही यह mapफ़ंक्शन या सूची की समझ का उपयोग करने की तुलना में बहुत अधिक कुशल न हो ।

import numpy as np 
a = b = range(10)
zipped = zip(a,b)
result = np.array(zipped).tolist()
Out: [[0, 0],
 [1, 1],
 [2, 2],
 [3, 3],
 [4, 4],
 [5, 5],
 [6, 6],
 [7, 7],
 [8, 8],
 [9, 9]]

अन्यथा zipआप सीधे उपयोग कर सकते हैं समारोह लंघन np.dstack:

np.dstack((a,b))[0].tolist()

Question 8

सूची की समझ बहुत सरल समाधान होगा जो मुझे लगता है।

a=[1,2,3,4,5,6]

b=[7,8,9,10,11,12]

x = [[i, j] for i, j in zip(a,b)]

print(x)

output : [[1, 7], [2, 8], [3, 9], [4, 10], [5, 11], [6, 12]]