چگونه یک لیست را در پایتون به تکه های زوج تقسیم کنیم؟

معرفی

تقسیم رشته ها و لیست ها فعالیت های برنامه نویسی رایج در پایتون و سایر زبان ها هستند. گاهی اوقات باید داده های خود را به روش های عجیب و غریب تقسیم کنیم، اما معمولاً – به تکه های حتی.

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

در بیشتر موارد، می توانید با استفاده از ژنراتورها به دست آورید:

def chunk_using_generators(lst, n):
    for i in range(0, len(lst), n):
        yield lst(i:i + n)

اگرچه راه های جالب دیگری برای انجام این کار وجود دارد که هر کدام مزایا و معایب خاص خود را دارند!

یک لیست را به تکه های زوج از N عنصر تقسیم کنید

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

بیایید یک فایل جدید به نام ایجاد کنیم chunk_based_on_size.py و مطالب زیر را اضافه کنید:

def chunk_based_on_size(lst, n):
    for x in range(0, len(lst), n):
        each_chunk = lst(x: n+x)

        if len(each_chunk) < n:
            each_chunk = each_chunk + (None for y in range(n-len(each_chunk)))
        yield each_chunk

print(list(chunk_based_on_size((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), 7)))

بالا chunk_based_on_size() تابع آرگومان ها را می گیرد: lst برای لیست و chunk_size تا عددی تقسیم شود. تابع در لیست با افزایش اندازه تکه تکرار می شود n. انتظار می رود که هر تکه دارای اندازه ای باشد که به عنوان آرگومان آورده شده است. اگر عناصر کافی برای ایجاد یک تقسیم به همان اندازه وجود نداشته باشد، عناصر استفاده نشده باقیمانده با آنها پر می شوند. None.

با اجرای این اسکریپت لیست لیست های زیر را برمی گرداند:

$ python3 chunk_based_on_size.py
((1, 2, 3, 4, 5, 6, 7), (8, 9, 10, 11, 12, 13, None))

لیست به تکه های مساوی از 7 عنصر تقسیم شده است.

پایتون ابزارهایی برای ساده کردن این کار دارد process. ما می توانیم استفاده کنیم zip_longest تابع از itertools برای ساده کردن عملکرد قبلی بیایید یک فایل جدید ایجاد کنیم chunk_using_itertools.py و کد زیر را اضافه کنید:

from itertools import zip_longest

def chunk_using_itertools(lst):
    iter_ = iter(lst)
    return list(zip_longest(iter_, iter_, iter_, iter_, iter_, iter_, iter_))

print(chunk_using_itertools((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)))

این کد عناصر را تکرار می کند و تکه ای از طول مورد نظر را برمی گرداند روی استدلال هایی که ارائه می کنید ما 7 قرار داده ایم iter_ استدلال در اینجا را zip_longest() تابع عناصر را از هر تکرار شونده جمع می کند و برمی گرداند. در این حالت، عناصر لیستی که 7 بار در یک حرکت تکرار شده اند را جمع می کند. سپس تکرار کننده های متعددی ایجاد می کند که حاوی 7 عنصر متوالی است که سپس به یک لیست تبدیل شده و برگردانده می شوند.

هنگامی که این قطعه را اجرا می کنید، به این نتیجه می رسد:

$ python3 chunk_using_itertools.py
((1, 2, 3, 4, 5, 6, 7), (8, 9, 10, 11, 12, 13, None))

این تابع کوتاهتر همان ورودی را تولید می کند. با این حال، بسیار محدودتر است زیرا ما باید به صورت دستی تعداد عناصری را که می خواهیم در کد بنویسیم، و قرار دادن یک دسته از آن کمی سخت است. iter_در zip_longest() زنگ زدن.

بهترین راه حل استفاده از ژنراتور خواهد بود. بیایید یک فایل جدید ایجاد کنیم، chunk_using_generators.py:

def chunk_using_generators(lst, n):
    for i in range(0, len(lst), n):
        yield lst(i:i + n)

print(list(chunk_using_generators((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), 7)))

این مولد یک زیر لیست حاوی n عناصر. در پایان، برای هر تکه یک فهرست فرعی به دست می‌آمد. با اجرای این کد این خروجی تولید می شود:

$ python3 chunk_using_generators.py
((1, 2, 3, 4, 5, 6, 7), (8, 9, 10, 11, 12, 13))

این راه حل اگر نیازی به بالشتک نداشته باشید بهترین کار را دارد None یا درغیر این صورت.

یک لیست را به N تکه های زوج تقسیم کنید

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

به عنوان مثال، به جای تقسیم یک لیست به تکه هایی که هر تکه دارای 7 عنصر است، می خواهیم یک لیست را به 7 تکه زوج تقسیم کنیم. در این صورت ممکن است اندازه هر تکه را ندانیم.

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

import math

def chunk_based_on_number(lst, chunk_numbers):
    n = math.ceil(len(lst)/chunk_numbers)

    for x in range(0, len(lst), n):
        each_chunk = lst(x: n+x)

        if len(each_chunk) < n:
            each_chunk = each_chunk + (None for y in range(n-len(each_chunk)))
        yield each_chunk

print(list(chunk_based_on_number((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), chunk_numbers=7)))

ما تعیین می کنیم که چه تعداد لیست نیاز داریم تا آن مقدار را ایجاد و در آنها ذخیره کنیم n. سپس یک فهرست فرعی برای دو عنصر در یک زمان ایجاد می کنیم، در صورتی که اندازه تکه ما کوچکتر از طول مورد نظر باشد، خروجی را اضافه می کنیم.

وقتی آن فایل را اجرا می کنیم، خواهیم دید:

$ python3 chunk_based_on_number.py
((1, 2), (3, 4), (5, 6), (7, 8), (9, 10), (11, 12), (13, None))

همانطور که در خروجی بالا مشاهده می شود، لیست به 7 لیست جداگانه با اندازه های مساوی تقسیم شده است روی بحث و جدل chunk_numbers ارائه شده است.

نتیجه

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

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