Python چگونه یک لیست را به N قطعه با اندازه مساوی تقسیم کنیم

برای تقسیم یک لیست به N قسمت در پایتون، می توانید از تکرار کننده ها استفاده کنید:

def split_list(lst, chunk_size):
    for i in range(0, len(lst), chunk_size):
        yield lst[i:i+chunk_size]

# Example use
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
chunk_size = 3

for chunk in split_list(lst, chunk_size):
    print(chunk)

توجه داشته باشید که همیشه امکان ایجاد لیستی وجود ندارد که طول قطعات آن یکسان باشد. این به این دلیل است که عناصر لیست ممکن است به طور مساوی به N قطعه تقسیم نشوند.

این یک راهنمای جامع برای تقسیم یک لیست به N قسمت در پایتون است. در صورتی که به دنبال یک راه حل سریع هستید، مطمئن هستم که موارد بالا این کار را انجام خواهند داد. اما اگر در حال یادگیری پایتون هستید، حتماً کل راهنما را بخوانید تا چندین رویکرد برای تقسیم لیست ها به قسمت ها را درک کنید. ایده این راهنما استفاده از راه حل موجود نیست، بلکه این است که خودتان منطق را پیاده سازی کنید.

بیایید به آن بپریم!

1. رویکرد تکراری

در اینجا مثالی از نحوه تقسیم لیست پایتون به تکه هایی با اندازه مساوی با استفاده از تکرار کننده ها و کلمه کلیدی بازده آورده شده است:

def split_list(lst, chunk_size):
    for i in range(0, len(lst), chunk_size):
        yield lst[i:i+chunk_size]

# Example usage
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
chunk_size = 3

for chunk in split_list(lst, chunk_size):
      print(chunk)

این کد خروجی زیر را خواهد داشت:

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

بیایید نگاهی دقیق تر به کد بیندازیم.

این split_list تابع دو آرگومان می گیرد: یک لیست lst و یک عدد صحیح chunk_size که اندازه هر قسمت را مشخص می کند. تابع از a استفاده می کند for برای تکرار روی لیست حلقه بزنید و یک فهرست فرعی از آن را برمی گرداند lst از شاخص فعلی شروع می شود و با شاخص فعلی به اضافه اندازه تکه پایان می یابد.

در اینجا توضیحی گام به گام در مورد نحوه عملکرد کد آورده شده است:

1. این split_list تابع با یک لیست فراخوانی می شود lst و اندازه قطعه chunk_size.
2. این for حلقه لیست را با شروع از شاخص 0 و افزایش شاخص را تکرار می کند chunk_size هر زمان. به عنوان مثال، اگر اندازه قطعه 3 باشد، اولین تکرار با شاخص 0، تکرار دوم با شاخص 3، سوم با 6 و غیره شروع می شود.
3. در هر تکرار، yield کلمه کلیدی یک زیر لیست از lst از شاخص فعلی شروع می شود و با شاخص فعلی به اضافه اندازه تکه پایان می یابد. به عنوان مثال، اگر شاخص فعلی 0 و اندازه تکه 3 باشد، فهرست فرعی خواهد بود lst[0:3]که سه عنصر از lst.
4. این for در کد نمونه حلقه بزنید، سپس روی تکه های به دست آمده از کد تکرار می شود split_list و هر قسمت را چاپ می کند.

نتیجه همه اینها لیستی است که به N قسمت تقسیم شده است.

اما روی زمین «بازده» چه می کند؟

روشی که قبلا ارائه شد، ساده‌ترین روش برای تقسیم فهرست به بخش‌ها است. اما اگر تازه وارد هستید yield کلیدواژه و تکرار کننده ها، این راه حل ممکن است شما را گیج کند.

اگر به تکرار کننده ها علاقه مند هستید، حتما این راهنمای کامل برای تکرار کننده ها و تکرارشونده ها در پایتون را بخوانید.

بخش بعدی به شما آموزش می دهد که چگونه روش قبلی را بدون استفاده انجام دهید yield کلمه کلیدی، اما به جای آن از لیست ها استفاده کنید.

2. رویکرد چرخه ای

در اینجا روش دیگری برای تقسیم لیست ها به قطعات در پایتون وجود دارد. این رویکرد از حلقه‌ها و لیست‌ها استفاده می‌کند و بنابراین نسبت به مثال قبلی کمی مناسب‌تر برای مبتدیان است.

در اینجا مراحلی وجود دارد که باید انجام دهید:

1. تعداد تکه هایی را که می خواهید لیست را به آنها تقسیم کنید مشخص کنید. با این شماره تماس بگیریم n.
2. طبقه – طول لیست را بر تقسیم کنید n برای پیدا کردن اندازه هر قسمت (قسمت کف گرد شده است تا اندازه قطعه مثلاً 3.3333 نباشد، بلکه فقط 3 باشد). با این شماره تماس می گیریم chunk_size.
3. از آن استفاده کنید range() برای ایجاد لیستی از اعداد که شاخص هایی را مشخص می کند که هر قسمت باید از کجا شروع شود. اگر لیست اصلی دارای 10 عنصر باشد و بخواهید آن را به 3 قسمت تقسیم کنید، لیست با شاخص های شروع به صورت [0, 3, 6].
4. از آن استفاده کنید for حلقه را برای تکرار بر روی فهرست شاخص شروع و استفاده کنید list[start:end] نحو برای بازیابی هر قسمت از لیست اصلی.

در اینجا کدی است که این مراحل را انجام می دهد. حتما نظرات را بخوانید تا همیشه در جریان باشید!

# Set the number of chunks
N = 4

# Create a list of numbers
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Create an empty list to store the chunks
chunks = []

# Iterate over the elements of the list in groups of N
for i in range(0, len(my_list), N):
  # Extract each group of N elements as a sublist
  chunk = my_list[i:i + N]
  
  # Append the sublist to the list of chunks
  chunks.append(chunk)

# Print the chunks
print(chunks)

این کد خروجی زیر را تولید می کند:

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

2.1. درک لیست می تواند همین کار را انجام دهد

هنگام برخورد با حلقه‌های for، ممکن است در برخی موارد بتوانید از یک لیست استفاده کنید فهم برای مرتب کردن کد

اینکه آیا باید از درک مطلب استفاده کنید یا نه همیشه مورد بحث است. این به این دلیل است که درک لیست قطعا کد را کوتاه می کند، اما در واقع می تواند آن را کمتر خوانا کند.

به هر حال، در اینجا مثال قبلی است که از درک لیست به جای حلقه for استفاده می کند:

# Define the input list
input_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Define the chunk size
chunk_size = 3

# Create the output list using a list comprehension
output_list = [input_list[i:i + chunk_size] for i in range(0, len(input_list), chunk_size)]

# Print the output list
print(output_list)

این نتیجه زیر را ایجاد خواهد کرد:

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

3. در حالی که چرخه

در مثال های قبلی، از حلقه for برای تقسیم لیست به بخش ها استفاده کردید. از آنجایی که می توانید از یک حلقه for استفاده کنید، مطمئناً می توانید آن را با حلقه while نیز انجام دهید!

این کد با استفاده از حلقه while به نظر می رسد:

# define the list of elements
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# define the size of the chunks
chunk_size = 3

# create an empty list to store the chunks
chunks = []

# create an index variable to track the current position in the list
index = 0

# loop until the index is larger than the length of the list
while index < len(my_list):
    # get the sublist of the current chunk
    chunk = my_list[index:index+chunk_size]

    # append the chunk to the list of chunks
    chunks.append(chunk)

    # update the index to the next chunk
    index += chunk_size

# print the resulting chunks
print(chunks)

خروجی:

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

این راه حل یک لیست خالی برای نگهداری تکه های به دست آمده ایجاد می کند و سپس از یک حلقه while برای تکرار بر روی لیست اصلی بر اساس اندازه های تکه استفاده می کند و هر تکه را به لیست تکه اضافه می کند. متغیر شاخص برای پیگیری موقعیت فعلی در لیست استفاده می شود و در هر تکرار به قسمت بعدی به روز می شود.

4. از NumPy برای پارتیشن بندی به N تکه استفاده کنید

پایتون یک ماژول ریاضی و علوم محبوب به نام NumPy دارد که جامعه علمی پایتون از آن بسیار استفاده می کند.

اگر قبلا از NumPy استفاده می کنید، می توانید استفاده کنید array_split() عملکرد برای تقسیم لیست ها به بخش ها. این تابع لیست را به عنوان آرگومان اول و اندازه قطعه را به عنوان آرگومان دوم می گیرد.

توجه داشته باشید که این رویکرد عناصر را مجبور می کند تا به N قسمت تقسیم شوند. مقادیر باقیمانده در قسمت خودشان قرار نمی گیرند، بلکه به قسمت آخر منتقل می شوند.

به عنوان مثال، بیایید یک لیست از 10 عدد را به 3 قسمت تقسیم کنیم:

import numpy as np

# Define the list to be split
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Split the list into chunks of size 3
chunks = np.array_split(my_list, 3)

# Print the resulting chunks
print(chunks)

# Output: [array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9, 10])]

توجه کنید که چگونه قسمت آخر به جای اینکه عنصر اضافی را بردارید و در قسمت خودش قرار دهید، اکنون 4 عنصر دارد.

با تشکر برای خواندن. کد نویسی مبارک!

همچنین بخوانید

آشنایی با پایتون