นิยามและการใช้ try-except

คำสั่ง try-except ในภาษา Python เป็นโครงสร้างการควบคุมการทำงาน (Control Flow Structure) ที่ช่วยให้เราสามารถตรวจสอบบล็อกของโค้ดเพื่อหาข้อผิดพลาดที่อาจเกิดขึ้นระหว่างการรันโปรแกรม วัตถุประสงค์หลักของการใช้งาน try-except คือการป้องกันไม่ให้โปรแกรมหยุดทำงานเมื่อเกิดข้อผิดพลาดที่ไม่คาดคิด และเปิดโอกาสให้เราสามารถเขียนโค้ดเพื่อจัดการกับข้อผิดพลาดเหล่านั้นได้อย่างเหมาะสม

เมื่อโปรแกรมพบข้อผิดพลาดภายในบล็อก try แทนที่จะหยุดทำงานทันที Python จะมองหาบล็อก except ที่ถูกกำหนดไว้เพื่อจัดการกับข้อผิดพลาดประเภทนั้นๆ หากพบ บล็อก except นั้นจะถูกดำเนินการ ทำให้โปรแกรมสามารถดำเนินการต่อไปได้ หรืออย่างน้อยก็สามารถปิดตัวเองลงได้อย่างสวยงามโดยไม่ทิ้งร่องรอยของความผิดพลาดที่ทำให้ผู้ใช้สับสน การจัดการข้อผิดพลาดด้วย try-except จึงเป็นทักษะที่สำคัญสำหรับนักพัฒนาโปรแกรมทุกคน ไม่ว่าจะเป็นมือใหม่หรือผู้มีประสบการณ์

โครงสร้างทางไวยากรณ์ของบล็อก try-except

บล็อก try-except ใน Python มีโครงสร้างทางไวยากรณ์ที่ชัดเจน ประกอบด้วยคีย์เวิร์ดหลักๆ ดังนี้:

• try: เป็นคีย์เวิร์ดที่เริ่มต้นบล็อกของโค้ดที่เราต้องการตรวจสอบว่าอาจมีข้อผิดพลาดเกิดขึ้นหรือไม่.
• except: เป็นคีย์เวิร์ดที่กำหนดบล็อกของโค้ดที่จะถูกดำเนินการเมื่อมีข้อผิดพลาดเกิดขึ้นภายในบล็อก try. เราสามารถระบุประเภทของข้อผิดพลาดที่เราต้องการจัดการได้ (เช่น ValueError, TypeError, FileNotFoundError) หรือจะใช้ except โดยไม่มีการระบุประเภทเพื่อจัดการกับข้อผิดพลาดทุกประเภทก็ได้.
• else: (ทางเลือก) เป็นคีย์เวิร์ดที่กำหนดบล็อกของโค้ดที่จะถูกดำเนินการเฉพาะเมื่อไม่มีข้อผิดพลาดเกิดขึ้นในบล็อก try.
• finally: (ทางเลือก) เป็นคีย์เวิร์ดที่กำหนดบล็อกของโค้ดที่จะถูกดำเนินการเสมอ ไม่ว่าจะมีข้อผิดพลาดเกิดขึ้นในบล็อก try หรือไม่ก็ตาม. มักใช้สำหรับการดำเนินการที่ต้องทำความสะอาด (Cleanup) เช่น การปิดไฟล์.

try:
    # โค้ดที่อาจทำให้เกิดข้อผิดพลาด
    result = 10 / int(input("ป้อนตัวหาร: "))
    print("ผลลัพธ์:", result)
except ValueError:
    # โค้ดที่จะถูกดำเนินการเมื่อเกิดข้อผิดพลาดประเภท ValueError
    print("คุณป้อนข้อมูลที่ไม่ใช่ตัวเลข กรุณาป้อนตัวเลขเท่านั้น")
except ZeroDivisionError:
    # โค้ดที่จะถูกดำเนินการเมื่อเกิดข้อผิดพลาดประเภท ZeroDivisionError
    print("ไม่สามารถหารด้วยศูนย์ได้ กรุณาป้อนตัวหารที่ไม่ใช่ศูนย์")
else:
    # โค้ดที่จะถูกดำเนินการถ้าไม่มีข้อผิดพลาดเกิดขึ้นในบล็อก try
    print("การคำนวณสำเร็จ")
finally:
    # โค้ดที่จะถูกดำเนินการเสมอ ไม่ว่าจะมีข้อผิดพลาดเกิดขึ้นหรือไม่
    print("การทำงานเสร็จสิ้น")

คีย์เวิร์ด	คำอธิบาย	ตัวอย่างการใช้งาน
try	กำหนดจุดเริ่มต้นของบล็อกโค้ดที่อาจทำให้เกิดข้อผิดพลาด	try:…
except	กำหนดวิธีการจัดการกับข้อผิดพลาดประเภทใดประเภทหนึ่ง หรือทุกประเภท	except ValueError:…, except:…
else	(ทางเลือก) โค้ดที่จะทำงานเมื่อไม่มีข้อผิดพลาดเกิดขึ้นในบล็อก try	else:…
finally	(ทางเลือก) โค้ดที่จะทำงานเสมอ ไม่ว่าจะมีข้อผิดพลาดเกิดขึ้นหรือไม่ก็ตาม	finally:…

ขั้นตอนการทำงานของ try-except

เพื่อให้เข้าใจการทำงานของ try-exceptเราจะพิจารณาถึงสิ่งที่เกิดขึ้นในสถานการณ์ต่างๆดังต่อไปนี้ :

เกิดอะไรขึ้นเมื่อไม่มีข้อผิดพลาดเกิดขึ้นในบล็อก try

เมื่อโค้ดทั้งหมดภายในบล็อก try ทำงานเสร็จสมบูรณ์โดยไม่มีข้อผิดพลาดใดๆ เกิดขึ้น Python จะข้ามบล็อก except ทั้งหมดไป หากมีบล็อก else โค้ดภายในบล็อก else จะถูกดำเนินการหลังจากบล็อก try ทำงานเสร็จ สุดท้าย หากมีบล็อก finally โค้ดภายในบล็อก finally จะถูกดำเนินการ แล้วโปรแกรมจะดำเนินการโค้ดที่อยู่ถัดจากบล็อก try-except ต่อไป. กล่าวได้ว่า ในสถานการณ์ที่ไม่มีข้อผิดพลาด บล็อก except จะไม่มีบทบาทใดๆ ในการทำงานของโปรแกรม

เกิดอะไรขึ้นเมื่อมีข้อผิดพลาดเกิดขึ้นในบล็อก try และมีบล็อก except ที่ตรงกับประเภทของข้อผิดพลาดนั้น

เมื่อมีข้อผิดพลาด (Exception) เกิดขึ้นภายในบล็อก try การทำงานของโค้ดในบล็อก try จะหยุดลงทันที จากนั้น Python จะตรวจสอบว่ามีบล็อก except ใดบ้างที่สามารถจัดการกับข้อผิดพลาดประเภทนั้นได้ หากพบ บล็อก except ที่ตรงกันจะถูกดำเนินการ หลังจากบล็อก except ทำงานเสร็จ หากมีบล็อก finally โค้ดภายในบล็อก finally จะถูกดำเนินการ แล้วโปรแกรมจะดำเนินการโค้ดที่อยู่ถัดจากบล็อก try-except ต่อไป. สิ่งสำคัญคือ โปรแกรมจะไม่หยุดทำงาน แต่จะดำเนินการตามที่เราได้กำหนดไว้ในบล็อก except

อธิบายการทำงานของบล็อก else ที่จะถูกรันเมื่อไม่มีข้อผิดพลาดเกิดขึ้นในบล็อก try

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

อธิบายการทำงานของบล็อก finally ที่จะถูกรันเสมอ ไม่ว่าจะมีข้อผิดพลาดเกิดขึ้นหรือไม่

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

การใช้บล็อก except หลายบล็อกเพื่อจัดการกับข้อผิดพลาดประเภทต่างๆ

Python อนุญาตให้เราใช้บล็อก except หลายบล็อกต่อท้ายบล็อก try หนึ่งบล็อก เพื่อให้เราสามารถจัดการกับข้อผิดพลาดแต่ละประเภทได้อย่างเฉพาะเจาะจง เมื่อมีข้อผิดพลาดเกิดขึ้นในบล็อก try Python จะตรวจสอบบล็อก except ตามลำดับ และจะดำเนินการบล็อกแรกที่ประเภทของข้อผิดพลาดตรงกันเท่านั้น

ตัวอย่างเช่น หากเราต้องการจัดการกับข้อผิดพลาด ValueError ที่อาจเกิดขึ้นจากการแปลงข้อมูลเป็นตัวเลข และข้อผิดพลาด ZeroDivisionError ที่อาจเกิดขึ้นจากการหารด้วยศูนย์ เราสามารถเขียนโค้ดได้ดังนี้:

try:
    numerator = int(input("ป้อนตัวเศษ: "))
    denominator = int(input("ป้อนตัวส่วน: "))
    result = numerator / denominator
    print("ผลลัพธ์:", result)
except ValueError:
    print("เกิดข้อผิดพลาด: กรุณาป้อนตัวเลขเท่านั้น")
except ZeroDivisionError:
    print("เกิดข้อผิดพลาด: ไม่สามารถหารด้วยศูนย์ได้")
except Exception as e:
    print(f"เกิดข้อผิดพลาดที่ไม่คาดคิด: {e}")

ในตัวอย่างนี้ หากผู้ใช้ป้อนข้อมูลที่ไม่ใช่ตัวเลขในขณะที่ป้อนตัวเศษหรือตัวส่วน บล็อก except ValueError จะถูกดำเนินการ หากผู้ใช้ป้อนศูนย์เป็นตัวส่วน บล็อก except ZeroDivisionError จะถูกดำเนินการ และหากมีข้อผิดพลาดอื่นๆ ที่ไม่ได้ระบุไว้ บล็อก except Exception as e จะถูกดำเนินการ ซึ่ง Exception เป็นคลาสแม่ของข้อผิดพลาดส่วนใหญ่ใน Python ดังนั้นการจับ Exception จะเป็นการจับข้อผิดพลาดทุกประเภทที่ไม่ได้รับการจัดการโดย except บล็อกก่อนหน้า. สิ่งสำคัญคือควรเรียงลำดับบล็อก except จากประเภทข้อผิดพลาดที่เฉพาะเจาะจงที่สุดไปยังประเภทที่กว้างที่สุด เพื่อให้แน่ใจว่าการจัดการข้อผิดพลาดเป็นไปตามที่เราต้องการ.

การใช้ except โดยไม่มีการระบุประเภทข้อผิดพลาด (bare except) และข้อควรระวังในการใช้งาน

เราสามารถใช้คีย์เวิร์ด except โดยไม่มีการระบุประเภทของข้อผิดพลาดได้ ซึ่งในกรณีนี้ บล็อก except จะจับข้อผิดพลาดทุกประเภทที่เกิดขึ้นในบล็อก try. รูปแบบการใช้งานจะเป็นดังนี้:

try:
    # โค้ดที่อาจทำให้เกิดข้อผิดพลาด
except:
    # โค้ดที่จะถูกดำเนินการเมื่อมีข้อผิดพลาดใดๆ เกิดขึ้น
    print("มีบางอย่างผิดพลาดเกิดขึ้น")

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

โดยทั่วไปแล้ว การใช้ except โดยไม่มีการระบุประเภทข้อผิดพลาดถือเป็นแนวทางที่ไม่แนะนำ. หากจำเป็นต้องจับข้อผิดพลาดทุกประเภท ควรระบุเป็น except Exception as e: เพื่อให้เราสามารถเข้าถึงข้อมูลเกี่ยวกับข้อผิดพลาดนั้นได้ (เช่น ข้อความแสดงข้อผิดพลาด) และอาจทำการบันทึก (Logging) หรือส่งต่อ (Re-raise) ข้อผิดพลาดนั้นไปยังส่วนอื่นของโปรแกรมเพื่อจัดการต่อไป.

ตัวอย่างการใช้งาน try-except

การใช้งาน try-except มีประโยชน์อย่างมากในสถานการณ์ต่างๆ ในการเขียนโปรแกรมจริง ต่อไปนี้คือตัวอย่างบางส่วน:

• การอ่านไฟล์: เมื่อเราพยายามเปิดและอ่านไฟล์ อาจเกิดข้อผิดพลาดขึ้นได้ เช่น ไฟล์นั้นไม่มีอยู่ หรือเราไม่มีสิทธิ์ในการเข้าถึงไฟล์. การใช้ try-except ช่วยให้เราสามารถจัดการกับข้อผิดพลาดเหล่านี้ได้อย่างเหมาะสม เช่น แสดงข้อความแจ้งเตือนผู้ใช้ หรือสร้างไฟล์ใหม่หากจำเป็น.

  try:
      with open("data.txt", "r") as file:
          content = file.read()
          print(content)
  except FileNotFoundError:
      print("Error: ไม่พบไฟล์ data.txt")
  except IOError as e:
      print(f"Error: เกิดข้อผิดพลาดในการอ่านไฟล์: {e}")
              

• การรับข้อมูลจากผู้ใช้: เมื่อเราขอให้ผู้ใช้ป้อนข้อมูล อาจเกิดข้อผิดพลาดขึ้นได้ เช่น ผู้ใช้อาจป้อนข้อมูลที่ไม่ตรงกับประเภทที่เราคาดหวัง (เช่น ป้อนตัวอักษรแทนตัวเลข). การใช้ try-except ช่วยให้เราสามารถตรวจสอบและจัดการกับข้อมูลที่ผู้ใช้ป้อนเข้ามาได้อย่างปลอดภัย.

  while True:
      try:
          age = int(input("กรุณาป้อนอายุของคุณ: "))
          if age >= 0:
              break
          else:
              print("อายุไม่สามารถเป็นค่าลบได้")
      except ValueError:
          print("รูปแบบการป้อนข้อมูลไม่ถูกต้อง กรุณาป้อนตัวเลข")
  print("อายุของคุณคือ:", age)



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

  import requests
  try:
      response = requests.get("http://www.example.com", timeout=5)
      response.raise_for_status() # ตรวจสอบว่าการร้องขอสำเร็จหรือไม่
      print("เนื้อหาเว็บไซต์:", response.text[:100])
  except requests.exceptions.ConnectionError:
      print("Error: ไม่สามารถเชื่อมต่อกับเว็บไซต์ได้")
  except requests.exceptions.Timeout:
      print("Error: การเชื่อมต่อหมดเวลา")
  except requests.exceptions.RequestException as e:
      print(f"Error: เกิดข้อผิดพลาดในการร้องขอ: {e}")

แนวทางการเขียน try-except ที่ดี

เพื่อให้การใช้งาน try-except มีประสิทธิภาพและช่วยให้โค้ดของเรามีคุณภาพดี ในเรื่องเรามีเครื่องมือที่คอยจัดการกับปัญหาเหล่านี้แล้วแต่ถ้าเราใช้มันอย่างไม่เหมาะสมผลลัพท์ที่ได้อาจจะไม่ดีเท่าที่ควร เราควรปฏิบัติตามแนวทางต่อไปนี้:

• จัดการกับข้อผิดพลาดที่คาดการณ์ได้: ใช้ try-except สำหรับสถานการณ์ที่คุณคาดการณ์ได้ว่าอาจมีข้อผิดพลาดเกิดขึ้น เช่น การอ่านไฟล์ การรับข้อมูลจากผู้ใช้ หรือการเชื่อมต่อเครือข่าย.
• ให้ข้อมูลข้อผิดพลาดที่ชัดเจน: ในบล็อก except ควรให้ข้อความแสดงข้อผิดพลาดที่ชัดเจนและเข้าใจง่าย เพื่อช่วยให้ผู้ใช้หรือนักพัฒนาสามารถระบุและแก้ไขปัญหาได้.
• หลีกเลี่ยงการใช้ try-except มากเกินความจำเป็น: อย่าใช้ try-except เพื่อจัดการกับข้อผิดพลาดที่สามารถป้องกันได้ด้วยการเขียนโค้ดที่ดี เช่น การตรวจสอบค่าก่อนการหาร หรือการตรวจสอบดัชนีของรายการก่อนการเข้าถึง. การใช้ try-except มากเกินไปอาจทำให้โค้ดอ่านยากและลดประสิทธิภาพของโปรแกรม.[5]
• จับข้อผิดพลาดเฉพาะเจาะจง: พยายามระบุประเภทของข้อผิดพลาดที่คุณต้องการจัดการให้ชัดเจน แทนที่จะใช้ except โดยไม่มีการระบุประเภท. การจับข้อผิดพลาดเฉพาะเจาะจงช่วยให้คุณสามารถจัดการกับแต่ละสถานการณ์ได้อย่างเหมาะสม.
• ใช้บล็อก else สำหรับโค้ดที่ควรทำงานเมื่อไม่มีข้อผิดพลาด: การใช้บล็อก else ช่วยให้โค้ดของคุณอ่านง่ายขึ้น โดยแยกส่วนของการจัดการข้อผิดพลาดออกจากส่วนของการทำงานปกติ.
• ใช้บล็อก finally สำหรับการดำเนินการที่ต้องทำเสมอ: ใช้บล็อก finally เพื่อให้แน่ใจว่าการดำเนินการที่สำคัญ เช่น การปิดไฟล์หรือการปล่อยทรัพยากร จะเกิดขึ้นเสมอ ไม่ว่าจะมีข้อผิดพลาดเกิดขึ้นหรือไม่.