छोटी सूचियों में विभाजित सूची (आधे में विभाजित)


150

मैं आसानी से आधे में एक अजगर सूची को विभाजित करने का एक तरीका ढूंढ रहा हूं।

ताकि अगर मेरे पास एक सरणी हो:

A = [0,1,2,3,4,5]

मैं प्राप्त करने में सक्षम हो जाएगा:

B = [0,1,2]

C = [3,4,5]

जवाबों:


226
A = [1,2,3,4,5,6]
B = A[:len(A)//2]
C = A[len(A)//2:]

यदि आप एक समारोह चाहते हैं:

def split_list(a_list):
    half = len(a_list)//2
    return a_list[:half], a_list[half:]

A = [1,2,3,4,5,6]
B, C = split_list(A)

70
आपको पायथन में इंट डिवीजन को मजबूर करने की आवश्यकता है। 3. // की आवश्यकता है।
स्टीफन केंडल

4
अच्छा समाधान, धन्यवाद। यह Python3 में 80/20 जैसे अंशों के साथ भी काम करता हैB = A[:(len(A) // 10) * 8] C = A[(len(A) // 10) * 8:]
Gergely M

87

थोड़ा और सामान्य समाधान (आप अपने इच्छित भागों की संख्या निर्दिष्ट कर सकते हैं, न कि केवल 'आधा' में विभाजित):

EDIT : विषम सूची की लंबाई को संभालने के लिए अद्यतन पोस्ट

EDIT2 : अपडेट पोस्ट Brians जानकारीपूर्ण टिप्पणियों के आधार पर फिर से

def split_list(alist, wanted_parts=1):
    length = len(alist)
    return [ alist[i*length // wanted_parts: (i+1)*length // wanted_parts] 
             for i in range(wanted_parts) ]

A = [0,1,2,3,4,5,6,7,8,9]

print split_list(A, wanted_parts=1)
print split_list(A, wanted_parts=2)
print split_list(A, wanted_parts=8)

2
जब सूची समान रूप से विभाजित नहीं होती है (जैसे स्प्लिट_लिस्ट ([१,२,३], २))) तो यह वास्तव में चाहता है कि १_ सूचियाँ वापस आ जाए।
ब्रायन

3
एक बेहतर तरीका मुझे लगता है कि होगा: लंबाई = लेन (एलिस्ट); वापसी [एलिस्ट [i * लंबाई // वांटेड_पार्ट्स: (i + 1) * लेंथ / वांटेड_पार्ट्स] आई फॉर रेंज (वांट_पार्ट्स)]। इस तरह से आपको एक समान वितरण संभव हो जाता है, और हमेशा बिलकुल वांटेड_पार्ट्स आइटम (यहां तक ​​कि पैड के साथ [] अगर वांछित_प्रेंट> लेन (ए)) मिलता है
ब्रायन

2
हाय .. प्रतीक "//" का क्या अर्थ है ??
frazman

2
@ फ़्रीज़ इसका मतलब इनलाइन टिप्पणी के रूप में है। स्क्रिप्ट निष्पादित करने के लिए "// वांटेड_पार्ट्स" और "// वांट_पार्ट्स" पर ध्यान न दें।
PunjCoder

19
//पूर्णांक विभाजन का मतलब है। उन्हें बाहर नहीं छोड़ा जाना चाहिए क्योंकि वे इस काम को बनाने में काफी आवश्यक हैं।
अल्फालदत्त 14

43
f = lambda A, n=3: [A[i:i+n] for i in range(0, len(A), n)]
f(A)

n - परिणाम सरणियों की पूर्वनिर्धारित लंबाई


1
यह मेरी स्थिति में बहुत अच्छा काम करता है, हालांकि यह प्रत्येक सूची के प्रत्येक अंतिम सूचकांक को अपनी सूची में जोड़ रहा है। समझाना मुश्किल है। कृपया जवाब दें यदि आप मदद कर सकते हैं और मैं और अधिक समझाऊंगा।
माइक इस्सा

34
def split(arr, size):
     arrs = []
     while len(arr) > size:
         pice = arr[:size]
         arrs.append(pice)
         arr   = arr[size:]
     arrs.append(arr)
     return arrs

परीक्षा:

x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
print(split(x, 5))

परिणाम:

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

1
मैट्रिक्स को सूची में परिवर्तित करने के लिए भी उपयोगी है
21

यह काम करता है, लेकिन काफी नहीं। मैं इस फ़ंक्शन को लूप में उपयोग कर रहा हूं, और लंबाई अलग-अलग हैं। दूसरे शब्दों में: for i,j in zip(list,lengths): print(split(i,j))listऔर lengthsसूचियों में एक ही लंबाई की है। j अल्टरनेटिंग है: 5,4,5,4,5, और स्प्लिट फंक्शन पहले दो ऑल्टरनेशन पर काम करता है, यानी यह i5 और 4 की लिस्ट में से पहला बंटवारा करता है , BUT अगले इक्वेशन पर इसे 4,4 पर विभाजित करता है, 1। : \ Please उत्तर दें यदि आप मुझे और अधिक समझाना चाहते हैं (एक नया प्रश्न पोस्ट करें)
माइक इस्सा

15

यदि आप आदेश की परवाह नहीं करते हैं ...

def split(list):  
    return list[::2], list[1::2]

list[::2]0 तत्व से शुरू होने वाली सूची में हर दूसरा तत्व मिलता है।
list[1::2]1 तत्व से शुरू होने वाली सूची में हर दूसरा तत्व मिलता है।


4
अंतर्निहित इनका listछायांकन करने के साथ सावधानीपूर्वक arg को नाम देना list(...)। मैंने इससे बचने के लिए आमतौर पर देखा lstऔर list_इस्तेमाल किया है।
टेलर एड्मिस्टन

3
यह सबसे अधिक
पायथोनिक


11

यहाँ एक आम समाधान है, गिनती भाग में विभाजित गिरफ्तारी

def split(arr, count):
     return [arr[i::count] for i in range(count)]

यह सूची का क्रम खो देता है
तिमाह

9
def splitter(A):
    B = A[0:len(A)//2]
    C = A[len(A)//2:]

 return (B,C)

मैंने परीक्षण किया, और अजगर में इंट डिवीजन को मजबूर करने के लिए डबल स्लैश की आवश्यकता है। 3. मेरा मूल पद सही था, हालांकि किसी कारणवश ओपेरा में विस्विएग टूट गया।


यह अजीब लेन (ए) को नहीं संभालता है - क्या आपके पास इसके लिए समाधान है?
N997

6

आकार के छोटे सरणियों में एक सरणी को विभाजित करने के अधिक सामान्यीकृत मामले के लिए एक आधिकारिक पायथन रसीद है n

from itertools import izip_longest
def grouper(n, iterable, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

यह कोड स्निपेट अजगर इटर्टोल्स डॉक्टर पृष्ठ से है


6

सूची का उपयोग करना । वाक्यविन्यास मूल रूप से हैmy_list[start_index:end_index]

>>> i = [0,1,2,3,4,5]
>>> i[:3] # same as i[0:3] - grabs from first to third index (0->2)
[0, 1, 2]
>>> i[3:] # same as i[3:len(i)] - grabs from fourth index to end
[3, 4, 5]

सूची के पहले भाग को पाने के लिए, आप पहले सूचकांक से len(i)//2(जहां //पूर्णांक विभाजन है - तो 3//2 will give the floored result of1 , instead of the invalid list index of1.5`) स्लाइस करें:

>>> i[:len(i)//2]
[0, 1, 2]

.. और दूसरी छमाही पाने के लिए मूल्यों को स्वैप करें:

>>> i[len(i)//2:]
[3, 4, 5]

विषम लेन सूचियों के बारे में क्या)
N997

@ N997 कोड को अभी भी काम करना चाहिए; आप बस प्रत्येक सूची में विभिन्न मदों की संख्या के साथ समाप्त होते हैं। तो कहते हैं कि सूची तीन आइटम लंबी है, डिवीजन ऑपरेटर परिणाम 3//2देता है 1, इसलिए आपको वह मिलता है i[:1]जो आपको देता है [0]और i[1:]जो देता है[1, 2]
dbr

3

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

from itertools import islice

def make_chunks(data, SIZE):
    it = iter(data)
    # use `xragne` if you are in python 2.7:
    for i in range(0, len(data), SIZE):
        yield [k for k in islice(it, SIZE)]

आप इसका उपयोग कर सकते हैं जैसे:

A = [0, 1, 2, 3, 4, 5, 6]

size = len(A) // 2

for sample in make_chunks(A, size):
    print(sample)

आउटपुट है:

[0, 1, 2]
[3, 4, 5]
[6]

@Thefourtheye और @Bede Constantinides को धन्यवाद


3

10 साल बाद .. मैंने सोचा - क्यों न एक और जोड़ा जाए:

arr = 'Some random string' * 10; n = 4
print([arr[e:e+n] for e in range(0,len(arr),n)])

2

जबकि ऊपर दिए गए उत्तर कम या ज्यादा सही हैं, आप परेशानी में पड़ सकते हैं यदि आपके सरणी का आकार 2 से विभाज्य नहीं है, जिसके परिणामस्वरूप a / 2, विषम होने के नाते, अजगर 3.0 में एक फ्लोट है, और यदि आप पहले संस्करण में हैं from __future__ import divisionअपनी स्क्रिप्ट की शुरुआत में निर्दिष्ट करें । आप किसी भी मामले में पूर्णांक विभाजन के लिए जा रहे हैं, यानी a // 2, अपने कोड की "फॉरवर्ड" संगतता पाने के लिए।



0

@ChristopheD से संकेत के साथ

def line_split(N, K=1):
    length = len(N)
    return [N[i*length/K:(i+1)*length/K] for i in range(K)]

A = [0,1,2,3,4,5,6,7,8,9]
print line_split(A,1)
print line_split(A,2)


0

एक और 2020 में इस समस्या को ले ... यहाँ समस्या का एक सामान्यीकरण है। मैं 'आधा में एक सूची को विभाजित करने के लिए' की व्याख्या करता हूं .. (यानी केवल दो सूचियां और एक विषम आदि के मामले में तीसरे सरणी के लिए कोई स्पिलओवर नहीं होगा)। उदाहरण के लिए, यदि सरणी की लंबाई 19 है और दो का उपयोग करके एक डिवीजन // ऑपरेटर 9 देता है, और हम लंबाई के दो सरणियों को समाप्त करेंगे और लंबाई 1 का एक सरणी (तीसरा) (कुल तीन सरणियों में)। यदि हम हर समय दो सरणियों को देने के लिए एक सामान्य समाधान चाहते हैं, तो मैं मान लूंगा कि हम परिणामी डुओ सरणियों से खुश हैं जो लंबाई में बराबर नहीं हैं (एक दूसरे की तुलना में लंबा होगा)। और यह माना जाता है कि आदेश मिलाया जाना ठीक है (इस मामले में बारी-बारी से)।

"""
arrayinput --> is an array of length N that you wish to split 2 times
"""
ctr = 1 # lets initialize a counter

holder_1 = []
holder_2 = []

for i in range(len(arrayinput)): 

    if ctr == 1 :
        holder_1.append(arrayinput[i])
    elif ctr == 2: 
        holder_2.append(arrayinput[i])

    ctr += 1 

    if ctr > 2 : # if it exceeds 2 then we reset 
        ctr = 1 

यह अवधारणा किसी भी सूची विभाजन के लिए काम करती है जैसा आप चाहते हैं (आपको कितने सूची भागों के आधार पर कोड को ट्विक करना होगा)। और व्याख्या करने के लिए सीधा है। चीजों को गति देने के लिए, आप चीजों को गति देने के लिए इस लूप को साइथन / C / C ++ में भी लिख सकते हैं। फिर, मैंने इस कोड को अपेक्षाकृत छोटी सूचियों ~ 10,000 पंक्तियों पर आज़माया है और यह दूसरे के एक अंश में समाप्त हो गया है।

केवल मेरे दो सेंट्स।

धन्यवाद!

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