คอร์สพื้นฐานสัมภาษณ์เขียนโปรแกรม Python

ในการสัมภาษณ์งานเขียนโปรแกรมด้วย Python สิ่งแรกที่ผู้สมัครต้องเข้าใจคือความต่างระหว่างค่าและตัวตนของวัตถุ เพราะตัวแปรใน Python เป็นเพียงชื่อที่ชี้ไปยังวัตถุในหน่วยความจำเท่านั้น ตัวดำเนินการ == ใช้เปรียบเทียบค่า ขณะที่ is ใช้ตรวจสอบว่าทั้งสองชื่อชี้ไปยังวัตถุเดียวกัน และฟังก์ชัน id() แสดงเลขประจำตัวของวัตถุนั้น ในหลายกรณี Python จะแคชวัตถุขนาดเล็ก เช่น จำนวนเต็มช่วงหนึ่ง ทำให้การเปรียบเทียบด้วย is อาจให้ผลที่ทำให้เข้าใจผิดได้ ดังนั้นจึงควรใช้ == ในการเปรียบเทียบค่าเป็นหลัก

การแยก ชนิดที่แก้ไขได้ กับ ชนิดที่แก้ไขไม่ได้ มีผลโดยตรงต่อวิธีที่ข้อมูลถูกส่งต่อไปในโปรแกรม ชนิดที่แก้ไขไม่ได้ เช่น int, str, tuple และ frozenset จะไม่เปลี่ยนค่าหลังจากสร้างแล้ว ส่วนชนิดที่แก้ไขได้ เช่น list, dict และ set สามารถเพิ่ม ลบ หรือแก้ไขสมาชิกได้ เมื่อส่ง list เข้าไปในฟังก์ชัน การแก้ไขภายในฟังก์ชันจะกระทบวัตถุเดิมนอกฟังก์ชันด้วย การเข้าใจพฤติกรรมนี้ช่วยให้คาดการณ์ผลลัพธ์ของโค้ดได้แม่นยำและอธิบายให้ผู้สัมภาษณ์ฟังได้อย่างมั่นใจ

Type hints หรือคำอธิบายชนิดข้อมูลช่วยให้โค้ดอ่านง่ายขึ้นและบอกเจตนาของผู้เขียนได้ชัดเจนขึ้น เช่น การเขียน def total(prices: list[float]) -> float: บอกว่าพารามิเตอร์เป็นรายการตัวเลขทศนิยมและค่าที่ส่งกลับเป็นตัวเลขทศนิยม Python ตรวจสอบ type hints แบบไม่บังคับ โดยจะไม่ทำให้โปรแกรมหยุดทำงานเมื่อชนิดไม่ตรง แต่เครื่องมืออย่าง mypy หรือ Pyright ใช้ข้อมูลนี้ในการตรวจจับข้อผิดพลาดก่อนรัน ในระหว่างสัมภาษณ์ การใส่ type hints ที่เหมาะสมแสดงถึงความเป็นมืออาชีพและช่วยให้ผู้สัมภาษณ์เข้าใจโค้ดได้เร็วขึ้น

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

สภาพแวดล้อมและเครื่องมือก็เป็นส่วนหนึ่งของการเตรียมตัวเช่นกัน ผู้เข้าสัมภาษณ์ควรคุ้นเคยกับการรันโค้ดผ่านเทอร์มินัลหรือ IDE และรู้จักใช้ python -m venv เพื่อสร้างสภาพแวดล้อมเสมือน การใช้ debugger หรือการพิมพ์ค่าตัวแปรด้วย print() อย่างตั้งใจช่วยตรวจสอบสมมติฐานได้เร็วขึ้น การฝึกในสภาพแวดล้อมใกล้เคียงกับงานจริง เช่น การติดตั้งแพ็กเกจด้วย pip และการจัดการไฟล์โปรเจกต์ จะลดความกังวลและช่วยให้โฟกัสกับโจทย์ได้มากขึ้น

เคล็ดลับฝึกฝน พื้นฐานของ Python และแนวคิดการสัมภาษณ์: ทบทวนบทเรียนนี้ในเวลาสั้น ๆ ทุกวัน หลังทำแบบฝึกหัดแต่ละข้อให้บอกกฎหรือขั้นตอนที่ใช้ ถ้าบอกไม่ได้ ให้ทบทวนหัวข้อนั้นก่อนไปต่อ ความสม่ำเสมอช่วยจำได้ดีกว่าการอ่านนาน ๆ ครั้งเดียว

โครงสร้างข้อมูลเป็นหัวใจของการแก้โจทย์ Python เพราะโครงสร้างที่เลือกใช้กำหนดทั้งความง่ายในการเขียนและประสิทธิภาพของโปรแกรม โครงสร้างหลักที่ใช้บ่อย ได้แก่ list, tuple, set และ dict ซึ่งแต่ละชนิดมีคุณสมบัติและกรณีการใช้งานที่ต่างกัน การรู้ว่าควรใช้ชนิดใดในสถานการณ์ใดจะช่วยให้โค้ดสั้นลงและเร็วขึ้น

list เป็นลำดับที่แก้ไขได้ ใช้เก็บข้อมูลหลายรายการโดยรักษาลำดับและอนุญาตให้มีค่าซ้ำได้ ส่วน tuple เป็นลำดับที่แก้ไขไม่ได้ มักใช้แทนข้อมูลที่ตายตัว เช่น พิกัด (x, y) หรือค่าที่ไม่ควรเปลี่ยน เมื่อต้องการแปลงระหว่างสองชนิดนี้สามารถใช้ list(tuple_data) หรือ tuple(list_data) ได้โดยตรง

set เก็บสมาชิกที่ไม่ซ้ำกันและไม่มีการเรียงลำดับ ส่วน dict เก็บคู่คีย์กับค่าโดยคีย์ต้องเป็นชนิดที่แก้ไขไม่ได้ และการค้นหาค่าด้วยคีย์มีความเร็วสูงมาก ตัวอย่างเช่น counts[word] = counts.get(word, 0) + 1 ใช้ dict เพื่อนับจำนวนคำได้อย่างกระชับ และ len(set(items)) ใช้หาจำนวนค่าที่ไม่ซ้ำกันได้ทันที

ฟังก์ชัน built-in ช่วยลดโค้ดซ้ำและทำให้อ่านง่าย เช่น len() หาความยาว sorted() เรียงลำดับโดยไม่แก้ข้อมูลต้นฉบับ ส่วน enumerate() ใช้วนลูปพร้อมดัชนี และ zip() ใช้รวมหลายลำดับเข้าด้วยกัน ฟังก์ชัน min() และ max() หาค่าต่ำสุดและสูงสุดได้ทั้งกับข้อมูลหลายตัวหรือ iterable หนึ่งตัว การฝึกใช้ฟังก์ชันเหล่านี้ให้คล่องช่วยให้เขียนคำตอบได้ตรงประเด็นและประหยัดเวลา

การเลือกโครงสร้างข้อมูลควรพิจารณา time complexity หรือความซับซ้อนของเวลาเป็นหลัก เช่น การค้นหาสมาชิกใน list ใช้เวลาเชิงเส้น O(n) แต่การค้นหาใน set หรือคีย์ใน dict ใช้เวลาเฉลี่ยคงที่ O(1) ส่วนการเรียงลำดับด้วย sorted() ใช้เวลา O(n log n) เมื่อต้องการตรวจสอบค่าซ้ำหรือค้นหาอย่างรวดเร็ว ควรเลือก set หรือ dict แทนการไล่ดูทีละตัวด้วยลูปซ้อน เพราะลูปซ้อนอาจทำให้ความซับซ้อนพุ่งขึ้นเป็น O(n^2)

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

ฟังก์ชันใน Python รับพารามิเตอร์ได้หลายรูปแบบ เช่น พารามิเตอร์ตำแหน่ง พารามิเตอร์แบบ keyword และค่าปริยาย เช่น def greet(name, greeting="Hello"): การวางค่าปริยายไว้ด้านหลังและเรียกใช้ด้วยชื่อพารามิเตอร์ช่วยให้โค้ดชัดเจนขึ้น การเข้าใจลำดับการรับค่าและการส่งค่าจะช่วยหลีกเลี่ยงข้อผิดพลาดที่พบได้บ่อยในโจทย์สัมภาษณ์

*args ใช้รวบรวมอาร์กิวเมนต์ตำแหน่งจำนวนไม่จำกัดเป็น tuple ส่วน **kwargs ใช้รวบรวมอาร์กิวเมนต์แบบ keyword เป็น dict ตัวอย่างเช่น def log(message, *args, **kwargs): ช่วยให้ฟังก์ชันยืดหยุ่นต่อการรับข้อมูลเพิ่มเติม และยังใช้ในการส่งต่ออาร์กิวเมนต์ไปยังฟังก์ชันอื่นได้ด้วยเครื่องหมาย * และ ** ในการเรียกใช้

ขอบเขตตัวแปร (scope) กำหนดว่าชื่อใดมองเห็นได้จากจุดใดในโค้ด ตัวแปรที่กำหนดนอกฟังก์ชันเป็น global ส่วนตัวแปรภายในฟังก์ชันเป็น local โดยค่าเริ่มต้น ฟังก์ชันอ่านตัวแปร global ได้แต่ต้องประกาศ global หรือ nonlocal ก่อนจึงจะแก้ไขได้ เมื่อฟังก์ชันภายในอ้างถึงตัวแปรจากฟังก์ชันภายนอกและส่งคืนออกมา จะเกิด closure ซึ่งช่วยเก็บสถานะไว้ใช้ในภายหลัง เช่น ฟังก์ชันนับจำนวนครั้งที่ถูกเรียก

Decorator เป็นฟังก์ชันที่รับฟังก์ชันอื่นเป็นอินพุตและส่งคืนฟังก์ชันใหม่ที่เพิ่มพฤติกรรม เช่น การบันทึกเวลา หรือการตรวจสอบสิทธิ์ ตัวอย่างง่ายๆ คือการใช้ @timer เหนือฟังก์ชันเพื่อวัดเวลารัน ซึ่งเทียบเท่ากับการเขียน func = timer(func) การเข้าใจ decorator แสดงถึงความเข้าใจเรื่องฟังก์ชันที่เป็น first-class objects และช่วยให้เขียนโค้ดที่นำกลับมาใช้ซ้ำได้

Comprehension เป็นรูปแบบกระชับสำหรับสร้างคอลเลกชันใหม่ เช่น [x * x for x in range(10)] สร้าง list {x: len(x) for x in words} สร้าง dict และ {x % 3 for x in nums} สร้าง set โดย comprehension มักอ่านง่ายกว่าและเร็วกว่า loop แบบเดิมเมื่อโค้ดไม่ซับซ้อน แต่ถ้ามีเงื่อนไขหรือ logic หลายชั้น ควรเลือกเขียนเป็นลูปปกติเพื่อให้โค้ดยังคงชัดเจน

Generator สร้างค่าทีละค่าแบบขี้เกียจ (lazy evaluation) โดยใช้คีย์เวิร์ด yield แทน return เช่น def squares(n): จากนั้นในลูปใช้ yield i * i เพื่อผลิตค่าตามต้องการ Generator ไม่เก็บค่าทั้งหมดไว้ในหน่วยความจำ จึงเหมาะกับข้อมูลขนาดใหญ่หรือลำดับอนันต์ แต่ข้อเสียคือวนซ้ำได้เพียงครั้งเดียวและไม่รองรับการเข้าถึงแบบดัชนี การเลือกใช้ generator เมื่อไม่ต้องการเก็บผลลัพธ์ทั้งหมดในครั้งเดียวเป็นจุดที่ควรพูดถึงในการสัมภาษณ์

เคล็ดลับฝึกฝน ฟังก์ชัน คอมปรีเฮนชัน และเจเนอเรเตอร์: ทบทวนบทเรียนนี้ในเวลาสั้น ๆ ทุกวัน หลังทำแบบฝึกหัดแต่ละข้อให้บอกกฎหรือขั้นตอนที่ใช้ ถ้าบอกไม่ได้ ให้ทบทวนหัวข้อนั้นก่อนไปต่อ ความสม่ำเสมอช่วยจำได้ดีกว่าการอ่านนาน ๆ ครั้งเดียว

คลาสใน Python ใช้ class เพื่อรวมข้อมูลและพฤติกรรมไว้ด้วยกัน โดย __init__ เป็นเมธอดพิเศษที่ใช้กำหนดค่าเริ่มต้นให้กับวัตถุ และ self หมายถึงตัววัตถุเอง ตัวอย่างเช่น class BankAccount: ที่มีแอตทริบิวต์ balance และเมธอด deposit() ช่วยให้เขียนโค้ดที่สะท้อนแนวคิดของโดเมนได้ชัดเจนขึ้น แอตทริบิวต์ของคลาสใช้ร่วมกันทุก instance ส่วนแอตทริบิวต์ของ instance ถูกสร้างใน __init__

Inheritance ช่วยให้คลาสย่อยสืบทอดเมธอดและแอตทริบิวต์จากคลาสแม่ แล้วปรับแต่งเพิ่มเติมได้ เช่น class SavingsAccount(BankAccount): ส่วน polymorphism ทำให้วัตถุต่างชนิดกันตอบสนองต่อการเรียกเมธอดชื่อเดียวกันได้ตามพฤติกรรมของตัวเอง เช่น เรียก area() กับรูปทรงต่างกันแล้วได้ผลลัพธ์ต่างกัน การออกแบบด้วยการสืบทอดและ polymorphism ช่วยลดโค้ดซ้ำและทำให้ระบบขยายได้ง่าย

Dunder methods หรือ magic methods เป็นเมธอดที่ขึ้นต้นและลงท้ายด้วย __ ใช้กำหนดพฤติกรรมของวัตถุกับตัวดำเนินการและฟังก์ชัน built-in เช่น __str__ สำหรับการแสดงผลด้วย str(), __eq__ สำหรับ ==, และ __len__ สำหรับ len() การ implement dunder methods ที่เหมาะสมช่วยให้วัตถุทำงานเหมือนชนิดข้อมูลมาตรฐานและทำให้โค้ดอ่านง่ายขึ้น

การจัดการข้อผิดพลาดใน Python ใช้บล็อก try เพื่อรันโค้ดที่อาจผิดพลาด และ except เพื่อจัดการข้อยกเว้น ส่วน else จะทำงานเมื่อไม่มีข้อยกเว้นเกิดขึ้น และ finally จะทำงานเสมอแม้มีหรือไม่มีข้อผิดพลาด เช่น การปิดไฟล์ใน finally ควรจับข้อยกเว้นเฉพาะประเภท เช่น except ValueError แทนการจับทุกอย่างด้วย except Exception เพราะการซ่อนข้อผิดพลาดทำให้ดีบั๊กยาก

การสร้างข้อผิดพลาดใช้คีย์เวิร์ด raise เช่น raise ValueError("amount must be positive") เพื่อหยุดการทำงานเมื่อข้อมูลไม่ถูกต้อง และสามารถสร้าง custom exception โดยสืบทอดจาก Exception เช่น class InsufficientFundsError(Exception): ข้อยกเว้นที่ออกแบบดีจะช่วยให้ผู้เรียกใช้ฟังก์ชันรู้สาเหตุที่ชัดเจนและเลือกจัดการได้ตรงจุด ในการสัมภาษณ์ ควรอธิบายว่าข้อยกเว้นใดควรจับที่ขอบเขตใด และข้อมูลอะไรที่ควรใส่ในข้อความแสดงข้อผิดพลาด

เคล็ดลับฝึกฝน OOP และการจัดการข้อยกเว้นในการสัมภาษณ์: ทบทวนบทเรียนนี้ในเวลาสั้น ๆ ทุกวัน หลังทำแบบฝึกหัดแต่ละข้อให้บอกกฎหรือขั้นตอนที่ใช้ ถ้าบอกไม่ได้ ให้ทบทวนหัวข้อนั้นก่อนไปต่อ ความสม่ำเสมอช่วยจำได้ดีกว่าการอ่านนาน ๆ ครั้งเดียว

การวิเคราะห์ความซับซ้อนเป็นพื้นฐานของการออกแบบอัลกอริทึมที่ผู้สัมภาษณ์คาดหวังให้พูดถึงทุกครั้ง Big O ใช้อธิบายว่าจำนวนการทำงานเพิ่มขึ้นตามขนาดอินพุตอย่างไร เช่น การวนลูปเดียวคือ O(n) ลูปซ้อนคือ O(n^2) และการค้นหาแบบ binary search คือ O(log n) นอกเหนือจากเวลา ควรพิจารณา space complexity ด้วย เพราะโครงสร้างข้อมูลเสริมอาจกินหน่วยความจำมาก

Two pointers เป็นเทคนิคที่ใช้ตัวชี้สองตัวเดินบน array หรือ string เพื่อลดจำนวนการเปรียบเทียบ เช่น การหา palindrome หรือการตรวจสอบคู่ผลรวมใน array ที่เรียงลำดับแล้ว ส่วน hashing ใช้ dict หรือ set เก็บข้อมูลที่เห็นก่อนหน้าเพื่อให้ค้นหาได้เร็ว เช่น seen = set() และตรวจสอบค่าที่ต้องการในเวลา O(1) ทั้งสองเทคนิคช่วยเปลี่ยนแนวคิดลูปซ้อนให้มีประสิทธิภาพมากขึ้น

Sliding window ใช้สำหรับปัญหาที่ต้องการพิจารณาช่วงย่อยต่อเนื่อง เช่น ผลรวมหรือความยาวของ subarray ที่ตรงเงื่อนไข โดยเลื่อนจุดเริ่มต้นและจุดสิ้นสุดของหน้าต่างแทนการสร้างช่วงใหม่ทุกครั้ง ส่วนการเรียงลำดับด้วย sorted() ช่วยทำให้ข้อมูลอยู่ในลำดับที่ค้นหาและเปรียบเทียบได้ง่าย เช่น การหา element ที่ซ้ำหรือคู่ผลรวม การจำรูปแบบเหล่านี้ให้ได้จะช่วยให้เลือกแนวทางที่ถูกต้องได้เร็วขึ้น

Recursion คือการที่ฟังก์ชันเรียกตัวเองเพื่อแก้ปัญหาย่อย เช่น การคำนวณ factorial หรือการท่องต้นไม้ การออกแบบ recursion ที่ดีต้องมี base case ที่หยุดการเรียกซ้ำและ recursive case ที่ลดขนาดปัญหาในแต่ละรอบ การแปลง recursion เป็น iterative ด้วย stack ก็เป็นทักษะที่ควรฝึก เพราะช่วยหลีกเลี่ยงปัญหา stack overflow เมื่อข้อมูลมีขนาดใหญ่

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

การทำงานแบบทำซ้ำได้จะช่วยให้การสัมภาษณ์สม่ำเสมอ เช่น กระบวนการ solve-explain-refine ที่เริ่มจากทำความเข้าใจโจทย์และยกตัวอย่าง ออกแบบวิธีแก้แบบ brute force ก่อน แล้วจึงปรับปรุงให้ดีขึ้นและอธิบายการแลกเปลี่ยนระหว่างเวลาและหน่วยความจำ เมื่อได้คำตอบแล้วให้ทดสอบกับ edge cases และสรุปความซับซ้อนอย่างกระชับ การฝึกกระบวนการนี้ซ้ำๆ จะเปลี่ยนจากความกังวลให้เป็นความมั่นใจเมื่อเจอโจทย์ใหม่

เคล็ดลับฝึกฝน อัลกอริทึม ความซับซ้อน และกลยุทธ์การสัมภาษณ์: ทบทวนบทเรียนนี้ในเวลาสั้น ๆ ทุกวัน หลังทำแบบฝึกหัดแต่ละข้อให้บอกกฎหรือขั้นตอนที่ใช้ ถ้าบอกไม่ได้ ให้ทบทวนหัวข้อนั้นก่อนไปต่อ ความสม่ำเสมอช่วยจำได้ดีกว่าการอ่านนาน ๆ ครั้งเดียว