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


95

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

मेरे पास है

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]]

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

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


1
खैर, क्या आपको वास्तव में सूचियों की आवश्यकता है? आप परिणामों के साथ क्या करने जा रहे हैं?
कार्ल केनचेल

14
एक उदाहरण स्केलेरन होगा, जहां कई बार इस तरह से डेटा का आयोजन किया जाना चाहिए।
tumultous_rooster

जवाबों:


103

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

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

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


55

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

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

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

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


अजगर 3 संग्रह संचालन वापस करने का दुर्भाग्यपूर्ण निर्णय यहां generatorडबल की लागत लगाता listहै।
StephenBoesch

15

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

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

2
यह ओपी क्या करने की कोशिश कर रहा है, इसका एक संक्रमण है। क्या आप अपनी पोस्ट को अपडेट कर सकते हैं? यानी, ओपी जोड़े की सूची या मनमानी संख्या को दो सूचियों में परिवर्तित कर रहा है। आप सूचियों के एक जोड़े को मनमाने ढंग से जोड़ रहे हैं।
मैड फिजिसिस्ट

यह किस अजगर संस्करण के साथ मापा जाता है?
Moberg

मुझे याद नहीं है, यह दो साल पहले था, लेकिन सबसे अधिक संभावना 2.6 या 2.7 थी। मुझे लगता है कि आप कोड को कॉपी कर सकते हैं और इसे अपने स्वयं के संस्करण / मंच पर आज़मा सकते हैं।
18

2
अजगर 2 zipएक वास्तविक सूची बनाता है। जो चीजों को धीमा कर देता है। तब के zipसाथ बदलने की कोशिश करें itertools.izip
जीन-फ्रांकोइस फैबरे

पायथन 3.5 में, ज़िप 3.5 सेकंड और आइटमगेटर 0.10 सेकंड लेता है। सूची समझ के शौकीन लोगों के लिए, list1 = [x[0] for x in origlist]साथ ही साथ काम करता है list1 = map(itemgetter(0), origlist)
एलियास स्ट्रील

3

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

>>> 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]]

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


4
lambdaयहाँ क्या जोड़ता है? कोई फ़ंक्शन को कॉल करने के बजाय केवल अभिव्यक्ति लिख सकता है (यह वास्तव में जटिल नहीं है), और यहां तक ​​कि अगर कोई इसके लिए फ़ंक्शन चाहता है, तो इसे दो लाइनों में दर्द रहित रूप से परिभाषित किया जा सकता है (एक अगर आपकी वापसी कुंजी टूट गई है या आप पागल हैं) । mapदूसरी तरफ पूरी तरह से ठीक है अगर पहला तर्क एक सादे कार्य (जैसा कि विरोध किया जाता है lambda) होगा।

1
खैर उसने एक फंक्शन के लिए कहा। लेकिन मैं सहमत हूँ - शायद अतिरिक्त लाइन का भुगतान करने के लिए बेहतर है। नक्शे के अनुसार, मेरा मानना ​​है कि सूची की समझ लगभग हमेशा स्पष्ट होती है।
सीज़र ब्यूटिस्टा

1
मैं सलाह mapदूंगा lambda। तो map(list, zip(a,b))। सूची की समझ थोड़ी स्पष्ट हो सकती है, लेकिन नक्शा तेज होना चाहिए (अप्रकाशित)
इंस्पेक्टरगैजेट

मेरा मतलब है, फिर से, अगर ओपी को गति की आवश्यकता है, तो नक्शा जाने का रास्ता है। लेकिन सामान्य तौर पर, और विशेष रूप से पायथन में, गति पर पठनीयता पर जोर दिया जाता है (अन्यथा आप समय से पहले अनुकूलन में डुबकी लगाते हैं)।
सीज़र बॉटिस्टा

3

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

>>> 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]]

यह मुझे बाकी की तुलना में बेहतर उत्तर लगता है क्योंकि यहाँ हम एक ज़िप न करके और सीधे एक सूची बनाकर एक कदम कम कर रहे हैं। बहुत बढ़िया
अक्षय हजारी

2

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

लालित्य की परिभाषा काफी संदेहास्पद हो सकती है लेकिन अगर आप 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()

1

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

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]]
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.