ในการทำงานกับคอมพิวเตอร์นั้นมักจะต้องมีการแบ่งแยกเงื่อนไขเพื่อที่จะให้คอมทำงานแตกต่างกันไปตามสถานการณ์

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

ในคอมพิวเตอร์เองก็สามารถมีการแบ่งแยก เช่นเวลาคำนวณ เจอจำนวนบวกให้คำนวณอย่างหนึ่ง เจอจำนวนลบให้คำนวนแบบหนึ่ง เป็นต้น

หากมีการตั้งเงื่อนไขก็จะสร้างให้เกิดทางแยกในการทำงาน และทำงานได้ยืดหยุ่นกว้างขวางมากขึ้น

ในภาษาไพธอน (รวมถึงภาษาโปรแกรมอื่นๆส่วนใหญ่) คำสั่งที่ใช้ในการตั้งเงื่อนไขก็คือ if และ else



การใช้ if และ else เพื่อตั้งเงื่อนไข

โครงสร้างของการใช้ if เป็นดังนี้

if เงื่อนไข:
    คำสั่งที่จะให้ทำเมื่อเงื่อนไขเป็นจริง
else เงื่อนไข:
    คำสั่งที่จะให้ทำเมื่อเงื่อนไขเป็นเท็จ

ยกตัวอย่าง

x = int(input('1+1 เท่ากับเท่าไหร่? : '))
if x==2:
    print('ถูกต้องนะคร้าบ')
else:
    print('ไม่น่าเชื่อว่าจะมีคนตอบผิด')

ผลที่ได้ก็คือเริ่มมาโปรแกรมจะถามคำถามว่า "1+1 เท่ากับเท่าไหร่?" แล้วก็ให้พิมพ์คำตอบลงไป

ถ้าพิมพ์ 2 ลงไป ก็คือตอบถูก จะมีข้อความ "ถูกต้องนะคร้าบ" ขึ้นมา

แต่ถ้าพิมพ์ตัวเลขค่าอื่นลงไป จะมีข้อความ "ไม่น่าเชื่อว่าจะมีคนตอบผิด" ขึ้นมา

จากตัวอย่าง สรุปโครงสร้างโดยรวมก็คือ

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

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

ซึ่งหมายถึงการเคาะเครื่องหมายเว้นวรรค (spacebar) ให้ตัวหนังสืออยู่ห่างออกมาทางขวาเมื่อเทียบกับคำว่า if และ else

การใช้การร่นเพื่อกำหนดขอบเขตของโครงสร้างแบบนี้เป็นเอกลักษณ์อย่างหนึ่งของภาษาไพธอน ในภาษาอื่นส่วนใหญ่เช่นภาษาซีจะใช้วงเล็บปีกกาคร่อม { } แต่ถึงอย่างนั้นก็ตาม เมื่อมีการใช้ if else คนก็มักจะนิยมทำการร่นเพื่อให้ดูแล้วเข้าใจง่าย แม้ว่าจริงๆจะไม่จำเป็นก็ตาม

ในภาษาไพธอนการร่นกลายเป็นสิ่งบังคับตายตัว ข้อดีก็คือเราไม่จำเป็นต้องใส่วงเล็บปีกกาหรือใช้สัญลักษณ์ใดๆเพื่อบ่งบอกขอบเขต

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



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

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

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

ลองดูอีกตัวอย่างหนึ่ง เช่น โปรแกรมหาค่าสัมบูรณ์ของค่าที่ป้อนเข้าไป

x = float(input())
if(x<0):
    print("ค่าติดลบ") x = -x
else:
    print("ค่าไม่ติดลบ")
print('ค่าสัมบูณ์คือ', x)

ในกรณีนี้ถ้าป้อนค่ามากกว่าหรือเท่ากับ 0 ลงไปจะทำให้เงื่อนไขเป็นเท็จ แล้วก็จะแสดงผลว่าค่าเป็นบวก

แต่ถ้ามากกว่า 0 เงื่อนไขจะเป็นจริง ก็จะมีการแสดงผลว่าค่าเป็นลบ พร้อมมีการคำนวณติดลบ

แต่ไม่ว่าจะเข้าเงื่อนไขอะไร สุดท้ายแล้วก็จะมีการทำสิ่งที่อยู่บรรทัดถัดไปซึ่งอยู่ในตำแหน่งที่เท่าเทียมกับ if และ else คือไม่มีการร่น นั่นคือคำสั่ง print ที่พิมพ์ค่า x ออกมา

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

แม้ภาษาไพธอนจะไม่จำเป็นต้องใสวงเล็บหลัง if แต่การใส่วงเล็บนั้นจำเป็นในหลายภาษา เช่นภาษาซี, ฟอร์แทรน, จาวาสคริปต์, php, ฯลฯ

เนื่องจากการใส่วงเล็บทำให้การเขียนดูสวยงามมีระเบียบกว่า ดังนั้นในตัวอย่างต่อจากนี้ไปทั้งหมดจะใส่วงเล็บหลัง if เสมอ หากใครจะนำโค้ดไปเขียนตามโดยตัดวงเล็บออกไปก็ทำงานได้ไม่ต่างกัน

กรณีที่โค้ดมีอยู่เพียงบรรทัดเดียวก็สามารถเขียนคำสั่งต่อจาก if ได้เลยโดยไม่ต้องขึ้นบรรทัดใหม่ก็ได้ เช่นตัวอย่างแรกอาจเขียนใหม่เป็น

x = int(input('1+1 เท่ากับเท่าไหร่? : '))
if(x==2): print('ถูกต้องนะคร้าบ')
else: print('ไม่น่าเชื่อว่าจะมีคนตอบผิด')

หากไม่มีสิ่งที่ต้องการให้ทำเมื่อเงื่อนไขเป็นเท็จก็อาจไม่ต้องใส่ else แต่ใส่แค่ if เฉยๆก็ได้ เช่น

x = int(input('โปรดระบุอายุผู้เข้าชม'))
if(x<18): print('คำเตือน: ผู้ชมอายุต่ำกว่า 18 ปีไม่แนะนำให้เข้าชม กรุณาใช้วิจารณญาณ')

ผลลัพธ์

โปรดระบุอายุผู้เข้าชม: 17
คำเตือน: ผู้ชมอายุต่ำกว่า 18 ปีไม่แนะนำให้เข้าชม กรุณาใช้วิจารณญาณ

แต่ถ้าใส่เลข 18 ขึ้นไปจะไม่มีอะไรขึ้นมา



การเขียนผังงาน

เพื่อให้เข้าใจการทำงานของโปรแกรมได้ง่ายอาจต้องมีการเขียนผังงาน (flow chart) เพื่อให้เห็นภาพชัดเจนขึ้น

ตัวอย่างแผนภาพผังงานสำหรับตัวอย่างแรก





การเขียนนิพจน์ทางตรรกศาสตร์

จากตัวอย่างที่ผ่านมาจะเห็นเงื่อนไขที่ถูกเขียนอยู่หลัง if นั้นอยู่ในรูปของตัวแปรหรือข้อมูลสองตัวเปรียบเทียบกันแล้วพิจารณาว่าสิ่ง ที่เขียนนั้นเป็นจริงหรือเท็จ การเขียนในลักษณะนี้เรียกว่าเป็น นิพจน์ทางตรรกศาสตร์

เมื่อพิจารณาเงื่อนไขแล้วก็จะส่งค่าบูลออกมา โดยหากเป็นจริงจะให้ค่า True หากเป็นเท็จจะให้ค่า False

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

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

ความจริงแล้วเป็นเพราะเครื่องหมายเท่ากับอันเดียว = กับสองอัน == นั้นถือว่ามีความหมายต่างกัน ใช้ในคนละสถานการณ์

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

แต่หากเขียนสองอัน == จะหมายถึงการเปรียบเทียบว่าซ้ายกับขวาว่าเท่ากันหรือเปล่า ถ้าเท่ากันก็คืนค่า True ถ้าไม่เท่ากันก็คืนค่า False สิ่งที่อยู่สองข้างของ == นั้นสามารถสลับกันได้



การเปรียบเทียบระหว่างข้อมูล ๒ ตัว

x < y	หมายถึง	x น้อยกว่า y
x <= y		x น้อยกว่าหรือเท่ากับ y
x > y		x มากกว่า y
x >= y		x มากกว่าหรือเท่ากับ y
x == y		x เท่ากับ y
x != y		x ไม่เท่ากับ y

การเปรียบเทียบระหว่างข้อมูลต่างชนิดกัน

ข้อมูลที่เป็นตัวเลขทั้งจำนวนจริงและจำนวนจริงสามารถนำมาเปรียบเทียบกันได้ตามปกติ เช่น

3 > 3.1 # ได้ False
7.0 == 7 # ได้ True

แต่จำนวนจริงหรือจำนวนเต็มไม่สามารถนำไปเปรียบเทียบกับจำนวนเชิงซ้อนได้

3 > (3+0j) # ได้ TypeError: '>' not supported between instances of 'int' and 'complex'

ยกเว้นเครื่องหมาย == สามารถเปรียบเทียบได้

3 == (3+0j) # ได้ True

ข้อมูลตัวเลขไม่สามารถนำไปเปรียบเทียบกับสายอักขระได้

3.1 > '3' # ได้ TypeError: '>' not supported between instances of 'float' and 'str'

สำหรับเครื่องหมาย == สามารถใช้เทียบได้ แต่จะได้เท็จเสมอ

3 == '3' # ได้ False

สำหรับเรื่องของการเปรียบเทียบระหว่างสายอักขระนั้นจะยกไปพูดถึงในบทที่กล่าวถึงสายอักขระอย่างละเอียดอีกที



การรวมหลายนิพจน์เข้าด้วยกัน

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

ให้ A และ B ในที่นี้เป็นข้อมูลชนิดบูลที่ได้มาจากการพิจารณาเงื่อนไข ค่าความจริงที่ได้จาก and กับ or จะเป็นไปตามตารางนี้

A	B	A and B	A or B
จริง	จริง	จริง	จริง
จริง	เท็จ	เท็จ	จริง
เท็จ	จริง	เท็จ	จริง
เท็จ	เท็จ	เท็จ	เท็จ

เช่น

x = 10
x > 0 and x < 5 # ได้ False
x > 0 or x < 5 # ได้ True
x > 0 and x < 15 # ได้ True
x > 15 or x < 5 # ได้ False

หากต้องการให้ผลที่ได้กลับเป็นในทางตรงกันข้ามสามารถทำได้โดยเติม not เช่น

x > 0 and not x < 5 # ได้ True
not x > 0 or x < 5 # ได้ False

สามารถใส่วงเล็บเพื่อให้มีการคิดผลในวงเล็บก่อน ดังนั้นการใส่วงเล็บกับไม่ใส่ให้ผลต่างกัน

not (x > 0 and x < 5) # ได้ True
not x > 0 and x < 5 # ได้ False

การใช้ if elif else

บางครั้งเราอาจไม่ได้พิจารณาเงื่อนไขที่แบ่งสถานการณ์ออกเป็นแค่ ๒ กรณี แต่อาจแบ่งย่อยมากกว่านั้น ในกรณีนั้นใช้แค่ if else ไม่เพียงพอ ต้องใช้ if elif else

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

khanaen = float(input('จงป้อนคะแนนของคุณ: '))
if(khanaen<50): print('คุณได้ F เสียใจด้วย พบกันใหม่ปีหน้า')
elif(khanaen<60): print('คุณได้ D')
elif(khanaen<70): print('คุณได้ C')
elif(khanaen<80): print('คุณได้ B')
elif(khanaen<=100): print('คุณได้ A ยินดีด้วย ทำได้ดีมาก')
else: print('คะแนนไม่ควรเกิน 100')

ตัวอย่างผล
ครั้งที่ ๑

จงป้อนคะแนนของคุณ: 49
คุณได้ F เสียใจด้วย พบกันใหม่ปีหน้า  

ครั้งที่ ๒

จงป้อนคะแนนของคุณ: 81
คุณได้ A ยินดีด้วย ทำได้ดีมาก

ครั้งที่ ๓

จงป้อนคะแนนของคุณ: 555
คะแนนไม่ควรเกิน 100

เงื่อนไขซ้อนกันหลายชั้น

บางครั้งเงื่อนไขก็ไม่ได้แยกเป็นหลายทางพร้อมๆกัน แต่บางครั้งต้องผ่านเงื่อนไขหนึ่งจึงจะมีการทำอะไรต่อแล้วจึงเจอกับเงื่อนไขต่อไปอีก

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

ยิ่งมีการซ้อนก็จะยิ่งมีการร่น เกิดเป็นโครงสร้างเป็นชั้นๆ

if(เงื่อนไข):
    คำสั่ง
    if(เงื่อนไข):
        คำสั่ง
    else:
        คำสั่ง
    คำสั่ง
else:
    คำสั่ง
    if(เงื่อนไข):
        คำสั่ง
    else:
        คำสั่ง
    คำสั่ง

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

เพียงแต่ว่าขอบเขตเลเวลของผู้เล่นต้องเป็นจำนวนเต็มบวก ไม่เกิน 100 ส่วนศัตรูต้องไม่เกิน 500 ถ้าหากป้อนตัวเลขที่ไม่ได้อยู่ในขอบเขตนี้ก็จะขึ้นเตือนมาแล้วหยุดทำงานไป ทันที

lv_rao = int(input('คุณเลเวล: '))
if(lv_rao<1 or lv_rao>100):
    print('เลเวลผู้เล่นต้องอยู่ระหว่าง 1 ถึง 100')
else:
    lv_sattru = int(input('ศัตรูเลเวล: '))
    if(lv_sattru<1 or lv_sattru>500):
        print('เลเวลศัตรูต้องอยู่ระหว่าง 1 ถึง 500')
    else:
        if(lv_rao+50<=lv_sattru):
            print('ศัตรูเมพเกินไป')
        elif(lv_rao-50>=lv_sattru):
            print('ศัตรูกากเกินไป')
        else:
            print('คุณมีโอกาสชนะ', 50+lv_rao-lv_sattru,'%')

ตัวอย่างผล
ครั้งที่ ๑

คุณเลเวล: 101
เลเวลผู้เล่นต้องอยู่ระหว่าง 1 ถึง 100

ครั้งที่ ๒

คุณเลเวล: 50
ศัตรูเลเวล: 600
เลเวลศัตรูต้องอยู่ระหว่าง 1 ถึง 500

ครั้งที่ ๓

คุณเลเวล: 80
ศัตรูเลเวล: 200
ศัตรูเมพเกินไป

ครั้งที่ ๔

คุณเลเวล: 90
ศัตรูเลเวล: 110
คุณมีโอกาสชนะ 30 %

การใช้ข้อมูลชนิดต่างๆแทนค่าความจริงเท็จ

ปกติเวลาตั้งเงื่อนไขโดยเปรียบเทียบข้อมูลผลที่ได้จะออกมาเป็นตัวแปรชนิดบูลซึ่งมีค่าได้แค่ True หรือ False

แต่ที่จริงแล้วก็ไม่ใช่ว่าหลัง if จะใส่ได้แต่ค่า True หรือ False ลงไปเท่านั้น แต่สามารถใส่ข้อมูลชนิดอื่นลงไปได้ทุกชนิด แล้วข้อมูลจะถูกแปลงเป็นชนิดบูลไปก่อนนำไปพิจารณาเป็นเงื่อนไข

โดยปกติแล้วเราสามารถแปลงข้อมูลจากชนิดใดๆเป็นชนิดบูลได้ โดยถ้าเป็นจำนวนตัวเลข ค่า 0 จะได้ False นอกนั้นจะได้ True ถ้าเป็นสายอักขระ ค่าว่างเปล่าจะได้ False นอกนั้นจะได้ True

bool(1) # ได้ True
bool(0.1) # ได้ True
bool(0) # ได้ False
bool(0.0) # ได้ False
bool('0') # ได้ True
bool('') # ได้ False

ลองนำค่าไปใช้กับ if

if(10): print('จริง')
else: print('เท็จ')

ผลจะได้ว่าเป็นจริงดังนั้นจึงแสดงผล จริง



สรุปเนื้อหา

• ในโปรแกรมจะต้องมีการตัดสินจริงเท็จเพื่อกำหนดเงื่อนไขให้เกิดทางแยก
• คำสั่งสำหรับสร้างเงื่อนไขคือ if elif else
• เงื่อนไขตัดสินจากนิพจน์ทางตรรกศาสตร์ ซึ่งประกอบไปด้วย == > < >= <= and or not เป็นต้น ซึ่งให้ผลลัพธ์เป็นข้อมูลชนิดบูล True หรือ False
• โครงสร้าง if elif else สามารถซ้อนกันกี่ชั้นก็ได้
• ข้อมูลชนิดอื่นก็สามารถนำมาใช้แทนค่าบูลเพื่อพิจารณาค่าความจริงเท็จได้เช่นกัน

อ้างอิง