آموزش حلقه while پایتون : آموزش آسان و سریع

آموزش حلقه while پایتون

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

حلقه while در پایتون چیست؟

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

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

این در کد زیر نشان داده شده است:

person1 = ('Anne', 17)
person2 = ('Marie', 42)
person3 = ('Kate', 63)
print(f"{person1[0]}, {person1[1]} years old")
print(f"{person2[0]}, {person2[1]} years old")
print(f"{person3[0]}, {person3[1]} years old")

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

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

people = ('Jim', 'Jack', 'John')
ages = (17, 42, 63)
for person, age in zip(people, ages):
    print(f"{person}, {age} years old")

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

while connection_open():
    print('Ready to receive')
    process_messages()
    if should_close_connection():
        close_connection()
# once loop terminates
print('Connection was closed')

حلقه های Python while نیز برای تکرارهای نامحدود استفاده می شود. برخی از نمونه های معروف عبارتند از ATM ها، خط فرمان لینوکس و حلقه خواندن-ایوال-چاپ پایتون (REPL). در زیر طرحی از اجرای REPL با استفاده از حلقه while بی نهایت نشان می دهیم.

# Loop
while True:
    # Read user input
    user_input = read_input()
    # Evaluate input and produce result
    result = eval(user_input)
    # Print result
    print(result)

آموزش حلقه while پایتون : حلقه while چگونه پایتون کار می کند؟

حلقه while در پایتون بسیار شبیه عبارات if در پایتون عمل می کند. هر دوی این ساختارهای کنترلی دارای دو بخش هستند:

• شرایطی که مورد ارزیابی قرار خواهد گرفت
• بدن با دستورالعمل

تفاوت آنها در این است که بدن چند بار اعدام می شود. بدنه یک دستور if حداکثر یک بار اجرا می شود:

if condition:
    run_once()

در مقابل، بدنه یک حلقه while می تواند چندین بار اجرا شود:

while condition:
    run_again()

یک حلقه while پایتون به صورت زیر اجرا می شود:

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

مشابه عبارات if، حلقه while در پایتون نیز می تواند شامل یک بلوک else باشد. بلوک else اختیاری است و اگر شرط نادرست باشد (یا تبدیل شود) یک بار اجرا می شود.

while False:
    # this code doesn't loop
    never_runs()
else:
    # instead, this code runs once
    runs_once()

آموزش حلقه while پایتون : تفاوت بین حلقه‌های for و حلقه‌های while در پایتون چیست؟

حلقه while Python مربوط به حلقه for است. هر دوی آنها برای اجرای مکرر یک بلوک کد استفاده می شوند. (به این “تکرار” نیز می گویند.) تفاوت این است که کد چند بار اجرا می شود.

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

for letter in 'Python':
    print(letter)

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

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

counter = 0
limit = 10
while counter < limit:
    print(counter)
    counter += 1

معادل حلقه کوتاه تر و مستقیم تر است:

for counter in range(10):
    print(counter)

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

word = 'Python'
letters = iter(word)
letter = ''
while letter is not None:
    letter = next(letters, None)
    if letter:
        print(letter)

آموزش حلقه while پایتون : مراقب حلقه های infinite while در پایتون باشید

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

while True:
    print("Forever…")

حلقه های بی نهایت تصادفی معمولاً نتیجه عبارتی هستند که همیشه به True ارزیابی می شود. مثلا:

while 1 == 1 + 1 - 1:
    print("And ever…")

با این حال، تعدادی کاربرد برای حلقه های بی نهایت ایجاد شده عمدی وجود دارد.

شکستن و پرش در حین حلقه در پایتون

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

aborted = False
while not aborted:
    print("Still going…")
    if some_cond:
        # will prevent next iteration
        aborted = True

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

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

while True:
    print("Still going…")
    if some_cond:
        break
        # we never get here
        print("We shouldn't be here")
# we end up here after breaking
print("Done.")

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

# 'continue' takes us here
while True:
    print("Press G to start a new game")
    print("Press S to see stats")
    print("Press M for main menu")
    print("Press Q to quit")
    
    key_press = input("Your choice \n")[0].upper()
    print(f"You pressed {key_press}")
    
    if key_press == "G":
        # start game routines
        print("Starting game …")
    elif key_press == "S":
        # show stats
        print("Showing stats …")
    elif key_press == "M":
        # back to main menu
        print("Returning to menu")
        continue
    elif key_press == "Q":
        # break out of loop
        print("Quitting")
        break
    else:
        print("Unknown command. Try again")
# "break" takes us here
...

آموزش حلقه while پایتون

تعدادی کاربرد متنوع برای حلقه‌های while در پایتون وجود دارد. در حالی که حلقه‌ها معمولاً برای الگوریتم‌هایی استفاده می‌شوند که تعداد تکرارها را نمی‌توان از قبل تعریف کرد یا جایی که این تعداد در طول اجرا تغییر می‌کند. در حالی که حلقه ها اغلب در ترکیب با سایر ساختارهای کنترلی مانند عبارات تصمیم گیری و عبارات try-else استفاده می شوند. بیایید به چند نمونه نگاه کنیم.

مصرف یک مجموعه با حلقه‌های while در پایتون

حلقه‌های For گزینه خوبی برای تکرار بر روی عناصر یک مجموعه در پایتون هستند. حداقل تا زمانی که مجموعه در بدنه حلقه تغییر نکرده باشد، این مورد صادق است. اما چه اتفاقی می‌افتد اگر در حین عبور از عناصر، تغییراتی ایجاد کنیم؟ تصور کنید می خواهیم در حین تکرار، عناصر را از مجموعه حذف کنیم. این به عنوان “مصرف” یک مجموعه نامیده می شود.

هنگامی که مجموعه زیرین حلقه for در طول تکرار تغییر می کند، ممکن است خطاهای عجیبی ایجاد شود. اگر بخواهیم مجموعه ای را مصرف کنیم، حلقه while بهترین انتخاب در پایتون است. مجموعه را شرط حلقه while قرار می دهیم. تا زمانی که مجموعه همچنان حاوی عناصر باشد، در یک زمینه بولی به True ارزیابی می شود. اگر مجموعه خالی باشد، به False ارزیابی می شود و حلقه خاتمه می یابد.

pieces = ['x', 'o', 'o', 'o', 'x', 'o', 'x', 'x']
while pieces:
    piece = pieces.pop()
    print(f"Removed {piece}")
# test
assert pieces == []

پیاده سازی تابع range() خود با حلقه های while در پایتون

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

def my_range(start, stop):
    # only positive ranges implemented
    if stop <= start:
        return None
    current = start
    while current < stop:
        yield current
        # next call of next() continues here
        current += 1
# test
assert list(my_range(7, 9)) == list(range(7, 9))

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

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

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

limit = 5
round = 0
progress = True
while progress and round < limit:
    # attempt next optimization
    round += 1
    # compute optimized parameters
    params = optimize(params)
    # make a copy of the old model
    old_model = model
    # compute new model using optimized parameters
    model = run(model, params)
    # worthwhile to continue optimizing?
    progress = has_improved(model, old_model)

ایجاد ارتباط با حلقه while و پیاده سازی try-except

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

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

max_tries = 10
attempt = 0
conn = None
# 'continue' takes us here
while attempt < max_tries:
    attempt += 1
    print("Trying to get a connection")
    try:
        # might raise 'ConnectionException'
        conn = get_connection()
        # got our connection
        break
    # "get_connection()" raised 'ConnectionException'
    except ConnectionException:
        print("Something went wrong. Trying again")
        continue
# went through 'max_tries' unsuccessful connection attempts
else:
    assert conn is None
    print("Unable to connect")
# 'break' takes us here
assert conn is not None
print("Connection established")

تکرار بر روی ساختارهای بازگشتی با حلقه while پایتون

حلقه while در پایتون برای حل مسائل بازگشتی مناسب است. این به این معنی است که گزینه خوبی برای تکرار مجدد است:

• لیست های جاسازی شده
• سازه های درختی
• گراف ها

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

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

def open_doll(doll):
    """
    * Dolls dolls stacked five levels deep, with 'None' inside:
    'doll = [[[[[None]]]]]'
    """
    while type(doll) is list:
        print("Opening the next doll")
        # go one level deeper
        doll = doll.pop()
    else:
        print(f"Reached the bottom and found {doll}")
        return doll
# test
doll = [[[[[None]]]]]
assert open_doll(doll) is None

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

اجرای پایتون در حین حلقه روی صفحه بازی

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

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

ابتدا تابع random_walk() را تعریف می کنیم که حاوی حلقه while خواهد بود. با عملگر پایتون برای “برابر با”، بررسی می کنیم که آیا مکان فعلی کاراکتر مقصد آن است یا خیر. اگر نه، دوباره تکرار می کنیم.

def random_walk(board = (10, 10), goal = (4, 4), start = (0, 0)):
    # ensure arguments are valid
    if not (goal[0] in range(board[0]) and goal[1] in range(board[1]) and start[0] in range(board[0]) and start[1] in range(board[1])):
        print(f"Goal {goal} and / or start position {start} outside of board with dimensions {board}")
        return None, 0
    steps = 0
    pos = start
    # as long as we haven't reached the goal
    while not pos == goal:
        # move to neighboring position
        pos = get_neighbor(pos, board)
        steps += 1
        print(f"Moved to position {pos}")
    print(f"Reached goal at {pos} after {steps} steps")
    return pos, steps

ما همچنین یک تابع کمکی get_neighbor() تعریف می کنیم که فیلد را در اطراف یک مکان خاص برمی گرداند.

def get_neighbor(pos, bounds):
    from random import choice
    """
        x = 0    . . .    m
            - - - - - - - -
     y = 0 |
           |
         . |           (x, y-1)
         . |  (x-1, y) (x, y)  (x+1, y)
         . |           (x, y+1)
           |
         n |
   
    """
    x, y = pos
    # computer neighbors
    neighbors = [ (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1) ]
    # filter out neighbors that are outside of bounds
    neighbors = [ pos for pos in neighbors if 0 <= pos[0] < bounds[0] and 0 <= pos[1] < bounds[1] ]
    # select a random neighbor
    neighbor = choice(neighbors)
    return neighbor

در نهایت، پیاده‌سازی تصادفی خود را آزمایش می‌کنیم.

random_walk(board = (10, 10), goal = (4, 4), start = (5, 7))

آموزش حلقه while پایتون

ترجمه شده توسط سایت دریای شرق از سایت
کپی بدون ذکر نام و لینک سایت دریای شرق ممنوع است !

About The Author