एक सूची के तत्वों के जोड़े में शामिल होना


82

मुझे पता है कि एक लंबी स्ट्रिंग बनाने के लिए एक सूची में शामिल किया जा सकता है:

x = ['a', 'b', 'c', 'd']
print ''.join(x)

जाहिर है यह उत्पादन होगा:

'abcd'

हालांकि, मैं जो करने की कोशिश कर रहा हूं वह सूची में पहले और दूसरे तार से जुड़ना है, फिर तीसरे और चौथे और इतने पर शामिल हों। संक्षेप में, उपरोक्त उदाहरण से इसके बजाय एक आउटपुट प्राप्त करते हैं:

['ab', 'cd']

क्या ऐसा करने का कोई सरल तरीका है? मुझे शायद यह भी उल्लेख करना चाहिए कि सूची में तार की लंबाई अप्रत्याशित होगी, जैसा कि सूची के भीतर तार की संख्या होगी, हालांकि तार की संख्या हमेशा भी होगी। तो मूल सूची बस के रूप में अच्छी तरह से हो सकता है:

['abcd', 'e', 'fg', 'hijklmn', 'opq', 'r'] 

"मुझे शायद यह भी उल्लेख करना चाहिए कि सूची में तार की लंबाई अप्रत्याशित होगी" - तो क्या लंबाई मायने रखती है? यानी क्या आप केवल सूची तत्वों के हर जोड़े में शामिल होना चाहते हैं, या क्या आप वास्तव में सामग्री को देखना चाहते हैं और तब तक इसमें शामिल होना चाहते हैं जब तक कि तत्व कुछ विशेष लंबाई सीमा से नीचे नहीं रहता है?
प्रहार

बस हर जोड़ी में शामिल हों, मैंने बस सोचा था कि जोड़े की संख्या नहीं जानने से समस्या हो सकती है
जॉन

जवाबों:


76

आप चरणों के साथ स्लाइस अंकन का उपयोग कर सकते हैं:

>>> x = "abcdefghijklm"
>>> x[0::2] #0. 2. 4...
'acegikm'
>>> x[1::2] #1. 3. 5 ..
'bdfhjl'
>>> [i+j for i,j in zip(x[::2], x[1::2])] # zip makes (0,1),(2,3) ...
['ab', 'cd', 'ef', 'gh', 'ij', 'kl']

समान तर्क सूचियों के लिए भी लागू होते हैं। स्ट्रिंग लिन्थ से कोई फर्क नहीं पड़ता, क्योंकि आप बस एक साथ दो तार जोड़ रहे हैं।


1
इसमें कोई शक नहीं है कि केवपी का जवाब कहीं बेहतर है। इस में, x[:::2]एक ऑब्जेक्ट x[1::2]बनाता है , एक अन्य ऑब्जेक्ट बनाता है, ये रचनाएं संभवतः हुड के नीचे अनुक्रमित की गणना पर आधारित होती हैं, और इन दो वस्तुओं के साथ एक फ़ंक्शन को कॉल किया जाता है जो तत्वों के क्रमिक जोड़े को प्राप्त करने में सक्षम होने से पहले तर्क आवश्यक है। यह संक्षिप्त किया जाना चाहिए। हालांकि केवीपी के उत्तर में, केवल एक पुनरावृत्ति का निर्माण होता है और फिर पुनरावृत्ति को ध्यान में रखते हुए, पुन: अछूता सूची के तत्व से तत्व को छोड़ दिया जाता है, और यह बहुत अधिक पायथोनिक है।
पलक

@eyquem, itertools.islice[] के बजाय का उपयोग करके , मध्यवर्ती वस्तुओं को समाप्त करता है। लेकिन चूंकि दोनों उत्तर समान शर्तों पर काम करते हैं और समान रिटर्न देते हैं, इसलिए वे दोनों सही हैं। और zip(i[::2], i[1::2])मुझे इतनी प्यारी लगती है, तो, क्यों नहीं? :)
utdemir

यह केवल दृश्यों पर काम करता है , जबकि @ kevpie का उत्तर अधिक सामान्य है और किसी भी चलने योग्य पर काम करता है ।
कोस

37

एक पुनरावृत्ति का उपयोग करें।

सूची की समझ:

>>> si = iter(['abcd', 'e', 'fg', 'hijklmn', 'opq', 'r'])
>>> [c+next(si, '') for c in si]
['abcde', 'fghijklmn', 'opqr']
  • मेमोरी उपयोग के लिए बहुत कुशल है।
  • बिल्कुल एक ट्रावेल के एस

जनरेटर अभिव्यक्ति:

>>> si = iter(['abcd', 'e', 'fg', 'hijklmn', 'opq', 'r'])
>>> pair_iter = (c+next(si, '') for c in si)
>>> pair_iter # can be used in a for loop
<generator object at 0x4ccaa8>
>>> list(pair_iter) 
['abcde', 'fghijklmn', 'opqr']
  • एक iterator के रूप में उपयोग करें

मानचित्र का उपयोग, str .__ add__, iter

>>> si = iter(['abcd', 'e', 'fg', 'hijklmn', 'opq', 'r'])
>>> map(str.__add__, si, si)
['abcde', 'fghijklmn', 'opqr']

अगला (पुनरावृत्त [, डिफ़ॉल्ट]) पायथन 2.6 में शुरू हो रहा है


2
अब तक, सबसे अच्छा जवाब। उत्‍तरमा के उत्‍तर देने के लिए मेरी टिप्‍पणी देखें।
पलक

4

बस अजगर होने के लिए :-)

>>> x = ['a1sd','23df','aaa','ccc','rrrr', 'ssss', 'e', '']
>>> [x[i] + x[i+1] for i in range(0,len(x),2)]
['a1sd23df', 'aaaccc', 'rrrrssss', 'e']

यदि आप चाहते हैं कि सूची की लंबाई विषम हो तो आप सतर्क रह सकते हैं:

[x[i] + x[i+1] if not len(x) %2 else 'odd index' for i in range(0,len(x),2)]

शुभकामनाएँ


2

अस्थायी सूचियों के निर्माण के बिना:

>>> import itertools
>>> s = 'abcdefgh'
>>> si = iter(s)
>>> [''.join(each) for each in itertools.izip(si, si)]
['ab', 'cd', 'ef', 'gh']

या:

>>> import itertools
>>> s = 'abcdefgh'
>>> si = iter(s)
>>> map(''.join, itertools.izip(si, si))
['ab', 'cd', 'ef', 'gh']

अच्छा है, लेकिन मेरे कोड को देखते हुए मुझे मूल सूची के साथ शुरू करने पर वैसे भी, मुझे लगता है कि बीमार को utdmr के लिए चुनते हैं .... धन्यवाद, हालांकि
जॉन


1

वैसे मैं इसे इस तरह से करूंगा क्योंकि मैं Regs के साथ अच्छा नहीं हूं।

कोड

t = '1. eat, food\n\
7am\n\
2. brush, teeth\n\
8am\n\
3. crack, eggs\n\
1pm'.splitlines()

print [i+j for i,j in zip(t[::2],t[1::2])]

उत्पादन:

['1. eat, food   7am', '2. brush, teeth   8am', '3. crack, eggs   1pm']  

उम्मीद है की यह मदद करेगा :)

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