โลกแห่งการเขียนโปรแกรม Python

Python: นำเข้าโมดูลด้วยพาธสัมพัทธ์ + วิธีแก้ข้อผิดพลาด

ไลบรารีภายนอก, API และการสื่อสาร
目次

1. ภาพรวมของคำสั่ง import และการนำเข้าแบบเส้นทางสัมพัทธ์ใน Python

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

การนำเข้าแบบเส้นทางสัมพัทธ์คืออะไร?

การนำเข้าแบบเส้นทางสัมพัทธ์คือวิธีการนำเข้าโมดูลอื่นโดยอ้างอิงจากตำแหน่งของโมดูลปัจจุบัน โดยเฉพาะอย่างยิ่ง มีประโยชน์ในโปรเจกต์ขนาดใหญ่หรือการพัฒนาแพ็กเกจที่มีหลายโมดูล การใช้การนำเข้าแบบเส้นทางสัมพัทธ์ช่วยทำให้ความสัมพันธ์การพึ่งพาระหว่างโมดูลชัดเจนขึ้น และทำให้การบำรุงรักษาโปรเจกต์ทำได้ง่ายขึ้น ตัวอย่างเช่น สมมติว่ามีโครงสร้างไดเรกทอรีดังนี้
project/
    ├── main.py
    ├── package/
    │   ├── module_a.py
    │   └── sub_package/
    │       └── module_b.py
หากต้องการนำเข้า module_a.py จาก module_b.py ด้วยเส้นทางสัมพัทธ์ ให้เขียนดังนี้
from ..module_a import some_function
ด้วยวิธีนี้ การใช้เส้นทางสัมพัทธ์ทำให้สามารถนำเข้าโมดูลได้อย่างยืดหยุ่นตามโครงสร้างลำดับชั้นของไดเรกทอรี

2. ความแตกต่างระหว่างพาธสัมพัทธ์กับพาธสัมบูรณ์

ในภาษา Python คำสั่ง import มีอยู่ 2 แบบ คือพาธสัมพัทธ์และพาธสัมบูรณ์ ทั้งสองแบบแตกต่างกันที่วิธีระบุโมดูลที่จะนำเข้า

การนำเข้าแบบพาธสัมบูรณ์

การนำเข้าแบบพาธสัมบูรณ์คือวิธีที่เริ่มจากรูทไดเรกทอรีของโปรเจ็กต์เพื่อระบุโมดูลที่จะนำเข้า ตัวอย่างเช่น สำหรับโปรเจ็กต์ที่มีโครงสร้างดังต่อไปนี้ หากต้องการนำเข้า module_a.py จาก main.py ด้วยพาธสัมบูรณ์ จะเขียนได้ดังนี้
from package.module_a import some_function
วิธีนี้สะดวกเมื่อโครงสร้างโดยรวมของโปรเจ็กต์ชัดเจนและตำแหน่งของโมดูลมีความสม่ำเสมอ

การนำเข้าแบบพาธสัมพัทธ์

ในทางกลับกัน การนำเข้าแบบพาธสัมพัทธ์จะอิงตำแหน่งของโมดูลปัจจุบันในการนำเข้าโมดูลอื่น การนำเข้าแบบพาธสัมพัทธ์ค่อนข้างยืดหยุ่น โดยเฉพาะเมื่อโครงสร้างของโปรเจ็กต์มีการเปลี่ยนแปลง ซึ่งช่วยคงความสัมพันธ์การพึ่งพาระหว่างโมดูลไว้ พร้อมทั้งเพิ่มความสามารถในการนำโค้ดกลับมาใช้ซ้ำได้ ตัวอย่างเช่น โค้ดด้านล่างเป็นตัวอย่างของการนำเข้าโมดูลที่อยู่ในไดเรกทอรีที่สูงขึ้นไปหนึ่งระดับจากโมดูลปัจจุบัน
from ..module_a import some_function
การเลือกใช้แบบใดขึ้นอยู่กับขนาดและความซับซ้อนของโปรเจ็กต์ แต่โดยทั่วไป หากตำแหน่งของโมดูลคงที่ให้ใช้พาธสัมบูรณ์ หากมีการเปลี่ยนแปลงบ่อยให้ใช้พาธสัมพัทธ์จะเหมาะสมกว่า
侍エンジニア塾

3. วิธีการนำเข้าโดยใช้พาธสัมพัทธ์

นำเข้าโมดูลจากไดเรกทอรีเดียวกัน

เมื่อต้องการนำเข้าโมดูลที่อยู่ในไดเรกทอรีเดียวกัน ไม่จำเป็นต้องระบุอะไรที่ซับซ้อน เพียงระบุชื่อโมดูลเท่านั้น ตัวอย่างเช่น หาก module_a.py และ module_b.py อยู่ในไดเรกทอรีเดียวกัน คุณสามารถนำเข้าได้ดังนี้
import module_a
และหากต้องการนำเข้าฟังก์ชันหรือคลาสเฉพาะ ให้ทำดังนี้
from module_a import some_function

การนำเข้าจากไดเรกทอรีระดับบน

หากต้องการนำเข้าโมดูลที่อยู่ในไดเรกทอรีระดับบน ให้ใช้ .. เพื่อย้อนกลับไปยังระดับที่สูงกว่า แล้วระบุโมดูลต่อไป ตัวอย่างเช่น เมื่อนำเข้าจากไดเรกทอรีที่อยู่เหนือขึ้นไปหนึ่งระดับ เขียนได้ดังนี้
from ..module_a import some_function

การนำเข้าจากไดเรกทอรีย่อย

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

4. การนำเข้าโมดูลภายในแพ็กเกจ

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

โครงสร้างของแพ็กเกจและไฟล์__init__.py

เมื่อสร้างแพ็กเกจ จำเป็นต้องเพิ่มไฟล์ชื่อ __init__.py ไว้ในไดเรกทอรีนั้น ไฟล์นี้มีหน้าที่ทำให้ Python รับรู้ว่าไดเรกทอรีนั้นเป็น “แพ็กเกจ” ต่อไปจะอธิบายโดยยกตัวอย่างโปรเจ็กต์ที่มีโครงสร้างดังนี้
project/
    ├── main.py
    ├── package/
    │   ├── __init__.py
    │   ├── module_a.py
    │   └── sub_package/
    │       ├── __init__.py
    │       └── module_b.py

การนำเข้าโมดูลภายในแพ็กเกจด้วยพาธสัมพัทธ์

ตัวอย่างเช่น หากต้องการนำเข้า module_a.py จาก module_b.py ด้วยพาธสัมพัทธ์ สามารถเขียนได้ดังนี้
from ..module_a import some_function
.. นี้หมายถึงการเลื่อนไปยังไดเรกทอรีที่อยู่เหนือขึ้นไปหนึ่งระดับจากไดเรกทอรีปัจจุบัน ด้วยวิธีนี้ คุณสามารถแชร์ฟังก์ชันหรือคลาสระหว่างโมดูลภายในแพ็กเกจได้ นอกจากนี้ เมื่อต้องการนำเข้าโมดูลภายในแพ็กเกจเดียวกันด้วยพาธสัมพัทธ์ ก็สามารถระบุได้อย่างง่ายดายด้วยจุด
from .module_a import some_function
ด้วยวิธีนี้ โมดูลต่างๆ ในโปรเจ็กต์สามารถทำงานร่วมกันได้อย่างเรียบง่าย และต่อให้โครงสร้างไดเรกทอรีเปลี่ยนไป ก็ไม่จำเป็นต้องแก้ไขโค้ดมากนัก
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

5. ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

ในการนำเข้าโมดูลด้วยพาธสัมพัทธ์ของ Python อาจเกิดข้อผิดพลาดที่พบได้บ่อยหลายอย่าง ในส่วนนี้จะอธิบายข้อผิดพลาดเหล่านั้นและวิธีการแก้ไข

ImportError: attempted relative import with no known parent package

ข้อผิดพลาดนี้เป็นข้อผิดพลาดที่พบได้ทั่วไปเมื่อพยายามนำเข้าโมดูลด้วยพาธสัมพัทธ์ โดยเฉพาะอย่างยิ่งเมื่อสคริปต์ถูกเรียกใช้งานโดยตรง ตัวอย่างเช่น โค้ดต่อไปนี้อาจก่อให้เกิดปัญหา
from ..module_a import some_function
ข้อผิดพลาดนี้เกิดขึ้นเพราะ Python ไม่สามารถรับรู้แพ็กเกจแม่ของสคริปต์ได้ ใน Python จำเป็นต้องสามารถระบุได้อย่างชัดเจนว่าโมดูลเป็นส่วนหนึ่งของแพ็กเกจ เมื่อรันสคริปต์โดยตรง การใช้พาธสัมพัทธ์มีโอกาสทำให้เกิดข้อผิดพลาดสูงขึ้น

วิธีแก้ไข

วิธีหนึ่งในการหลีกเลี่ยงปัญหานี้คือกำหนดเส้นทางการค้นหาโมดูลให้ชัดเจนด้วย sys.path ตัวอย่างเช่น ใช้ sys.path.append() เพื่อเพิ่มไดเรกทอรีแม่เข้าไปในเส้นทางการค้นหา
import sys
sys.path.append('..')
from module_a import some_function
วิธีนี้ทำให้ Python สามารถค้นหาโมดูลได้อย่างถูกต้อง

ModuleNotFoundError

อีกข้อผิดพลาดหนึ่งที่พบบ่อยคือ ModuleNotFoundError ซึ่งเกิดขึ้นเมื่อไม่พบโมดูลที่ระบุ เมื่อพยายามนำเข้าโมดูลด้วยพาธสัมพัทธ์ อาจเกิดจากตำแหน่งของโมดูลไม่ถูกต้อง หรือ sys.path ถูกตั้งค่าไม่ถูกต้อง

วิธีแก้ไข

วิธีแก้ปัญหาคือทบทวนคำสั่ง import และตรวจสอบว่าโมดูลมีอยู่จริง นอกจากนี้ คุณสามารถหลีกเลี่ยงข้อผิดพลาดได้โดยระบุไดเรกทอรีที่ Python ควรค้นหาโมดูลอย่างชัดเจนด้วย sys.path.append()

6. ตัวอย่างการใช้งานจริงและการประยุกต์ใช้

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

ตัวอย่าง: การนำเข้าจากไดเรกทอรีชั้นบน

สมมติว่าโครงสร้างโปรเจ็กต์เป็นดังนี้
project/
    ├── main.py
    ├── package/
    │   ├── module_a.py
    │   └── sub_package/
    │       └── module_b.py
โค้ดต่อไปนี้จะแสดงวิธีนำเข้าฟังก์ชัน some_function จาก module_a.py ภายใน module_b.py:
# module_b.py
from ..module_a import some_function

def use_function():
    some_function()
ในโค้ดนี้ เราใช้ .. เพื่อย้อนกลับไปยังไดเรกทอรีชั้นบนหนึ่งระดับ แล้วนำเข้าฟังก์ชันจาก module_a วิธีนี้มีประโยชน์เมื่อต้องการแชร์ฟังก์ชันหรือคลาสระหว่างโมดูลที่อยู่ข้ามหลายไดเรกทอรี

ตัวอย่าง: การนำเข้าโมดูลโดยใช้ sys.path

ต่อไปนี้เป็นตัวอย่างการใช้ sys.path.append() เพื่อนำเข้าโมดูลจากไดเรกทอรีแม่
# module_b.py
import sys
sys.path.append('..')
from module_a import some_function

def use_function():
    some_function()
ด้วยวิธีนี้ เมื่อเราเพิ่มไดเรกทอรีแม่ลงใน sys.path Python จะสามารถค้นหา module_a ได้อย่างถูกต้อง แนวทางนี้มีประโยชน์เป็นพิเศษเมื่อรันสคริปต์โดยตรง

7. สรุป

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