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

افزایش سرعت پایتون؛ ۷ ترفند کاربردی برای بهینه‌سازی کد بدون پیچیده‌کاری

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

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

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

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

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

برای مقایسه دو عبارت کوتاه یا یک عملیات کوچک، ماژول استاندارد timeit گزینه مناسبی است:

import timeit

list_time = timeit.timeit(
    "'python' in items",
    setup="items = list(range(10000))",
    number=10000,
)

set_time = timeit.timeit(
    "'python' in items",
    setup="items = set(range(10000))",
    number=10000,
)

print(list_time, set_time)

در این مثال نوع داده‌ها با مقدار جست‌وجو هم‌خوانی ندارد و نتیجه برای مقایسه عضویت معتبر نیست. نسخه درست را با داده‌های یکسان آزمایش کنید:

import timeit

list_time = timeit.timeit(
    "5000 in items",
    setup="items = list(range(10000))",
    number=10000,
)

set_time = timeit.timeit(
    "5000 in items",
    setup="items = set(range(10000))",
    number=10000,
)

print(f"list: {list_time:.4f}s")
print(f"set:  {set_time:.4f}s")

برای پیدا کردن بخش‌های پرهزینه در یک برنامه کامل، می‌توانید از cProfile استفاده کنید:

python -m cProfile -s cumulative app.py

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

آموزش مرحله‌به‌مرحله: ۷ ترفند مؤثر برای سریع‌تر شدن کد

۱. برای جست‌وجوی پرتکرار، ساختار داده مناسب انتخاب کنید

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

# وقتی فقط بررسی عضویت مهم است
allowed_ids = set(load_allowed_ids())

if user_id in allowed_ids:
    process_user(user_id)

این تغییر زمانی بیشترین فایده را دارد که تعداد بررسی‌ها یا اندازه داده‌ها زیاد باشد. اگر فقط چند عضو دارید، تفاوت ممکن است ناچیز باشد.

۲. محاسبه‌های تکراری را بیرون از حلقه ببرید

هر چیزی که در هر دور حلقه تغییر نمی‌کند، احتمالاً نباید بی‌دلیل دوباره محاسبه شود. این کار هم هزینه پردازشی را کاهش می‌دهد و هم منطق برنامه را روشن‌تر می‌کند.

# شکل کم‌بازده‌تر
for item in items:
    threshold = get_threshold_from_config()
    if item.value > threshold:
        handle(item)

# اگر مقدار آستانه ثابت است، آن را یک‌بار محاسبه کنید
threshold = get_threshold_from_config()
for item in items:
    if item.value > threshold:
        handle(item)

این الگو برای محاسبه‌های سنگین، فراخوانی پایگاه داده یا خواندن تنظیمات اهمیت بیشتری دارد.

۳. برای داده‌های بزرگ از generator استفاده کنید

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

# ایجاد همه نتایج در حافظه
squares = [number * number for number in range(10_000_000)]

# تولید مرحله‌ای نتایج
squares = (number * number for number in range(10_000_000))

for value in squares:
    process(value)

عبارت generator الزاماً زمان اجرای هر عملیات را کمتر نمی‌کند؛ مزیت اصلی آن تولید مرحله‌ای داده و کاهش نیاز به حافظه است. اگر به دسترسی چندباره یا تصادفی به همه نتایج نیاز دارید، فهرست مناسب‌تر خواهد بود.

۴. برای اتصال رشته‌ها در حلقه از join کمک بگیرید

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

# مناسب برای تعداد زیادی قطعه
parts = []
for name in names:
    parts.append(format_name(name))

result = "".join(parts)

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

۵. نتیجه تابع‌های پرهزینه را در صورت امن بودن cache کنید

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

from functools import lru_cache

@lru_cache(maxsize=512)
def calculate_score(category, level):
    # نمونه‌ای از محاسبه پرهزینه
    return expensive_calculation(category, level)

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

۶. از ابزارهای استاندارد برای مرتب‌سازی و شمارش استفاده کنید

توابع و ساختارهای آماده پایتون معمولاً از پیاده‌سازی دستیِ معادل، سریع‌تر و قابل‌اعتمادتر هستند. برای شمارش تکرارها، به‌جای ساختن حلقه‌های چندلایه می‌توانید از Counter استفاده کنید:

from collections import Counter

word_counts = Counter(words)
print(word_counts.most_common(10))

برای مرتب‌سازی نیز از sorted یا متد sort استفاده کنید و کلید مرتب‌سازی را واضح بنویسید:

users = sorted(users, key=lambda user: user.created_at)

۷. ورودی و خروجی را بهینه و مرحله‌ای مدیریت کنید

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

with open("events.log", encoding="utf-8") as file:
    for line in file:
        process_line(line)

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

نکات مهمی که پیش از انتشار تغییرات باید بدانید

  • درستی را حفظ کنید: پس از هر تغییر، تست‌ها را اجرا کنید و مطمئن شوید خروجی برنامه عوض نشده است.
  • روی داده واقعی آزمایش کنید: نتیجه یک مثال کوچک لزوماً رفتار برنامه در مقیاس واقعی را نشان نمی‌دهد.
  • زمان و حافظه را با هم بسنجید: روشی که سریع‌تر است ممکن است حافظه بیشتری مصرف کند.
  • نسخه پایتون را در نظر بگیرید: عملکرد بعضی قابلیت‌ها و کتابخانه‌ها می‌تواند بین نسخه‌ها متفاوت باشد.
  • خوانایی را قربانی نکنید: بهبود ناچیز سرعت معمولاً ارزش پیچیده‌کردن کد را ندارد.
  • وابستگی‌های خارجی را بی‌دلیل نصب نکنید: ابتدا ابزارهای استاندارد مانند timeit و cProfile را امتحان کنید.
نکته امنیتی و فنی: کش‌کردن داده‌های شخصی یا وابسته به دسترسی کاربر بدون طراحی درست می‌تواند باعث نمایش اطلاعات اشتباه به افراد دیگر شود. در سرویس‌های چندکاربره، کلید کش و زمان انقضا را با دقت طراحی کنید.

یک چک‌لیست کوتاه برای بهینه‌سازی اصولی

  1. سناریویی را که کند است با ورودی مشخص بازتولید کنید.
  2. زمان اجرا یا پروفایل برنامه را اندازه بگیرید.
  3. بزرگ‌ترین گلوگاه را انتخاب کنید و فقط یک تغییر انجام دهید.
  4. تست‌های خودکار و بررسی خروجی را اجرا کنید.
  5. سرعت و مصرف حافظه را دوباره اندازه بگیرید.
  6. اگر بهبود ارزشمند بود، دلیل تغییر را در کد یا مستندات توضیح دهید.

نتیجه‌گیری

برای سریع‌تر کردن پایتون لازم نیست از ترفندهای عجیب شروع کنید. انتخاب ساختار داده مناسب، حذف محاسبه‌های تکراری، استفاده از generator برای داده‌های حجیم، کش‌کردن امن نتایج و اندازه‌گیری با ابزارهای استاندارد، در بسیاری از پروژه‌ها نتیجه ملموسی دارد. مهم‌ترین اصل این است: اول گلوگاه را پیدا کنید، بعد تغییر کوچکی انجام دهید و در پایان با تست و اندازه‌گیری مطمئن شوید که هم برنامه سریع‌تر شده و هم درست کار می‌کند.

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