افزونه های ووکامرس, وب و اینترنت

ترفندهای کاربردی پایتون برای نوشتن کد سریع‌تر و تمیزتر؛ از پروفایل‌گیری تا کش کردن

کند شدن یک برنامه پایتون همیشه به این معنا نیست که باید آن را با زبان دیگری بازنویسی کنید. گاهی یک حلقهٔ پرهزینه، خواندن تکراری فایل یا فراخوانی بی‌مورد یک تابع، سرعت کل پروژه را پایین می‌آورد. در این راهنما چند روش کاربردی را می‌بینید که کمک می‌کنند گلوگاه واقعی را پیدا کنید و با تغییرهای هدفمند، برنامه‌ای سریع‌تر و قابل‌نگهداری‌تر بسازید.

نکتهٔ کلیدی: قبل از بهینه‌سازی، اندازه‌گیری کنید. کدی که از نظر ظاهری پیچیده‌تر است لزوماً سریع‌تر نیست؛ نتیجه به داده، نسخهٔ پایتون و محیط اجرا بستگی دارد.

چرا بهینه‌سازی پایتون را باید از اندازه‌گیری شروع کرد؟

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

اندازه‌گیری سریع با timeit

برای مقایسهٔ دو قطعه‌کد کوچک، از ماژول timeit استفاده کنید. این ابزار کد را چند بار اجرا می‌کند تا مقایسه قابل‌اعتمادتر از یک بار اندازه‌گیری دستی باشد:

import timeit

list_time = timeit.timeit(
    'sum([x * x for x in range(1000)])',
    number=5000
)
generator_time = timeit.timeit(
    'sum(x * x for x in range(1000))',
    number=5000
)

print(f'list: {list_time:.4f}s')
print(f'generator: {generator_time:.4f}s')

این مثال فقط برای نمایش روش مقایسه است؛ نتیجهٔ دقیق را روی نسخهٔ پایتون و سخت‌افزار خودتان بسنجید. تفاوت اصلی این دو روش در مصرف حافظه است: عبارت مولد معمولاً همهٔ مقادیر را یک‌باره در فهرست ذخیره نمی‌کند.

پیدا کردن تابع‌های کند با cProfile

وقتی برنامه بزرگ‌تر است، ابزار cProfile نشان می‌دهد کدام تابع‌ها بیشترین زمان را مصرف می‌کنند:

python -m cProfile -s cumulative app.py

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

آموزش مرحله‌به‌مرحلهٔ بهینه‌سازی کد پایتون

مرحلهٔ اول: یک معیار قابل‌تکرار بسازید

پیش از تغییر کد، یک ورودی نمونهٔ واقعی انتخاب کنید و زمان اجرا و مصرف حافظه را ثبت کنید. معیار شما می‌تواند زمان پاسخ یک درخواست، زمان پردازش یک فایل یا تعداد رکوردهای پردازش‌شده در ثانیه باشد.

  • از ورودی‌های کوچک، متوسط و بزرگ استفاده کنید.
  • هر آزمایش را چند بار اجرا کنید و به یک نتیجهٔ تصادفی تکیه نکنید.
  • نسخهٔ پایتون، سیستم‌عامل و مشخصات محیط آزمایش را یادداشت کنید.
  • در کنار سرعت، درستی خروجی را هم با آزمون‌ها کنترل کنید.

مرحلهٔ دوم: حلقه‌های غیرضروری را با عملیات مناسب جایگزین کنید

توابع آمادهٔ پایتون در بسیاری از کارهای رایج، خواناتر هستند و می‌توانند از اجرای دستی یک حلقهٔ پرهزینه جلوگیری کنند. برای جمع کردن مقادیر، sum و برای بررسی شرط‌ها، any یا all را در نظر بگیرید:

scores = [72, 91, 84, 66]

passed = all(score >= 60 for score in scores)
total = sum(scores)

print(passed, total)

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

مرحلهٔ سوم: از generator برای داده‌های حجیم استفاده کنید

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

def read_numbers(path):
    with open(path, encoding='utf-8') as file:
        for line in file:
            line = line.strip()
            if line:
                yield int(line)

for number in read_numbers('numbers.txt'):
    process(number)

این الگو به‌خصوص برای فایل‌های بزرگ مفید است. البته generator فقط زمانی انتخاب خوبی است که به دسترسی چندباره یا تصادفی به همهٔ داده‌ها نیاز نداشته باشید.

مرحلهٔ چهارم: جست‌وجوی تکراری را به set یا dict بسپارید

بررسی عضویت در فهرست بزرگ می‌تواند بارها عناصر را یکی‌یکی بررسی کند. اگر جست‌وجوهای زیادی دارید، تبدیل داده به set معمولاً انتخاب مناسب‌تری است:

allowed_users = {'mina', 'arash', 'sara'}

if username in allowed_users:
    grant_access(username)

ساختن مجموعه هم هزینه دارد؛ بنابراین اگر فقط یک بررسی انجام می‌دهید، تبدیل فهرست به set الزاماً سودی ندارد. این تغییر زمانی ارزشمند است که همان مجموعه چندین بار برای جست‌وجو استفاده شود.

مرحلهٔ پنجم: نتیجهٔ محاسبات تکراری را کش کنید

اگر تابعی برای ورودی یکسان همیشه خروجی یکسان می‌دهد، functools.cache یا lru_cache می‌تواند محاسبه‌های تکراری را کاهش دهد:

from functools import lru_cache

@lru_cache(maxsize=512)
def convert_currency(amount, rate):
    return amount * rate

print(convert_currency(100, 1.08))

کش حافظه مصرف می‌کند و برای تابع‌هایی که نتیجه‌شان به زمان، فایل، تنظیمات متغیر یا وضعیت بیرونی وابسته است ممکن است نتیجهٔ قدیمی برگرداند. اندازهٔ کش را متناسب با برنامه انتخاب کنید و در صورت نیاز از cache_clear() استفاده کنید.

مرحلهٔ ششم: برای اشیای پرشمار، هزینهٔ حافظه را کاهش دهید

اگر تعداد بسیار زیادی نمونه از یک کلاس می‌سازید، تعریف __slots__ را بررسی کنید. این ویژگی می‌تواند در برخی کلاس‌ها مصرف حافظه را کم کند، اما دسترسی پویا به ویژگی‌های دلخواه را محدود می‌کند:

class Point:
    __slots__ = ('x', 'y')

    def __init__(self, x, y):
        self.x = x
        self.y = y

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

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

  • کد را خوانا نگه دارید: چند میلی‌ثانیه بهبود، اگر فهم و نگهداری برنامه را دشوار کند، همیشه معاملهٔ خوبی نیست.
  • ورودی واقعی را آزمایش کنید: دادهٔ مصنوعی کوچک ممکن است گلوگاه‌های پروژه را نشان ندهد.
  • I/O را از محاسبه جدا کنید: در برنامه‌های فایل‌محور یا شبکه‌ای، انتظار برای دیسک و شبکه می‌تواند از زمان اجرای پایتون مهم‌تر باشد.
  • همهٔ کارها را با asyncio حل نکنید: برنامه‌نویسی ناهمگام برای کارهای ورودی/خروجی مناسب است، اما خودبه‌خود محاسبات سنگین پردازنده را سریع‌تر نمی‌کند.
  • نسخهٔ پایتون را به‌روز نگه دارید: نسخه‌های جدید ممکن است بهبودهای اجرایی و اصلاحات امنیتی داشته باشند؛ ارتقا را ابتدا در محیط آزمایش و با آزمون‌های پروژه بررسی کنید.
  • بهینه‌سازی را مرحله‌ای انجام دهید: هر بار یک تغییر اعمال کنید تا مشخص باشد کدام تصمیم واقعاً اثر گذاشته است.
هشدار: کش کردن داده‌های حساس، نتیجه‌های وابسته به کاربر یا اطلاعاتی که مرتب تغییر می‌کنند می‌تواند باعث نمایش دادهٔ نادرست یا ناخواسته شود. پیش از افزودن کش، عمر داده و شرایط پاک‌سازی آن را مشخص کنید.

یک چک‌لیست کوتاه پیش از انتشار

  1. آیا آزمون‌ها خروجی درست را تأیید می‌کنند؟
  2. آیا با پروفایل‌گیری، گلوگاه اصلی مشخص شده است؟
  3. آیا تغییر پیشنهادی روی دادهٔ واقعی بهبود قابل‌اندازه‌گیری دارد؟
  4. آیا مصرف حافظه، پیچیدگی و رفتار خطاها نیز بررسی شده‌اند؟
  5. آیا نتیجهٔ مقایسه و دلیل تغییر در مستندات پروژه ثبت شده است؟

نتیجه‌گیری

برای سریع‌تر کردن پایتون، لازم نیست از ابتدا همه‌چیز را پیچیده کنید. ابتدا با timeit یا cProfile محل اتلاف زمان را پیدا کنید؛ سپس سراغ انتخاب ساختار دادهٔ مناسب، generator برای پردازش جریانی، کش کنترل‌شده یا کاهش مصرف حافظه بروید. بهینه‌سازی موفق تغییری است که هم روی ورودی واقعی نتیجهٔ قابل‌اندازه‌گیری داشته باشد و هم کیفیت و خوانایی برنامه را حفظ کند.

اگر ایده‌ای برای یک وب‌سایت یا اپلیکیشن دارید، تیم وب برد در مسیر ساخت انواع سایت وردپرسی و اپلیکیشن نیتیو همراه شماست؛ از جرقهٔ اولیه تا محصولی که آمادهٔ رشد است.