เนื้อหา
ในกระบวนการเรียนรู้การเขียนโปรแกรม มักจะจำเป็นต้องสร้างโปรแกรมที่นำไปใช้ในชีวิตจริงได้ไม่ง่ายนัก ท้ายที่สุดคุณต้องทำตามคำแนะนำภายใต้เงื่อนไขบางประการเท่านั้น เพื่อให้สามารถใช้งานได้ในโปรแกรม ทุกภาษามีคำสั่งควบคุม ด้วยความช่วยเหลือของพวกเขา คุณสามารถควบคุมโฟลว์ของการรันโค้ด สร้างลูป หรือดำเนินการบางอย่างได้ก็ต่อเมื่อเงื่อนไขบางอย่างเป็นจริงเท่านั้น
วันนี้เราจะมาพูดถึง if statement ซึ่งตรวจสอบสถานการณ์ปัจจุบันสำหรับเงื่อนไขบางอย่าง และจากข้อมูลนี้ จะทำการตัดสินใจเกี่ยวกับการดำเนินการเพิ่มเติม
ประเภทของคำสั่งควบคุม
โดยทั่วไป ถ้าไม่ใช่คำสั่งเดียวที่ควบคุมโฟลว์ของโปรแกรม ตัวเขาเองก็สามารถเป็นส่วนประกอบของสายโซ่ที่ใหญ่ขึ้นของผู้ปฏิบัติงานได้
นอกจากนี้ยังมีลูปและคำสั่งที่ควบคุมกระบวนการดำเนินการ วันนี้เราจะพูดถึงเฉพาะตัวดำเนินการแบบมีเงื่อนไขและเชนที่สามารถเข้าร่วมได้
ในการเขียนโปรแกรมมีสิ่งเช่นการแตกแขนง นี่คือสิ่งที่หมายถึงลำดับของคำสั่งที่ดำเนินการก็ต่อเมื่อเงื่อนไขบางอย่างเป็นจริงเท่านั้น เกณฑ์อาจแตกต่างกัน:
- ความเท่าเทียมกันของตัวแปรกับค่าที่แน่นอน
- การดำเนินการเฉพาะ
- สถานะการสมัคร (ยุบหรือไม่)
สเปกตรัมอาจมีขนาดใหญ่กว่ามาก คำสั่งแบบมีเงื่อนไขมีหลายประเภท:
- ด้วยสาขาเดียว นั่นคือทำการตรวจสอบเพียงครั้งเดียวซึ่งเป็นผลมาจากการดำเนินการบางอย่าง
- ที่มีสองสาขาขึ้นไป หากเกณฑ์ที่ 1 เป็นจริง ให้ตรวจสอบเกณฑ์ที่ 2 หากเป็นจริง ให้ตรวจสอบ 3 และดำเนินการตรวจสอบให้มากเท่าที่ต้องการ
- โดยมีเงื่อนไขหลายประการ ทุกอย่างง่ายที่นี่ ล่ามจะตรวจสอบหลายเงื่อนไขหรือเงื่อนไขใดเงื่อนไขหนึ่ง
ถ้าคำสั่ง
โครงสร้างของคำสั่ง if มีความคล้ายคลึงกันในทุกภาษา อย่างไรก็ตาม ใน Python ไวยากรณ์ของมันค่อนข้างแตกต่างจากที่อื่นทั้งหมด:
ถ้าเงื่อนไข:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
ขั้นแรกให้ประกาศตัวดำเนินการเองหลังจากนั้นจะมีการเขียนเงื่อนไขที่เริ่มทำงาน เงื่อนไขอาจเป็นจริงหรือเท็จก็ได้
ตามด้วยบล็อกที่มีคำสั่ง หากเป็นไปตามเกณฑ์ทันที ลำดับของคำสั่งที่เกี่ยวข้องจะเรียกว่า if block คุณสามารถใช้คำสั่งจำนวนเท่าใดก็ได้ในนั้น
โปรดทราบ! การเยื้องภายใน all if block command ต้องมีขนาดเท่ากัน ขอบเขตของบล็อกถูกกำหนดโดยการเยื้อง
ตามเอกสารภาษา การเยื้องคือ 4 ช่องว่าง
ตัวดำเนินการนี้ทำงานอย่างไร เมื่อล่ามเห็นคำว่า if ล่ามจะตรวจสอบนิพจน์ตามเกณฑ์ที่ผู้ใช้ระบุทันที หากเป็นกรณีนี้ เขาก็เริ่มมองหาคำแนะนำและปฏิบัติตามคำแนะนำเหล่านั้น มิฉะนั้น คำสั่งทั้งหมดจากบล็อกนี้จะถูกข้ามไป
หากคำสั่งหลังจากเงื่อนไขไม่ได้เยื้อง จะไม่ถือว่าเป็นการบล็อก if ในสถานการณ์ของเรา บรรทัดนี้คือ
นี่คือข้อมูลโค้ดสำหรับตัวอย่างวิธีการทำงานของโอเปอเรเตอร์นี้
จำนวน = int(อินพุต("ป้อนตัวเลข: "))
ถ้าตัวเลข > 10:
พิมพ์("ตัวเลขมากกว่า 10")
โปรแกรมนี้พร้อมท์ให้ผู้ใช้ป้อนตัวเลขและตรวจสอบว่ามีค่ามากกว่า 10 หรือไม่ ถ้าใช่ โปรแกรมจะส่งคืนข้อมูลที่เหมาะสม ตัวอย่างเช่น ถ้าผู้ใช้ป้อนหมายเลข 5 โปรแกรมก็จะจบลงแค่นั้น
แต่ถ้าคุณระบุหมายเลข 100 ล่ามจะเข้าใจว่ามากกว่าสิบและรายงาน
โปรดทราบ! ในกรณีของเรา หากเงื่อนไขเป็นเท็จ โปรแกรมจะหยุดทำงาน เนื่องจากไม่มีคำสั่งให้หลังจากคำสั่ง
มีเพียงหนึ่งคำสั่งในรหัสข้างต้น แต่มีอีกมาก ข้อกำหนดเพียงอย่างเดียวคือการเยื้อง
ทีนี้มาวิเคราะห์ลำดับของคำสั่งกัน
number = int(input(“เขียนตัวเลข: “))
ถ้าตัวเลข > 10:
พิมพ์("บรรทัดแรก")
พิมพ์("บรรทัดที่สอง")
พิมพ์ (“บรรทัดที่สาม”)
พิมพ์("บรรทัดที่ดำเนินการโดยไม่คำนึงถึงจำนวนที่ป้อน")
พิมพ์ (“สิ้นสุดการสมัคร”)
ลองเดาว่าผลลัพธ์จะเป็นอย่างไรหากคุณป้อนค่า 2, 5, 10, 15, 50
อย่างที่คุณเห็น หากตัวเลขที่ป้อนโดยผู้ใช้มากกว่าสิบ จะมีสามบรรทัดที่ส่งออก + หนึ่งบรรทัดที่มีข้อความ "เรียกใช้ทุกครั้ง …” และหนึ่ง "สิ้นสุด" และหากน้อยกว่าสิบ ให้มีเพียงบรรทัดเดียวด้วย ข้อความอื่น เฉพาะบรรทัดที่ 3,4,5 เท่านั้นที่จะถูกดำเนินการหากเป็นจริง อย่างไรก็ตาม สองบรรทัดสุดท้ายจะถูกเขียนไม่ว่าผู้ใช้จะระบุหมายเลขใด
หากคุณใช้คำสั่งโดยตรงในคอนโซล ผลลัพธ์จะแตกต่างออกไป ล่ามจะเปิดโหมดหลายบรรทัดทันที หากหลังจากระบุเกณฑ์การตรวจสอบแล้ว ให้กด Enter
สมมติว่าเราได้เขียนลำดับของคำสั่งต่อไปนี้
>>>
>>> n = 100
>>> ถ้า n > 10:
...
หลังจากนั้นเราจะเห็นว่า >>> ถูกแทนที่ด้วยจุดไข่ปลา ซึ่งหมายความว่าเปิดใช้งานโหมดอินพุตแบบหลายบรรทัด พูดง่ายๆ ก็คือ หากคุณกด Enter คุณจะถูกโอนไปยังอินพุตของขั้นตอนที่สองของคำสั่ง
และเพื่อออกจากบล็อกนี้ คุณต้องเพิ่มโครงสร้างอีกหนึ่งรายการในบล็อก if.
>>>
>>> n = 100
>>> ถ้า n > 10:
… พิมพ์(«nv 10»)
...
หากเงื่อนไขไม่เป็นจริง โปรแกรมจะสิ้นสุด นี่เป็นปัญหาเนื่องจากผู้ใช้อาจรับรู้ว่าโปรแกรมดังกล่าวปิดเนื่องจากความล้มเหลว ดังนั้นจึงจำเป็นต้องให้ข้อเสนอแนะแก่ผู้ใช้ สำหรับสิ่งนี้จะใช้ลิงค์ ถ้าอื่น.
โอเปอเรเตอร์นิพจน์ ถ้าอื่น
โอเปอเรเตอร์นี้อนุญาตให้คุณใช้ลิงก์ได้: หากนิพจน์ตรงกับกฎเกณฑ์ใดกฎหนึ่ง ให้ดำเนินการเหล่านี้ และหากไม่ใช่ ให้ทำอย่างอื่นด้วย นั่นคือช่วยให้คุณแบ่งการไหลของโปรแกรมออกเป็นสองสาย ไวยากรณ์ใช้งานง่าย:
ถ้าเงื่อนไข:
#ถ้าบล็อค
คำสั่ง 1
คำสั่ง 2
เป็นต้น
อื่น:
#บล็อกอื่นๆ
คำสั่ง 3
คำสั่ง 4
และอื่น ๆ :
มาอธิบายว่าตัวดำเนินการนี้ทำงานอย่างไร ขั้นแรก คำสั่งมาตรฐานจะถูกดำเนินการในเธรด ต้นยู ตรวจสอบว่าตรงกันหรือไม่ สภาพ “จริง” หรือ “เท็จ” การดำเนินการเพิ่มเติมขึ้นอยู่กับผลการตรวจสอบ ถ้าเป็นจริง คำสั่งที่อยู่ในลำดับของคำสั่งตามเงื่อนไขจะถูกดำเนินการโดยตรง ต้นยู ถ้าเป็นเท็จก็ อื่น.
วิธีนี้คุณสามารถจัดการกับข้อผิดพลาดได้ ตัวอย่างเช่น ผู้ใช้ต้องป้อนรัศมี แน่นอน มันต้องเป็นตัวเลขที่มีเครื่องหมายบวกเท่านั้น หรือเป็นค่าว่างก็ได้ หากน้อยกว่า 0 คุณต้องออกข้อความขอให้คุณป้อนจำนวนบวก
นี่คือรหัสที่ใช้งานงานนี้ แต่มีข้อผิดพลาดอย่างหนึ่งที่นี่ ลองเดาดูว่าอันไหน
รัศมี = int(อินพุต("ป้อนรัศมี:"))
ถ้ารัศมี >= 0:
พิมพ์("เส้นรอบวง = ", 2 * 3.14 * รัศมี)
พิมพ์("พื้นที่ = ", 3.14 * รัศมี ** 2)
อื่น:
พิมพ์(“กรุณาใส่จำนวนบวก”)
ข้อผิดพลาดการเยื้องไม่ตรงกัน ถ้าและอย่างอื่น ต้องอยู่โดยไม่มีพวกเขาหรือมีจำนวนเท่ากัน (ขึ้นอยู่กับว่าพวกเขาซ้อนกันหรือไม่)
ลองใช้อีกกรณีหนึ่ง (ซึ่งทุกอย่างจะถูกต้องด้วยการจัดตำแหน่งผู้ปฏิบัติงาน) – องค์ประกอบแอปพลิเคชันที่ตรวจสอบรหัสผ่าน
รหัสผ่าน = อินพุต (“ ป้อนรหัสผ่าน: “)
ถ้ารหัสผ่าน == «sshh»:
พิมพ์("ยินดีต้อนรับ")
อื่น:
พิมพ์ (“การเข้าถึงถูกปฏิเสธ”)
คำแนะนำนี้จะข้ามบุคคลต่อไปหากรหัสผ่านคือ sshh หากมีตัวอักษรและตัวเลขผสมกัน ระบบจะแสดงข้อความว่า "ปฏิเสธการเข้าถึง"
คำสั่ง-นิพจน์ if-elif-else
เฉพาะในกรณีที่หลายเงื่อนไขไม่เป็นความจริง คำสั่งที่อยู่ในบล็อกจะถูกดำเนินการ อื่น. นิพจน์นี้ทำงานเช่นนี้
ถ้าเงื่อนไข_1:
#ถ้าบล็อค
คำสั่ง
คำสั่ง
คำชี้แจงเพิ่มเติม
เอลฟ์เงื่อนไข_2:
#บล็อกเอลฟ์ตัวแรก
คำสั่ง
คำสั่ง
คำชี้แจงเพิ่มเติม
เอลฟ์เงื่อนไข_3:
# บล็อก elif ที่สอง
คำสั่ง
คำสั่ง
คำชี้แจงเพิ่มเติม
...
อื่น
คำสั่ง
คำสั่ง
คำชี้แจงเพิ่มเติม
คุณสามารถระบุเงื่อนไขเพิ่มเติมจำนวนเท่าใดก็ได้.
ข้อความที่ซ้อนกัน
อีกวิธีหนึ่งในการใช้หลายเงื่อนไขคือการแทรกการตรวจสอบเงื่อนไขเพิ่มเติมในบล็อก if
ผู้ประกอบการ if ภายในบล็อกเงื่อนไขอื่น
gre_score = int(input("ป้อนวงเงินเครดิตปัจจุบันของคุณ"))
per_grad = int(input(“ป้อนอันดับเครดิตของคุณ: “))
ถ้า per_grad > 70:
# นอกถ้าบล็อก
ถ้า gre_score > 150:
#ภายในถ้าบล็อก
พิมพ์("ยินดีด้วย คุณได้รับเงินกู้")
อื่น:
พิมพ์("ขออภัย คุณไม่มีสิทธิ์ได้รับเงินกู้")
โปรแกรมนี้ทำการตรวจสอบอันดับเครดิต หากน้อยกว่า 70 โปรแกรมรายงานว่าผู้ใช้ไม่มีสิทธิ์ได้รับเครดิต หากมากกว่า จะมีการตรวจสอบครั้งที่สองเพื่อดูว่าวงเงินสินเชื่อปัจจุบันมากกว่า 150 หรือไม่ หากใช่ ระบบจะแสดงข้อความว่ามีการออกเงินกู้แล้ว
หากค่าทั้งสองเป็นเท็จ จะมีข้อความแสดงขึ้นว่าผู้ใช้ไม่มีโอกาสได้รับเงินกู้
ทีนี้มาทำโปรแกรมนั้นใหม่สักหน่อย
gre_score = int(อินพุต("ป้อนขีดจำกัดปัจจุบัน:"))
per_grad = int(input(“ป้อนคะแนนเครดิต: “))
ถ้า per_grad > 70:
ถ้า gre_score > 150:
พิมพ์("ยินดีด้วย คุณได้รับเงินกู้")
อื่น:
พิมพ์ (“วงเงินเครดิตของคุณเหลือน้อย”)
อื่น:
พิมพ์ (“ขออภัย คุณไม่มีสิทธิ์ได้รับเครดิต”)
โค้ดนั้นคล้ายกันมาก แต่ซ้อนกัน if ยังจัดเตรียมอัลกอริธึมในกรณีที่เงื่อนไขนั้นกลายเป็นเท็จ นั่นคือ วงเงินในบัตรไม่เพียงพอ แต่ประวัติเครดิตดี ข้อความ "คุณมีอันดับเครดิตต่ำ" จะปรากฏขึ้น
คำสั่ง if-else ภายในเงื่อนไข อื่น
มาสร้างโปรแกรมอื่นที่กำหนดเกรดของนักเรียนตามคะแนนสอบกันเถอะ
คะแนน = int(อินพุต("ป้อนคะแนนของคุณ: "))
ถ้าคะแนน >= 90:
พิมพ์("เยี่ยมมาก! เกรดของคุณคือ A")
อื่น:
ถ้าคะแนน >= 80:
พิมพ์ (“ดีมาก! เกรดของคุณคือ B”)
อื่น:
ถ้าคะแนน >= 70:
พิมพ์("ดี! เกรดของคุณคือ C")
อื่น:
ถ้าคะแนน >= 60:
พิมพ์("เกรดของคุณคือ D เนื้อหาซ้ำจะคุ้มค่า")
อื่น:
print("คุณสอบไม่ผ่าน")
แอปพลิเคชันจะตรวจสอบก่อนว่าคะแนนมากกว่าหรือเท่ากับ 90 หรือไม่ ถ้าใช่ ระบบจะส่งคืนเกรด A หากเงื่อนไขนี้เป็นเท็จ จะมีการตรวจสอบในภายหลัง เราเห็นว่าอัลกอริทึมเกือบจะเหมือนกันในแวบแรก ดังนั้นแทนที่จะตรวจสอบภายใน อื่น ดีกว่าที่จะใช้ชุดค่าผสม ถ้า-elif-อื่น.
ดังนั้นตัวดำเนินการ if ทำหน้าที่ที่สำคัญมาก - ทำให้แน่ใจว่าโค้ดบางส่วนจะถูกรันก็ต่อเมื่อมีความจำเป็นเท่านั้น เป็นไปไม่ได้ที่จะจินตนาการถึงการเขียนโปรแกรมหากไม่มีมัน เพราะแม้แต่อัลกอริธึมที่ง่ายที่สุดก็ยังต้องใช้ส้อมอย่างเช่น “ถ้าคุณไปทางซ้าย คุณจะพบมัน และถ้าคุณไปทางขวา คุณต้องทำสิ่งนี้และสิ่งนั้น”