मैं आसानी से आधे में एक अजगर सूची को विभाजित करने का एक तरीका ढूंढ रहा हूं।
ताकि अगर मेरे पास एक सरणी हो:
A = [0,1,2,3,4,5]
मैं प्राप्त करने में सक्षम हो जाएगा:
B = [0,1,2]
C = [3,4,5]
मैं आसानी से आधे में एक अजगर सूची को विभाजित करने का एक तरीका ढूंढ रहा हूं।
ताकि अगर मेरे पास एक सरणी हो:
A = [0,1,2,3,4,5]
मैं प्राप्त करने में सक्षम हो जाएगा:
B = [0,1,2]
C = [3,4,5]
जवाबों:
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)
B = A[:(len(A) // 10) * 8]
C = A[(len(A) // 10) * 8:]
थोड़ा और सामान्य समाधान (आप अपने इच्छित भागों की संख्या निर्दिष्ट कर सकते हैं, न कि केवल 'आधा' में विभाजित):
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)
//
पूर्णांक विभाजन का मतलब है। उन्हें बाहर नहीं छोड़ा जाना चाहिए क्योंकि वे इस काम को बनाने में काफी आवश्यक हैं।
f = lambda A, n=3: [A[i:i+n] for i in range(0, len(A), n)]
f(A)
n
- परिणाम सरणियों की पूर्वनिर्धारित लंबाई
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]]
for i,j in zip(list,lengths): print(split(i,j))
। list
और lengths
सूचियों में एक ही लंबाई की है। j अल्टरनेटिंग है: 5,4,5,4,5, और स्प्लिट फंक्शन पहले दो ऑल्टरनेशन पर काम करता है, यानी यह i
5 और 4 की लिस्ट में से पहला बंटवारा करता है , BUT अगले इक्वेशन पर इसे 4,4 पर विभाजित करता है, 1। : \ Please उत्तर दें यदि आप मुझे और अधिक समझाना चाहते हैं (एक नया प्रश्न पोस्ट करें)
यदि आप आदेश की परवाह नहीं करते हैं ...
def split(list):
return list[::2], list[1::2]
list[::2]
0 तत्व से शुरू होने वाली सूची में हर दूसरा तत्व मिलता है।
list[1::2]
1 तत्व से शुरू होने वाली सूची में हर दूसरा तत्व मिलता है।
list
छायांकन करने के साथ सावधानीपूर्वक arg को नाम देना list(...)
। मैंने इससे बचने के लिए आमतौर पर देखा lst
और list_
इस्तेमाल किया है।
यहाँ एक आम समाधान है, गिनती भाग में विभाजित गिरफ्तारी
def split(arr, count):
return [arr[i::count] for i in range(count)]
def splitter(A):
B = A[0:len(A)//2]
C = A[len(A)//2:]
return (B,C)
मैंने परीक्षण किया, और अजगर में इंट डिवीजन को मजबूर करने के लिए डबल स्लैश की आवश्यकता है। 3. मेरा मूल पद सही था, हालांकि किसी कारणवश ओपेरा में विस्विएग टूट गया।
आकार के छोटे सरणियों में एक सरणी को विभाजित करने के अधिक सामान्यीकृत मामले के लिए एक आधिकारिक पायथन रसीद है 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)
यह कोड स्निपेट अजगर इटर्टोल्स डॉक्टर पृष्ठ से है ।
सूची का उपयोग करना । वाक्यविन्यास मूल रूप से है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 of
1 , instead of the invalid list index of
1.5`) स्लाइस करें:
>>> i[:len(i)//2]
[0, 1, 2]
.. और दूसरी छमाही पाने के लिए मूल्यों को स्वैप करें:
>>> i[len(i)//2:]
[3, 4, 5]
3//2
देता है 1
, इसलिए आपको वह मिलता है i[:1]
जो आपको देता है [0]
और i[1:]
जो देता है[1, 2]
यदि आपके पास एक बड़ी सूची है, तो इटर्लूल का उपयोग करना बेहतर है और आवश्यकतानुसार प्रत्येक भाग की उपज के लिए एक फ़ंक्शन लिखें।
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 को धन्यवाद
जबकि ऊपर दिए गए उत्तर कम या ज्यादा सही हैं, आप परेशानी में पड़ सकते हैं यदि आपके सरणी का आकार 2 से विभाज्य नहीं है, जिसके परिणामस्वरूप a / 2
, विषम होने के नाते, अजगर 3.0 में एक फ्लोट है, और यदि आप पहले संस्करण में हैं from __future__ import division
अपनी स्क्रिप्ट की शुरुआत में निर्दिष्ट करें । आप किसी भी मामले में पूर्णांक विभाजन के लिए जा रहे हैं, यानी a // 2
, अपने कोड की "फॉरवर्ड" संगतता पाने के लिए।
यह अन्य समाधानों के समान है, लेकिन थोड़ा तेज है।
# Usage: split_half([1,2,3,4,5]) Result: ([1, 2], [3, 4, 5])
def split_half(a):
half = len(a) >> 1
return a[:half], a[half:]
#for python 3
A = [0,1,2,3,4,5]
l = len(A)/2
B = A[:int(l)]
C = A[int(l):]
एक और 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 पंक्तियों पर आज़माया है और यह दूसरे के एक अंश में समाप्त हो गया है।
केवल मेरे दो सेंट्स।
धन्यवाद!