Python นำเข้าจากไดเร็กทอรีหลัก: คู่มือฉบับย่อ

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

หากต้องการนำเข้าจากไดเร็กทอรีหลักใน Python คุณสามารถใช้โมดูลsys โดยการแทรกไดเร็กทอรีที่จำเป็นลงในรายการ sys.path คุณจัดเตรียมตำแหน่งของโมดูลที่ต้องการให้กับล่าม หลังจากแก้ไข sys.path แล้ว คุณสามารถอิมพอร์ตโมดูลเป้าหมายได้โดยใช้คำสั่งอิมพอร์ตมาตรฐาน

ในบทความนี้ เราจะมาดูกันว่าคุณสามารถนำเข้าจากไดเร็กทอรีหลักใน Python ได้อย่างไร นอกจากนี้ เราจะพิจารณากรณีการใช้งานเฉพาะของการนำเข้า ซึ่งจะช่วยให้คุณเข้าใจโครงสร้างพื้นฐานของไดเร็กทอรีได้ดียิ่งขึ้น

เข้าเรื่องกันเลย!

สารบัญ

• วิธีการนำเข้าใน Python
  • Python Import System คืออะไร?
  • สาธิตการนำเข้าจาก Parent Directory
    • 1. การสร้างไดเร็กทอรีและไฟล์ที่จำเป็น
    • 2. การเพิ่มไฟล์ Python
    • 3. แก้ไขไฟล์ Python
    • 4. การรันโค้ด
  • วิธีจัดการ ImportError และ ModuleNotFoundError ใน Python
• โครงสร้างไดเร็กทอรี Python
  • โครงสร้างบรรจุภัณฑ์
  • ไฟล์ init.py คืออะไร
• เส้นทางการค้นหา Python
  • 1. sys.path List ใน Python คืออะไร?
  • 2. PythonPath Environment Variables คืออะไร?
• การนำเข้าไดเร็กทอรีหลัก
  • 1. การนำเข้าที่เกี่ยวข้อง
  • 2. การปรับ sys.path
• วิธีการทำงานกับโมดูลและแพ็คเกจ
  • 1. เนมสเปซคืออะไร?
  • 2. ตัวแปรและคำจำกัดความคืออะไร?
  • 3. คำสั่งนำเข้าคืออะไร?
• ความคิดสุดท้าย

วิธีการนำเข้าใน Python

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

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

Python Import System คืออะไร?

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

หากต้องการนำเข้าโมดูลหรือแพ็คเกจใน Python คุณสามารถใช้คำสั่งนำเข้า โมดูลถูกแจกจ่ายเป็นแพ็คเกจ ซึ่งเป็นไดเร็กทอรีที่มีคอลเล็กชันของไฟล์ Python

หากต้องการนำเข้าโมดูลจากไดเร็กทอรีหลัก คุณสามารถใช้ โมดูล sys.pathเพื่อเพิ่มไดเร็กทอรีหลักไปยังพาธของ Python หลังจากเพิ่มไดเร็กทอรีหลัก คุณสามารถอิมพอร์ตโมดูลโดยใช้คำสั่งอิมพอร์ต

สาธิตการนำเข้าจาก Parent Directory

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

1. การสร้างไดเร็กทอรีและไฟล์ที่จำเป็น

ขั้นแรก ให้เปิดตัวสำรวจไฟล์และไปที่ไดรฟ์ในเครื่องที่คุณต้องการ ฉันใช้ไดรฟ์ E ในเครื่อง ดังนั้นฉันจะสร้างไดเร็กทอรีใหม่ชื่อmy_project

ภายในmy_projectให้สร้างไดเร็กทอรีอื่นชื่อmodule_dir

ตอนนี้คุณควรมี:

E:
|-- /my_project
    |-- /module_dir

2. การเพิ่มไฟล์ Python

จากนั้น สร้าง ไฟล์ .py ใหม่ ชื่อmain.pyในไดเร็กทอรีmy_project

หลังจากนั้น สร้างไฟล์ Python อีกไฟล์ชื่อmy_module.pyในmodule_dir

โครงสร้างของคุณควรมีลักษณะดังนี้:

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

หากคุณใช้Visual Studio Codeโครงสร้างไดเร็กทอรีของคุณควรมีลักษณะดังนี้:

3. แก้ไขไฟล์ Python

เปิดmy_module.py ของคุณ และเพิ่มรหัสต่อไปนี้:

def my_function():
    print("Hello from my_module!")

จากนั้นดำเนินการต่อและบันทึกและปิดไฟล์

ตอนนี้เปิดmain.pyและเพิ่มรหัสต่อไปนี้:

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import the module from the parent directory
from module_dir import my_module

# Use a function from my_module
my_module.my_function()

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

หลังจากนั้น เราจะนำเข้าโมดูลชื่อmy_moduleซึ่งอยู่ในไดเร็กทอรีชื่อmodule_dirซึ่งอยู่ในไดเร็กทอรีหลักนี้ สุดท้าย เรากำลังเรียกใช้ฟังก์ชันชื่อmy_functionจากmy_module

หลังจากเพิ่มโค้ดข้างต้นแล้ว ให้บันทึกและปิดไฟล์

4. การรันโค้ด

ในการรันโค้ดนี้ ให้เปิดเทอร์มินัลของโปรแกรมแก้ไขโค้ดที่คุณต้องการ แล้วรันไฟล์main.py หากคุณใช้ Visual Studio Code ผลลัพธ์ควรมีลักษณะดังนี้:

main.py จะนำเข้าฟังก์ชันจากmy_module.py ดัง ที่แสดงในภาพด้านบน

ตัวอย่างนี้แสดงรายละเอียดว่าระบบไฟล์และการนำเข้าจากไดเร็กทอรีหลักทำงานอย่างไรใน Python

วิธีจัดการ ImportError และ ModuleNotFoundError ใน Python

Python จะเพิ่ม ข้อยกเว้น ImportErrorเมื่อไม่พบโมดูลที่คุณพยายามนำเข้าในระหว่างกระบวนการนำเข้า

ImportErrorเป็นคลาสย่อยของข้อยกเว้นModuleNotFoundError มันถูกยกขึ้นเมื่อไม่มีโมดูลที่นำเข้าหรือไม่สามารถโหลดได้

ต่อไปนี้คือตัวอย่างสถานการณ์ที่อาจเกิดขึ้น:

• โมดูลหรือแพ็คเกจไม่ได้อยู่ในsys.path

• ชื่อโมดูลหรือแพ็คเกจสะกดผิดหรือไม่มีอยู่

• มีปัญหากับโค้ดของโมดูล ทำให้ไม่สามารถนำเข้าได้อย่างถูกต้อง

เมื่อพบข้อผิดพลาดเหล่านี้ คุณสามารถใช้วิธีแก้ปัญหาต่อไปนี้:

• ตรวจสอบการสะกดและการมีอยู่ของโมดูลหรือแพ็คเกจอีกครั้ง

• การเพิ่มไดเร็กทอรีที่จำเป็นไปยังsys.pathโดยใช้append()หรือinsert( )

• แก้ไขปัญหาใดๆ ในโค้ดของโมดูลที่อาจขัดขวางการนำเข้า

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการจัดการข้อผิดพลาดใน Python โปรดดูวิดีโอต่อไปนี้:

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

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

โครงสร้างไดเร็กทอรี Python

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

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

โครงสร้างบรรจุภัณฑ์

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

ต่อไปนี้เป็นโครงสร้างไดเร็กทอรีโครงการ Python ทั่วไป:

project/
?
??? package1/
?   ??? __init__.py
?   ??? module1.py
?   ??? module2.py
?
??? package2/
?   ??? __init__.py
?   ??? module3.py
?   ??? module4.py
?
??? main.py

ในตัวอย่างข้างต้นโปรเจ็กต์คือไดเร็กทอรีรากที่มีแพ็กเกจย่อย 2 แพ็กเกจได้แก่package1และpackage2 แต่ละแพ็คเกจมี ไฟล์ .pyและไฟล์init.py ที่ไม่ซ้ำกัน

ไฟล์ init.py คืออะไร

ไฟล์ init.pyมีความสำคัญต่อการกำหนดพฤติกรรมของแพ็คเกจเมื่อมีการนำเข้า ไฟล์เหล่านี้จะถูกเรียกใช้งานเมื่ออิมพอร์ตแพ็คเกจพาเรนต์

ไฟล์init.pyสามารถว่างเปล่าหรือมีรหัสเริ่มต้น พวกเขายังระบุให้ Python ทราบว่าโฟลเดอร์ควรได้รับการปฏิบัติเหมือนเป็นแพ็คเกจ

หากต้องการนำเข้าโมดูลจากไดเร็กทอรีหลัก คุณสามารถใช้เมธอดsys.path คุณจะต้องเพิ่มพาธไดเร็กทอรีพาเรนต์ต่อท้ายsys.path

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

E:
|-- /my_project
    |-- main.py
    |-- /module_dir
        |-- my_module.py

ตอนนี้ มาเพิ่ม ไฟล์ init.pyไปที่ไดเร็กทอรีmy_module คุณสามารถปล่อยไฟล์นี้ว่างไว้ก่อนได้ การมีอยู่ของมันบ่งชี้ให้ Python ทราบว่าไดเร็กทอรีนี้ควรได้รับการปฏิบัติเหมือนเป็นแพ็คเกจ

โครงสร้างไดเร็กทอรีของคุณควรมีลักษณะดังนี้:

หลังจากเพิ่ม ไฟล์ init.pyคุณต้องทำการเปลี่ยนแปลง ไฟล์ main.pyเพื่อสั่งให้ถือว่า โฟลเดอร์ module_dirเป็นแพ็คเกจ ไฟล์ main.pyของคุณควรมีรหัสต่อไปนี้:

import sys
import os

# Get the parent directory
parent_dir = os.path.dirname(os.path.realpath(__file__))

# Add the parent directory to sys.path
sys.path.append(parent_dir)

# Import my_module from the package module_dir
import module_dir

# Call my_function from my_module
my_module.my_function()

ในตัวอย่างนี้main.pyนำเข้า แพ็คเกจ module_dirแล้วเรียกใช้ฟังก์ชันmy_function()จาก my_module ภายในแพ็คเกจนั้น

สังเกตการเปลี่ยนแปลงในการเรียกใช้my_function ; เนื่องจากตอนนี้เรากำลังปฏิบัติต่อmodule_dirเป็นแพ็คเกจ เราจึงต้องรวมชื่อแพ็คเกจเมื่อเรียกใช้ฟังก์ชันจากโมดูลภายในแพ็คเกจ

ผลลัพธ์จะคล้ายกับก่อนหน้านี้ การเปลี่ยนแปลงเดียวที่เราทำคือปฏิบัติต่อmodule_dirเป็นแพ็คเกจที่รวมไฟล์init.py

เส้นทางการค้นหา Python

เคยสงสัยไหมว่า Python รู้ได้อย่างไรว่าจะหาโมดูลที่คุณพยายามนำเข้าได้จากที่ใด หรือบางทีคุณอาจพบ 'ModuleNotFoundError' ที่น่ารำคาญและหาสาเหตุไม่ได้

ในส่วนนี้ เราจะจัดการกับความลึกลับเหล่านี้แบบตัวต่อตัวและเจาะลึกแนวคิดของเส้นทางการค้นหา Python

เส้นทางการค้นหาของ Python หรือที่เรียกว่าsys.pathเป็นแผนงานเล็กๆ ของ Python ในการค้นหาโมดูลทั้งหมดที่คุณต้องการ เช่นเดียวกับหน่วยสอดแนมที่ขยันขันแข็ง Python ใช้เส้นทางนี้เพื่อค้นหาโมดูลในคอมพิวเตอร์ของคุณเมื่อใดก็ตามที่คุณใช้คำสั่งนำเข้า

Understanding how it works can save you from headaches and help you troubleshoot when things go awry, so let’s go over some basics!

1. What is the sys.path List in Python?

The sys.path list is a crucial component when importing modules in a directory. It’s a list of strings that represents the module search path.

Each string in the list is a directory location where Python looks for modules (*.py files) or packages (folders containing init.py files).

The following example shows you how to view your current sys.path list:

import sys

for path in sys.path:
    print(path)

After running the above code, you’ll see an output like the following:

You can also add new directories to the sys.path list so that Python finds your custom modules.

For instance:

import sys
sys.path.append('/path/to/new/module/directory')

2. What are PythonPath Environment Variables?

Another way you can manage the module search path is by using the PYTHONPATH environment variable.

PYTHON PATH is a string containing a list of directories that is appended to the default sys.path list. This means you can add directories to PYTHONPATH. This allows Python to search for modules in those directories when importing.

Setting the PYTHONPATH environment variable depends on your operating system:

• Unix-based systems (Linux, macOS): You can use the export command in your terminal or add the following line to your shell configuration file (.bashrc, .zshrc or similar):

  export PYTHONPATH="/path/to/module/directory1:/path/to/module/directory2"

• Windows OS: Go to System Properties > Environment Variables, and under User variables, click New to create a new variable with the name: “PYTHONPATH” and the value as a list of directory paths separated by a semi-colon (;).

  C:pathtomoduledirectory1;C:pathtomoduledirectory2
  

Once the path variable is set, you can run your Python script. It will search for imported modules in those directories as well as the default ones in sys.path.

When organizing your code into files and folders, you’ll frequently come across relative imports and adjusting sys.path.

In the next section, we’ll explore both and see how they fit into the framework for Python imports.

Parent Directory Imports

You can organize code into different folders and files to improve both readability and maintainability. However, importing modules from parent directories can be a bit tricky.

In this section, we’ll discuss two approaches to achieve this:

1. Relative Imports

2. Adjusting sys.path

1. Relative Imports

Relative imports allow you to import modules based on their relative position in the directory hierarchy.

You can use the dot (.) notation to refer to the current directory or double dot (..) notation to refer to the parent directory.

Suppose you have a directory structure like the following:

parent_directory/
?
??? module_a.py
?
??? sibling_directory/
    ??? module_b.py

Inside module_b.py, you can use relative imports to access module_a.py:

from .. import module_a

The double dot refers to the parent directory. It is important to note that relative imports only work if the parent directory is a package (has an init.py file).

2. Adjusting sys.path

You can also import modules from a parent directory by modifying the sys.path.

ก่อน คำ สั่งอิมพอร์ตคุณสามารถผนวกพาธไดเร็กทอรีพาเรนต์เข้ากับsys.path ก่อนอื่น คุณต้องนำเข้าโมดูลsys จากนั้น คุณใช้ โมดูล osเพื่อรับพาธไดเร็กทอรีพาเรนต์

สมมติว่าคุณมีโครงสร้างไดเร็กทอรีดังต่อไปนี้:

project_root/
?
??? parent_directory/
?   ??? module_a.py
?
??? current_directory/
    ??? module_b.py

ในmodule_b.pyคุณสามารถผนวกพาธไดเร็กทอรีพาเรนต์เข้ากับsys.pathได้ดังนี้:

import os
import sys

parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)

import module_a

ตอน นี้Python จะค้นหาmodule_a.pyในไดเร็กทอรีหลักเมื่อนำเข้าในmodule_b.py

คุณสามารถใช้วิธีนำเข้าแบบสัมพัทธ์หรือ วิธี sys.pathเพื่อนำเข้าโมดูลจากไดเร็กทอรีหลัก

วิธีการทำงานกับโมดูลและแพ็คเกจ

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

ส่วน นี้จะกล่าวถึงวิธีการทำงานกับโมดูลและแพ็คเกจในPython นอกจากนี้ เราจะรวมแนวคิดหลัก เช่น:

1. เนมสเปซ

2. ตัวแปรและคำจำกัดความ

3. งบนำเข้า

1. เนมสเปซคืออะไร?

เนมสเปซใน Python เป็นวิธีที่ช่วยให้แน่ใจว่าชื่อของตัวแปร ฟังก์ชัน และคลาสไม่ขัดแย้งกันระหว่างโมดูลต่างๆ

เนมสเปซใน Python มีหลายระดับ เช่น:

• Global Namespace:หมายถึงเนมสเปซของโมดูลทั้งหมด

• Local Namespace:หมายถึงเนมสเปซภายในฟังก์ชันหรือคลาส

คุณสามารถรับชื่อในเนมสเปซเฉพาะได้ด้วยสัญกรณ์เนมสเปซ [ชื่อ]

2. ตัวแปรและคำจำกัดความคืออะไร?

ในสคริปต์ Python คุณสามารถกำหนดตัวแปรฟังก์ชันและคลาสได้ คำจำกัดความเหล่านี้ถูกเก็บไว้ในเนมสเปซของสคริปต์

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

ต่อไปนี้คือตัวอย่างการกำหนดตัวแปรและฟังก์ชันในเนมสเปซเดียวกัน:

# my_variable.py
my_variable = 5

def my_function(x):
    return x + my_variable

โมดูลนี้มีตัวแปรmy_variableและฟังก์ชันmy_function

ในการรันโค้ดนี้ คุณสามารถสร้างไฟล์ใหม่ชื่อmy_variable.pyและใส่โค้ดตามที่แสดงด้านล่าง:

ตอนนี้ คุณสามารถนำเข้าไฟล์นี้และใช้ในสคริปต์อื่นได้ดังที่แสดงด้านล่าง:

หลังจากเรียกใช้ ไฟล์ main.pyคุณจะได้ผลลัพธ์ที่คล้ายกับต่อไปนี้:

3. คำสั่งนำเข้าคืออะไร?

คุณสามารถนำเข้าไฟล์ โมดูล หรือแพ็คเกจใน Python ด้วยคำสั่งนำเข้า

วิธีการนำเข้าทั่วไปบางวิธีคือ:

• import module_name : เมธอดนี้นำเข้าโมดูล ทำให้เข้าถึงคำจำกัดความทั้งหมดได้ด้วยสัญกรณ์module_name.definition_name

import mymodule

result = mymodule.my_function(3)

• จาก module_name import some_definition : วิธีนี้จะนำเข้าข้อกำหนดเฉพาะจากโมดูล ให้คุณใช้งานได้โดยตรงโดยไม่ต้องใช้คำนำหน้าโมดูล

from mymodule import my_function

result = my_function(3)

• from module_name import * : วิธีนี้นำเข้าคำจำกัดความทั้งหมดจากโมดูล แต่ไม่แนะนำเนื่องจากอาจทำให้เกิดความขัดแย้งในการตั้งชื่อ

ความคิดสุดท้าย

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

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

ทักษะในการใช้ คำสั่ง นำเข้าและจากคำสั่งนั้นมีค่ามากที่สุดเมื่อคุณทำงานในโครงการขนาดใหญ่ที่มีการแบ่งฟังก์ชันการทำงานตามไดเร็กทอรีต่างๆ

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

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

ด้วยคำแนะนำฉบับย่อนี้ คุณควรมีความพร้อมในการจัดการกับปริศนาการนำเข้าใดๆ ที่ Python โยนใส่คุณ แต่อย่าหยุดเพียงแค่นี้ มีเทคนิคและลูกเล่นของ Python มากมายรอให้คุณค้นพบ!