บทนำ
การใช้ สำหรับลูป และ ขณะวนซ้ำ ใน 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 ซึ่งช่วยให้คุณเลือกแนวทางที่มีประสิทธิภาพสูงสุดสำหรับสถานการณ์ของคุณ
สำหรับสถานการณ์ส่วนใหญ่ที่คุณต้องการออกจากลูปแบบซ้อนหรือเงื่อนไขที่ซับซ้อน ฟังก์ชันหรือแฟล็กเป็นวิธีที่แนะนำเนื่องจากความชัดเจนและประสิทธิภาพ หลีกเลี่ยงการใช้ข้อยกเว้น เว้นแต่จะจัดการกับข้อผิดพลาดจริงหรือเงื่อนไขที่ไม่คาดคิด
การใช้ 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คำสั่งจะหยุดการวนซ้ำทันที - หากการวนซ้ำเสร็จสิ้นโดยไม่พบ
837840รหัส> บล็อกทำงาน
เอาต์พุต: ป>
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?
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 เพื่อออกจากลูปที่ซ้อนกันหลายอันพร้อมกัน แต่คุณสามารถแยกออกจากลูปที่ซ้อนกันได้โดยใช้วิธีใดวิธีหนึ่งต่อไปนี้:
-
ใช้ตัวแปรแฟล็ก: ป>
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 -
ล้อมลูปในฟังก์ชันแล้วใช้
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. จะออกจากวงนอกจากภายในวงในได้อย่างไร
หากต้องการออกจากลูปด้านนอกจากภายในลูปด้านใน คุณสามารถ:
-
ใช้ตัวแปรแฟล็กที่ได้รับการตั้งค่าภายในลูปด้านในและตรวจสอบในลูปด้านนอก:
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 -
สรุปลูปในฟังก์ชันและใช้
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
งานนี้ได้รับอนุญาตภายใต้ Creative Commons Attribution-NonCommercial- ShareAlike 4.0 International License