เวลาที่เราดีบัก เราควรจะแยกชนิดของข้อผิดพลาดให้ออก เพื่อจะได้หาสาเหตุมันได้เร็วขึ้น:
: ที่คำสั่ง def ก็จะทำให้ไพธอนอินเตอร์พรีเตอร์แจ้ง ข้อความ SyntaxError: invalid syntax ออกมาRecursionError: maximum recursion depth exceeded ออกมาขั้นตอนแรกในการดีบัก คือหาว่า ข้อผิดพลาดที่เราเจอ เป็นชนิดไหน หัวข้อย่อยต่อไปนี้ แม้จะเรียบเรียงตามชนิดของข้อผิดพลาด แต่บางเทคนิคอาจจะใช้ได้กับข้อผิดพลาดชนิดอื่นได้ด้วย
ข้อผิดพลาดเชิงวากยสัมพันธ์ (syntax errors) มักจะแก้ได้ง่าย ถ้าเรารู้แล้วว่ามันคืออะไร แต่หลายครั้ง ข้อความแจ้งข้อผิดพลาดก็ไม่ได้บอกอะไรมาก ข้อความแจ้งข้อผิดพลาดที่พบบ่อยๆ คือ SyntaxError: invalid syntax และ SyntaxError: invalid token ซึ่งไม่ได้บอกอะไรมาก
อีกมุมหนึ่ง ข้อความแจ้งข้อผิดพลาด บอกเราว่าที่ไหนในโปรแกรมที่มีปัญหา จริงๆ แล้ว มันบอกเราว่าตำแหน่งไพธอนเจอปัญหา ซึ่งอาจไม่ใช่ตำแหน่งที่มีข้อผิดพลาดอยู่ บางครั้งข้อผิดพลาดก็จะอยู่ก่อนตำแหน่งที่ข้อความแจ้งออกมา บ่อยๆ เลยที่ข้อผิดพลาดจริงๆ อยู่บรรทัดก่อนตำแหน่งที่แจ้ง
ถ้าเราเขียนโปรแกรมแบบค่อยๆ เพิ่ม ค่อยๆ เติมคำสั่งเข้าไป เราน่าจะเห็นข้อผิดพลาดได้ง่ายๆ กว่า เพราะว่า มันจะเป็นบรรทัดคำสั่งที่พึ่งเพิ่มเข้าไป
ถ้าเราเอาโค้ดมาจากหนังสือ เราหาข้อผิดพลาด โดย เปรียบเทียบโค้ดที่เขียน กับโค้ดในหนังสือ ตรวจดูทุกๆ อักขระ และให้นึกในใจว่า หนังสือก็อาจจะผิดได้ ดังนั้น ถ้าเห็นอะไรที่ดูน่าจะผิดวากยสัมพันธ์ มันก็อาจจะผิดจริงๆ
รายการต่อไปนี้แสดงแนวทางปฎิบัติที่จะหลีกเลี่ยง ข้อผิดพลาดเชิงวากยสัมพันธ์ที่พบบ่อยๆ
for คำสั่ง while คำสั่ง if และคำสั่ง def' ปิดด้วย '. ถ้าเปิดด้วย " ปิดด้วย ") ตรวจสอบว่าทุกๆ เครื่องหมายคำพูด เป็นเครื่องหมายแบบตรง ได้แก่ ' หรือ " ไม่ใช่แบบโค้ง ซึ่งได้แก่ “ ” หรือ ‘ ’''' หรือแบบคู่ """) ตรวจสอบให้แน่ใจว่า สายอักขระหลายบรรทัดนั้นถูกปิดถูกต้องดีแล้ว สายอักขระที่ไม่ได้ถูกปิด (หรือปิดไม่ถูก) จะทำให้เกิดข้อผิดพลาด invalid token ออกมาที่ท้ายโปรแกรม หรือ ไพธอนอาจจะเหมารวมเอาส่วนของโปรแกรมที่ตามมาเป็นสายอักขระไปด้วย จนกว่ามันจะเจอสายอักขระใหม่ ในกรณีที่สองนี้ ไพธอนจะไม่ให้ข้อความแจ้งข้อผิดพลาดออกมาเลย( หรือ ตัวดำเนินการ { หรือ ตัวดำเนินการ [ จะทำให้ไพธอนคิดว่าบรรทัดถัดไปเป็นส่วนหนึ่งของคำสั่งที่ยังไม่ปิด ส่วนใหญ่แล้ว ข้อความแจ้งข้อผิดพลาด จะออกมาที่บรรทัดถัดไป= แทน == ในการตรวจสอบเงื่อนไขหรือไม่ เช่น การตรวจสอบเงื่อนไข ของคำสั่ง ifถ้าลองตรวจดูตามนี้แล้ว ก็ยังแก้ปัญหาไม่ได้ ลองดูหัวข้อถัดไป
ถ้าอินเตอร์พรีเตอร์บอกว่ามีข้อผิดพลาดอยู่ แต่เราไม่เห็นมีอะไรผิดในโค้ด อาจจะเป็นเพราะว่า เรากับอินเตอร์พรีเตอร์กำลังดูคนละโค้ดกันก็ได้ ตรวจสอบไอดีอีที่กำลังใช้อยู่ ว่าโค้ดไพธอนที่เรากำลังเขียนอยู่ เป็นอันเดียวกับที่อินเตอร์พรีเตอร์รัน
ถ้ายังไม่แน่ใจ ให้ลองใส่โค้ดที่เป็นข้อผิดพลาดเชิงวากยสัมพันธ์ชัดๆ เด่นๆ สักอัน ไปที่ตอนต้นๆ ของโปรแกรมเลย แล้วลองรันดู ถ้าอินเตอร์พรีเตอร์ไม่เจอข้อผิดพลาดใหม่ที่เราตั้งใจใส่เข้าไป เราอาจจะไม่ได้รันโค้ดที่กำลังเขียนอยู่
มีตัวการเด่นๆ อยู่บ้าง เช่น
import อยู่ ให้ตรวจสอบว่า ไม่ได้ตั้งชื่อโมดูล ไปเหมือนกับโมดูลมาตราฐานของไพธอนimport เพื่ออ่านโมดูล ให้รู้ว่า เราต้องเริ่มอินเตอร์พรีเตอร์ขึ้นมาใหม่ หรือไม่ก็ใช้ reload เพื่ออ่านโมดูลที่แก้ไขใหม่ ถ้าแค่ใช้คำสั่ง import โมดูลที่เคยนำเข้ามาแล้ว ไพธอนจะไม่ทำอะไรเลยถ้ายังติดอีก และก็ยังหาไม่เจอ ให้ลองเปิดไฟล์ขึ้นมาเขียนโปรแกรมใหม่เลย เช่น “Hello, World!” และลองให้เห็นว่าโปรแกรมนี้ถูกรันได้ แล้วค่อยๆ ใส่ส่วนต่างๆ ของโปรแกรมเดิมเข้าไปในโปรแกรมใหม่นี้
ถ้าโปรแกรมมีวากยสัมพันธ์ที่ถูกต้อง ไพธอนจะอ่านมันได้ และอย่างน้อยก็กสามารถเริ่มรันมันได้ แล้วจะมีอะไรที่จะผิดได้อีก?
ปัญหานี้เจอบ่อยที่สุด เวลาที่โค้ดมีฟังก์ชัน มีคลาสต่างๆ อยู่ แต่ไม่ได้เรียกฟังก์ชันขึ้นมาทำงานจริงๆ บางทีเราอาจจะอยากให้เป็นแบบนี้ เวลาเขียนโมดูลที่มีคลาสและฟังก์ชันต่างๆ เพื่อให้ไฟล์อื่นเรียกใช้
แต่ถ้าเราไม่ได้อยากให้เป็นแบบนี้ ตรวจสอบว่ามีการเรียกใช้ฟังก์ชันในโปรแกรม และตรวจสอบดูลำดับของการรันคำสั่ง ว่า การเรียกฟังก์ชันนั้นจะถูกรัน (ดูเรื่อง “ลำดับการรันคำสั่ง” ข้างล่าง)
ถ้าโปรแกรมหยุด และดูเหมือนไม่ได้ทำอะไร มันเรียกว่าโปรแกรมแฮง (hang) ซึ่งบ่อยๆ เลย ที่โปรแกรมแฮง มาจากโปรแกรมติดอยู่ในลูปไม่สิ้นสุด (infinite loop) หรือติดอยู่ในการวนซ้ำไม่สิ้นสุด (infinite recursion)
print เข้าไปก่อนเข้าลูป โดยให้พิมพ์ออกมาว่า “entering the loop” และอีกอันใส่เข้าไปหลังจากเพิ่งออกจากลูป พิมพ์ว่า “exiting the loop”รันโปรแกรม แล้วถ้าเห็นแต่ข้อความแรก ไม่เห็นข้อความที่สอง เราเจอลูปไม่สิ้นสุดแล้ว ลองดูหัวข้อ “ลูปไม่สิ้นสุด” ข้างล่าง
“RuntimeError: Maximum recursion depth exceeded” ออกมา. ถ้าเป็นแบบนี้ ลองดูหัวข้้อ “การวนซ้ำไม่สิ้นสุด” ข้างล่าง.ถ้าไม่เห็นข้อความแจ้งข้อผิดพลาดแบบนี้ แต่สงสัยว่าจะมีปัญหากับการวนซ้ำ หรือว่าฟังก์ชัน ก็ยังสามารถใช้เทคนิคที่อภิปรายในหัวข้อ “การวนซ้ำไม่สิ้นสุด” ได้
ถ้าคิดว่า กำลังเจอกับลูปไม่สิ้นสุด อยู่ และสงสัยว่า ลูปไหนที่เป็นตัวปัญหา ให้ลองใส่คำสั่ง print ที่ท้ายของลูป โดยพิมพ์ค่าของตัวแปรต่างๆ ในเงื่อนไข และค่าของเงื่อนไขออกมา
ตัวอย่างเช่น:
while x > 0 and y < 0 : # do something to x # do something to y print('x: ', x) print('y: ', y) print("condition: ", (x > 0 and y < 0))
ตอนนี้ถ้าเรารันโปรแกรม เราจะเห็น เอาต์พุตออกมาสามบรรทัด สำหรับการทำงานแต่ละครั้งในลูป การทำงานครั้งสุดท้ายในลูป เงื่อนไขควรจะเป็น False ถ้าลูปทำงานไปเรื่อยๆ เราน่าจะเห็นค่าของ x และ y และก็น่าจะพอสืบต่อได้ว่า ทำไมค่าตัวแปรต่างๆ ถึงไม่ได้ถูกเปลี่ยนค่าอย่างถูกต้อง
ส่วนใหญ่ การวนซ้ำไม่สิ้นสุด จะทำให้โปรแกรมรันไปได้พักหนึ่ง ก่อนจะให้ข้อผิดพลาด Maximum recursion depth exceeded ออกมา
ถ้าสงสัยว่า ฟังก์ชันเป็นตัวการทำให้เกิดการวนซ้ำไม่สิ้นสุด ลองดูให้แน่ใจว่า มีกรณีฐาน (base case) มันจะต้องมีเงื่อนไข ที่ให้ฟังก์ชันคืนค่าออกมาได้ โดยไม่ต้องเรียกการวนซ้ำอีก ถ้าไม่มี ลองทนทวนอัลกอริทึมใหม่ และกำหนดกรณีฐาน นี้
ถ้ามีกรณีฐาน แต่โปรแกรมดูเหมือนไปไม่ถึงมัน ลองใส่คำสั่ง print เข้าไปที่ต้นของฟังก์ชัน และพิมพ์ค่าพารามิเตอร์ต่างๆ ออกมา ตอนนี้ ถ้ารันโปรแกรม เราจะเห็น บรรทัดที่พิมพ์ค่าต่างๆ ออกมาทุกครั้งที่ฟังก์ชันถูกเรียกใช้งาน และเห็นค่าพารามิเตอร์ต่างๆ เหล่านั้น ถ้าค่าของพารามิเตอร์ไม่ได้เปลี่ยนแปลงไปหากรณีฐาน เราก็น่าจะพอรู้อะไรบ้างแล้วว่าทำไม
ถ้าไม่แน่ใจว่าลำดับขั้นตอนการทำงานของโปรแกรมเป็นอย่างไร ลองใส่คำสั่ง print เข้าไปตอนเริ่มของแต่ละฟังก์ชัน โดยพิมพ์ข้อความ เช่น “entering function foo” เมื่อ foo เป็นชื่อของฟังก์ชัน
ตอนนี้ถ้ารันโปรแกรม มันจะพิมพ์ข้อความต่างๆ ซึ่งเหมือนร่องรอยบอกการเรียกใช้ของแต่ละฟังก์ชัน
ถ้ามีอะไรผิดพลาดระหว่างการรันโปรแกรม ไพธอนจะพิมพ์ข้อความ รวมถึงชื่อของเอ็กเซ็ปชั่น และบรรทัดที่โปรแกรมเจอปัญหา และการสืบย้อน (traceback) ออกมา
การสืบย้อน ระบุฟังก์ชันที่กำลังรันอยู่ ฟังก์ชันที่เรียกใช้มัน และฟังก์ชันที่เรียกใช้ฟังก์ชันที่เรียกใช้มัน ต่อขึ้นไปเป็นทอดๆ พูดอีกอย่างก็คือ มันสืบย้อนลำดับของการเรียกใช้ฟังก์ชัน จนไปถึงที่ที่เราอยู่ รวมถึงบรรทัดในโปรแกรมที่มีการเรียกแต่ละครั้ง
ขั้นตอนแรก เป็นการตรวจสอบตำแหน่งที่โปรแกรมเจอข้อผิดพลาดอยู่ และลองหาดูว่าอะไรเป็นสาเหตุ รายการต่อไปนี้แสดงข้อผิดพลาดเวลาดำเนินการ ที่พบได้บ่อยที่สุด:
เกิดจากการที่พยายามจะใช้ตัวแปรที่ยังไม่ได้กำหนด ลองดูว่า สะกดชื่อถูกหรือเปล่า หรืออย่างน้อยก็สะกดแบบเดียวกันตลอด จำไว้ว่า ตัวแปรเฉพาะที่ ใช้งานได้เฉพาะที่ เราไม่สามารถใช้งานมันได้นอกฟังก์ชันที่กำหนดค่าของมัน
อาจเกิดได้จากหลายสาเหตุ:
print("%d, %d"%(5, 6, 7)) และ print("%d"%'5')self แล้วตรวจดูการเรียกใช้เมธอด ว่าเรียกใช้เมธอดจากออบเจ๊คต์ถูกชนิด และส่งอาร์กิวเมนต์อื่นๆ ไปให้ถูกอาจเกิดจากการพยายามอ้างถึงรายการภายในของดิกชันนารี โดยใช้กุญแจที่ดิกชันนารีไม่มี ถ้ากุญแจเป็นสายอักขระ ตรวจสอบดูว่าการสะกด รวมถึงการใช้ตัวพิมพ์เล็กพิมพ์ใหญ่
อาจเกิดจากการพยายามอ้างถึงลักษณะประจำ หรือเมธอด ที่ไม่มีอยู่ ลองตรวจสอบการสะกด เราสามารถใช้ฟังก์ชันสำเร็จ dir หรือ vars เพื่อตรวจดูลักษณะประจำต่างๆ ที่มีอยู่ได้
ถ้า AttributeError บอกว่า ออบเจ๊คต์มีNoneType นั่นหมายถึงว่า ตัวออบเจ๊คต์มีค่าเป็น None ดังนั้นปัญหาไม่ใช่ชื่อของลักษณะประจำ แต่เป็นตัวออบเจ๊คต์เอง
สาเหตุที่ออบเจ๊คต์เป็น None อาจจะมาจาก เราลืม return ค่าออกมาจากฟังก์ชัน อย่างเช่น ถ้ามีวิธีที่จะรันฟังก์ชันจนจบได้ โดยไม่ต้องทำคำสั่ง return ฟังก์ชันจะให้ค่า None ออกมาโดยอัตโนมัติ อีกสาเหตุที่พบบ่อยๆ ก็คือ การใช้ผลลัพธ์จากเมธอดของลิสต์ เช่น sort ที่ให้ค่าออกมาเป็น None
อาจเกิดจาก ดัชนีที่ใช้ในการอ้างถึงรายการในลิสต์ สายอักขระ หรือทูเพิล ใหญ่กว่าความยาวลบหนึ่ง ลองใส่คำสั่ง print เข้าไปก่อนตำแหน่งที่แจ้งข้อผิดพลาดออกมา โดยให้พิมพ์ค่าของดัชนี และความยาวของลิสต์ สายอักขระ หรือทูเพิลออกมา ตรวจสอบดูความยาว ว่าถูกต้องตามที่คาดหมายหรือไม่ และค่าดัชนีเป็นตามที่คาดหมายหรือไม่
ไพธอนดีบักเกอร์ (pdb) มีประโยชน์มากในการช่วยสืบหาสาเหตุของเอ็กเซ็ปชั่น เพราะว่า มันจะช่วยให้เราสามารถดูสถานะของโปรแกรมได้ทันทีก่อนข้อผิดพลาดจะเกิดขึ้น ศึกษาเรื่อง pdb เพิ่มเติมได้จาก https://docs.python.org/3/library/pdb.html
ปัญหาหนึ่งจากการใช้คำสั่ง print เพื่อดีบัก คือสุดท้ายเราอาจจะท่วมท้นกับเอาต์พุตจำนวนมากที่ได้ มีสองวิธี คือ สะสางเอาต์พุตให้ดูง่ายขึ้น หรือสะสางโปรแกรมให้เรียบง่ายขึ้น
เพื่อสะสางเอาต์พุต เราอาจจะเอาคำสั่ง print ที่ไม่ได้ช่วยเท่าไรออก ซึ่งอาจจะลบออกเลย หรืออาจจะคอมเมนต์มันออก หรือเราอาจจะปรับให้คำสั่ง print พิมพ์เอาต์พุตที่ดูง่ายขึ้นออกมาแทน
เพื่อสะสางโปรแกรมให้เรียบง่าย มีหลายๆ อย่างที่ทำได้ หนึ่ง จำกัดโจทย์ที่โปรแกรมทำลง ตัวอย่างเช่น ถ้าโปรแกรมทำการค้นหาในลิสต์ ลองค้นหาในลิสต์ขนาดเล็กดู ถ้าโปรแกรมรับอินพุตจากผู้ใช้ ลองใส่อินพุตที่ง่ายที่สุดที่สร้างปัญหาดู
สอง สะสางโปรแกรมจริงๆ จังๆ ลบส่วนของโปรแกรมที่ไม่ได้ทำงานอะไรออก และจัดเรียบเรียงโปรแกรมให้อ่านได้ง่ายที่สุดเท่าที่ทำได้ ตัวอย่างเช่น ถ้าสงสัยว่า ปัญหาอยู่ในส่วนที่ซ้อนอยู่ลึกๆ ของโปรแกรม ลองเขียนส่วนนั้นของโปรแกรมใหม่ ด้วยโครงสร้างที่เรียบง่ายขึ้น ถ้าสงสัยการทำงานของฟังก์ชันใหญ่ ลองแตกมันออกเป็นฟังก์ชันเล็กๆ และทดสอบแต่ละฟังก์ชันแยกกันดู
บ่อยๆ เลยที่ระหว่างที่กำลังคิดหากรณีทดสอบส่วนย่อยๆ จะช่วยให้เราเจอบัก ถ้าพบว่าโปรแกรมทำงานได้ในสถานการณ์หนึ่ง แต่ทำงานไม่ได้ในอีกสถานการณ์ อันนี้จะใช้เป็นเงื่อนงำในการหาสาเหตุของปัญหา
ทำนองเดียวกัน การเขียนส่วนของโปรแกรมใหม่ จะช่วยให้เราหาบักที่ซ่อนอยู่ได้ ถ้าเราเปลี่ยนส่วนของโปรแกรมที่คิิดว่าไม่น่ามีผล แต่พบว่ามันมีผล นี่เป็นสัญญาณที่สำคัญของสาเหตุของปัญหา
จากหลายๆ แง่มุม ข้อผิดพลาดเชิงความหมาย (semantic errors) เป็นเรื่องที่ดีบักยากที่สุด เพราะว่า ไพธอนอินเตอร์พรีเตอร์ จะไม่บอกว่ามีอะไรผิดเลย มีแต่เราเท่านั้นที่รู้ว่าโปรแกรมควรจะทำงานอย่างไร
ขั้นตอนแรก คือหาความเชื่อมโยงระหว่างข้อความที่เห็นจากโปรแกรม กับพฤติกรรมของโปรแกรม เราต้องอ่านว่าจริงๆ แล้ว โปรแกรมทำอะไร สิ่งหนึ่งที่ทำให้มันยากก็คือคอมพิวเตอร์รันเร็วมาก
บางที เราก็อยากจะให้โปรแกรมรันช้าลงพอที่จะเห็นการทำงานได้ และดีบักเกอร์ก็ช่วยทำให้โปรแกรมรันช้าลงได้ เพียงแต่ การใช้คำสั่ง print มันจะสะดวกกว่าการใช้ดีบักเกอร์ ที่รวมการใส่จุดหยุด (breakpoint) และการรันทีละขั้น (single stepping) ไปจนพบตำแหน่งของปัญหา
เราควรจะลองถามตัวเองดูว่า:
เพื่อจะเขียนโปรแกรม เราต้องมีแนวคิดในหัวก่อน ว่าโปรแกรมจะทำงานอย่างไร ถ้าเราเขียนโปรแกรม แล้วโปรแกรมไม่ทำงานตามที่เราคิด บ่อยๆ ครั้งเลยที่ปัญหาไม่ได้อยู่ที่โปรแกรม แต่อยู่ในหัวเราเอง
วิธีดีที่สุดในการปรับแนวคิดในหัว คือ แตกโปรแกรมออกเป็นส่วนย่อยๆ (โดยทั่วไป คือ แตกเป็นฟังก์ชัน และเมธอดต่างๆ) แล้วทดสอบการทำงานของแต่ละส่วนอย่างอิสระ ถ้าเราเจอว่าอะไรที่แนวคิดในหัวกับความเป็นจริงไม่ตรงกัน เราก็จะเจอคำตอบของปัญหา
แน่นอนว่า เราควรจะสร้างและทดสอบส่วนประกอบย่อยต่างๆ ไปเรื่อยๆ ระหว่างเขียนโปรแกรม ถ้าตรวจสอบเรื่อยๆ เมื่อเจอปัญหา เราก็จะพอรู้ว่า ปัญหาก็น่าจะอยู่ในส่วนของโปรแกรมที่เพิ่งเพิ่มเข้าไปใหม่
การเขียนนิพจน์ที่ซับซ้อน ก็ไม่ได้ผิดอะไร ถ้ามันยังอ่านรู้เรื่องอยู่ แต่มันอาจจะทำให้ดีบักได้ยาก จริงๆ แล้ว มันดีกว่าที่จะแตกนิพจน์ที่ซับซ้อน ออกเป็นนิพจน์ย่อยๆ ที่กำหนดค่าให้กับตัวแปรชั่วคราวต่างๆ
ตัวอย่างเช่น:
self.hands[i].addCard(self.hands[self.findNeighbor(i)].popCard())
อันนี้อาจจะเขียนใหม่เป็น:
neighbor = self.findNeighbor(i) pickedCard = self.hands[neighbor].popCard() self.hands[i].addCard(pickedCard)
รูปแบบหลังนี้ อ่านได้ง่ายกว่า เพราะว่า ชื่อตัวแปรบอกความหมาย และมันก็ง่ายที่จะดีบักด้วย เพราะว่า เราสามารถดูชนิดของค่าต่างๆ ในกระบวนการคำนวณ ผ่านตัวแปรชั่วคราวได้
ปัญหาอีกอย่าง ที่อาจเกิดกับนิพจน์ที่ซับซ้อน คือ ลำดับของการคำนวณอาจจะตรงตามที่เราคิด ตัวอย่างเช่น ถ้าเราตีความนิพจน์ $\frac{x}{2 \pi}$ เป็นโปรแกรมไพธอน เราอาจจะเขียน:
y = x / 2 * math.pi
ซึ่ง มันไม่ถูก เพราะว่า การคูณและการหาร มีลำดับการทำก่อนหลังเท่ากัน และจะถูกทำจากซ้ายไปขวา ดังนั้นนิพจน์ของโปรแกรมไพธอนนี้ คือ $x \pi / 2$
วิธีแก้ปัญหาที่ดี คือ การใส่วงเล็บเข้าไป เพื่อกำหนดลำดับการทำให้ชัดเจน:
y = x / (2 * math.pi)
ถ้าเราไม่แน่ใจลำดับการทำก่อนหลัง ให้ใช้วงเล็บช่วย การใช้วงเล็บช่วย นอกจากจะช่วยให้โปรแกรมทำงานถูกต้อง (ในแง่ที่ว่าทำงานตรงตามที่เราตั้งใจ) แล้วมันยังช่วยให้โปรแกรมอ่านได้ง่ายขึ้นด้วย โดยเฉพาะสำหรับคนที่จำลำดับการทำปฏิบัติการไม่ได้
ถ้ามีคำสั่ง return กับนิพจน์ที่ซับซ้อน เราจะพิมพ์ผลลัพธ์ออกมาดูได้ยาก เหมือนกับที่อภิปรายไป เราสามารถใช้ตัวแปรชั่วคราวมาช่วยปรับให้นิพจน์อ่านง่ายขึ้น ตัวอย่างเช่น แทนที่:
return self.hands[i].removeMatches()
เราอาจจะเขียนโปรแกรมเป็น:
count = self.hands[i].removeMatches() return count
ตอนนี้ เราสามารถพิมพ์ค่า count ออกมาดูก่อนได้ง่ายขึ้น
อันดับแรก ลองพักจากคอมพิวเตอร์ไปทำอย่างอื่นสักประเดี๋ยว คอมพิวเตอร์ปล่อยคลื่นที่ส่งผลกับสมอง ที่อาจจะทำให้เกิดอาการ:
ถ้ารู้สึกตัวเองว่ากำลังมีอาการเหล่านี้ พักและออกไปเดินเล่นก่อน พอสงบแล้ว ค่อยกลับคิดโปรแกรมต่อ โปรแกรมมันทำอะไร? อะไรที่มันจะทำให้เกิดพฤติกรรมแบบนั้นได้? ตอนไหนที่โปรแกรมมันทำงานได้ และเราทำอะไรไปหลังจากนั้น?
บางครั้ง มันก็แค่ต้องใช้เวลาบ้าง เพื่อจะแก้ปัญหา บ่อยๆ ครั้งเลย ที่เราจะดีบักได้ ตอนที่เราพักจากคอมพิวเตอร์ และใจเราผ่อนออก ในจังหวะที่ที่ดีบักได้ดีที่สุด คือ กำลังอาบน้ำ และก็กำลังจะหลับ
บางทีมันก็แก้เองไม่ได้จริงๆ แม้แต่นักเขียนโปรแกรมที่เก่งที่สุด บางครั้งก็ติดเหมือนกัน บางครั้ง เราอยู่กับโปรแกรมงานเกินไป จนทำให้เรามองไม่เห็นข้อผิดพลาด เราต้องการสายตาสดๆ คู่ใหม่
ก่อนที่เราจะไปตามคนมาช่วย ให้เตรียมตัวก่อน โปรแกรมเราอาจจะเรียบง่ายที่สุด และเราก็ควรจะลองกับอินพุตที่เล็กที่สุด แล้วที่จะเห็นข้อผิดพลาด เราควรจะวางคำสั่ง print ไว้ที่ที่เหมาะสมเรียบร้อยแล้ว (และเอาต์พุตก็ควรจะเข้าใจได้ง่าย) เราควรจะต้องเข้าใจโปรแกรมดีพอที่จะอธิบายได้อย่างชัดเจน และกระชับ
เวลาที่เอาคนมาช่วย ให้แน่ใจว่า ให้ข้อมูลต่างๆ ที่เขาต้องการแล้ว:
เวลาที่เจอสาเหตุของปัญหาแล้ว ให้สละเวลา ลองคิดดูว่า เราน่าจะทำอะไรบ้าง เพื่อจะหามันเจอได้ง่ายขึ้น คราวหน้า ถ้าเราเจออะไรคล้ายๆ กัน เราจะได้ดีบักได้เร็วขึ้น
จำไว้ว่า เป้าหมาย คือ ไม่ใช่แค่ให้โปรแกรมทำงานได้ เป้าหมาย คือ เรียนรู้ว่าจะทำอย่างไรให้โปรแกรมทำงานได้
https://greenteapress.com/thinkpython2/html/thinkpython2021.html