2015-05-04 5 views
13

साथ Interleave सूची मुझे पता है कि मैं के साथ दो अजगर सूचियों बिछा कर सकते हैं:निश्चित तत्व

list = [1, 2, 3, 4] 
# python magic 
output = [1, 0, 2, 0, 3, 0, 4] 

उत्तर

6

एक वास्तव में सरल समाधान:

[elem for pair in zip(*lists) for elem in pair] 

अब मैं की तरह एक निश्चित तत्व के साथ एक सूची बिछा करने की जरूरत है है:

[elem for x in list for elem in (x, 0)][:-1] 
+1

मेरा मानना ​​है कि यह सबसे आसान और सबसे स्पष्ट समाधान है। – recursive

+0

यह जादूगर कैसे काम करता है? – aitchnyu

+1

@aitchnyu अगर आपके पास नेस्टेड संरचना 'सूची = [(1,2), (3,4)] है और आप इसे फ़्लैट करना चाहते हैं तो आप' जोड़ी में elem के लिए सूची में जोड़ी के लिए 'elem का उपयोग कर सकते हैं] ताकि आप प्रत्येक 'जोड़ी' लें और फिर आप जोड़ी में प्रत्येक 'elem' ले लें। उपर्युक्त कोड में आपके पास जोड़े नहीं हैं, लेकिन आप मूल सूची में प्रत्येक तत्व 'x' के लिए एक जोड़ी' (x, 0) 'बनाते हैं, फिर आप सूची को फ़्लैट करने के लिए पहले की तरह ही रणनीति का लाभ उठाते हैं, प्राप्त करना [x1, 0, x2, 0, x3, 0] '। फिर आप '[: -1] 'का उपयोग कर पिछला' 0' हटा दें। –

6

आप निम्न itertools जादू की कोशिश कर सकते हैं:

0,123,
>>> from itertools import repeat, chain, izip 
>>> l = [1, 2, 3, 4] 
>>> list(chain.from_iterable(izip(l[:-1], repeat(0)))) + l[-1:] 
[1, 0, 2, 0, 3, 0, 4] 
3

पायथन के sum समारोह मनमाना डेटाटाइप्स कि start पैरामीटर उचित रूप से निर्धारित अलावा समर्थन पर इस्तेमाल किया जा सकता है। (see docs)

input = [1, 2, 3, 4] 
fixed = 0 
output = sum([[elem, fixed] for elem in input], [])[:-1] # to drop the last `fixed` 

या आप सूचियों के साथ इसके अलावा ऑपरेटर का उपयोग करने का विचार पसंद नहीं है, तो:

input = [1, 2, 3, 4] 
fixed = 0 
output = [] 
for elem in input: 
    output.extend([elem, fixed]) 
output = output[:-1] 
4
from itertools import izip, repeat 

start = [1, 2, 3, 4] 

print [i for j in izip(start, repeat(0)) for i in j][:-1] 
+0

मैंने देखा है कि यह सूची के अंत में एक अतिरिक्त 0 को जोड़ता है। – Shashank

+0

इसे फिक्स्ड। धन्यवाद। –

1

आप functools की reduce समारोह इस्तेमाल कर सकते हैं।

>>> from functools import reduce 
>>> reduce(lambda x, y: x + [y, 0], [1,2,3,4], [])[:-1] 
[1, 0, 2, 0, 3, 0, 4] 
2
>>> lst = [1, 2, 3, 4] 
>>> newlst = [0]*((len(lst) * 2) - 1) 
>>> newlst[::2] = lst 
>>> newlst 
[1, 0, 2, 0, 3, 0, 4] 

यह एक एक लाइनर नहीं हो सकता है, लेकिन यह काम करता है। इसके अलावा, मेरे time tests दिखाते हैं कि यह अब तक का सबसे तेज़ समाधान है। समारोह रूप में, यह है:

def interzero(lst): 
    newlst = [0]*((len(lst) * 2) - 1) 
    newlst[::2] = lst 
    return newlst 
1
>>> from itertools import chain 

>>> lst = [1, 2, 3, 4] 
>>> list(chain(*zip(lst, [0]*(len(lst)-1)))) + [lst[-1]] 
[1, 0, 2, 0, 3, 0, 4] 
संबंधित मुद्दे