حلقه while در پایتون + مثال‌های کاربردی

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

برای درک بهتر حلقه while، تصور کنید در حال رانندگی هستید و به رانندگی خود را تا زمانی که به مقصد نرسیده‌اید و از ماشین پیاده نشده‌اید، ادامه میدهید. حتی این امکان هم وجود دارد که مادر یا همسرتان هم بین رانندگی تماس بگیرند و سوال یا درخواستی داشته باشند اما شما همچنان در حال رانندگی هستید (اگر پلیس شما را نبیند و ماشین را توقیف نکند 🙂 مفهوم break در while).

ساختار پایه و مثال ساده حلقه while

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

				
					while شرط_منطقی:
    # کدهایی که باید تا برقرار بودن شرط اجرا شوند

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

				
					count = 5
while count > 0:
    print(count)
    count -= 1  # کاهش شمارنده در هر دور
print("be akhar khat residim :)")

در این کد، ابتدا متغیر count مقدار ۵ می‌گیرد. حلقه while بررسی می‌کند که آیا count > 0 است یا نه. تا زمانی که این شرط برقرار باشد، بدنه‌ی حلقه اجرا می‌شود. داخل حلقه، مقدار count چاپ شده و سپس ۱ واحد کم می‌شود. این روند تکرار می‌گردد تا در نهایت شرط count > 0
False شود (یعنی count به ۰ برسد). نتیجه‌ی اجرای این برنامه به صورت زیر خواهد بود:

				
					5  
4  
3  
2  
1  
be akhar khat residim :)

ابتدا اعداد ۵ تا ۱ را به ترتیب نزولی می‌بینیم و در انتها، پس از خاتمه‌ی حلقه، پیام ” (: be akhar khat residim ” چاپ می‌شود. این مثال نشان می‌دهد که چگونه حلقه‌ی while می‌تواند یک عملیات (مثلاً شمارش معکوس) را تا زمانی که شرط مشخصی برقرار است، تکرار کند.

کاربردهای حلقه while

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

				
					while True:
    data = input("یک عدد صحیح مثبت وارد کنید: ")
    try:
        value = int(data)
        if value > 0:
            print("مقدار معتبر است:", value)
            break  # خروج از حلقه پس از دریافت ورودی صحیح
        else:
            print("لطفاً یک عدد بزرگ‌تر از ۰ وارد کنید.")
    except ValueError:
        print("ورودی معتبر نیست؛ یک عدد صحیح وارد کنید.")

در این قطعه‌کد، حلقه‌ی while True تا زمانی ادامه می‌یابد که یک break رخ دهد. ابتدا ورودی از کاربر گرفته می‌شود. سپس در بلوک try تلاش می‌کنیم ورودی را به عدد صحیح تبدیل کنیم. اگر موفق بودیم، بررسی می‌کنیم مقدار مثبت باشد. در صورت مثبت بودن، پیام تأیید چاپ شده و با دستور break از حلقه خارج می‌شویم. اگر مقدار مثبت نباشد یا تبدیل ورودی به عدد صحیح شکست بخورد ( ValueError Exception رخ دهد)، پیام خطای مناسبی چاپ شده و حلقه تکرار می‌شود تا کاربر یک ورودی صحیح ارائه دهد. این الگو یکی از روش‌های رایج برای جلوگیری از ورودی نامعتبر و درخواست مجدد تا رسیدن به حالت صحیح است.
پردازش‌های طولانی و پایش مداوم: در برنامه‌هایی که نیاز به اجرای مداوم دارند (مثلاً یک سرور که همیشه در حال اجرا و گوش دادن به اتصالات است، یا اسکریپتی که وضعیت یک حسگر را مرتب چک می‌کند)، از حلقه while استفاده می‌شود. معمولاً در چنین مواردی شرط حلقه همیشه True است (مانند while True) تا حلقه بی‌وقفه اجرا شود. به این نوع حلقه که پایانی برای آن در نظر گرفته نشده، حلقه بی‌نهایت می‌گوییم. البته در عمل ما مکانیزمی برای خروج یا توقف چنین حلقه‌هایی در نظر می‌گیریم (مثلاً یک سیگنال توقف یا رسیدن به یک وضعیت خاص). همچنین برای جلوگیری از استفاده بی‌مورد از منابع سیستم، گاهی داخل حلقه از تأخیر زمانی (time.sleep) یا انتظار رویداد استفاده می‌شود تا پردازنده بی‌جهت درگیر نشود. به عنوان نمونه، یک حلقه پایش ممکن است این‌گونه باشد:

				
					import time

while True:
    # ... کد بررسی وضعیت یا انجام کارهای دوره‌ای ...
    if condition_met:
        break  # خروج از حلقه در صورت برآورده شدن شرط پایان
    time.sleep(5)  # صبر 5 ثانیه‌ای قبل از تکرار بعدی

این ساختار کلی نشان می‌دهد که چگونه می‌توان یک حلقه‌ی همیشه در حال اجرا را کنترل‌شده پیاده‌سازی کرد. حلقه هر ۵ ثانیه یک‌بار کاری انجام می‌دهد و شرطی را بررسی می‌کند و در صورت لزوم خاتمه می‌یابد. استفاده از time.sleep تضمین می‌کند که حلقه به طور مداوم و بدون توقف CPU اجرا نمی‌شود و بین تکرارها اندکی مکث می‌کند.

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

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

حلقه‌ی while بی‌نهایت

while بینهایت یا infinite while زمانی رخ میدهد که شرط استفاده شده در حلقه هیچگاه False نشود یا به اصطلاح یک while true ایجاد شده باشد

تغییر وضعیت شرط در هر دور:

در هر بار اجرای حلقه، باید چیزی در شرط حلقه تغییر کند. یعنی یکی از متغیرهایی که شرط به آن وابسته است، باید در طول حلقه تغییر کند تا بالاخره شرط نادرست شود و حلقه پایان یابد.
برای مثال، اگر شرط این باشد که count > 0، باید مقدار count را در هر دور کمتر کنیم تا به صفر برسد و حلقه متوقف شود. اگر این تغییر انجام نشود، حلقه به‌صورت بی‌پایان ادامه خواهد داشت. در ادامه نمونه‌ای از while true را می‌بینید:

				
					x = 1
while x < 5:
    print("dostat daram ❤️")
    # !فراموش کرده‌ایم ایکس را تغییر دهیم

استفاده صحیح از break:

دستور break می‌تواند هر زمان که لازم شد، اجرای حلقه را متوقف کند. در مثال اعتبارسنجی ورودی که در بخش قبل دیدیم، به محض دریافت ورودی صحیح از حلقه خارج شدیم. استفاده از break یک روش متداول برای جلوگیری از ادامه‌ی غیرضروری حلقه است. اگر در حلقه‌ی while True کار می‌کنید (که ذاتاً بی‌نهایت است)، تنها راه خاتمه استفاده از break (یا یک استثناء) خواهد بود. بنابراین، مطمئن شوید در چنین مواردی حتماً شرط خروج با break وجود داشته باشد تا برنامه بی‌وقفه در حلقه گیر نکند.

break، continue و else در حلقه‌های while

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

break در حلقه پایتون

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

				
					secret_number = 7
attempts = 0
while attempts < 3:  # حداکثر 3 تلاش
    guess = int(input("حدس بزن عدد (۱ تا ۱۰): "))
    attempts += 1
    if guess == secret_number:
        print("تبریک! درست حدس زدید 🎉")
        break  # خروج از حلقه چون حدس صحیح بود
    else:
        print("اشتباه است. دوباره تلاش کنید.")
if guess != secret_number:
    print("متأسفانه تلاش‌های شما تمام شد. عدد درست", secret_number, "بود.")

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

continue در حلقه پایتون

دستور continue برای رد شدن از ادامه‌ی روند جاری حلقه و رفتن به دور بعدی به کار می‌رود. زمانی که برنامه به continue می‌رسد، از آن نقطه به انتهای بدنه‌ی حلقه می‌رود و بلافاصله دور بعدی (تکرار بعدی) حلقه را شروع می‌کند. برخلاف break که کل حلقه را متوقف می‌کرد، continue فقط از اجرای باقی‌مانده‌ی کدهای همان دور صرف‌نظر می‌کند. از این قابلیت زمانی استفاده می‌شود که بخواهید برخی تکرارهای خاص را نادیده بگیرید اما حلقه به طور کامل متوقف نشود. به عنوان نمونه، کد زیر مجموع اعداد مثبت یک لیست را محاسبه می‌کند و اعداد منفی را نادیده می‌گیرد:

				
					numbers = [5, -1, 3, 0, 8, -2]
total = 0
i = 0
while i < len(numbers):
    if numbers[i] < 0:
        i += 1
        continue  # رد شدن از اعداد منفی
    total += numbers[i]
    i += 1
print("مجموع اعداد مثبت:", total)

در اینجا هرگاه با یک عدد منفی برخورد کنیم، continue اجرا می‌شود و اجرای آن دور از حلقه پایان می‌یابد (بدون اینکه جمع کردن یا سایر محاسبات انجام شود). سپس حلقه با مقدار i افزوده‌شده ادامه پیدا می‌کند. حاصل اجرای کد بالا جمع کردن ۵ + ۳ + ۰ + ۸ است و اعداد منفی ۱- و ۲- در نتیجه لحاظ نمی‌شوند. استفاده از continue باعث می‌شود نیازی به else اضافی یا تو در تو نوشتن شرط‌ها برای موارد استثنا نداشته باشیم؛ به محض اینکه تشخیص دادیم باید آن دور حلقه را رد کنیم، این دستور ما را به ابتدای دور بعد می‌برد.

بلوک else در حلقه while

شاید برای تازه‌کارها تعجب‌آور باشد، اما حلقه‌های while (و همین‌طور for) در پایتون می‌توانند یک بخش else اختیاری داشته باشند. این بخش else تنها زمانی اجرا می‌شود که حلقه به طور عادی خاتمه یابد (یعنی شرط حلقه False شود یا در مورد حلقه for، تمام عناصر پیمایش شوند) و نه به خاطر break. به بیان دیگر، اگر حلقه با break شکسته شود، بلوک else نادیده گرفته می‌شود. این ویژگی می‌تواند برای برخی موارد کاربردی باشد. برای مثال، در جستجوی یک مقدار در بین داده‌ها، می‌توانید از else استفاده کنید تا بفهمید آیا حلقه طبیعی تمام شده (یعنی مقدار مورد نظر پیدا نشده) یا با break خارج شده‌اید (یعنی مقدار پیدا شده است). مثال زیر این مفهوم را نشان می‌دهد:

				
					target = 17
numbers = [3, 9, 12, 17, 21]
i = 0
while i < len(numbers):
    if numbers[i] == target:
        print("مقدار مورد نظر یافت شد:", target)
        break
    i += 1
else:
    print("مقدار مورد نظر در لیست وجود ندارد")

در این کد، حلقه در لیست اعداد به دنبال مقدار target می‌گردد. اگر مقدار یافت شود، با break خارج می‌شویم و پیام موفقیت چاپ می‌گردد. در صورتی که تمام لیست پیمایش شود و حلقه به پایان برسد بدون اینکه break رخ دهد (یعنی مقدار مورد نظر هرگز پیدا نشد)، بلوک else اجرا شده و پیامی مبنی بر موجود نبودن مقدار نمایش داده می‌شود. این الگو بسیار خوانا است و به‌راحتی منظور را می‌رساند، در حالی که بدون استفاده از else مجبور بودیم بعد از حلقه با یک شرط اضافی بررسی کنیم که آیا مقدار پیدا شده یا نه. البته استفاده از else برای حلقه‌ها اجباری نیست و بسیاری از برنامه‌نویسان تازه‌کار ممکن است هرگز نیاز به آن پیدا نکنند. اما دانستن این قابلیت به شما دید بهتری برای نوشتن کدهای تمیزتر و حرفه‌ای‌تر می‌دهد.
نکته: استفاده بیش از حد از break و continue می‌تواند گاهی به خوانایی کد لطمه بزند، مخصوصاً اگر به صورت پراکنده و در چندین جای بدنه‌ی حلقه به‌کار بروند. همیشه سعی کنید منطق حلقه را ساده و قابل‌فهم نگه دارید. اگر نیاز دارید از چندین break و continue استفاده کنید، شاید وقت آن باشد که بخش‌هایی از کد را به توابع کوچکتر تقسیم کنید یا رویکرد دیگری برای ساده‌سازی منطق پیدا کنید.

نکات پیشرفته:بهینه‌سازی و حلقه‌ها در پایتون

در برنامه‌های بزرگتر و حرفه‌ای، صرفاً کار کردن حلقه while یا for کافی نیست؛ بلکه بهینه بودن و درست مدیریت شدن آن‌ها نیز اهمیت دارد. در این بخش به چند نکته‌ی پیشرفته‌تر درباره‌ی حلقه‌های while اشاره می‌کنیم:

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

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

از توابع و کتابخانه‌های بهینه استفاده کنید: در بسیاری از موارد، استفاده از توابع داخلی پایتون (نظیر sum, min, max و …) یا کتابخانه‌های تخصصی (مثل NumPy برای محاسبات عددی برداری) به جای نوشتن حلقه‌های پایتونی، بهینه‌تر و سریع‌تر است. به عنوان مثال، به جای اینکه با یک حلقه کل اعضای یک لیست را جمع کنید، استفاده از تابع sum(my_list) بسیار سریع‌تر خواهد بود.

حلقه‌ی for در برابر while: از نظر سرعت اجرا، در خیلی از موارد حلقه for می‌تواند کمی سریع‌تر از while باشد، چون برخی بهینه‌سازی‌های داخلی برای آن وجود دارد (به ویژه وقتی از range برای تعداد تکرار ثابت استفاده می‌کنیم). با این حال، تفاوت معمولاً چشمگیر نیست و خوانایی کد و منطق صحیح باید اولویت شما در انتخاب نوع حلقه باشد، نه صرف چند میلی‌ثانیه سرعت. (در بخش بعدی تفاوت این دو را بیشتر بررسی می‌کنیم.)

مدیریت منابع و خطاها در حلقه: وقتی حلقه‌ها با عملیات حساس سر و کار دارند (مثل کار با فایل‌ها، شبکه یا تعامل با پایگاه داده)، باید دقت ویژه‌ای به مدیریت منابع و خطاها داشت. چند راهکار مناسب عبارت‌اند از:

استفاده از مدیریت خودکار منابع: بهترین روش برای کار با منابعی مثل فایل این است که اجازه دهید پایتون خودش مدیریت باز و بسته شدن آن را انجام دهد. به عنوان نمونه، اگر در هر دور حلقه قصد دارید داده‌ای را از یک فایل بخوانید، از ساختار with open(…) as f: بهره ببرید. با این کار، حتی اگر در میانه‌ی حلقه break کنید یا خطایی رخ دهد، فایل به طور خودکار بسته می‌شود و نشت منبع اتفاق نمی‌افتد. مثال:

				
					filenames = ["data1.txt", "data2.txt", "data3.txt"]
for name in filenames:
    with open(name) as f:
        for line in f:
            if "ERROR" in line:
                print("Error found in file", name)
                break  # خروج از حلقه خواندن فایل جاری
        # فایل به طور خودکار در پایان بلوک with بسته می‌شود

در قطعه کد بالا (که از حلقه for استفاده شده، اما مفهوم در while هم یکسان است)، حتی اگر با break خواندن یک فایل متوقف شود و به سراغ فایل بعدی برویم، فایل جاری به لطف with بسته خواهد شد.
استفاده از بلوک‌های try/except/finally:در مواقعی که نیاز است بعد از پایان حلقه حتماً عملی انجام شود (مثل بستن فایل یا بخشی از حافظه که درگیر شده است)، می‌توان از بلوک‌های try/finally استفاده کرد. در این الگو، حلقه در بخش try قرار می‌گیرد و در بخش finally کارهای تمیزکاری (cleanup) انجام می‌شود. بخش finally حتی اگر خطا یا break رخ دهد، باز هم اجرا خواهد شد

				
					resource = acquire_resource()
try:
    while condition:
        # استفاده از منبع
        if some_event:
            break
        # سایر عملیات...
finally:
    resource.release()  # آزاد کردن منبع حتی اگر حلقه زودتر خاتمه یابد

این الگو تضمین می‌کند که حتی اگر وسط حلقه با break خارج شویم یا خطایی رخ دهد، منبعی که گرفته بودیم (مثل حافظه یا رم) حتماً آزاد شود و برنامه در وضعیت نادرست باقی نماند.
توجه به مدیریت خطا داخل حلقه: اگر درون حلقه عملیاتی ممکن است خطا رخ دهد، باید مشخص کنید که در صورت بروز خطا،

حلقه متوقف شود
از آن صرف‌نظر شود (با continue)
یا اقدامی برای رفع آن انجام گیرد.

بی‌توجهی به خطاها ممکن است باعث توقف ناخواسته حلقه یا اجرای بی‌پایان آن شود. بنابراین، هنگام طراحی حلقه‌ها، باید سناریوهای خطا را در نظر بگیرید.
حلقه‌های تو در تو و پیچیدگی: استفاده از حلقه‌های while تو در تو (Nested while loops) در شرایطی ضروری است، مثلاً وقتی با داده‌های چندبعدی سروکار داریم یا نیاز به مقایسه هر عضو یک مجموعه با اعضای مجموعه‌ای دیگر باشد. اما به خاطر داشته باشید که هر حلقه‌ی تو در تو، می‌تواند پیچیدگی زمان اجرا را به شدت افزایش دهد (مثلاً دو حلقه‌ی تو در تو که هر کدام N بار اجرا شوند، در مجموع مرتبه‌ی $O(N^2)$ عملیات خواهند داشت). بنابراین:
حتی‌المقدور از عمق تو در توی زیاد پرهیز کنید؛ وجود دو حلقه‌ی تودرتو متداول است، اما سه یا چهار حلقه‌ی تو در تو معمولاً نشانه‌ی کدی است که می‌توان آن را بهینه‌تر یا خواناتر کرد (مثلاً با تفکیک به توابع کمکی، یا استفاده از ساختار داده مناسب‌تر).
در حلقه‌های تو در تو، break و continue با دقت بیشتری عمل می‌کنند. دستور break فقط از داخلی‌ترین حلقه‌ای که در آن قرار دارد خارج می‌شود. اگر نیاز باشد از چندین سطح حلقه بیرون بیایید، شاید لازم شود از متغیرهای به اصطلاح flag یا روش‌های دیگر مثل ایجاد استثناء(Exception) استفاده کنید. این وضعیت ممکن است طراحی کد را پیچیده کند. پس همیشه بپرسید آیا راه بهتری جز چندین حلقه‌ی تودرتو برای مسئله‌ی شما وجود دارد یا خیر.
برای حفظ خوانایی، می‌توانید بخش داخلی یک حلقه‌ی تودرتو را به یک تابع جداگانه تبدیل کنید. بدین ترتیب هر حلقه وظیفه‌ی مشخص‌تری خواهد داشت و کد تمیزتر می‌شود.

مقایسه‌ی حلقه while و حلقه for

حلقه‌های while و for هر دو ابزار تکرار در پایتون هستند، اما هر کدام کاربردها و ویژگی‌های خاص خود را دارند. به طور خلاصه:

زمان استفاده از while

هنگامی که از قبل نمی‌دانید حلقه چند بار باید تکرار شود و ادامه‌ی تکرار وابسته به برقرار ماندن یک شرط در طول اجرا است، از while استفاده کنید. به بیان دیگر، حلقه‌ی while برای مواقعی مناسب است که ماهیت تکرار مبتنی بر یک شرط پویا است. برای مثال: دریافت ورودی معتبر از کاربر (تا وقتی ورودی درست نداده حلقه ادامه دارد)، منتظر ماندن برای اتمام یک فرآیند پس‌زمینه، یا پیمایش یک ساختار داده تا زمانی که به عنصر دلخواه برسیم.

زمان استفاده از for

زمانی که تعداد تکرار معلوم یا قابل محاسبه است یا قصد دارید روی مجموعه‌ای از اقلام (مثلاً عناصر یک لیست یا کاراکترهای یک رشته) یکی‌یکی عبور کنید، از حلقه‌ی for بهره ببرید. حلقه‌ی for در پایتون مستقیماً بر روی مجموعه‌ها و توالی‌ها حرکت می‌کند و به خاطر خوانایی بالاتر، انتخاب اول برای اکثر انواع پیمایش دنباله‌ها است. برای مثال: اجرای یک قطعه کد برای هر فایل در یک پوشه، محاسبه‌ی مجموع عناصر یک لیست، یا تکرار ۱۰ بار اجرای یک دستور خاص (که می‌توان با for i in range(10): انجام داد).

تفاوت در خوانایی و خطر خطا: حلقه‌ی for به علت اینکه مدیریت شمارنده یا اندیس را خود پایتون بر عهده می‌گیرد، احتمال خطاهایی مثل فراموش کردن به‌روزرسانی شمارنده (که در حلقه‌ی while منجر به حلقه‌ی بی‌نهایت می‌شود) یا اشتباه در محدوده‌ی پیمایش را کمتر می‌کند. از این رو، توصیه می‌شود هر زمان امکان‌پذیر است و مسئله ذاتاً یک پیمایش روی مجموعه یا یک تعداد دفعات ثابت است، از for استفاده کنید و سراغ while نروید.
تفاوت در عملکرد: همان‌طور که اشاره شد، حلقه‌های for برای موارد مشخص بهینه شده‌اند و در برخی سناریوها ممکن است کمی سریع‌تر از while باشند. اما در اکثر کاربردهای معمول، این تفاوت آن‌قدر نیست که بخواهد تعیین‌کننده‌ی انتخاب شما باشد. مهمتر این است که کد شما قابل فهم، قابل نگهداری و بدون باگ باشد. بنابراین ابتدا به تناسب معنایی حلقه با نیازتان توجه کنید (شرط محور بودن در برابر شمارش یا پیمایش محور بودن)، سپس اگر نیاز به بهینه‌سازی سرعت داشتید به جزئیاتی مانند نوع حلقه فکر کنید.

در آخر، هر دو حلقه‌ی while و for ابزارهای ارزشمندی هستند. یک توسعه‌دهنده‌ی حرفه‌ای پایتون کسی است که بداند کِی از کدام یک بهره ببرد: وضوح و سادگی کد را در نظر بگیرد، از قابلیت‌های هر کدام (مثل else در حلقه یا توابع کمکی) بهره‌مند شود، و از تله‌های رایج (مانند حلقه‌ی بی‌نهایت یا infinite loop) دوری کند.

حلقه do while در پایتون

در پایتون حلقه‌ی do…while به‌طور مستقیم وجود ندارد، اما می‌توان آن را با استفاده از حلقه‌ی while شبیه‌سازی کرد. در این ساختار، کد ابتدا اجرا می‌شود و سپس شرط بررسی می‌شود. برای شبیه‌سازی این رفتار در پایتون، می‌توان از حلقه‌ی while True به همراه دستور break استفاده کرد تا یک تکرار حداقل انجام شود.

				
					while True:
    # کاری که باید انجام بشه
    ...
    if not شرط:
        break

				
					while True:
    user_input = input("برای خروج 'exit' را وارد کن: ")
    if user_input == "exit":
        break

محاسبه فاکتوریل در پایتون با while

فاکتوریل یک عدد صحیح مثبت n برابر است با حاصل‌ضرب همه‌ی اعداد صحیح از ۱ تا n یعنی:

				
					n! = n × (n-1) × (n-2) × ... × 1

سورس کد:

				
					n = int(input("عدد را وارد کنید: "))
factorial = 1
counter = 1

while counter <= n:
    factorial *= counter
    counter += 1

print(f"{n}! = {factorial}")