วิธีจำลอง Do-While Loops ใน Python

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีจำลอง do-while loop ใน Python

ในภาษาการเขียนโปรแกรมใด ๆ ลูปช่วยให้คุณดำเนินการบางอย่างซ้ำ ๆ ขึ้นอยู่กับเงื่อนไขการวนซ้ำ Python รองรับโครงสร้าง while และ for loop แต่ไม่รองรับการวนซ้ำ do-while โดยกำเนิด

อย่างไรก็ตาม คุณสามารถจำลองลูป do-while ได้ด้วยการทำความเข้าใจวิธีการทำงาน โดยใช้คำสั่งควบคุมลูปและลูปที่มีอยู่ใน Python

คุณจะได้เรียนรู้วิธีดำเนินการนี้ในอีกไม่กี่นาทีข้างหน้า เอาล่ะ!

Do-While Loop Construct คืออะไร?

หากคุณตั้งโปรแกรมในภาษาเช่น C หรือ C++ คุณอาจเจอโครงสร้างลูป do-while

ในลูป do-while ชุดของคำสั่งในเนื้อหาของลูป—ภายในบล็อกที่คั่นด้วยเครื่องหมายปีกกา—จะถูกดำเนินการก่อน จากนั้นจึงตรวจสอบเงื่อนไขการวนซ้ำ

คุณสามารถเรียกใช้ตัวอย่าง C ต่อไปนี้ในคอมไพเลอร์ C ออนไลน์ของ admintrick.com ได้จากเบราว์เซอร์ของคุณโดยตรง

พิจารณาข้อมูลโค้ดต่อไปนี้:

//do_while_example1

#include <stdio.h>

int main() {
    int count = 1;
    printf("Do-While loop: n");
    
    do{
        printf("Loop runs...");
        }while(count<0);

    return 0;
}

นี่คือผลลัพธ์

Output

Do-While loop: 
Loop runs...

ในตัวอย่างข้างต้น:

  • ค่าของการนับคือ 1 และเงื่อนไขการวนซ้ำคือจำนวน < 0 อย่างไรก็ตาม การวนซ้ำจะทำงานเพียงครั้งเดียวแม้ว่าเงื่อนไขการวนซ้ำจะเป็นเท็จในขั้นต้น
  • สิ่งนี้ตรงกันข้ามกับลูป while ที่ดำเนินการเฉพาะเมื่อเงื่อนไขการวนซ้ำเป็น True ในตอนแรก
//while_example1

#include <stdio.h>

int main() {
    int count = 1;
    printf("While loop: n");
    
    while(count<0){
        printf("Loop runs...");
        }

    return 0;
}

ดังที่กล่าวไว้ เงื่อนไขการวนซ้ำ การนับ < 0 เป็นเท็จ ในขั้นต้น ตัวแปรการนับถูกเริ่มต้นเป็น 1 ดังนั้นเมื่อรวบรวมและรันโค้ดด้านบน เราจะเห็นว่าคำสั่งใน while loop body จะไม่ถูกดำเนินการ

Output

While loop: 
//loop body does not run!

ในขณะที่ vs. ทำในขณะที่: ภาพรวมของความแตกต่าง

มาดูความแตกต่างระหว่างลูป while และ do-while กันดีกว่า

พิจารณาตัวอย่างนี้:

//do_while_example2

#include <stdio.h>

int main() {
    int count = 1;
    printf("Do-while loop: n");
    
    do{
       printf("%dn",count);
       count++;
    }while(count<5);

    return 0;
}

ในเซลล์รหัสด้านบน:

  • ตัวแปรการนับเริ่มต้นเป็น 1
  • เราใช้ลูป do-while
  • ตัวแปรการนับจะเพิ่มขึ้น 1 ในแต่ละครั้งที่ผ่านลูป และเงื่อนไขการวนซ้ำถูกตั้งค่าให้นับ < 5
  ตัวติดตาม GPS ที่ดีที่สุด 9 อันดับแรก

ต่อไปนี้คือคำอธิบายภาพว่าการดำเนินการเกิดขึ้นอย่างไร: do-while loop ทำงานอย่างไร และตรวจสอบเงื่อนไขการวนซ้ำสี่ครั้ง

Output

Do-while loop: 
1
2
3
4

หากคุณใช้ while loop แทน นี่คือสิ่งที่เรามี

//while_example2

#include <stdio.h>

int main() {
    int count = 1;
    printf("While loop: n");
    
    while(count<5){
       printf("%dn",count);
       count++;
    };

    return 0;
}

รูปด้านล่างอธิบายการทำงานของลูป while ในตัวอย่างนี้ while loop ตรวจสอบเงื่อนไขการวนซ้ำห้าครั้ง

Output

While loop: 
1
2
3
4

แม้ว่าผลลัพธ์สำหรับลูปด้านบนและ do-while จะเหมือนกัน แต่ก็มีความแตกต่างเล็กน้อย

ในอีกสักครู่ การตรวจสอบเงื่อนไขจะมาก่อน ตามด้วยเนื้อหาของลูป ดังนั้นหากคุณต้องการให้ลูปรัน K ครั้ง ควรมี K รันตรงที่เงื่อนไขการวนซ้ำเป็น True ในการวนซ้ำหมายเลข K+1 เงื่อนไขจะกลายเป็น False และตัวควบคุมจะแยกออกจากลูป

ในทางกลับกัน ถ้าคุณใช้ลูป do-while: เงื่อนไขการวนซ้ำจะถูกตรวจสอบเป็นครั้งที่ K-th หลังจากที่ K ผ่านลูปเท่านั้น

เหตุใดการปรับปรุงส่วนเพิ่มนี้จึงมีประโยชน์ 🤔

สมมติว่าเงื่อนไขการวนซ้ำมีราคาแพงในการคำนวณ เช่น เกี่ยวข้องกับการเรียกฟังก์ชันแบบเรียกซ้ำ การดำเนินการทางคณิตศาสตร์ที่ซับซ้อน และอื่นๆ

ในกรณีเช่นนี้ สำหรับการทำซ้ำ K ของเนื้อหาลูป จะเป็นประโยชน์หากใช้ลูป do-while แทน

ขณะ vs. ขณะทำอย่างย่อ

มาจัดตารางความแตกต่างที่สำคัญที่เราได้เรียนรู้กัน 👩‍🏫

ในขณะที่ LoopDo-While LoopCheck สำหรับเงื่อนไขการวนซ้ำ: ก่อนดำเนินการของ loop body ตรวจสอบเงื่อนไขการวนซ้ำ: หลังจากดำเนินการของ loop body หากเงื่อนไขเป็น False ในขั้นต้น เนื้อหาของลูปจะไม่ถูกดำเนินการ หากเงื่อนไขเป็น False ในตอนแรก เนื้อหาของลูป ถูกดำเนินการเพียงครั้งเดียวเงื่อนไขการวนซ้ำจะถูกตรวจสอบ K ครั้งสำหรับ K ที่ผ่านลูปเงื่อนไขการวนซ้ำจะถูกตรวจสอบ K-1 ครั้งสำหรับ K ที่ผ่านลูปเมื่อใดควรใช้ while loop?
– ลูปควรทำงานตราบเท่าที่เงื่อนไขเป็น True
– สำหรับลูปควบคุมการเข้า
– เมื่อเงื่อนไขการวนซ้ำไม่แพงในการคำนวณจะใช้ do-while loop เมื่อใด
– ลูปควรรันอย่างน้อยหนึ่งครั้งสำหรับเงื่อนไขการวนซ้ำเท็จเริ่มต้น
– สำหรับลูปควบคุมทางออก
– เมื่อเงื่อนไขการวนซ้ำมีราคาแพงในการคำนวณ

การจำลองพฤติกรรม Do-While ใน Python

จากส่วนก่อนหน้านี้ เรามีสองเงื่อนไขต่อไปนี้เพื่อจำลองลูป do-while:

  • คำสั่งใน loop body ควรดำเนินการอย่างน้อยหนึ่งครั้ง ไม่ว่าเงื่อนไขการวนซ้ำจะเป็น True หรือ False
  • ควรตรวจสอบเงื่อนไขหลังจากดำเนินการคำสั่งในเนื้อหาของลูป หากเงื่อนไขเป็น False ตัวควบคุมควรแยกออกจากลูป: exit control

ไม่มีที่สิ้นสุดในขณะที่คำสั่งวนและแบ่งใน Python

คุณสามารถกำหนด infinite while loop ใน Python ดังที่แสดงด้านล่าง

while True:
    pass

# Instead of True, you can have any condition that is always True

while always-True-condition:
   pass

คำสั่ง break สามารถใช้เพื่อแยกออกจาก loop body และโอนการควบคุมไปยังคำสั่งแรกนอก loop body

while <condition>:
    if <some-condition>:
        break

ในตัวอย่างแรกสุดของลูป do-while ใน C เงื่อนไขในการวนซ้ำคือการนับ < 0 ดังนั้นเงื่อนไขที่จะแยกจากลูปคือค่าการนับเป็นศูนย์หรือมากกว่าศูนย์ (นับ >= 0)

  ปิดการใช้งานหน้าจอเริ่มต้นของ MS Office 2013 & เปิดเอกสารเปล่าเสมอ

นี่คือการจำลอง do-while loop ใน Python:

count = 1
while True:
    print("Loop runs...")
    if(count >= 0):
        break

Python Do-While ตัวอย่างลูป

เราจะทบทวนตัวอย่างจากส่วนก่อนหน้าและเขียนใหม่ใน Python โดยจำลอง do while loop

#1. มาทบทวนตัวอย่างกัน: การพิมพ์ค่าของตัวแปรการนับออกมาเมื่อการนับมีค่าน้อยกว่าห้า

เรารู้วิธีกำหนด infinite loop เพื่อให้ loop body ทำงานอย่างน้อยหนึ่งครั้ง

การวนซ้ำควรดำเนินต่อไปตราบเท่าที่การนับน้อยกว่าห้า ดังนั้น เมื่อนับถึงห้า เราควรแยกวง ดังนั้น count == 5 คือเงื่อนไขการควบคุมทางออก

เมื่อนำมารวมกัน เราได้:

count = 1
while True:
  print(f"Count is {count}")
  count += 1
  if count==5:
    break
Output

Count is 1
Count is 2
Count is 3
Count is 4

#2. นอกจากนี้เรายังสามารถเขียนเกมเดาตัวเลขใหม่เป็น Python do-while construct

ในเกมการเดาตัวเลข เราตรวจสอบการเดาของผู้ใช้กับหมายเลขลับที่กำหนดไว้ล่วงหน้า ผู้ใช้ควรเดาหมายเลขลับภายในจำนวนครั้งสูงสุดที่อนุญาต เช่น max_guesses

รหัสควรแจ้งให้ผู้ใช้ป้อนข้อมูล โดยไม่คำนึงว่าการเดาของพวกเขาถูกหรือผิด เราสามารถทำได้โดยใช้ infinite while loop

แล้วเมื่อไหร่ที่เราควรแยกตัวออกจากวง?

ตัวควบคุมควรแยกออกจากลูปเมื่อสิ่งใดสิ่งหนึ่งต่อไปนี้เกิดขึ้น:

  • เมื่อผู้ใช้ทายเลขได้แล้ว
  • เมื่อผู้ใช้ยังไม่ได้เดาตัวเลข แต่หมดจำนวนการเดาที่มีอยู่แล้ว จำนวนการเดาที่ไม่ถูกต้องโดยผู้ใช้ = max_guesses
  • เซลล์รหัสด้านล่างแสดงให้เห็นว่าเราสามารถทำได้อย่างไร

    import random
    
    low, high = 5,50
    
    secret_number = random.choice(range(low,high))
    
    max_guesses = 10
    
    num_guesses = 0
    
    while True:
        guess = int(input("nGuess a number:"))
        num_guesses += 1
        
        conditions = [num_guesses==max_guesses,guess==secret_number]
        
        if any(conditions):
            break

    แทนที่จะแยกจากลูป เราสามารถเพิ่มคำสั่ง print() ที่อธิบายได้เมื่อเราพบแต่ละเงื่อนไขข้างต้นแล้วแยกออกจากลูป

    import random
    
    low, high = 5,50
    
    secret_number = random.choice(range(low,high))
    
    print(secret_number)
    
    max_guesses = 10
    
    num_guesses = 0
    
    while True:
        guess = int(input("nGuess a number:"))
        num_guesses += 1
        
        if guess==secret_number:
            print("Congrats, you guessed it right!")
            break
        if num_guesses==max_guesses:
            print("Sorry, you have no more guesses left!")
            break

    เอาต์พุตตัวอย่างสองรายการแสดงอยู่ด้านล่าง

      8 หลักสูตรออนไลน์เพื่อเรียนรู้พื้นฐานของวิศวกรรมข้อมูล

    ในเอาต์พุตตัวอย่างนี้ คำสั่ง break จะแยกออกจากลูปเมื่อผู้ใช้เดาหมายเลขลับได้อย่างถูกต้อง

    # Sample output when secret_number = 43 and user gets it right!
    
    Guess a number:4
    
    Guess a number:3
    
    Guess a number:43
    Congrats, you guessed it right!
    

    นี่คือตัวอย่างเอาต์พุตอื่นเมื่อผู้ใช้ถึงจำนวนการเดาสูงสุดที่มี แต่ไม่สามารถเดาหมายเลขลับได้อย่างถูกต้อง

    # Sample output when secret_number = 33 and user fails to guess it right!
    
    Guess a number:3
    
    Guess a number:15
    
    Guess a number:21
    
    Guess a number:50
    
    Guess a number:17
    
    Guess a number:6
    
    Guess a number:18
    
    Guess a number:5
    
    Guess a number:12
    
    Guess a number:43
    Sorry, you have no more guesses left!

    บทสรุป

    ฉันหวังว่าบทช่วยสอนนี้จะช่วยให้คุณเข้าใจวิธีจำลองการวนซ้ำ do-while ใน Python

    นี่คือประเด็นสำคัญ:

    • ใช้การวนซ้ำแบบอนันต์เพื่อให้แน่ใจว่าเนื้อความของลูปทำงานอย่างน้อยหนึ่งครั้ง อาจเป็นลูปอนันต์เล็กน้อยเช่นในขณะที่ True หรืออาจเป็นในขณะที่ ซึ่งเงื่อนไขจะเป็น True เสมอ
    • ตรวจสอบเงื่อนไขการออกภายในลูปและใช้คำสั่ง break เพื่อแยกออกจากลูปภายใต้เงื่อนไขเฉพาะ

    ต่อไป เรียนรู้วิธีใช้ลูปและฟังก์ชัน enumerate() ใน Python

    เรื่องล่าสุด

    x