การเขียน Module ใน Python

Post id: 27 , Date 08/01/2022

1. โมดูลคืออะไร

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

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

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

1.1 การสร้างฟังก์ชัน

การสร้างฟังก์ชันใน python นั้นง่ายมาก เพียงแค่เราเขียน key word คำว่า “def” เอาไว้ข้างหน้า โปรแกรมมันก็จะรู้ทันทีว่านี่คือฟังก์ชันนะ เราไม่ต้องยุ่งยากประกาศชนิดของฟังก์ชัน ไม่ต้องยุ่งยากไปกำหนด output ของฟังก์ชัน

และเมื่อฟังก์ชันของ python ไม่ได้ระบุประเภทเอาไว้ การ return output จึงเปิดกว้างมาก กล่าวคือ ฟังก์ชันจะมี return หรือไม่มีก็ได้ หรือจะ return ข้อมูลตัวเดียว หรือ หลายตัวก็ได้

ตัวอย่างฟังก์ชัน

def myloop(N):
    for i in range(N):
        print(i)

ฟังก์ชันนี้มีชื่อว่า myloop ต้องการ input 1 ตัว คือ N

เมื่อรับค่ามาแล้ว ฟังก์ชันจะวนลูปแสดงตัวเลขจาก 0 ถึง N

จริงๆ รายละเอียดเรื่องฟังก์ชันยังมีอีกเยอะนะ เอาไว้ผมจะเขียนแยกเป็นอีกบทความให้แล้วกัน

1.2 การเรียกใช้งานฟังก์ชัน

สมมุติว่าผมจะเรียกใช้งานฟังก์ชัน myloop ที่ผมสร้างเอาไว้ ก็แค่ต้องพิมพ์ชื่อฟังก์ชันแบบนี้

myloop(10)

หรือ

A = 10
myloop(A)

2. การสร้างโมดูล

การสร้างโมดูล ก็เหมือนกับการสร้างโปรแกรมทั่วไปครับ นั่นก็คือกด new file ขึ้นมา แล้วก็ตั้งชื่อ ในตัวอย่างนี้ ผมจะตั้งชื่อว่า mymodule.py ก็แล้วกันนะครับ

mymodule.py

# Global variable
module_name = []
COFFEE = {
    'ESPRESSO': 0,
    'CAPUCCINO': 0,
    'LATTE': 0,
    'MOCHA': 0,
    'AMERICANO': 0
}

# function in module
def init(Name='None', ESP=0, CAP=0, LAT=0, MOC=0, AME=0):
    global module_name
    global COFFEE
 
    module_name = Name
    COFFEE['ESPRESSO'] = ESP
    COFFEE['CAPUCCINO'] = CAP
    COFFEE['LATTE'] = LAT
    COFFEE['MOCHA'] = MOC
    COFFEE['AMERICANO'] = AME

def calculate_price(CoffeeList):
    Price = 0
    for c in CoffeeList:
        Price += COFFEE[c]
    return Price
def myshop():
    print(module_name)

เพียงเท่านี้ก็เรียบร้อยแล้วครับ

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

3. การใช้งานโมดูล

สมมุติว่าผมจะเขียนโปรแกรมร้านกาแฟนะครับ โดยจะตั้งชื่อโปรแกรมว่า coffeeShop.py โดยให้สร้างไว้ในโฟลเดอร์เดียวกันกับไฟล์ mymodule.py

coffeeShop.py

import mymodule as md
# 1. Set menu
MENU = {
    1: 'ESPRESSO',
    2: 'CAPUCCINO',
    3: 'LATTE',
    4: 'MOCHA',
    5: 'AMERICANO'
}
# 2. initial 
md.init("Panda - Coffee", ESP=30, CAP=50, LAT=55, MOC=45, AME=40)
# 3. Print my cafe name
md.myshop()
# 4. Calculate price from customer
Customer1 = [MENU[1], MENU[3]]
Price1 = md.calculate_price(Customer1)
print(Price1)
Customer2 = [MENU[2], MENU[4], MENU[5]]
Price2 = md.calculate_price(Customer2)
print(Price2)

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

ขั้นตอนที่ 2 ผมกำหนดชื่อร้าน และราคาขายของกาแฟแต่ละชนิด

ขั้นตอนที่ 3 ผมสั่งให้โปรแกรม print ชื่อร้านออกมาดูสิว่าตรงกับที่ผมได้ตั้งเอาไว้รึเปล่า

ขั้นตอนที่ 4 สมมุติว่ามีลูกค้าเข้าร้าน และผมจะใช้โปรแกรมคำนวณเงินให้ลูกค้า

โดยลูกค้าคนแรกสั่ง 2 เมนูคือ ESPRESSO และ LATTE

ส่วนลูกค้าคนที่สองสั่ง 3 เมนูคือ CAPUCCINO, MOCHA และ AMERICANO

หลังจากนั้นก็ให้โปรแกรมแสดงราคาออกมา ซึ่งผลลัพธ์ที่ได้ก็จะเป็นดังนี้

# ตัวอย่างผลรัน
Panda - Coffee
85
135

4. ประโยชน์ของโมดูล

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

ประโยชน์อีกอย่างก็คือ เราไม่ต้องเขียนโค้ดเดิมซ้ำๆ ยกตัวอย่างเช่น

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

สมมุติว่าผมเขียนโปรแกรมเทรดหุ้น 10 โปรแกรม ผมก็ต้องก็อปปี้ฟังก์ชันนี้เอาไปใส่ไว้ในทุกโปรแกรม แล้วถ้าเกิดฟังก์ชันนี้มันมี BUG ผมก็ต้องตามไปแก้ทั้ง 10 โปรแกรมเช่นกัน ซึ่งไม่ใช่งานที่สบายเลย

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

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

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