ลูปเป็นหนึ่งในเครื่องมือหลักของทุกภาษา มีสองลูปพื้นฐานใน Python ซึ่งหนึ่งในนั้นคือ while พิจารณาและเพื่อความเข้าใจที่ดีขึ้นของภาพอีกครั้งหนึ่ง ที่จริงแล้ว เมื่อเทียบกับสิ่งที่คล้ายกัน จะเข้าใจเนื้อหาใด ๆ ได้ง่ายกว่ามากใช่ไหม
แนวคิดของวัฏจักร
จำเป็นต้องมีการวนซ้ำเมื่อต้องดำเนินการบางอย่างหลายครั้ง นี่เป็นเรื่องง่ายมากเพราะในความเป็นจริงช่วงของแอปพลิเคชันสำหรับรอบนั้นกว้างกว่ามาก มีสองประเภทหลักของลูปใน Python: for และ while ที่นิยมมากที่สุดคือสำหรับ
นอกจากการดำเนินการเฉพาะแล้ว คุณยังสามารถวนซ้ำโค้ดต่างๆ จนถึงจุดใดจุดหนึ่งได้ นี้สามารถเป็นจำนวนครั้ง หรือตราบเท่าที่เงื่อนไขเฉพาะเป็นจริง
ก่อนที่เราจะเริ่มเข้าใจประเภทของลูปและโดยเฉพาะอย่างยิ่งเรายังต้องเข้าใจว่าการวนซ้ำคืออะไร นี่เป็นการทำซ้ำของการกระทำหรือลำดับของการกระทำระหว่างรอบปัจจุบันภายในแอปพลิเคชันปัจจุบันที่รัน
วงจรสำหรับ
For loop ของเราไม่ใช่ตัวนับ เช่นเดียวกับในภาษาอื่นๆ หน้าที่ของมันคือการระบุลำดับของค่าบางอย่าง สิ่งนี้หมายความว่า? สมมติว่าเรามีรายการองค์ประกอบ ขั้นแรก การวนซ้ำจะใช้เวลาที่หนึ่ง สอง สาม และอื่นๆ
ข้อดีของลูปนี้ใน Python คือคุณไม่จำเป็นต้องกำหนดดัชนีขององค์ประกอบเพื่อรู้ว่าเมื่อใดควรออกจากลูป ทุกอย่างจะทำโดยอัตโนมัติ
>>> สปิสก = [10, 40, 20, 30]
>>> สำหรับองค์ประกอบใน spisok:
… พิมพ์ (องค์ประกอบ + 2)
...
12
42
22
32
ในตัวอย่างของเรา เราใช้ตัวแปร ธาตุ หลังจากคำสั่ง for โดยทั่วไปแล้วชื่อสามารถเป็นอะไรก็ได้ ตัวอย่างเช่น การกำหนดที่นิยมคือ i และการวนซ้ำแต่ละครั้ง ตัวแปรนี้จะได้รับการกำหนดวัตถุเฉพาะจากรายการ ซึ่งเราเรียกว่าคำที่เหมาะสม
ในกรณีของเรา รายการเป็นลำดับของตัวเลข 10,40,20,30 ในการวนซ้ำแต่ละครั้ง ค่าที่สอดคล้องกันจะปรากฏในตัวแปร ตัวอย่างเช่น ทันทีที่ลูปเริ่มต้น ตัวแปร ธาตุ ค่า 10 ถูกกำหนด ในการวนซ้ำครั้งต่อไป สิบเปลี่ยนเป็นหมายเลข 40 ครั้งที่สามกลายเป็นหมายเลข 20 และในที่สุด ในการวนซ้ำครั้งสุดท้ายของลูป มันกลายเป็น 30
สัญญาณสำหรับการสิ้นสุดของรอบคือจุดสิ้นสุดขององค์ประกอบในรายการ
หากคุณต้องการวนซ้ำเพื่อทำการแจงนับค่าแบบคลาสสิก เช่นเดียวกับในภาษาโปรแกรมอื่นๆ คุณควรสร้างรายการที่มีลำดับของตัวเลขธรรมชาติจนถึงค่าที่เราต้องการ
>>> สปิสก = [1,2,3,4,5]
หรือใช้ฟังก์ชัน เลน (), เพื่อกำหนดความยาวของรายการ แต่ในกรณีนี้ ควรใช้ลูป ในขณะที่, เพราะไม่จำเป็นต้องใช้ตัวแปร
หากคุณต้องการเปลี่ยนลำดับของค่าในรายการ ให้วนลูป for และมาที่นี่เพื่อช่วยชีวิต ในการทำซ้ำแต่ละครั้ง แต่ละองค์ประกอบของรายการต้องได้รับการกำหนดค่าที่เหมาะสม
ในขณะที่วนซ้ำ
ต่างจากวัฏจักร for ซึ่งเพียงแค่วนซ้ำค่าของลำดับ, ลูป ในขณะที่ มีประโยชน์มากขึ้น ชื่อของวงจรประเภทนี้แปลว่า “ยัง” นั่นก็คือ “จน”
นี่คือวนรอบสากลที่พบในภาษาการเขียนโปรแกรมทั้งหมด และในบางแง่ก็คล้ายกับตัวดำเนินการตามเงื่อนไข ต้นยู ซึ่งทำการตรวจสอบเพื่อดูว่าตรงตามเงื่อนไขหรือไม่ ตรงกันข้ามกับตัวดำเนินการตามเงื่อนไขเท่านั้น ในขณะที่ ดำเนินการตรวจสอบในการวนซ้ำแต่ละครั้ง ไม่ใช่แค่ครั้งเดียว และเฉพาะในกรณีที่เงื่อนไขเป็นเท็จ การวนรอบจะสิ้นสุดลงและคำสั่งที่ตามมาจะถูกดำเนินการ พูดง่ายๆ ก็คือ หากสถานการณ์ที่เขาทำงานอยู่นั้นใช้ไม่ได้อีกต่อไป
ถ้าเราวาดวงจร ในขณะที่ ง่าย ๆ ทำได้โดยใช้รูปแบบดังกล่าว
สาขาหลักของโปรแกรม (ซึ่งทำงานนอกลูป) แสดงในรูปนี้ด้วยสี่เหลี่ยมสีน้ำเงิน เทอร์ควอยซ์เป็นตัวแทนของวัฏจักร ในทางกลับกัน รูปสี่เหลี่ยมขนมเปียกปูนเป็นเงื่อนไขที่มีการตรวจสอบในการวนซ้ำแต่ละครั้ง
วงจร ในขณะที่ อาจส่งผลให้มีข้อยกเว้นสองประการ:
- หากที่จุดเริ่มต้นของลูป นิพจน์เชิงตรรกะไม่คืนค่า จริง แสดงว่าไม่เริ่มต้นโดยสมบูรณ์ก่อนดำเนินการ โดยทั่วไป สถานการณ์นี้เป็นเรื่องปกติ เนื่องจากภายใต้สถานการณ์บางอย่าง แอปพลิเคชันอาจไม่จัดให้มีนิพจน์ในส่วนเนื้อหาของลูป
- หากนิพจน์เป็นจริงเสมอ อาจนำไปสู่การวนซ้ำ นั่นคือการเลื่อนรอบไม่รู้จบ ดังนั้นในโปรแกรมดังกล่าว ควรมีคำสั่งออกจากลูปหรือโปรแกรมเสมอ อย่างไรก็ตาม สถานการณ์นี้จะเกิดขึ้นหากโปรแกรมสามารถระบุความจริงหรือความเท็จของเงื่อนไขเฉพาะได้ หากเธอล้มเหลวในการทำเช่นนี้ ข้อผิดพลาดจะถูกส่งกลับพร้อมกับการยกเลิกโปรแกรม หรือคุณสามารถจัดการกับข้อผิดพลาด และจากนั้น ถ้ามันเกิดขึ้น รหัสบางอย่างจะถูกดำเนินการ
อาจมีตัวเลือกมากมายสำหรับวิธีจัดการกับข้อผิดพลาด เช่น โปรแกรมอาจขอให้ผู้ใช้ป้อนข้อมูลให้ถูกต้อง ดังนั้น หากบุคคลระบุจำนวนลบที่สามารถเป็นบวกได้เท่านั้น หรือป้อนตัวอักษรที่ควรเป็นตัวเลขเท่านั้น โปรแกรมสามารถบอกได้
ในขณะที่ตัวอย่างลูป
นี่คือตัวอย่างโค้ดที่จัดการข้อผิดพลาดในกรณีนี้
n = อินพุต ("ป้อนจำนวนเต็ม: ")
ในขณะที่พิมพ์ (n) != int:
ลอง:
n = int (n)
ยกเว้น ValueError:
พิมพ์("รายการผิด!")
n = อินพุต ("ป้อนจำนวนเต็ม: ")
ถ้า n % 2 == 0:
พิมพ์("คู่")
อื่น:
พิมพ์("แปลก")
โปรดทราบว่า Python ใช้โคลอนเพื่อประกาศการสร้างโค้ดที่ซับซ้อน
ในโค้ดด้านบน เรากำหนดเป็นเงื่อนไขที่เราควรตรวจสอบว่าตัวเลขเป็นจำนวนเต็มหรือไม่ ถ้าใช่ จะคืนค่าเท็จ ถ้าไม่ใช่ก็จริง
ในส่วนที่สองของรหัสที่ใช้ตัวดำเนินการ ifเราใช้ตัวดำเนินการ % เพื่อค้นหาส่วนที่เหลือหลังจากการหาร ขั้นตอนต่อไปคือการตรวจสอบว่าตัวเลขเป็นคู่หรือไม่ ถ้าไม่เช่นนั้นส่วนที่เหลือจะเป็นหนึ่งเดียวในกรณีนี้ ดังนั้นตัวเลขจึงเป็นเลขคี่
พูดง่ายๆ ก็คือ รหัสด้านบนจะตรวจสอบว่าสตริงที่ผู้ใช้ป้อนเป็นตัวเลขก่อนหรือไม่ ถ้าใช่ ให้ทำการตรวจสอบครั้งที่สองเพื่อดูว่ามีการแบ่งส่วนเหลือเป็นสองเท่าหรือไม่ แต่บล็อกที่สองจะไม่ถูกดำเนินการจนกว่าค่าที่ป้อนโดยผู้ใช้จะเป็นตัวเลข
นั่นคือการวนซ้ำจะดำเนินการอย่างสม่ำเสมอจนกว่าเงื่อนไขจะเกิดขึ้น ในสถานการณ์แบบนี้ มันทำงานแบบนี้
นั่นคือคุณสามารถไปจากสิ่งที่ตรงกันข้าม: วนซ้ำการกระทำบางอย่างจนกว่าเหตุการณ์จะกลายเป็นเท็จ
การแยกวิเคราะห์รหัส
ตอนนี้เรามาดูรายละเอียดเพิ่มเติมว่าโค้ดนี้ทำงานอย่างไร ในการทำเช่นนี้เราจะวิเคราะห์ทีละขั้นตอน
- ขั้นแรก ผู้ใช้ป้อนสตริงที่ตัวแปร n ยอมรับ
- การใช้ลูป ในขณะที่ มีการตรวจสอบชนิดของตัวแปรนี้ รายการแรกไม่เท่ากัน int. ดังนั้นจากการทดสอบจึงพบว่าเงื่อนไขนี้เป็นจริง ดังนั้นจึงป้อนเนื้อความของลูป
- ด้วยความช่วยเหลือของโอเปอเรเตอร์ ลอง เรากำลังพยายามแปลงสตริงเป็นตัวเลข หากทำเสร็จแล้วจะไม่มีข้อผิดพลาดเกิดขึ้น ดังนั้นจึงไม่จำเป็นต้องดำเนินการใดๆ ดังนั้นล่ามจะกลับไปที่จุดเริ่มต้นของลูปและจากผลการตรวจสอบปรากฎว่ากลายเป็นจำนวนเต็ม ไปที่ขั้นตอนที่7
- หากการแปลงไม่สำเร็จ จะเกิด ValueError ในกรณีนี้ โฟลว์ของโปรแกรมจะถูกส่งไปยังตัวจัดการยกเว้น
- ผู้ใช้ป้อนค่าใหม่ซึ่งกำหนดให้กับตัวแปร n
- ล่ามกลับไปที่ขั้นตอนที่ 2 และตรวจสอบอีกครั้ง หากเป็นค่าจำนวนเต็ม ให้ไปที่ขั้นตอนที่ 7 หากไม่เป็นเช่นนั้น ระบบจะพยายามแปลงอีกครั้งตามขั้นตอนที่ 3
- ด้วยความช่วยเหลือของโอเปอเรเตอร์ if กำหนดว่าเหลือเศษหลังจากหารจำนวนด้วย 2 หรือไม่
- หากไม่เป็นเช่นนั้น ข้อความ "คู่" จะถูกส่งกลับ
- หากไม่เป็นเช่นนั้น ข้อความ "คี่" จะถูกส่งกลับ
ลองพิจารณาตัวอย่างดังกล่าว ลองพิจารณาดูว่ารอบนี้จะผ่านไปกี่ครั้ง?
รวม = 100
i = 0
ในขณะที่ฉัน < 5:
n = int(อินพุต())
รวม = รวม — n
ผม = ผม + 1
พิมพ์("คงเหลือ", ทั้งหมด)
คำตอบที่ถูกต้องคือ 5. เริ่มแรก ค่าของตัวแปร i – ศูนย์ ล่ามตรวจสอบว่าตัวแปรมีค่าเท่ากันหรือไม่ i 4 หรือน้อยกว่า ถ้าใช่ ค่าจะถูกส่งคืน จริงและวนซ้ำจะดำเนินการตามนั้น มูลค่าเพิ่มขึ้นหนึ่ง
หลังจากการวนซ้ำครั้งแรก ค่าของตัวแปรจะกลายเป็น 1 การตรวจสอบจะดำเนินการ และโปรแกรมเข้าใจดีว่าตัวเลขนี้น้อยกว่า 5 อีกครั้ง ดังนั้น เนื้อหาลูปจึงถูกดำเนินการเป็นครั้งที่สอง เนื่องจากขั้นตอนมีความคล้ายคลึงกัน ค่าจึงเพิ่มขึ้นหนึ่งด้วย และตอนนี้ตัวแปรก็เท่ากับ 2
ค่านี้ยังน้อยกว่าห้า จากนั้นวนซ้ำเป็นครั้งที่สาม เพิ่มเข้าไปในตัวแปร i 1 และได้รับการกำหนดค่า 3 ซึ่งน้อยกว่าห้าอีกครั้ง ดังนั้นจึงมาถึงการวนซ้ำครั้งที่หกของลูปซึ่งค่าของตัวแปร i เท่ากับ 5 (แต่เดิมเป็นศูนย์เท่าที่เราจำได้) ดังนั้น เงื่อนไขนี้ไม่ผ่านการทดสอบ และการวนซ้ำจะถูกยกเลิกโดยอัตโนมัติและดำเนินการเปลี่ยนไปยังขั้นตอนถัดไป ซึ่งอยู่นอกเงื่อนไขนั้น (หรือการยกเลิกโปรแกรม หากไม่มีขั้นตอนต่อไปนี้) จะดำเนินการ
วัฏจักรยังสามารถเกิดขึ้นได้ในทิศทางตรงกันข้าม ต่อไปนี้คือตัวอย่างโค้ด โดยในการวนซ้ำแต่ละครั้ง โค้ดหนึ่งจะถูกหักออกจากค่าปัจจุบันของตัวแปร
รวม = 100
ในขณะที่ทั้งหมด > 0:
n = int(อินพุต())
รวม = รวม — n
พิมพ์ (“ทรัพยากรหมด”)
พยายามเดาว่าโปรแกรมนี้ทำอะไรได้บ้าง! ลองนึกภาพว่าในตัวแปร ทั้งหมด ข้อมูลเกี่ยวกับทรัพยากรของโปรแกรมถูกเก็บไว้ ทุกครั้งที่ล่ามตรวจสอบว่ามีทรัพยากรอยู่หรือไม่ หากไม่เป็นเช่นนั้น ข้อความ "ทรัพยากรหมด" จะปรากฏขึ้นและโปรแกรมจะปิดลง และในการวนซ้ำแต่ละครั้ง ทรัพยากรจะลดลงตามจำนวนที่ผู้ใช้ระบุ
และตอนนี้ทำการบ้าน ลองเปลี่ยนโค้ดด้านบนเพื่อไม่ให้ตัวแปรกลายเป็นค่าลบทางกายภาพ
ซีโค้ด อาฮาน อูซู กุดบี
ใช่
สวัสดี
ฮ่า ๆ