นำเข้าโมดูลเข้า Python ด้วยตัวอย่าง

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

มีโมดูลอะไรบ้าง Python?

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

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

เป็นสิ่งที่ Python นำเข้าโมดูล?

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

วิธีสร้างและนำเข้าโมดูลมา Python?

ต่อไปเราจะสร้างโมดูลและนำเข้าโมดูลนั้นไปยังไฟล์อื่น

นี่คือขั้นตอนการสร้างและนำเข้าโมดูลตามที่แสดงในภาพหน้าจอ:

ทำตามขั้นตอนที่กำหนดเพื่อสร้างโมดูลใน Python.

โครงสร้างโฟลเดอร์ที่ใช้ในการทดสอบโค้ดมีดังนี้:

modtest/
	test.py
	display.py	

ขั้นตอน 1) สร้างไฟล์และตั้งชื่อว่า test.py

ขั้นตอน 2) ภายใน test.py ให้สร้างฟังก์ชันชื่อ display_message()

Def display_message():
    return "Welcome to Guru99 Tutorials!"

ขั้นตอน 3) ตอนนี้สร้างไฟล์อื่น display.py

ขั้นตอน 4) ภายในไฟล์ display.py ให้ทำการ import โมดูล test.py ดังที่แสดงด้านล่าง:

import test

ขณะนำเข้า คุณไม่จำเป็นต้องระบุชื่อไฟล์ test.py แต่ระบุเพียงชื่อไฟล์ก็พอ

ขั้นตอน 5) จากนั้นคุณสามารถเรียกใช้ฟังก์ชัน display_message() จากไฟล์ test.py ภายในไฟล์ display.py ได้ โดยคุณต้องใช้รูปแบบ module_name.function_name

ตัวอย่างเช่น test.display_message()

Import test
print(test.display_message())

ขั้นตอน 6) เมื่อคุณเรียกใช้ไฟล์ display.py คุณจะได้รับผลลัพธ์ดังต่อไปนี้ Output:

Welcome to Guru99 Tutorials!

การนำเข้าคลาสเข้า Python

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

โครงสร้างโฟลเดอร์สำหรับทดสอบโค้ดมีดังนี้:

myproj/
	Car.py
	display.py

สร้างไฟล์ชื่อ Car.py โดยมีโค้ดต่อไปนี้:

ชื่อไฟล์ : Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

ในไฟล์ Car.py มีแอตทริบิวต์ brand_name, model และ manu_year ฟังก์ชันที่กำหนดไว้ภายในคลาส ได้แก่ car_details(), get_Car_brand(), get_Car_model()

ตอนนี้ให้เราใช้ไฟล์ Car.py เป็นโมดูลในไฟล์อื่นที่เรียกว่า display.py

ชื่อไฟล์ : display.py

import Car
car_det = Car.Car("BMW","Z5", 2020)
print(car_det.brand_name)
print(car_det.car_details())
print(car_det.get_Car_brand())
print(car_det.get_Car_model())

Output:

BMW
Car brand is  BMW
Car model is  Z5
Car manufacture year is  2020
Car brand is  BMW
Car model is  Z5

ดังนั้นเราจึงสามารถเข้าถึงตัวแปรและฟังก์ชันทั้งหมดจากไฟล์ Car.py ได้โดยใช้โมดูล Car

การใช้โมดูล from to import

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

เมื่อคุณต้องการนำเข้าเฉพาะสิ่งที่เจาะจง คุณสามารถใช้คำหลัก "จาก" เพื่อนำเข้าสิ่งที่คุณต้องการได้

ดังนั้นไวยากรณ์คือ

from  module import your function_name , variables,... etc.

โครงสร้างโฟลเดอร์ที่ใช้ในการทดสอบโค้ดมีดังนี้:

modtest/
	test.py
	display.py	

ในไฟล์ test.py มีฟังก์ชัน 2 ฟังก์ชันดังที่แสดงไว้:

ชื่อไฟล์ : test.py

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
def display_message1():
	return "All about Python!"

ตอนนี้คุณต้องการฟังก์ชัน display_message() ฟังก์ชันหรือตัวแปรที่คุณนำเข้าสามารถเข้าถึงได้โดยตรงดังที่แสดงด้านล่าง:

ชื่อไฟล์ : display.py

from test import display_message
print(display_message())

Output:

Welcome to Guru99 Tutorials!

หากคุณใช้ฟังก์ชัน display_message1() มันจะเกิดข้อผิดพลาดว่าฟังก์ชันนี้ไม่ได้ถูกกำหนดไว้ ดังที่แสดงด้านล่าง:

from test import display_message
print(display_message1())

Output:

Traceback (most recent call last):
File "display.py", line 3, in <module>
print(display_message1())
Name Error: name 'display_message1' is not defined

การนำเข้าทุกอย่างจากโมดูล

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

ไวยากรณ์:

Import module

หรือโดยการใช้

from module import *

โครงสร้างโฟลเดอร์ที่ใช้ในการทดสอบโค้ดมีดังนี้:

modtest/
	test.py
	display.py	

ต่อไปนี้เป็นรายละเอียดโค้ดภายใน test.py

my_name = "Guru99"
my_address = "Mumbai"

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
	
def display_message1():
	return "All about Python!"

การใช้โมดูลนำเข้า

หากใช้เพียงชื่อโมดูลในการนำเข้า คุณต้องใส่ชื่อโมดูลนำหน้าตัวแปรและฟังก์ชันภายในโมดูลนั้นด้วย

ตัวอย่าง

ชื่อไฟล์ : display.py

Import test
print(test.display_message())
print(test.display_message1())
print(test.my_name)
print(test.my_address)

ชื่อโมดูล `test` ใช้สำหรับอ้างอิงถึงฟังก์ชันและตัวแปรภายในโมดูล `test`

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

ใช้การนำเข้า *

เรามาดูตัวอย่างการใช้งานกัน นำเข้า *. การใช้ นำเข้า *สามารถเข้าถึงฟังก์ชันและตัวแปรได้โดยตรง ดังตัวอย่างด้านล่าง:

from test import *

print(display_message())
print(display_message1())
print(my_name)
print(my_address)

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

ฟังก์ชัน dir( )

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

ดังนั้นเมื่อใช้ dir() กับโมดูล มันจะให้ตัวแปรและฟังก์ชันที่อยู่ภายในโมดูลนั้น

ต่อไปนี้เป็นตัวอย่างการใช้งาน dir() บนโมดูล เรามีคลาสชื่อ Car.py ลองนำเข้าคลาส Car และกำหนดค่าให้กับ dir() เพื่อดูผลลัพธ์

โครงสร้างโฟลเดอร์ที่จะทดสอบโค้ดจะเป็นดังนี้:

test prop/
	Car.py
	test.py	

ชื่อไฟล์: Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

ชื่อไฟล์: test.py

import Car

class_contents = dir(Car)
print(class_contents)

ผลลัพธ์จะให้ชื่อของคลาสและฟังก์ชันทั้งหมดที่กำหนดไว้ใน Car.py

คุณยังสามารถลองใช้ dir() กับโมดูลในตัวที่มีอยู่ Pythonลองทำแบบเดียวกันกับ... JSON โมดูลดังแสดงในตัวอย่างด้านล่าง มันจะแสดงคุณสมบัติและเมธอดทั้งหมดที่มีอยู่ในโมดูล JSON โมดูล.

Import json
json_details = dir(json)
print(json_details)

Output:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu
iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac
kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en
coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa
d', 'loads', 'scanner']

แบบรวดเร็ว

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

ชื่อแพ็คเกจคือ แพ็คเกจของฉันในการเริ่มต้นใช้งานแพ็กเกจ ให้สร้างไดเร็กทอรีชื่อ mypackage/ ภายในไดเร็กทอรีนั้น ให้สร้างไฟล์เปล่าชื่อ __init__.py จากนั้นสร้างไฟล์อีก 3 ไฟล์ คือ module1.py, module2.py และ module3.py และกำหนดฟังก์ชันตามที่แสดงในภาพหน้าจอ รายละเอียดของ module1.py, module2.py และ module3.py มีดังนี้

module1.py

def mod1_func1():
print("Welcome to Module1 function1")

def mod1_func2():
print("Welcome to Module1 function2")

def mod1_func3():
print("Welcome to Module1 function3")

module2.py

def mod2_func1():
print("Welcome to Module2 function1")

def mod2_func2():
print("Welcome to Module2 function2")

def mod2_func3():
print("Welcome to Module2 function3")

module3.py

def mod3_func1():
print("Welcome to Module3 function1")

def mod3_func2():
print("Welcome to Module3 function2")

def mod3_func3():
print("Welcome to Module3 function3")

การขอ แพ็คเกจ พร้อมใช้งานแล้ว ตอนนี้เรียกใช้แพ็กเกจภายในไฟล์ใดก็ได้ของคุณดังที่แสดงด้านล่างในไฟล์ test.py:

ที่นี่ mypackage.module1 จะถูกนำเข้าและตั้งชื่อนามแฝงเป็น mod1ในทำนองเดียวกัน คุณสามารถใช้โมดูลอื่นๆ ได้แก่ module2.py และ module3.py จาก mypackage ได้เช่นกัน

import mypackage.module1 as mod1

print(mod1.mod1_func1())
print(mod1.mod1_func2())
print(mod1.mod1_func2())

Output:

Welcome to Module1 function1
None
Welcome to Module1 function2
None
Welcome to Module1 function2
None

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

Python เส้นทางการค้นหาโมดูล

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

สรุปแล้วล่ามจะทำการค้นหาต่อไปนี้เพื่อค้นหาโมดูล:

1. ในไดเร็กทอรีปัจจุบันของคุณ
2. ในรายการโมดูลที่ติดตั้งมากับระบบ
3. ภายในไดเร็กทอรี sys.path

คุณสามารถดูรายละเอียดของ sys.path ได้โดยการนำเข้าโมดูล sys และพิมพ์ sys.path ซึ่งจะแสดงรายการไดเร็กทอรีดังที่แสดงด้านล่าง:

importsys
print(sys.path)

Output:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\
\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P
ython37\\DLLs']

คุณยังสามารถแก้ไขเส้นทางและเก็บไดเร็กทอรีตามความต้องการของคุณ

การใช้นามแฝงโมดูลในการนำเข้า

นอกจากนี้ คุณยังสามารถแปลงชื่อโมดูลให้สั้นลงได้โดยการตั้งชื่อเล่นให้ ชื่อเล่นนี้สามารถสร้างได้โดยใช้ as คำสำคัญ.

ไวยากรณ์:

import filename as alias name

โครงสร้างโฟลเดอร์ที่จะทดสอบโค้ดจะเป็นดังนี้:

Mod test/
	test.py
	display.py	

ต่อไปนี้เป็นโค้ดภายใน test.py

my_name = "Guru99"
my_address = "Mumbai"

def display_message():
	return "Welcome to Guru99 Tutorials!"	
	
def display_message1():
	return "All about Python!"

ต่อไปนี้เราจะใช้นามแฝงสำหรับไฟล์ test.py ในไฟล์ display.py

Import test as t

print(t.display_message())
print(t.display_message1())
print(t.my_name)
print(t.my_address)

ชื่อย่อที่ใช้สำหรับโมดูลทดสอบคือ t ดังนั้นฟังก์ชันและตัวแปรจากไฟล์ test.py สามารถอ้างอิงได้โดยใช้ชื่อย่อ t

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

การนำเข้าแบบสัมบูรณ์และแบบสัมพัทธ์ใน Python

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

พิจารณาว่าคุณมีโครงสร้างโฟลเดอร์โครงการของคุณ ดังที่แสดงด้านล่าง:

โฟลเดอร์หลักคือ myproject/ และมีโฟลเดอร์ย่อยสองโฟลเดอร์คือ package1 และ package2

โฟลเดอร์ package1 ประกอบด้วยสองโมดูล คือ module1.py และ module2.py

โฟลเดอร์ package2 มีหนึ่งคลาส myclass.py, sub-package subpkg พร้อม module3.py และ module4.py สุดท้าย

• ในไฟล์ module1.py มีฟังก์ชันชื่อ myfunc1 อยู่
• ในไฟล์ module2.py มีฟังก์ชันชื่อ myfunc2 อยู่
• ในไฟล์ module3.py มีฟังก์ชันชื่อ myfunc3 อยู่
• ในไฟล์ module4.py มีฟังก์ชันชื่อ myfunc4 อยู่

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

สำหรับการนำเข้าแบบสัมบูรณ์ คุณต้องเพิ่มพาธแบบเต็มของโมดูลของคุณจากโฟลเดอร์รากของโปรเจ็กต์โดยตรง

ต่อไปนี้เราจะมาดูวิธีการใช้การนำเข้าแบบสัมบูรณ์ (absolute imports) เพื่ออ้างอิงถึงฟังก์ชันต่างๆ ที่มีอยู่ในแต่ละโมดูล

ในการใช้งานฟังก์ชัน myfunc1 คุณจะต้องนำเข้าฟังก์ชันดังนี้:

from package1.module1  import  myfunc1
or
from package1 import module1
module1.myfunc1()  

ในการใช้งานฟังก์ชัน myfunc3 คุณจะต้องนำเข้าฟังก์ชันดังนี้:

from package1.subpkg.module3  import  myfunc3
or
from package1.subpkg import module3
module3.myfunc3()  

ข้อดีและข้อเสียของการใช้การนำเข้าแบบสัมบูรณ์

ข้อดีของการใช้การนำเข้าแบบสัมบูรณ์มีดังนี้

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

ข้อเสียของการใช้การนำเข้าแบบสัมบูรณ์

ต่อไปนี้คือข้อเสียของการใช้การนำเข้าแบบสัมบูรณ์:

• เส้นทางการนำเข้าอาจยาวมากในกรณีที่โมดูลมีการซ้อนกันและชื่อโมดูลมีความยาว

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

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

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

วากยสัมพันธ์

ในการนำเข้าแบบสัมพันธ์ คุณต้องเพิ่มจุด (.) ก่อนชื่อโมดูลเมื่อนำเข้าโดยใช้ จาก.

หากโมดูลนั้นอยู่เหนือตำแหน่งปัจจุบันหนึ่งระดับ จะต้องมีจุดสองจุด (..) นำหน้าชื่อโมดูล

จากโครงสร้างโฟลเดอร์ที่แสดงในภาพด้านบน เรามีโมดูลต่างๆ พร้อมฟังก์ชันการทำงานดังต่อไปนี้ ซึ่งเราจำเป็นต้องอ้างอิงถึง

• ในไฟล์ module1.py มีฟังก์ชันชื่อ myfunc1 อยู่
• ในไฟล์ module2.py มีฟังก์ชันชื่อ myfunc2 อยู่
• ในไฟล์ module3.py มีฟังก์ชันชื่อ myfunc3 อยู่
• ในไฟล์ module4.py มีฟังก์ชันชื่อ myfunc4 อยู่

ในการใช้งานฟังก์ชัน myfunc1 คุณจะต้องนำเข้าฟังก์ชันดังนี้:

from  .module1  import  myfunc1

ในการใช้งานฟังก์ชัน myfunc3 คุณจะต้องนำเข้าฟังก์ชันดังนี้:

from  .subpkg.module3  import  myfunc3

ข้อดีของการนำเข้าแบบสัมพันธ์

• มันง่ายที่จะทำงานกับการนำเข้าแบบสัมพันธ์
• จากตำแหน่งปัจจุบัน การนำเข้าสามารถย่อให้สั้นลงเมื่อเปรียบเทียบกับการนำเข้าแบบสัมบูรณ์

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

• การใช้การนำเข้าแบบสัมพัทธ์นั้นทำได้ยาก tracกลับไปยังตำแหน่งที่โค้ดอยู่

คำถามที่พบบ่อย