আনুমানিক সমান দৈর্ঘ্যের N অংশগুলিতে একটি তালিকা বিভক্ত করা

Question

কোনও তালিকা প্রায় সমান ভাগে ভাগ করার সর্বোত্তম উপায় কী ? উদাহরণস্বরূপ, যদি তালিকার 7 টি উপাদান থাকে এবং এটি 2 ভাগে বিভক্ত হয় তবে আমরা একটি অংশে 3 টি উপাদান পেতে চাই এবং অন্যটিতে 4 টি উপাদান থাকা উচিত।

আমি ভালো কিছু খুঁজছি even_split(L, n)যে বিরতি Lমধ্যে nঅংশ।

def chunks(L, n):
    """ Yield successive n-sized chunks from L.
    """
    for i in range(0, len(L), n):
        yield L[i:i+n]

উপরের কোডটি 3 টি খণ্ডের চেয়ে 3 টি করে দেয় আমি কেবল স্থানান্তর করতে পারি (এটির উপরে পুনরাবৃত্তি করতে এবং প্রতিটি কলামের প্রথম উপাদানটি নিতে পারি, সেই অংশটিকে একটি কল করতে পারি, তারপরে দ্বিতীয়টি নিয়ে পার্ট টু ইত্যাদিতে রাখি) তবে এটি আইটেমের ক্রমকে নষ্ট করে দেয়।

Answer 1

রাউন্ডিং ত্রুটির কারণে এই কোডটি নষ্ট হয়ে গেছে। এটা ব্যবহার করোনা!!!

assert len(chunkIt([1,2,3], 10)) == 10  # fails

---

এখানে কাজ করতে পারে এমন একটি:

def chunkIt(seq, num):
    avg = len(seq) / float(num)
    out = []
    last = 0.0

    while last < len(seq):
        out.append(seq[int(last):int(last + avg)])
        last += avg

    return out

পরীক্ষামূলক:

>>> chunkIt(range(10), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
>>> chunkIt(range(11), 3)
[[0, 1, 2], [3, 4, 5, 6], [7, 8, 9, 10]]
>>> chunkIt(range(12), 3)
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]

Comments

আপনার উদাহরণ >>> chunkIt(range(8), 6)=>[[0], [1], [2, 3], [4], [5], [6], [7]]

— op ই

@ নপার, আমি এই প্রান্তের কেসটি পরিচালনা করতে শর্তসাপেক্ষে একটি "if num == 1:" যুক্ত করেছি।

— পাউলি 4

নতুন দর্শনার্থী: দয়া করে এই কোডটি ব্যবহার বা উজ্জীবিত করবেন না এটি ভেঙে গেছে। যেমন chunkIt(range(10), 9)9 অংশ ফিরে আসা উচিত, কিন্তু এটি না।

— উইম

উত্তরটি বেশ কয়েকবার সম্পাদনা করা হওয়ায় এই মন্তব্য থ্রেডটি সত্যই বিভ্রান্তিকর। এটি কি ভাল উত্তর? ভাল উত্তর না?

— কনকোচিয়া

@ কনকোয়েসিয়া একটি ভাল উত্তর নয়, নিচে স্ক্রোলিং রাখুন। এটি এখন পর্যন্ত একবারে সম্পাদিত হয়েছিল এবং এটি কেবল একটি তুচ্ছ সম্পাদনা ছিল (2 স্পেস ইন্ডেন্টটি পরিবর্তিত হয়ে 4 এ পরিণত হয়েছিল)। দুর্ভাগ্যক্রমে ওপিতে "ইউজার 248237dfsf" 3 বছরেরও বেশি সময় ধরে সাইটে দেখা যায়নি, সুতরাং গৃহীত উত্তরটি পরিবর্তিত হওয়ার খুব কম আশা রয়েছে।

— উইম

Answer 2

আপনি তালিকা জেনারেটর হিসাবে মোটামুটি সহজভাবে এটি লিখতে পারেন:

def split(a, n):
    k, m = divmod(len(a), n)
    return (a[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n))

উদাহরণ:

>>> list(split(range(11), 3))
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10]]

Comments

যেখানে n = min(n, len(a)) # don't create empty bucketsযেমন list(split(range(X, Y)))X < Y

— দৃশ্যে

আমি আমার মন্তব্য সম্পাদনা করতে পারছি না এমনভাবে দেখে - আমার যুক্ত করা উচিত যে তালিকাটি খালি থাকলে আমার পূর্ববর্তী সংশোধনটি সম্ভবত শূন্য ত্রুটির দ্বারা একটি বিভাগ বাড়িয়ে তুলতে পারে, যাতে এটি বাহ্যিকভাবে নিয়ন্ত্রণ করা বা সমাধানে যুক্ত করা প্রয়োজন।

— আবানানা

এসও-তে এন উত্তরগুলির বাইরে, এটিই কেবলমাত্র আমার সমস্ত পরীক্ষায় উত্তীর্ণ। GJ!

— এভিশাইপ

stackoverflow.com/a/37414115/210971 একই পদ্ধতি ব্যবহার করে তবে খালি তালিকা এবং 0 বিভাজন কাউন্টারেও কাজ করে।

— লুকএইডআউটটিউর টাইপস

সুন্দর! এছাড়াও, ফেরত বিবৃতিতে কে এবং এন অদলবদল করে ব্যাচ_সাইজ হিসাবে কাজ করা যেতে পারে :)

— haraprasadj

Answer 3

এটি রাইসন ডি'অ্যাট্রেnumpy.array_split * এর জন্য :

>>> import numpy as np
>>> print(*np.array_split(range(10), 3))
[0 1 2 3] [4 5 6] [7 8 9]
>>> print(*np.array_split(range(10), 4))
[0 1 2] [3 4 5] [6 7] [8 9]
>>> print(*np.array_split(range(10), 5))
[0 1] [2 3] [4 5] [6 7] [8 9]

_{* ঘরে জিরো পাইরেয়াসকে ক্রেডিট করুন}

Comments

কি *মধ্যে printজন্য?

— yuqli

হেই @ ইউক্লি, এটি কোনও কিছুর তালিকাকে পৃথক যুক্তিতে রূপান্তর করে একটি ফাংশনে। চেষ্টা করুন print(L)এবং `মুদ্রণ (* এল)। এছাড়াও স্ট্যাকওভারফ্লো.com / a / 36908 / 2184122 দেখুন বা " অজগরটির অজগর ব্যবহার" অনুসন্ধান করুন।

— রবার্ট লাগেজ

Answer 4

যতক্ষণ না আপনি অবিচ্ছিন্ন অংশগুলির মতো নির্বোধ কিছু চান না:

>>> def chunkify(lst,n):
...     return [lst[i::n] for i in xrange(n)]
... 
>>> chunkify(range(13), 3)
[[0, 3, 6, 9, 12], [1, 4, 7, 10], [2, 5, 8, 11]]

Comments

আমি বলব না ক্রমাগত অংশগুলি নির্বোধ। সম্ভবত আপনি খণ্ডগুলি বাছাই করে রাখতে চাইবেন (উদাহরণস্বরূপ [[0] <हिस्सा [1]), উদাহরণস্বরূপ।

— tixxit

আমি মজা করছিলাম. তবে আপনি যদি সত্যিই যত্ন না করেন তবে তালিকা বোঝার সাথে এই উপায়টি দুর্দান্ত এবং সংক্ষিপ্ত।

— কাজ

এটি এন

— স্মিপি

এই জিপটিতে এই আউটপুটটি প্রেরণ আপনাকে zip(*chunkify(range(13), 3))[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11)]

— জিন্স

আপনার সমাধানের তালিকার ক্রম প্রয়োজন না হওয়া পর্যন্ত এই সমাধানগুলি সূক্ষ্মভাবে কাজ করে।

— s7anley

Answer 5

কোডগুলি পরিবর্তনের nঅংশগুলির চেয়ে খণ্ড ফল দিতে n:

def chunks(l, n):
    """ Yield n successive chunks from l.
    """
    newn = int(len(l) / n)
    for i in xrange(0, n-1):
        yield l[i*newn:i*newn+newn]
    yield l[n*newn-newn:]

l = range(56)
three_chunks = chunks (l, 3)
print three_chunks.next()
print three_chunks.next()
print three_chunks.next()

যা দেয়:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
[18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]
[36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]

এটি চূড়ান্ত গোষ্ঠীতে অতিরিক্ত উপাদানগুলি অর্পণ করবে যা নিখুঁত নয় তবে আপনার "মোটামুটি এন সমান অংশ" এর স্পেসিফিকেশনের মধ্যে ভাল: :) এর অর্থ, আমার মানে ৫ mean টি উপাদান (19,19,18) হিসাবে আরও ভাল হবে যেখানে এটি দেয় (18,18,20)।

আপনি নিম্নলিখিত কোড সহ আরও সুষম আউটপুট পেতে পারেন:

#!/usr/bin/python
def chunks(l, n):
    """ Yield n successive chunks from l.
    """
    newn = int(1.0 * len(l) / n + 0.5)
    for i in xrange(0, n-1):
        yield l[i*newn:i*newn+newn]
    yield l[n*newn-newn:]

l = range(56)
three_chunks = chunks (l, 3)
print three_chunks.next()
print three_chunks.next()
print three_chunks.next()

কোন ফলাফল:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
[19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37]
[38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]

Comments

এটি আমাকে একটি অদ্ভুত ফলাফল দেয়। খণ্ডগুলিতে পি এর জন্য (পরিসীমা (54), 3): প্রিন্ট লেন (পি) 18, 18, 51 রিটার্ন দেয় ...

স্থির, যে, এটি চূড়ান্ত ফলন ছিল।

— paxdiablo

লিঙ্কে

— জাকব ক্রোকার

এটি ব্যবহারিক বিবেচনার জন্য সবচেয়ে দরকারী উত্তর। ধন্যবাদ!

— এমভিসিএইচআর

যখন আমি এটি ব্যবহার করি, করণীয় হয় তখন আমি for x in chunks(mylist,num): print xপছন্দসই খণ্ডগুলি পাই তবে তাদের মধ্যে আমি একটি খালি তালিকা পাই। কোন ধারণা কেন? এটি হ'ল, আমি []প্রতিটি অংশের পরে একটি করে প্রচুর পরিমাণে পাই ।

— synaptik

Answer 6

আপনি যদি nউপাদানগুলিকে মোটামুটি kঅংশগুলিতে বিভক্ত করেন n % kতবে অতিরিক্ত উপাদানগুলি বিতরণ করার জন্য আপনি খণ্ডগুলি 1 টি উপাদানকে অন্যান্য অংশগুলির চেয়ে বড় করতে পারেন ।

নিম্নলিখিত কোড আপনাকে খণ্ডগুলি জন্য দৈর্ঘ্য দেবে:

[(n // k) + (1 if i < (n % k) else 0) for i in range(k)]

উদাহরণ: n=11, k=3ফলাফল[4, 4, 3]

তারপরে আপনি সহজেই খণ্ডগুলির জন্য সূচনার সূচকগুলি গণনা করতে পারেন:

[i * (n // k) + min(i, n % k) for i in range(k)]

উদাহরণ: n=11, k=3ফলাফল[0, 4, 8]

ব্যবহার i+1সীমানা হিসাবে তম খণ্ড করে আমরা পাই iতালিকার তম খণ্ড lলেন সঙ্গে nহয়

l[i * (n // k) + min(i, n % k):(i+1) * (n // k) + min(i+1, n % k)]

চূড়ান্ত পদক্ষেপ হিসাবে তালিকা বোঝার ব্যবহার করে সমস্ত খণ্ড থেকে একটি তালিকা তৈরি করুন:

[l[i * (n // k) + min(i, n % k):(i+1) * (n // k) + min(i+1, n % k)] for i in range(k)]

উদাহরণ: n=11, k=3, l=range(n)ফলাফল[range(0, 4), range(4, 8), range(8, 11)]

Answer 7

এটি একটি একক অভিব্যক্তি দ্বারা বিভাজন করবে:

>>> myList = range(18)
>>> parts = 5
>>> [myList[(i*len(myList))//parts:((i+1)*len(myList))//parts] for i in range(parts)]
[[0, 1, 2], [3, 4, 5, 6], [7, 8, 9], [10, 11, 12, 13], [14, 15, 16, 17]]

এই উদাহরণের তালিকার আকার 18 টি এবং 5 ভাগে বিভক্ত। অংশগুলির আকার একাধিক উপাদানের চেয়ে পৃথক নয়।

Answer 8

দেখুন more_itertools.divide:

n = 2

[list(x) for x in mit.divide(n, range(5, 11))]
# [[5, 6, 7], [8, 9, 10]]

[list(x) for x in mit.divide(n, range(5, 12))]
# [[5, 6, 7, 8], [9, 10, 11]]

এর মাধ্যমে ইনস্টল করুন > pip install more_itertools।

Answer 9

এখানে Noneতালিকাগুলির সমান দৈর্ঘ্য তৈরি করতে যুক্ত করা হয়েছে

>>> from itertools import izip_longest
>>> def chunks(l, n):
    """ Yield n successive chunks from l. Pads extra spaces with None
    """
    return list(zip(*izip_longest(*[iter(l)]*n)))

>>> l=range(54)

>>> chunks(l,3)
[(0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51), (1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52), (2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53)]

>>> chunks(l,4)
[(0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52), (1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53), (2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, None), (3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, None)]

>>> chunks(l,5)
[(0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50), (1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51), (2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52), (3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53), (4, 9, 14, 19, 24, 29, 34, 39, 44, 49, None)]

Answer 10

এখানে আমার সমাধান:

def chunks(l, amount):
    if amount < 1:
        raise ValueError('amount must be positive integer')
    chunk_len = len(l) // amount
    leap_parts = len(l) % amount
    remainder = amount // 2  # make it symmetrical
    i = 0
    while i < len(l):
        remainder += leap_parts
        end_index = i + chunk_len
        if remainder >= amount:
            remainder -= amount
            end_index += 1
        yield l[i:end_index]
        i = end_index

উত্পাদন

    >>> list(chunks([1, 2, 3, 4, 5, 6, 7], 3))
    [[1, 2], [3, 4, 5], [6, 7]]

Answer 11

এখানে এমন একটি জেনারেটর রয়েছে যা কোনও ধনাত্মক (পূর্ণসংখ্যার) সংখ্যাকে পরিচালনা করতে পারে। ইনপুট তালিকার দৈর্ঘ্যের চেয়ে অংশগুলির সংখ্যা বেশি হলে কিছু খণ্ড খালি থাকবে। এই অ্যালগরিদমটি আলাদা করার পরিবর্তে সংক্ষিপ্ত এবং দীর্ঘ অংশগুলির মধ্যে পরিবর্তিত হয়।

আমি ragged_chunksফাংশনটি পরীক্ষা করার জন্য কিছু কোডও অন্তর্ভুক্ত করেছি ।

''' Split a list into "ragged" chunks

    The size of each chunk is either the floor or ceiling of len(seq) / chunks

    chunks can be > len(seq), in which case there will be empty chunks

    Written by PM 2Ring 2017.03.30
'''

def ragged_chunks(seq, chunks):
    size = len(seq)
    start = 0
    for i in range(1, chunks + 1):
        stop = i * size // chunks
        yield seq[start:stop]
        start = stop

# test

def test_ragged_chunks(maxsize):
    for size in range(0, maxsize):
        seq = list(range(size))
        for chunks in range(1, size + 1):
            minwidth = size // chunks
            #ceiling division
            maxwidth = -(-size // chunks)
            a = list(ragged_chunks(seq, chunks))
            sizes = [len(u) for u in a]
            deltas = all(minwidth <= u <= maxwidth for u in sizes)
            assert all((sum(a, []) == seq, sum(sizes) == size, deltas))
    return True

if test_ragged_chunks(100):
    print('ok')

---

আমরা এই করতে পারেন সামান্য মধ্যে গুণ রপ্তানি করে আরও দক্ষ rangeকল, কিন্তু আমি মনে করি পূর্ববর্তী সংস্করণ আরো পাঠযোগ্য (এবং ড্রায়ার) হয়।

def ragged_chunks(seq, chunks):
    size = len(seq)
    start = 0
    for i in range(size, size * chunks + 1, size):
        stop = i // chunks
        yield seq[start:stop]
        start = stop

Answer 12

নামি.স্প্লিট এ একবার দেখুন :

>>> a = numpy.array([1,2,3,4])
>>> numpy.split(a, 2)
[array([1, 2]), array([3, 4])]

Comments

এবং numpy.array_split () আরও বেশি পর্যাপ্ত কারণ এটি প্রায় বিভক্ত হয়।

— ইয়ারিভ

অ্যারের আকার বিভাজনের সংখ্যা দ্বারা বিভাজ্য না হলে এটি কাজ করে না।

— ড্যান

এটি ভুল উত্তর, আপনার সমাধান ndarrays তালিকা ফিরে আসে, তালিকার তালিকা নয়

— Ch Zop Z Lasu

Answer 13

Numpy.linspace পদ্ধতি ব্যবহার করে বাস্তবায়ন।

আপনি যে অংশে অ্যারে বিভক্ত হতে চান তার সংখ্যা নির্দিষ্ট করুন division বিভাগগুলি প্রায় সমান আকারের হবে।

উদাহরণ:

import numpy as np   
a=np.arange(10)
print "Input array:",a 
parts=3
i=np.linspace(np.min(a),np.max(a)+1,parts+1)
i=np.array(i,dtype='uint16') # Indices should be floats
split_arr=[]
for ind in range(i.size-1):
    split_arr.append(a[i[ind]:i[ind+1]]
print "Array split in to %d parts : "%(parts),split_arr

দেয়:

Input array: [0 1 2 3 4 5 6 7 8 9]
Array split in to 3 parts :  [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8, 9])]

Answer 14

আমার সমাধান, বুঝতে সহজ

def split_list(lst, n):
    splitted = []
    for i in reversed(range(1, n + 1)):
        split_point = len(lst)//i
        splitted.append(lst[:split_point])
        lst = lst[split_point:]
    return splitted

এবং এই পৃষ্ঠায় স্বল্পতম ওয়ান-লাইনার (আমার মেয়ে দ্বারা লিখিত)

def split(l, n):
    return [l[int(i*len(l)/n):int((i+1)*len(l)/n-1)] for i in range(n)]

Comments

এফওয়াইআই: আপনার ওয়ান-লাইনারটি ভেঙে গেছে, ভুল ফলাফল দেয়। অন্যটি সুন্দরভাবে কাজ করে।

— পাওলো ফ্রেইটাস

Answer 15

তালিকা বোঝার ব্যবহার:

def divide_list_to_chunks(list_, n):
    return [list_[start::n] for start in range(n)]

Comments

এটি সমস্ত খণ্ডগুলি এমনকি তৈরি করার বিষয়টি বিবেচনা করে না।

— সুপারবিসাইডমান

Answer 16

আর একটি উপায় এর মতো কিছু হবে, এখানে ধারণাটি গ্রুপার ব্যবহার করা, তবে এ থেকে মুক্তি পাওয়া None। এক্ষেত্রে আমাদের তালিকার প্রথম অংশে উপাদানগুলি থেকে তৈরি সমস্ত 'ছোট_ভাগ' এবং তালিকার পরবর্তী অংশ থেকে 'বৃহত্তর_ভাগগুলি' থাকবে। 'বৃহত্তর অংশগুলির দৈর্ঘ্য লেন (ছোট_বিশেষ) + ১। আমাদের এক্সকে দুটি পৃথক উপ-অংশ হিসাবে বিবেচনা করা উচিত।

from itertools import izip_longest

import numpy as np

def grouper(n, iterable, fillvalue=None): # This is grouper from itertools
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

def another_chunk(x,num):
    extra_ele = len(x)%num #gives number of parts that will have an extra element 
    small_part = int(np.floor(len(x)/num)) #gives number of elements in a small part

    new_x = list(grouper(small_part,x[:small_part*(num-extra_ele)]))
    new_x.extend(list(grouper(small_part+1,x[small_part*(num-extra_ele):])))

    return new_x

আমার এটি যেভাবে সেট আপ করা হয়েছে তাতে টিপলগুলির একটি তালিকা ফিরে আসে:

>>> x = range(14)
>>> another_chunk(x,3)
[(0, 1, 2, 3), (4, 5, 6, 7, 8), (9, 10, 11, 12, 13)]
>>> another_chunk(x,4)
[(0, 1, 2), (3, 4, 5), (6, 7, 8, 9), (10, 11, 12, 13)]
>>> another_chunk(x,5)
[(0, 1), (2, 3, 4), (5, 6, 7), (8, 9, 10), (11, 12, 13)]
>>> 

Answer 17

এখানে আরও একটি বৈকল্পিক যা সমস্ত অংশগুলিতে সমানভাবে "অবশিষ্ট" উপাদানগুলি ছড়িয়ে দেয়, একসময় একবারে কোনও কিছুই অবশিষ্ট না থাকে। এই প্রয়োগে, বৃহত্তর অংশগুলি প্রক্রিয়াটির শুরুতে ঘটে।

def chunks(l, k):
  """ Yield k successive chunks from l."""
  if k < 1:
    yield []
    raise StopIteration
  n = len(l)
  avg = n/k
  remainders = n % k
  start, end = 0, avg
  while start < n:
    if remainders > 0:
      end = end + 1
      remainders = remainders - 1
    yield l[start:end]
    start, end = end, end+avg

উদাহরণস্বরূপ, 14 উপাদানগুলির তালিকা থেকে 4 টি অংশ তৈরি করুন:

>>> list(chunks(range(14), 4))
[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10], [11, 12, 13]]
>>> map(len, list(chunks(range(14), 4)))
[4, 4, 3, 3]

Answer 18

কাজের উত্তর হিসাবে একই , কিন্তু খণ্ডের সংখ্যার চেয়ে ছোট আকারের সাথে অ্যাকাউন্ট তালিকাগুলি গ্রহণ করে।

def chunkify(lst,n):
    [ lst[i::n] for i in xrange(n if n < len(lst) else len(lst)) ]

যদি এন (খণ্ডের সংখ্যা) 7 হয় এবং লোকে (ভাগ করার তালিকা) হয় [1, 2, 3] খণ্ডগুলি [[0], [1], [2]] এর পরিবর্তে [[0], [1 ], [২], [], [], [], []]

Answer 19

আপনি এটি ব্যবহার করতে পারেন:

split=lambda x,n: x if not x else [x[:n]]+[split([] if not -(len(x)-n) else x[-(len(x)-n):],n)][0]

split([1,2,3,4,5,6,7,8,9],2)

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

Answer 20

def evenly(l, n):
    len_ = len(l)
    split_size = len_ // n
    split_size = n if not split_size else split_size
    offsets = [i for i in range(0, len_, split_size)]
    return [l[offset:offset + split_size] for offset in offsets]

উদাহরণ:

l = [a for a in range(97)] 10 টি অংশ নিয়ে গঠিত হওয়া উচিত, প্রতিটিের 9 টি উপাদান থাকে যা শেষ অংশ ব্যতীত।

আউটপুট:

[[0, 1, 2, 3, 4, 5, 6, 7, 8],
 [9, 10, 11, 12, 13, 14, 15, 16, 17],
 [18, 19, 20, 21, 22, 23, 24, 25, 26],
 [27, 28, 29, 30, 31, 32, 33, 34, 35],
 [36, 37, 38, 39, 40, 41, 42, 43, 44],
 [45, 46, 47, 48, 49, 50, 51, 52, 53],
 [54, 55, 56, 57, 58, 59, 60, 61, 62],
 [63, 64, 65, 66, 67, 68, 69, 70, 71],
 [72, 73, 74, 75, 76, 77, 78, 79, 80],
 [81, 82, 83, 84, 85, 86, 87, 88, 89],
 [90, 91, 92, 93, 94, 95, 96]]

Answer 21

ধরা যাক আপনি একটি তালিকা [1, 2, 3, 4, 5, 6, 7, 8] কে 3 টি উপাদান তালিকায় বিভক্ত করতে চান

মত [[1,2,3], [4, 5, 6], [7, 8]] , যেখানে যদি গত অবশিষ্ট বাম উপাদান 3 তুলনায় কম, তারা একসাথে দলবদ্ধ করা হয়।

my_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_list2 = [my_list[i:i+3] for i in range(0, len(my_list), 3)]
print(my_list2)

আউটপুট: [[1,2,3], [4, 5, 6], [7, 8]]

যেখানে এক অংশের দৈর্ঘ্য ৩. আপনার নিজের খণ্ড আকারের সাথে 3 প্রতিস্থাপন করুন।

Answer 22

1>

import numpy as np

data # your array

total_length = len(data)
separate = 10
sub_array_size = total_length // separate
safe_separate = sub_array_size * separate

splited_lists = np.split(np.array(data[:safe_separate]), separate)
splited_lists[separate - 1] = np.concatenate(splited_lists[separate - 1], 
np.array(data[safe_separate:total_length]))

splited_lists # your output

2>

splited_lists = np.array_split(np.array(data), separate)

Answer 23

def chunk_array(array : List, n: int) -> List[List]:
    chunk_size = len(array) // n 
    chunks = []
    i = 0
    while i < len(array):
        # if less than chunk_size left add the remainder to last element
        if len(array) - (i + chunk_size + 1) < 0:
            chunks[-1].append(*array[i:i + chunk_size])
            break
        else:
            chunks.append(array[i:i + chunk_size])
            i += chunk_size
    return chunks

এখানে আমার সংস্করণ (ম্যাক্স থেকে অনুপ্রাণিত)

Answer 24

লিনস্পেসকে গোল করা এবং এটি একটি সূচক হিসাবে ব্যবহার করা amit12690 এর প্রস্তাবের চেয়ে সহজ সমাধান।

function chunks=chunkit(array,num)

index = round(linspace(0,size(array,2),num+1));

chunks = cell(1,num);

for x = 1:num
chunks{x} = array(:,index(x)+1:index(x+1));
end
end

Answer 25

#!/usr/bin/python


first_names = ['Steve', 'Jane', 'Sara', 'Mary','Jack','Bob', 'Bily', 'Boni', 'Chris','Sori', 'Will', 'Won','Li']

def chunks(l, n):
for i in range(0, len(l), n):
    # Create an index range for l of n items:
    yield l[i:i+n]

result = list(chunks(first_names, 5))
print result

এই লিঙ্কটি থেকে নেওয়া হয়েছে এবং এটিই আমাকে সহায়তা করেছিল। আমার একটি পূর্বনির্ধারিত তালিকা ছিল।

Answer 26

বলুন আপনি 5 ভাগে বিভক্ত করতে চান:

p1, p2, p3, p4, p5 = np.split(df, 5)

Comments

এটি প্রশ্নের উত্তর দেয় না, উদাহরণস্বরূপ আপনি যদি এটি পাঁচটি টুকরো টুকরো করে ভাগ করতে চান তা আগেই জানেন না তবে আপনি কীভাবে এটি লিখবেন write এছাড়াও, আপনি (আমি অনুমান করছি) অবুঝ এবং সম্ভবত একটি পান্ডাস ডেটা ফ্রেম ধরে নিচ্ছেন। ওপেন জেনেরিক তালিকা সম্পর্কে জিজ্ঞাসা করছে।

— নিকড

Answer 27

আমি নিজে এই ক্ষেত্রে কোড লিখেছি:

def chunk_ports(port_start, port_end, portions):
    if port_end < port_start:
        return None

    total = port_end - port_start + 1

    fractions = int(math.floor(float(total) / portions))

    results = []

    # No enough to chuck.
    if fractions < 1:
        return None

    # Reverse, so any additional items would be in the first range.
    _e = port_end
    for i in range(portions, 0, -1):
        print "i", i

        if i == 1:
            _s = port_start
        else:
            _s = _e - fractions + 1

        results.append((_s, _e))

        _e = _s - 1

    results.reverse()

    return results

ডিভাইড_পোর্টস (1, 10, 9) ফিরে আসবে

[(1, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10)]

Answer 28

এই কোডটি আমার জন্য কাজ করে (পাইথন 3- সামঞ্জস্যপূর্ণ):

def chunkify(tab, num):
    return [tab[i*num: i*num+num] for i in range(len(tab)//num+(1 if len(tab)%num else 0))]

উদাহরণ ( বাইটারে টাইপের জন্য, তবে এটি তালিকার পক্ষেও কাজ করে ):

b = bytearray(b'\x01\x02\x03\x04\x05\x06\x07\x08')
>>> chunkify(b,3)
[bytearray(b'\x01\x02\x03'), bytearray(b'\x04\x05\x06'), bytearray(b'\x07\x08')]
>>> chunkify(b,4)
[bytearray(b'\x01\x02\x03\x04'), bytearray(b'\x05\x06\x07\x08')]

Answer 29

এটি একটি দৈর্ঘ্যের <= n,> = 0 পরিমাণ সরবরাহ করে

Def

 chunkify(lst, n):
    num_chunks = int(math.ceil(len(lst) / float(n))) if n < len(lst) else 1
    return [lst[n*i:n*(i+1)] for i in range(num_chunks)]

উদাহরণ স্বরূপ

>>> chunkify(range(11), 3)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
>>> chunkify(range(11), 8)
[[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10]]

Answer 30

আমি বেশিরভাগ সমাধানের চেষ্টা করেছি, তবে তারা আমার ক্ষেত্রে কাজ করে নি, তাই আমি একটি নতুন ফাংশন তৈরি করি যা বেশিরভাগ ক্ষেত্রে এবং কোনও ধরণের অ্যারেতে কাজ করে:

import math

def chunkIt(seq, num):
    seqLen = len(seq)
    total_chunks = math.ceil(seqLen / num)
    items_per_chunk = num
    out = []
    last = 0

    while last < seqLen:
        out.append(seq[last:(last + items_per_chunk)])
        last += items_per_chunk

    return out