Computer >> บทช่วยสอนคอมพิวเตอร์ >  >> การเขียนโปรแกรม >> การเขียนโปรแกรม

การควบคุม Python Loop อย่างเชี่ยวชาญ:การใช้ตัวแบ่ง ดำเนินการต่อ และส่งคำสั่งอย่างมีประสิทธิภาพ

บทนำ

การใช้ สำหรับลูป และ ขณะวนซ้ำ ใน Python ช่วยให้คุณสามารถทำงานซ้ำได้โดยอัตโนมัติและมีประสิทธิภาพ ลูปเหล่านี้เป็นโครงสร้างพื้นฐานใน Python ที่ช่วยให้คุณสามารถวนซ้ำลำดับ เช่น รายการ สิ่งอันดับ และสตริง หรือดำเนินการบล็อกโค้ดซ้ำๆ ตามเงื่อนไข

อย่างไรก็ตาม มีสถานการณ์ที่คุณต้องการการควบคุมโฟลว์ของลูปของคุณมากขึ้น ตัวอย่างเช่น คุณอาจพบสถานการณ์ที่คุณต้องออกจากลูปก่อนเวลาอันควร ข้ามการวนซ้ำปัจจุบัน หรือเพียงแค่มีตัวยึดตำแหน่งสำหรับโค้ดในอนาคต Python มีคำสั่งที่มีประสิทธิภาพสามคำสั่งเพื่อจัดการกับกรณีเหล่านี้:05 , 12 และ 21 .

  • 32 คำสั่งอนุญาตให้คุณออกจากลูปโดยสิ้นเชิงเมื่อตรงตามเงื่อนไขที่กำหนด ซึ่งจะหยุดการทำงานของลูปได้อย่างมีประสิทธิภาพ
  • รหัส <48 คำสั่งช่วยให้คุณข้ามโค้ดที่เหลือภายในลูปสำหรับการวนซ้ำปัจจุบันและไปยังการวนซ้ำครั้งถัดไป
  • รหัส <51 คำสั่งเป็นการดำเนินการที่เป็นโมฆะ มันถูกใช้เป็นตัวยึดตำแหน่งในลูป ฟังก์ชัน คลาส หรือเงื่อนไขที่จำเป็นต้องมีโค้ดทางวากยสัมพันธ์ แต่คุณไม่มีอะไรต้องดำเนินการ

การทำความเข้าใจและการใช้คำสั่งเหล่านี้สามารถเพิ่มความสามารถของคุณในการจัดการโฟลว์การควบคุมลูปได้อย่างมาก ทำให้โค้ดของคุณมีประสิทธิภาพมากขึ้นและอ่านง่ายขึ้น บทความนี้ให้คำแนะนำที่ครอบคลุมเกี่ยวกับการใช้ 61 ของ Python , 74 และ 84 คำสั่งภายในลูปเพื่อควบคุมการไหลอย่างมีประสิทธิภาพ โดยจะอธิบายวัตถุประสงค์และพฤติกรรมของแต่ละคำสั่งด้วยตัวอย่างโค้ดที่ใช้งานได้จริงและการสาธิตผลลัพธ์ บทความนี้ยังสำรวจเทคนิคการควบคุมลูปขั้นสูง รวมถึงวิธีการออกจากลูปหลายระดับ และแนะนำ 95 ที่ไม่ค่อยมีใครรู้จัก ข้อที่มีการวนซ้ำเพื่อตรรกะหลังการวนซ้ำที่สะอาดยิ่งขึ้น สถานการณ์ในโลกแห่งความเป็นจริง เช่น การแยกวิเคราะห์ข้อมูล การสแกนไฟล์ และการสำรวจเมทริกซ์ จะถูกรวมไว้เพื่อแสดงให้เห็นว่าแนวคิดเหล่านี้นำไปใช้ในการเขียนโปรแกรม Python ที่ใช้งานจริงได้อย่างไร

ต้องการปรับใช้โปรเจ็กต์ Python และทำให้มันใช้งานได้อย่างรวดเร็วหรือไม่? ลองใช้แพลตฟอร์มแอป DigitalOcean และปรับใช้โปรเจ็กต์ Python โดยตรงจาก GitHub ได้ในไม่กี่นาที

ประเด็นสำคัญ

  • 103 คำสั่งใน Python ช่วยให้คุณสามารถออกจากลูปได้ทันทีเมื่อตรงตามเงื่อนไขที่กำหนด ซึ่งมีประโยชน์อย่างยิ่งสำหรับการยกเลิกตั้งแต่เนิ่นๆ ในระหว่างการดำเนินการค้นหาหรือการตรวจสอบความถูกต้อง
  • 118 คำสั่งข้ามการวนซ้ำปัจจุบันที่เหลือและย้ายไปยังรอบถัดไปของลูป ช่วยหลีกเลี่ยงเงื่อนไขที่ซ้อนกันลึกและปรับปรุงความชัดเจนของลูป
  • 121 คำสั่งคือตัวยึดตำแหน่งทางวากยสัมพันธ์ที่ไม่ดำเนินการใด ๆ โดยทั่วไปจะใช้เมื่อจำเป็นต้องมีบล็อกของโค้ดทางวากยสัมพันธ์ แต่ตรรกะยังไม่ได้ถูกนำมาใช้
  • เนื่องจาก Python ขาดการสนับสนุนดั้งเดิมสำหรับการแยกลูปที่ซ้อนกันหลายอัน การใช้ตัวแปรแฟล็กเพื่อติดตามเงื่อนไขและการควบคุมพฤติกรรมของลูปภายนอกจึงเป็นวิธีแก้ปัญหาเชิงปฏิบัติ
  • การห่อหุ้มลอจิกลูปในฟังก์ชันและใช้ 130 ช่วยให้คุณสามารถออกจากการวนซ้ำหลายระดับได้อย่างหมดจด และปรับปรุงความเป็นโมดูลและการบำรุงรักษาโค้ด
  • แม้ว่าจะสามารถใช้ข้อยกเว้นเพื่อออกจากลูปที่ซ้อนกันได้ แต่ควรสงวนไว้สำหรับเงื่อนไขพิเศษอย่างแท้จริง และไม่ต้องพึ่งพาการควบคุมลูปปกติเนื่องจากข้อกังวลด้านประสิทธิภาพและความสามารถในการอ่าน
  • 147 ข้อใน 153 และ 164 ลูปจะดำเนินการเฉพาะเมื่อลูปเสร็จสิ้นตามปกติโดยไม่ต้องกดปุ่ม 178 ทำให้เหมาะอย่างยิ่งสำหรับการใช้ตรรกะ "ไม่พบ" ที่ชัดเจนและกระชับ

ข้อกำหนดเบื้องต้น

คุณควรติดตั้ง Python 3 และสภาพแวดล้อมการเขียนโปรแกรมบนคอมพิวเตอร์หรือเซิร์ฟเวอร์ของคุณ หากคุณไม่ได้ตั้งค่าสภาพแวดล้อมการเขียนโปรแกรม คุณสามารถดูคู่มือการติดตั้งและการตั้งค่าสำหรับการตั้งค่าสภาพแวดล้อมการเขียนโปรแกรม Python ภายในบนเซิร์ฟเวอร์ของคุณที่เหมาะสมสำหรับระบบปฏิบัติการของคุณ (Ubuntu, CentOS, Debian ฯลฯ)

คำสั่งแบ่ง

ใน Python 183 คำสั่งอนุญาตให้คุณออกจากลูปเมื่อมีการทริกเกอร์เงื่อนไขภายนอก คุณจะต้องใส่ 194 คำสั่งภายในบล็อคโค้ดภายใต้คำสั่งลูปของคุณ โดยปกติจะอยู่หลัง 207 แบบมีเงื่อนไข คำสั่ง.

ข้อมูล: หากต้องการปฏิบัติตามโค้ดตัวอย่างในบทช่วยสอนนี้ ให้เปิดเชลล์เชิงโต้ตอบ Python บนระบบภายในของคุณโดยเรียกใช้ 219 คำสั่ง จากนั้นคุณสามารถคัดลอก วาง หรือแก้ไขตัวอย่างโดยเพิ่มตัวอย่างไว้หลัง 223 พรอมต์.

ลองดูตัวอย่างที่ใช้ 235 คำสั่งใน 243 วนซ้ำ:

number = 0
for number in range(10):
 if number == 5:
 break # break here
 print('Number is ' + str(number))
print('Out of loop')

ตัวแปร 250 เริ่มต้นได้ที่ 0 ในโปรแกรมขนาดเล็กนี้ จากนั้น 265 วนซ้ำถูกสร้างขึ้นเพื่อวนซ้ำตัวเลข 0 ถึง 9 ตามที่กำหนดโดย 270 .

หมายเหตุ :แม้ว่า 289 เริ่มแรกตั้งค่าเป็น 0 ค่านี้จะถูกเขียนทับทันทีด้วย 295 วนซ้ำซึ่งกำหนดค่าใหม่จาก 301 ในการวนซ้ำแต่ละครั้ง

ภายใน 315 วนซ้ำ 322 คำสั่งแสดงเงื่อนไขว่า if ตัวแปร 333 เทียบเท่ากับจำนวนเต็ม 5 จากนั้น ห่วงจะขาด คุณสามารถดูบทช่วยสอนนี้เกี่ยวกับการใช้ for() ลูปใน Python เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับการใช้ 348 วนซ้ำ.

ภายในลูปยังมี 353 คำสั่งที่จะดำเนินการกับการวนซ้ำของ 365 แต่ละครั้ง วนซ้ำจนกว่าลูปจะขาด เนื่องจากอยู่หลัง 374 คำสั่ง.

มาวาง 387 สุดท้ายกัน คำสั่งที่อยู่นอก 397 วนซ้ำเพื่อทราบเมื่อคุณไม่อยู่ในวงวน

เมื่อคุณเรียกใช้โค้ดนี้ คุณจะได้รับผลลัพธ์ต่อไปนี้:

Number is 0
Number is 1
Number is 2
Number is 3
Number is 4
Out of loop

นี่แสดงว่าเมื่อจำนวนเต็ม 401 ได้รับการประเมินว่าเทียบเท่ากับ 5 ลูปจะแตก ดังที่โปรแกรมได้รับคำสั่งให้ทำเช่นนั้นด้วย 415 คำสั่ง.

420 คำสั่งทำให้โปรแกรมแยกออกจากลูป

คำชี้แจงต่อ

438 คำสั่งอนุญาตให้คุณข้ามส่วนของลูปที่มีการทริกเกอร์เงื่อนไขภายนอก แต่เพื่อดำเนินการต่อเพื่อให้ส่วนที่เหลือของลูปสมบูรณ์ การวนซ้ำปัจจุบันของลูปจะหยุดชะงัก แต่โปรแกรมจะกลับสู่ด้านบนสุดของลูป

448 คำสั่งจะอยู่ภายในบล็อคโค้ดภายใต้คำสั่งลูป โดยปกติจะอยู่หลัง 450 แบบมีเงื่อนไข คำสั่ง.

ใช้ 463 เดียวกัน โปรแกรมวนซ้ำเช่นเดียวกับใน 476 ส่วนคำสั่งด้านบน เราจะใช้ 480 คำสั่งแทนที่จะเป็น 498 คำสั่ง:

number = 0
for number in range(10):
 if number == 5:
 continue # continue here
 print('Number is ' + str(number))
print('Out of loop')

ความแตกต่างในการใช้ 500 คำสั่งแทนที่จะเป็น 514 คำสั่งคือโค้ดของเราจะดำเนินต่อไปแม้จะหยุดชะงักเมื่อตัวแปร 523 ได้รับการประเมินว่าเทียบเท่ากับ 5 มาทบทวนผลลัพธ์ของเรากันดีกว่า:

Number is 0
Number is 1
Number is 2
Number is 3
Number is 4
Number is 6
Number is 7
Number is 8
Number is 9
Out of loop

ที่นี่ 539 ไม่เคยเกิดขึ้นในเอาต์พุต แต่การวนซ้ำจะดำเนินต่อไปหลังจากนั้นชี้เพื่อพิมพ์บรรทัดสำหรับหมายเลข 6–9 ก่อนที่จะออกจากการวนซ้ำ

คุณสามารถใช้ 549 คำสั่งเพื่อหลีกเลี่ยงโค้ดที่มีเงื่อนไขที่ซ้อนกันลึกหรือเพิ่มประสิทธิภาพการวนซ้ำโดยกำจัดกรณีที่เกิดขึ้นบ่อยครั้งที่คุณต้องการปฏิเสธ

555 คำสั่งทำให้โปรแกรมข้ามปัจจัยบางอย่างที่เกิดขึ้นภายในลูปแต่แล้วดำเนินการต่อผ่านส่วนที่เหลือของลูป

ใบแจ้งยอดผ่าน

เมื่อมีการทริกเกอร์เงื่อนไขภายนอก 569 คำสั่งช่วยให้คุณตอบสนองข้อกำหนดทางวากยสัมพันธ์ของ Python สำหรับบล็อกโค้ดโดยไม่ต้องดำเนินการใดๆ รหัสทั้งหมดจะยังคงอ่านต่อไป เว้นแต่ 570 หรือมีข้อความอื่นเกิดขึ้น

เช่นเดียวกับข้อความอื่นๆ 582 คำสั่งจะอยู่ภายในบล็อกโค้ดภายใต้คำสั่ง loop ซึ่งโดยทั่วไปจะอยู่หลัง 590 แบบมีเงื่อนไข คำสั่ง.

ใช้บล็อกโค้ดเดียวกันกับด้านบน มาแทนที่ 606 หรือ 618 คำสั่งที่มี 628 คำสั่ง:

number = 0
for number in range(10):
 if number == 5:
 pass # pass here
 print('Number is ' + str(number))
print('Out of loop')

หลัง 637 คำสั่งแบบมีเงื่อนไข 648 คำสั่งบอกให้โปรแกรมรันลูปต่อไปโดยไม่สนใจตัวแปร 653 ประเมินว่าเทียบเท่ากับ 5 ระหว่างการวนซ้ำครั้งหนึ่ง

คุณจะรันโปรแกรมและได้รับผลลัพธ์ต่อไปนี้:

Number is 0
Number is 1
Number is 2
Number is 3
Number is 4
Number is 5
Number is 6
Number is 7
Number is 8
Number is 9
Out of loop

โดยใช้ 664 คำสั่งในโปรแกรมนี้ คุณจะสังเกตเห็นว่าโปรแกรมทำงานเหมือนกับที่ควรจะเป็นหากไม่มีคำสั่งแบบมีเงื่อนไขในโปรแกรม 676 คำสั่งบอกให้โปรแกรมละเว้นเงื่อนไขนั้นและรันโปรแกรมต่อไปตามปกติ

681 คำสั่งสามารถสร้างคลาสขั้นต่ำ หรือทำหน้าที่เป็นตัวยึดตำแหน่งเมื่อทำงานกับโค้ดใหม่และคิดในระดับอัลกอริธึมก่อนที่จะลงรายละเอียด

ผลกระทบต่อประสิทธิภาพ:ข้อยกเว้นเทียบกับแฟล็กและฟังก์ชัน

เมื่อควบคุมการไหลของลูปใน Python คุณอาจพบว่าตัวเองกำลังตัดสินใจระหว่างการใช้ ข้อยกเว้น , ธง หรือ ฟังก์ชันที่มี 694 เพื่อออกจากลูปก่อนเวลา โดยเฉพาะในกรณีของลูปแบบซ้อนหรือเงื่อนไขลอจิกที่ซับซ้อน แต่ละวิธีมีประสิทธิภาพและความสามารถในการอ่านที่แตกต่างกัน ขึ้นอยู่กับวิธีใช้งาน

มาสำรวจแต่ละแนวทางด้วยตัวอย่างและอภิปรายว่าเมื่อใดควรใช้วิธีใดวิธีหนึ่งดีที่สุด

การใช้ข้อยกเว้นเพื่อออกจากลูป

ใน Python ข้อยกเว้นสามารถถูกยกขึ้นโดยเจตนาเพื่อแยกออกจากลูปที่ซ้อนกันลึก แม้ว่าวิธีการนี้จะได้ผล แต่ก็ ไม่ได้มีประสิทธิภาพมากที่สุด สำหรับโฟลว์การควบคุมปกติ

class ExitLoop(Exception):
 pass
try:
 for i in range(5):
 for j in range(5):
 if i == 2 and j == 3:
 raise ExitLoop()
 print(f"i={i}, j={j}")
except ExitLoop:
 print("Exited nested loops using an exception.")
i=0, j=0
i=0, j=1
i=0, j=2
i=0, j=3
i=0, j=4
i=1, j=0
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=0
i=2, j=1
i=2, j=2
Exited nested loops using an exception.

หมายเหตุ: การเพิ่มและการตรวจจับข้อยกเว้นค่อนข้างช้าใน Python เนื่องจากต้องมีการคลายสแต็กและการสร้างวัตถุ ข้อยกเว้นเหมาะอย่างยิ่งสำหรับเงื่อนไขพิเศษอย่างแท้จริง ไม่ใช่สำหรับตรรกะการควบคุมปกติ

การใช้แฟล็กเพื่อออกจากลูปที่ซ้อนกัน

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

found = False
for i in range(5):
 for j in range(5):
 if i == 2 and j == 3:
 found = True
 break
 print(f"i={i}, j={j}")
 if found:
 break
print("Exited nested loops using a flag.")
i=0, j=0
i=0, j=1
i=0, j=2
i=0, j=3
i=0, j=4
i=1, j=0
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=0
i=2, j=1
i=2, j=2
Exited nested loops using a flag.

แฟล็กมีประสิทธิภาพมากกว่าข้อยกเว้นสำหรับการควบคุมลูป และเป็นตัวเลือกที่ดีเมื่อ:

  • คุณต้องแยกออกจากหลายลูป
  • คุณต้องการโค้ดที่ชัดเจนและอ่านง่าย
  • คุณไม่ต้องการแนะนำฟังก์ชันหรือคำจำกัดความของคลาสเพิ่มเติม

การใช้ฟังก์ชันกับ 704 เพื่อออกก่อนเวลา

การล้อมลอจิกลูปของคุณในฟังก์ชันและใช้ 717 to exit เป็นวิธี Pythonic และมีประสิทธิภาพในการหยุดการดำเนินการเมื่อตรงตามเงื่อนไข

def search():
 for i in range(5):
 for j in range(5):
 if i == 2 and j == 3:
 print("Condition met. Exiting function.")
 return
 print(f"i={i}, j={j}")
search()
i=0, j=0
i=0, j=1
i=0, j=2
i=0, j=3
i=0, j=4
i=1, j=0
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=0
i=2, j=1
i=2, j=2
Condition met. Exiting function.

การใช้ฟังก์ชันทำให้ตรรกะเป็นแบบแยกส่วนและหลีกเลี่ยงขอบเขตภายนอกที่เกะกะด้วยแฟล็กหรือคลาสข้อยกเว้น เป็นแนวทางที่ดีเมื่อ:

  • คุณสามารถห่อหุ้มลูปภายในฟังก์ชันได้
  • คุณต้องการทางออกที่สะอาดและมีผลข้างเคียงน้อยลง
  • คุณวางแผนที่จะใช้ตรรกะซ้ำหรือทดสอบอย่างอิสระ

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

วิธีการ ความสามารถในการอ่าน ประสิทธิภาพ คำแนะนำกรณีการใช้งาน ข้อยกเว้น LowSlowAvoid สำหรับการควบคุมลูป; ใช้สำหรับข้อยกเว้นที่แท้จริงตั้งค่าสถานะ MediumFastGood สำหรับลูปที่ซ้อนกัน ง่ายต่อการติดตามฟังก์ชัน HighFastBest สำหรับตรรกะลูปแบบโมดูลาร์และทดสอบได้

สำหรับสถานการณ์ส่วนใหญ่ที่คุณต้องการออกจากลูปแบบซ้อนหรือเงื่อนไขที่ซับซ้อน ฟังก์ชันหรือแฟล็กเป็นวิธีที่แนะนำเนื่องจากความชัดเจนและประสิทธิภาพ หลีกเลี่ยงการใช้ข้อยกเว้น เว้นแต่จะจัดการกับข้อผิดพลาดจริงหรือเงื่อนไขที่ไม่คาดคิด

การใช้ 728 ข้อที่มีลูปสำหรับทางออกที่สะอาดกว่า

Python อนุญาต 738 ประโยคที่จะใช้กับทั้ง 747 และ 751 ลูป แม้ว่าคุณลักษณะนี้อาจดูผิดปกติในตอนแรก แต่ก็สามารถนำไปสู่โค้ดที่สะอาดตาและอ่านง่ายขึ้น โดยเฉพาะอย่างยิ่งเมื่อรวมกับคำสั่งควบคุมโฟลว์ เช่น 764 .

ทำความเข้าใจลูป 773 พฤติกรรม

780 บล็อกที่เกี่ยวข้องกับการวนซ้ำจะถูกดำเนินการก็ต่อเมื่อการวนซ้ำเสร็จสมบูรณ์โดยไม่ต้องพบกับ 796 คำสั่ง สิ่งนี้มีประโยชน์อย่างยิ่งสำหรับการดำเนินการค้นหา โดยที่คุณกำลังวนซ้ำตามลำดับและดำเนินการหากตรงตามเงื่อนไขหรือดำเนินการทางเลือกหากไม่ตรง

คุณลักษณะนี้มักถูกใช้น้อยเกินไป แต่เมื่อนำไปใช้อย่างถูกต้อง จะช่วยหลีกเลี่ยงตัวแปรสถานะที่ไม่จำเป็น (เช่น แฟล็ก) และเก็บตรรกะที่เกี่ยวข้องไว้ในขอบเขตของโครงสร้างลูป

ตัวอย่าง:การค้นหาค่าในรายการ

ลองพิจารณากรณีการใช้งานง่ายๆ:การค้นหารายการในรายการ

items = ["apple", "banana", "cherry", "date"]
for item in items:
 if item == "cherry":
 print("Found cherry!")
 break
else:
 print("Cherry not found.")

วิธีการทำงาน:

  • 807 วนซ้ำในรายการ
  • หาก 811 พบ 826 คำสั่งจะหยุดการวนซ้ำทันที
  • หากการวนซ้ำเสร็จสิ้นโดยไม่พบ 837 840 บล็อกทำงาน

เอาต์พุต:

Found cherry!

หากเราเปลี่ยนข้อความค้นหาเป็นสิ่งที่ไม่อยู่ในรายการ:

for item in items:
 if item == "fig":
 print("Found fig!")
 break
else:
 print("Fig not found.")

เอาต์พุต:

Fig not found.

วิธีการนี้ช่วยลดความจำเป็นในการใช้ตัวแปรแฟล็กภายนอกเพื่อตรวจสอบว่าพบรายการหรือไม่

เหตุใดจึงต้องใช้ 859 ด้วยลูป?

โดยไม่มี 866 โดยทั่วไปคุณจะจัดการตรรกะเดียวกันโดยใช้แฟล็กซึ่งอาจทำให้โฟลว์การควบคุมซับซ้อนโดยไม่จำเป็น:

found = False
for item in items:
 if item == "cherry":
 print("Found cherry!")
 found = True
 break
if not found:
 print("Cherry not found.")

แม้ว่าวิธีนี้จะได้ผล แต่ก็ต้องมีการแนะนำและจัดการตัวแปรเพิ่มเติม (878 ). ใช้ 883 clause ช่วยห่อหุ้มตรรกะทั้งหมดภายในโครงสร้างลูป นำไปสู่โค้ดที่เรียบง่ายและเน้นมากขึ้น โดยเฉพาะอย่างยิ่งในการค้นหาแบบสั้นหรือการวนซ้ำแบบมีเงื่อนไข

กรณีการใช้งานจริง:การสแกนไฟล์เพื่อหาคำหลัก

สมมติว่าคุณกำลังอ่านไฟล์ทีละบรรทัดและต้องการตรวจสอบว่ามีคำหลักเฉพาะหรือไม่ ใช้ 893 โครงสร้างช่วยให้คุณจัดการผลลัพธ์ทั้งสองได้อย่างหมดจด:

with open("example.txt") as f:
 for line in f:
 if "error" in line:
 print("Error found in file.")
 break
 else:
 print("No errors detected.")

ที่นี่:

  • วนซ้ำจะสแกนแต่ละบรรทัด
  • หากคำหลัก 908 พบแล้วจะพิมพ์ข้อความและออกจากลูปก่อนเวลา
  • หากไม่มีบรรทัดดังกล่าว แสดงว่า 910 ส่วนคำสั่งดำเนินการหลังจากการวนซ้ำเสร็จสิ้น

รูปแบบนี้อาจมีประโยชน์อย่างยิ่งในการสแกนไฟล์ การวิเคราะห์บันทึก หรือสถานการณ์การค้นหาตามลำดับใดๆ

การใช้ 923 ด้วย 938 ลูป

942 ข้อทำงานร่วมกับ 958 วนซ้ำในลักษณะเดียวกัน มันจะทำงานก็ต่อเมื่อเงื่อนไขการวนซ้ำกลายเป็นเท็จโดยไม่พบ 962 .

count = 0
while count < 5:
 if count == 3:
 print("Condition met. Exiting early.")
 break
 count += 1
else:
 print("Loop completed without meeting condition.")

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

  • หาก 976 ถึง 3 วงออกผ่าน 981 และ 996 ส่วนคำสั่งถูกข้ามไป
  • หากการวนซ้ำทำงานโดยสมบูรณ์โดยไม่ทริกเกอร์ 1008 , 1017 บล็อกดำเนินการ

สิ่งนี้มีประโยชน์เมื่อคุณต้องการตรวจสอบว่าลูปวนซ้ำจนครบขอบเขตหรือสิ้นสุดก่อนเวลาอันควรเนื่องจากเงื่อนไขเฉพาะหรือไม่

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

สถานการณ์ คือ 1020 ดำเนินการ? วนซ้ำเสร็จสิ้นการวนซ้ำทั้งหมดใช่ออกจากลูปด้วย 1037 NoLoop ออกเนื่องจากมีข้อยกเว้นไม่ใช่ (เว้นแต่จะได้รับการจัดการ) ลูปทำงานเป็นศูนย์ครั้งใช่

1042 ประโยคที่มีการวนซ้ำไม่สามารถแทนที่เงื่อนไขหรือข้อยกเว้นได้ แต่เป็นวิธีที่สะอาดและเป็น Pythonic ในการจัดการ “ไม่พบ” กรณีหรือตรรกะหลังการวนซ้ำโดยไม่มีการจัดการสถานะภายนอก

สถานการณ์ในโลกแห่งความเป็นจริงสำหรับการหยุดวนซ้ำหลายระดับ

ในสถานการณ์การเขียนโปรแกรมในโลกแห่งความเป็นจริง คุณอาจทำงานกับลูปที่ซ้อนกัน โดยเฉพาะอย่างยิ่งเมื่อจัดการข้อมูลที่มีโครงสร้าง ประมวลผลไฟล์ หรือค้นหาผ่านกริด บางครั้ง คุณต้องออกจากลูปหลายระดับพร้อมกันเมื่อตรงตามเงื่อนไขบางประการ เช่น การค้นหาที่ตรงกันหรือเผชิญกับข้อมูลที่ไม่ถูกต้อง

Python ไม่มี 1058 ในตัว เช่นเดียวกับบางภาษา คุณจึงมักจะใช้เทคนิคเช่น ธง ฟังก์ชันที่มี 1060 หรือข้อยกเว้นในการออกจากลูปที่ซ้อนกันอย่างหมดจด

มาดูตัวอย่างเชิงปฏิบัติหลายๆ ตัวอย่างเพื่อทำความเข้าใจว่าเมื่อใดและอย่างไรที่จะใช้การวนซ้ำหลายระดับอย่างมีประสิทธิภาพ

การแยกวิเคราะห์ข้อมูลที่มีโครงสร้าง (เช่น CSV หรือ JSON)

สมมติว่าคุณกำลังแยกวิเคราะห์ข้อมูลแบบตาราง (เช่น รายการแถวจากไฟล์ CSV) และคุณต้องการค้นหาค่าเฉพาะ เมื่อคุณพบแล้ว ไม่จำเป็นต้องสแกนต่อ

ต่อไปนี้เป็นรายการ 2 มิติที่เลียนแบบแถวและคอลัมน์ของชุดข้อมูลแบบง่าย:

data = [
 ["id", "name", "status"],
 ["001", "Alice", "active"],
 ["002", "Bob", "inactive"],
 ["003", "Carol", "active"]
]

สมมติว่าคุณต้องการค้นหาว่า 1072 มีอยู่ในชุดข้อมูล:

target = "Bob"
found = False
for row in data:
 for item in row:
 if item == target:
 print(f"Found target '{target}' in row: {row}")
 found = True
 break # Exit inner loop
 if found:
 break # Exit outer loop
Found target 'Bob' in row: ['002', 'Bob', 'inactive']

เหตุใดจึงได้ผล:

  • วงในจะตรวจสอบแต่ละรายการ
  • เมื่อพบเป้าหมาย จะตั้งค่า 1081 ตั้งค่าสถานะเป็น 1093 และหลุดออกจากวงใน
  • วงรอบนอกจะตรวจสอบธงและแตกหักด้วย

เทคนิคนี้หลีกเลี่ยงการสแกนข้อมูลเกินความจำเป็น ซึ่งช่วยปรับปรุงประสิทธิภาพสำหรับชุดข้อมูลขนาดใหญ่

การค้นหาไฟล์ในไดเรกทอรีที่ซ้อนกัน

เมื่อทำงานกับแอปพลิเคชันในโลกแห่งความเป็นจริง เช่น การวิเคราะห์บันทึก การค้นหาเนื้อหา หรือการตรวจสอบความปลอดภัย คุณอาจต้องค้นหาไฟล์ข้อความหลายร้อยไฟล์ที่กระจายอยู่ในไดเร็กทอรีที่ซ้อนกันหลายแห่ง เป้าหมายมักจะอยู่ที่การค้นหาคำหลักที่เฉพาะเจาะจง เช่น คีย์ API รหัสผ่าน หรือ ID ผู้ใช้ เมื่อพบคีย์เวิร์ดในไฟล์ใดๆ การค้นหาควรยุติทันทีเพื่อประหยัดเวลาและทรัพยากร

Python มีฟังก์ชันในตัวที่เรียกว่า 1106 ที่ช่วยให้คุณสามารถวนซ้ำไฟล์และโฟลเดอร์ทั้งหมดภายในไดเร็กทอรีรากแบบวนซ้ำ ซึ่งหมายความว่ามันจะเข้าไปในไดเร็กทอรีย่อยด้วย

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

import os
def search_file(root_dir, keyword):
 for folder, subfolders, files in os.walk(root_dir):
 for file in files:
 if file.endswith(".txt"):
 with open(os.path.join(folder, file)) as f:
 for line in f:
 if keyword in line:
 print(f"Found '{keyword}' in {file}")
 return # Exit all loops by returning from the function
 print("Keyword not found.")

คุณสามารถเรียกใช้ฟังก์ชันดังนี้:

search_file("./documents", "password123")

เหตุใดจึงต้องใช้ฟังก์ชันที่นี่:

  • 1121 ออกจากฟังก์ชันทันที ซึ่งมีประโยชน์เมื่อเกี่ยวข้องกับลูปที่ซ้อนกัน
  • สะอาดกว่าการใช้แฟล็กกับโค้ดหลายระดับ
  • เหมาะอย่างยิ่งเมื่อตรรกะสามารถทำให้เป็นโมดูลได้

การค้นหาตารางหรือเมทริกซ์ (เช่น ในเกมหรือการค้นหาเส้นทาง)

ลองนึกภาพการทำงานกับตาราง 2 มิติ (รายการรายการ) เช่น แผนที่เกมหรือผังที่นั่ง และจำเป็นต้องค้นหาสิ่งกีดขวางแรกหรือที่นั่งที่ถูกครอบครอง คุณต้องการหยุดการสแกนตารางทันทีที่พบสิ่งกีดขวางแรก แทนที่จะตรวจสอบทุกเซลล์ที่เหลือโดยไม่จำเป็น

มากำหนดตารางโดยที่ 1131 แสดงถึงพื้นที่ว่าง 1143 แสดงถึงอุปสรรค:

grid = [
 [0, 0, 0, 1],
 [0, 1, 0, 0],
 [0, 0, 0, 0],
]

สมมติว่างานของคุณคือค้นหาอุปสรรคแรก (1157 ) แล้วหยุด

found = False
for row_index, row in enumerate(grid):
 for col_index, cell in enumerate(row):
 if cell == 1:
 print(f"Obstacle found at ({row_index}, {col_index})")
 found = True
 break # Exit inner loop
 if found:
 break # Exit outer loop
Obstacle found at (0, 3)

เกิดอะไรขึ้น:

  • แต่ละเซลล์จะถูกตรวจสอบโดยใช้ 1166 ที่ซ้อนกัน วนซ้ำ
  • อันแรก 1172 พบทริกเกอร์การหยุดพักจากทั้งสองลูปโดยใช้ 1182 ธง.

การค้นหาประเภทนี้เป็นเรื่องปกติในการแก้เขาวงกต การสแกนเมทริกซ์ หรือเกมเช่น Minesweeper

การตรวจสอบความถูกต้องของฟิลด์ข้อมูลที่ซ้อนกัน

ในแอปพลิเคชันในโลกแห่งความเป็นจริง โดยเฉพาะอย่างยิ่งในการจัดการแบบฟอร์ม การประมวลผล API หรือระบบการจัดการผู้ใช้ คุณมักจะจัดการกับรายการพจนานุกรม โดยแต่ละพจนานุกรมจะแสดงบันทึกที่มีหลายฟิลด์

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

ลองดูตัวอย่าง. เรามีรายชื่อผู้ใช้ที่ผู้ใช้แต่ละคนต้องมี 1199 และ 1200; เป้าหมายของเราคือการสแกนผู้ใช้ทั้งหมด ตรวจสอบแต่ละฟิลด์ และหยุดการประมวลผลทันทีที่ฟิลด์ใดหายไป โดยรายงานอย่างแน่ชัดว่าฟิลด์ใดหายไปและสำหรับผู้ใช้รายใด

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

users = [
 {"name": "Alice", "email": "alice@example.com"},
 {"name": "Bob", "email": ""},
 {"name": "Carol", "email": "carol@example.com"},
]

ที่นี่ช่องอีเมลของ Bob ว่างเปล่า เราต้องการที่จะจับสิ่งนั้น

invalid = False
for user in users:
 for key, value in user.items():
 if not value:
 print(f"Invalid entry: Missing {key} for user {user['name']}")
 invalid = True
 break
 if invalid:
 break
Invalid entry: Missing email for user Bob

โปรแกรมระบุอย่างถูกต้องว่าอีเมลของ Bob หายไปและหยุดการตรวจสอบเพิ่มเติม แครอลไม่เคยถูกประเมิน เพราะเราออกจากวงเร็ว

เหตุใดรูปแบบนี้จึงมีประโยชน์:

  • คุณป้องกันการตรวจสอบที่ไม่จำเป็นเมื่อตรวจพบข้อผิดพลาด
  • ช่วยบังคับใช้ พฤติกรรมที่ล้มเหลวอย่างรวดเร็ว โดยที่ระบบจะหยุดก่อนเวลาหากมีสิ่งผิดปกติเกิดขึ้น

เมื่อใดที่คุณควรใช้การพักหลายระดับ?

ใช้ตัวแบ่งหลายระดับเมื่อ:

  • การวนซ้ำต่อไปจะเสียเวลาหรือทรัพยากร
  • คุณพบสิ่งที่คุณกำลังมองหาแล้ว
  • การออกก่อนกำหนดทำให้ตรรกะเข้าใจและบำรุงรักษาได้ง่ายขึ้น

เลือกวิธีการของคุณอย่างชาญฉลาด:

วิธีการ ดีที่สุดเมื่อ… ตั้งค่าสถานะ คุณอยู่ในวงแต่ไม่ต้องการออกจากฟังก์ชันฟังก์ชัน ตรรกะของคุณเป็นแบบโมดูลาร์และสามารถกลับมาจากกิจวัตรก่อนเวลาได้ข้อยกเว้น คุณมีตรรกะที่ฝังลึกและเป็นกรณีที่ "พิเศษ" อย่างแท้จริง

คำถามที่พบบ่อย

1. วิธีใช้ 1214 , 1225 และ 1233 ใน Python?

  • 1249 :1258 คำสั่งไม่ทำอะไรเลย มันถูกใช้เป็นตัวยึดตำแหน่งเมื่อจำเป็นต้องมีคำสั่งทางวากยสัมพันธ์แต่ไม่จำเป็นต้องดำเนินการใดๆ ตัวอย่างเช่น:

    for i in range(5):
     if i == 3:
     pass # Placeholder for future code
     print(i)
    
  • 1268 :1278 คำสั่งจะข้ามโค้ดที่เหลือในการวนซ้ำปัจจุบันและย้ายไปยังการวนซ้ำครั้งถัดไป ตัวอย่าง:

    for i in range(5):
     if i == 3:
     continue # Skip the current iteration when i == 3
     print(i)
    
  • 1289 :1296 คำสั่งออกจากลูปทันที โดยไม่คำนึงถึงเงื่อนไขการวนซ้ำ ตัวอย่าง:

    for i in range(5):
     if i == 3:
     break # Exit the loop when i == 3
     print(i)
    

2. คุณจะใช้ 1307 ได้อย่างไร และ 1319 คำสั่งใน 1322 วนซ้ำ?

1337 สามารถใช้คำสั่งภายใน 1347 ได้ วนซ้ำเพื่อยุติการทำงานก่อนกำหนดเมื่อตรงตามเงื่อนไขที่กำหนด ตัวอย่าง:

for i in range(10):
 if i == 5:
 break # Exit the loop when i == 5
 print(i)

1350 คำสั่งข้ามส่วนที่เหลือของการวนซ้ำปัจจุบันและย้ายไปยังการวนซ้ำครั้งถัดไป ตัวอย่าง:

for i in range(10):
 if i % 2 == 0:
 continue # Skip even numbers
 print(i) # Only prints odd numbers

3. คุณสามารถวนซ้ำต่อหลังจาก 1368 ได้หรือไม่ ?

หนึ่งครั้ง 1379 คำสั่งถูกดำเนินการ การวนซ้ำสิ้นสุดลง และโค้ดหลังจากดำเนินการการวนซ้ำ หากคุณต้องการ "ดำเนินการต่อ" ลูปหลังจากแตกหัก คุณจะต้องเริ่มต้นลูปใหม่

ตัวอย่างเช่น:

for i in range(3): # First loop
 if i == 1:
 break # Break out of the loop when i == 1
 print(f"First loop iteration: {i}")
# Restarting the loop
for i in range(3, 6): # Second loop
 print(f"Second loop iteration: {i}")

4. ฉันจะใช้ 1387 ได้อย่างไร คำสั่งใน Python for loops ของฉันคืออะไร?

1392 คำสั่งนั้นตรงไปตรงมาเพื่อใช้ใน for loop เพื่อยุติคำสั่งเมื่อตรงตามเงื่อนไขเฉพาะ:

for i in range(5):
 print(f"Checking value: {i}")
 if i == 2:
 print("Condition met. Breaking out of the loop.")
 break # Exit the loop immediately
print("Loop ended.")

5. จะเขียนโค้ดลูปใน Python ได้อย่างไร

ใน Python สามารถเขียนลูปได้โดยใช้ 1407 หรือ 1413 . ตัวอย่าง:

ใช้ 1423 วนซ้ำ:

for i in range(5):
 print(i) # Prints numbers from 0 to 4

ใช้ 1439 วนซ้ำ:

count = 0
while count < 5:
 print(count) # Prints numbers from 0 to 4
 count += 1

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการใช้ 1447 วนซ้ำและ 1451 วนซ้ำใน Python คุณสามารถอ้างอิงถึงบทช่วยสอนด้านล่าง:

  • การใช้ลูปใน Python
  • การใช้ While loop ใน Python

6. 1469 คืออะไร ทำใน Python 1478 วนซ้ำ?

1480 คำสั่งทำหน้าที่เป็นตัวแทนและไม่ดำเนินการใดๆ มักใช้เมื่อจำเป็นต้องมีบล็อกของโค้ดทางวากยสัมพันธ์แต่ยังไม่ได้นำไปใช้:

for i in range(5):
 if i == 3:
 pass # Placeholder
 print(i)
0
1
2
3
4

7. Python 1492 หรือไม่ ออกจากลูปทั้งหมด ?

ไม่ 1509 คำสั่งจะออกจากลูปในสุดที่มันถูกดำเนินการเท่านั้น หากต้องการออกจากลูปที่ซ้อนกัน คุณสามารถใช้กลไกการควบคุมเพิ่มเติม เช่น แฟล็กหรือฟังก์ชัน ตัวอย่าง:

for i in range(3):
 for j in range(3):
 if i == 1 and j == 1:
 break # Exits the inner loop
 print(f"i={i}, j={j}")
i=0, j=0
i=0, j=1
i=0, j=2
i=1, j=0
i=2, j=0
i=2, j=1
i=2, j=2

หากต้องการออกจากลูปทั้งหมด คุณสามารถใช้แฟล็กหรือล้อมลูปในฟังก์ชันแล้วใช้ 1519 :

# Using a flag
flag = False
for i in range(3):
 for j in range(3):
 if i == 1 and j == 1:
 flag = True
 break
 print(f"i={i}, j={j}")
 if flag:
 break
# Using a function
def nested_loops():
 for i in range(3):
 for j in range(3):
 if i == 1 and j == 1:
 return # Exit all loops
 print(f"i={i}, j={j}")
nested_loops()

8. จะแยกออกจากลูปที่ซ้อนกันหลายอันใน Python ได้อย่างไร

Python ไม่รองรับไวยากรณ์ในตัวเช่น 1526 เพื่อออกจากลูปที่ซ้อนกันหลายอันพร้อมกัน แต่คุณสามารถแยกออกจากลูปที่ซ้อนกันได้โดยใช้วิธีใดวิธีหนึ่งต่อไปนี้:

  1. ใช้ตัวแปรแฟล็ก:

    found = False
    for i in range(3):
     for j in range(3):
     if some_condition(i, j):
     found = True
     break # Break inner loop
     if found:
     break # Break outer loop
    
  2. ล้อมลูปในฟังก์ชันแล้วใช้ 1536 :

    def search():
     for i in range(3):
     for j in range(3):
     if some_condition(i, j):
     print("Condition met.")
     return # Exits both loops
    search()
    

แนวทางแบบอิงฟังก์ชันนี้มักนิยมใช้ในด้านความสามารถในการอ่านและการแยกส่วน

9. มีพารามิเตอร์ระดับการพักใน Python loop หรือไม่

ไม่ Python ไม่มี 1542 การควบคุมลูประดับหรือตามป้ายกำกับเช่นเดียวกับภาษาอื่น ๆ (เช่น Java หรือ PHP) 1553 คำสั่งใน Python จะออกจากเฉพาะลูปในสุดที่ใช้เสมอ

หากต้องการออกจากการซ้อนหลายระดับ คุณต้องใช้:

  • ธง เพื่อส่งสัญญาณวงนอก
  • ฟังก์ชัน ด้วย 1566 .
  • ข้อยกเว้น แม้ว่าควรใช้อย่างระมัดระวังและเมื่อเหมาะสมเท่านั้น

10. จะออกจากวงนอกจากภายในวงในได้อย่างไร

หากต้องการออกจากลูปด้านนอกจากภายในลูปด้านใน คุณสามารถ:

  1. ใช้ตัวแปรแฟล็กที่ได้รับการตั้งค่าภายในลูปด้านในและตรวจสอบในลูปด้านนอก:

    exit_outer = False
    for i in range(5):
     for j in range(5):
     if i == 2 and j == 3:
     exit_outer = True
     break
     if exit_outer:
     break
    
  2. สรุปลูปในฟังก์ชันและใช้ 1571 สำหรับแนวทางที่สะอาดกว่าและเป็น Pythonic มากขึ้น:

    def process():
     for i in range(5):
     for j in range(5):
     if i == 2 and j == 3:
     print("Exiting from nested loop.")
     return
    process()
    

11. การใช้ข้อยกเว้นสำหรับการวนซ้ำถือเป็นการละเมิดแนวปฏิบัติที่ดีหรือไม่

การใช้ข้อยกเว้นเพื่อแยกลูปออกในทางเทคนิคเป็นไปได้ แต่ไม่ถือเป็นแนวทางปฏิบัติที่ดีสำหรับโฟลว์การควบคุมปกติ

class BreakOut(Exception):
 pass
try:
 for i in range(3):
 for j in range(3):
 if i == 1 and j == 1:
 raise BreakOut()
except BreakOut:
 print("Exited nested loops using exception.")

ในขณะที่ใช้งานได้ ข้อยกเว้นมีไว้สำหรับเงื่อนไขที่ไม่คาดคิดหรือข้อยกเว้น ไม่ใช่การควบคุมลูปมาตรฐาน การใช้ข้อยกเว้นด้วยวิธีนี้อาจทำให้โค้ดของคุณอ่าน บำรุงรักษา และแก้ไขข้อบกพร่องได้ยากขึ้น ต้องการแฟล็กหรือการออกตามฟังก์ชัน เว้นแต่ว่าคุณกำลังเผชิญกับกรณีพิเศษอย่างแท้จริง

บทสรุป

คุณได้สำรวจคำสั่งควบคุมลูปหลักใน Python:1585 , 1591 และ 1606 พร้อมอธิบายพฤติกรรมพร้อมตัวอย่างที่ชัดเจนและกรณีการใช้งานจริง นอกจากนี้เรายังสำรวจเทคนิคโฟลว์การควบคุมขั้นสูงเพิ่มเติม เช่น การแยกลูปที่ซ้อนกันโดยใช้แฟล็กและการส่งคืนฟังก์ชัน และหารือเกี่ยวกับการใช้ข้อยกเว้นสำหรับการยุติลูปพร้อมกับข้อเสีย

นอกจากนี้เรายังแนะนำ 1619 clause on loops โดยเน้นว่าจะทำให้รูปแบบการค้นหาบางอย่างง่ายขึ้นโดยไม่จำเป็นต้องติดแฟล็กเพิ่มเติมได้อย่างไร ตัวอย่างในโลกแห่งความเป็นจริง เช่น การแยกวิเคราะห์ข้อมูล การสแกนไฟล์ การค้นหาตาราง และการตรวจสอบอินพุต ถูกนำมาใช้เพื่อแสดงให้เห็นว่าเทคนิคเหล่านี้นำไปใช้ในทางปฏิบัติอย่างไร แนวคิดเหล่านี้ร่วมกันช่วยให้คุณเขียนตรรกะลูปที่มีโครงสร้าง อ่านง่าย และมีประสิทธิภาพมากขึ้นใน Python

หากต้องการสร้างความเข้าใจเพิ่มเติมเกี่ยวกับลูป Python และแนวคิดการเขียนโปรแกรมหลัก โปรดดูบทช่วยสอนที่เป็นประโยชน์เหล่านี้:

  • หลามสำหรับการวนซ้ำ
  • บทช่วยสอน Python ที่ใช้งานได้จริงสำหรับผู้เริ่มต้น
  • 6 วิธีในการต่อรายการใน Python
  • วิธีสร้าง While Loop ใน Python 3
  • วิธีสร้าง Twitterbot ด้วย Python 3 และ Tweepy Library

การควบคุม Python Loop อย่างเชี่ยวชาญ:การใช้ตัวแบ่ง ดำเนินการต่อ และส่งคำสั่งอย่างมีประสิทธิภาพ งานนี้ได้รับอนุญาตภายใต้ Creative Commons Attribution-NonCommercial- ShareAlike 4.0 International License