ترفند chunking در پایتون: تقسیم لیست به قطعات با itertools.batched


ترفند chunking در پایتون که ای کاش زودتر می‌شناختم: itertools.batched با strict=True #

یک نوع خاص از کد وجود دارد که بارها و بارها بدون اینکه واقعاً به آن فکر کنید می‌نویسید: تقسیم یک لیست به chunk های با اندازه ثابت. صفحه‌بندی نتایج API، پردازش ردیف‌های دیتابیس به صورت دسته‌ای، تغذیه داده به یک مدل در mini-batch ها—یکی از آن کارهایی است که حس می‌کنید باید یک one-liner باشد اما به نحوی همیشه دقیقاً نیست.

الان هست. و پارامتر strict آن را حتی بهتر می‌کند.

روش قدیمی (چیزی که احتمالاً الان انجام می‌دهید) #

یک لیست دارید، chunk های با اندازه n می‌خواهید، و chunk آخر ممکن است کوتاه‌تر باشد. پس چیزی شبیه این می‌نویسید:

python
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
n = 3

for i in range(0, len(data), n):
    chunk = data[i:i + n]
    print(chunk)

خروجی:

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

کار می‌کند، اما چهار خط boilerplate برای چیزی که مفهوماً ساده است. و فقط روی sequence هایی کار می‌کند که از slicing پشتیبانی می‌کنند—پس اگر data یک generator باشد، شانس ندارید. باید ابتدا آن را materialize کنید یا یک streaming chunker پیچیده‌تر بنویسید.

همچنین idiom zip(*[iter(data)] * n) وجود دارد که هوشمندانه اما cryptic است. هیچ‌کس آن را نمی‌خواند و فوراً نمی‌فهمد. و اگر ورودی به طور مساوی تقسیم نشود، باقیمانده را بی‌صدا حذف می‌کند.

ترفند: itertools.batched #

از پایتون 3.12، کتابخانه استاندارد یک تابع اختصاصی برای این کار دارد:

python
from itertools import batched

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

for chunk in batched(data, 3):
    print(chunk)

خروجی:

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

چند چیز برای توجه:

  • tuple برمی‌گرداند، نه list. اگر list لازم دارید، wrap کنید: list(chunk).
  • روی هر iterable کار می‌کند، نه فقط sequence ها. Generator ها، set ها، file object ها—هر چیزی که بتوانید روی آن iterate کنید.
  • در C پیاده‌سازی شده، پس برای اکثر ورودی‌ها از رویکرد slicing سریع‌تر است.
  • اگر ورودی به طور مساوی تقسیم نشود، chunk آخر کوتاه‌تر است. این رفتار پیش‌فرض است، و برای بسیاری از موارد استفاده دقیقاً همان چیزی است که می‌خواهید.

پارامتر strict (پایتون 3.13+) #

اینجاست که جالب می‌شود. پایتون 3.13 یک keyword argument به نام strict اضافه کرد:

python
from itertools import batched

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

# This will raise a ValueError because 10 doesn't divide evenly by 3
for chunk in batched(data, 3, strict=True):
    print(chunk)

خروجی:

ValueError: batched(): incomplete batch

چرا می‌خواهید به جای یک chunk آخر کوتاه‌تر، یک error بگیرید؟ چون گاهی اوقات یک batch نامساوی یک باگ است، نه یک ویژگی.

تصور کنید دارید رکوردها را از یک دیتابیس در صفحه‌های ۱۰۰ تایی می‌خوانید. اگر صفحه آخر ۴۷ رکورد دارد، اشکالی ندارد. اما اگر دارید یک پیام پروتکل با اندازه ثابت را به packet ها تقسیم می‌کنید، و packet آخر کوتاه است، ممکن است به این معنی باشد که داده‌های شما خراب شده یا منطق شما اشتباه است. strict=True آن فرض بی‌صدا را به یک شکست پرصدا تبدیل می‌کند.

این همان فلسفه zip(..., strict=True) است، که اگر iterable ها طول‌های متفاوت داشته باشند error می‌دهد. دارید یک invariant را در خود کد encode می‌کنید.

یک مثال واقعی: صفحه‌بندی یک API #

این الگویی است که واقعاً استفاده می‌کنم:

python
from itertools import batched
import httpx

def fetch_all_users(user_ids: list[int]) -> list[dict]:
    """Fetch users from an API that accepts up to 50 IDs per request."""
    results = []
    for batch in batched(user_ids, 50):
        response = httpx.get(
            "https://api.example.com/users",
            params={"ids": list(batch)}
        )
        response.raise_for_status()
        results.extend(response.json())
    return results

بدون index arithmetic. بدون range(0, len(...), n). بدون off-by-one error. قصد—"این‌ها را در گروه‌های ۵۰ تایی پردازش کن"—دقیقاً همان‌جا در فراخوانی تابع است.

اگر می‌خواستم تضمین کنم که user_ids همیشه به طور مساوی بر ۵۰ تقسیم می‌شود (شاید API یک باگ دارد که batch های کوتاه را بی‌صدا حذف می‌کند)، فقط strict=True اضافه می‌کردم. این یک تغییر یک‌کلمه‌ای است که یک کلاس کامل از باگ‌ها را می‌گیرد.

داستان نسخه‌ها #

  • پایتون 3.12: itertools.batched اضافه شد.
  • پایتون 3.13: strict=True اضافه شد.
  • پایتون 3.11 و قبل‌تر: با idiom slicing یا یک generator دستی گیر کرده‌اید. اگر backport لازم دارید، more_itertools.batched وجود دارد، اما صادقانه بگویم، upgrade کردن حرکت بهتری است.

چرا این از list comprehension بهتر است #

نسخه list comprehension ([data[i:i+n] for i in range(0, len(data), n)]) خوب است اگر روی پایتون قدیمی هستید و data یک list است. اما batched از سه جهت برنده است:

  1. روی هر iterable کار می‌کند. می‌توانید مستقیماً یک generator بدهید. این بدان معنی است که می‌توانید یک streaming data source را بدون بارگذاری کل آن در حافظه chunk کنید.
  2. واضح‌تر است. batched(data, 3) مثل انگلیسی خوانده می‌شود. نسخه index arithmetic نیاز دارد که فراخوانی range را parse کنید و bounds های slice را ذهنی تأیید کنید.
  3. پرچم strict. list comprehension هیچ راه داخلی برای گفتن "اگر ورودی به طور مساوی تقسیم نشود، fail کن" ندارد. با batched، این یک keyword argument است.

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

این پست چطور بود؟

پست‌های مرتبط