คุณกำลังดำดิ่งสู่การเขียนโปรแกรม Python และคุณได้พบกับสิ่งที่น่าสนใจที่เรียกว่า "ความหลากหลาย" อาจฟังดูหรูหรา แต่เชื่อฉันเถอะ มันไม่ซับซ้อนอย่างที่คิด Polymorphism เป็นเรื่องของความยืดหยุ่นและการนำกลับมาใช้ซ้ำได้ในโค้ดของเรา มาดำดิ่งและไขปริศนาไปด้วยกัน
ความแตกต่างคืออะไร? ความหลากหลายทำให้เราสามารถปฏิบัติต่อวัตถุที่แตกต่างกันราวกับว่าพวกมันอยู่ในตระกูลเดียวกัน แม้ว่าจะมีคุณลักษณะเฉพาะที่แตกต่างกันก็ตาม คิดว่านี่เป็นวิธีการใช้อินเทอร์เฟซทั่วไปเพื่อดำเนินการต่างๆ กับออบเจ็กต์ประเภทต่างๆ มันช่วยให้เราไม่ต้องเขียนโค้ดซ้ำๆ และทำให้โปรแกรมของเราปรับเปลี่ยนได้มากขึ้น
การพิมพ์แบบไดนามิกของ Python: ใน Python เรามีสิ่งดีๆ ที่เรียกว่า "การพิมพ์แบบไดนามิก" หมายความว่าวัตถุสามารถเปลี่ยนประเภทได้ในขณะที่โปรแกรมกำลังทำงาน พฤติกรรมแบบไดนามิกนี้คือสิ่งที่ทำให้ความหลากหลายใน Python ทรงพลังมาก เราสามารถสลับระหว่างวัตถุประเภทต่างๆ ได้อย่างง่ายดายและเขียนโค้ดที่สื่อความหมายได้มากขึ้น
ความแตกต่างทำงานอย่างไร? ความแตกต่างเกิดขึ้นได้จากสองแนวคิดหลัก: การสืบทอดคลาสและการเอาชนะวิธีการ
การสืบทอดคลาส: ด้วยการสืบทอดคลาส เราสามารถสร้างลำดับชั้นของคลาสได้ แต่ละคลาสสามารถสืบทอดคุณลักษณะและวิธีการจาก "ซูเปอร์คลาส" หรือ "คลาสพาเรนต์" ทั่วไป การสืบทอดนี้ช่วยให้เราแบ่งปันฟังก์ชันการทำงานทั่วไประหว่างคลาสที่เกี่ยวข้อง ในขณะที่ยังคงมีความยืดหยุ่นในการปรับแต่งพฤติกรรมเฉพาะในแต่ละคลาส
การเอาชนะเมธอด: การเอาชนะเมธอดเปรียบเสมือนการให้พลังพิเศษแก่คลาสย่อย อนุญาตให้คลาสย่อยจัดให้มีการใช้งานเมธอดของตัวเองที่สืบทอดมาจากซูเปอร์คลาส ดังนั้นแม้ว่าคลาสที่ต่างกันอาจมีชื่อเมธอดเหมือนกัน แต่ก็สามารถทำงานแตกต่างกันได้ตามความต้องการเฉพาะของพวกเขา นี่คือจุดที่ความมหัศจรรย์ของความหลากหลายเกิดขึ้น!
ตัวอย่างการปฏิบัติของความหลากหลาย:
พฤติกรรมที่เป็นนามธรรม:
ลองนึกภาพคุณมีหลายคลาสที่มีฟังก์ชันการทำงานบางอย่างร่วมกัน ด้วยการใช้ความหลากหลาย คุณสามารถกำหนดอินเทอร์เฟซทั่วไป (ชุดของวิธีการ) ที่คลาสเหล่านี้ควรใช้
- ลองนึกถึงกลุ่มสัตว์ต่างๆ เช่น สุนัข แมว และนก แม้จะต่างกันแต่ก็สามารถส่งเสียงได้ ความหลากหลายทำให้เราปฏิบัติต่อพวกมันในลักษณะเดียวกัน ราวกับว่าพวกมันทั้งหมดอยู่ในกลุ่ม "สัตว์ทำเสียง" กลุ่มเดียวกัน เราสามารถมีกฎที่ว่า “ถ้าเป็นสัตว์ ให้ขอให้ส่งเสียง” ด้วยวิธีนี้ เราจะทำให้สัตว์ต่างๆ สร้างเสียงที่เป็นเอกลักษณ์ของตัวเองได้โดยไม่ต้องเขียนคำแนะนำแยกกันสำหรับสัตว์แต่ละตัว
class Bird:
def sound(self):
print('The bird goes tweet tweet')
class Cat:
def sound(self):
print('The cat meowed')
animal1 = Bird()
animal2 = Cat()
animal1.sound() #The bird goes tweet tweet
animal2.sound() #The cat meowed
การจัดการคอลเล็กชัน:
ความหลากหลายทำให้การทำงานกับคอลเลกชันที่มีวัตถุประเภทต่างๆ ง่ายขึ้น แทนที่จะเขียนโค้ดแยกกันสำหรับออบเจ็กต์แต่ละประเภท คุณสามารถปฏิบัติต่อโค้ดเหล่านั้นทั้งหมดเหมือนกันโดยอิงตามอินเทอร์เฟซที่ใช้ร่วมกัน ทำให้โค้ดของคุณมีความยืดหยุ่นและบำรุงรักษาได้ง่ายขึ้น
- ลองนึกภาพคุณมีกล่องของเล่น และของเล่นแต่ละชิ้นก็ทำสิ่งที่แตกต่างออกไป แทนที่จะแยกของเล่นแต่ละชิ้นแยกกันและเล่นกับมันต่างกัน เราสามารถถือว่าของเล่นทั้งหมดเป็นของเล่นและเล่นด้วยกันได้ ความหลากหลายทำให้เรามีกฎที่บอกว่า “ถ้าเป็นของเล่น มาเล่นกันเถอะ!” ด้วยวิธีนี้ เราจึงสามารถสนุกสนานกับของเล่นต่างๆ ได้โดยไม่ต้องกังวลกับคุณสมบัติเฉพาะของของเล่นเหล่านั้น เราสามารถปฏิบัติต่อพวกเขาทั้งหมดในลักษณะเดียวกันโดยอิงจากธรรมชาติของ "ของเล่น" ที่พวกเขามีร่วมกัน
class Toy:
def play(self):
pass
class Car(Toy):
def play(self):
print("Vroom! I'm a fast car!")
class Robot(Toy):
def play(self):
print("Beep boop! I'm a dancing robot!")
class TeddyBear(Toy):
def play(self):
print("Hug me! I'm a cuddly teddy bear!")
# Create a collection of toys
toys = [Car(), Robot(), TeddyBear()]
# Play with each toy in the collection
for toy in toys:
toy.play()
ในตัวอย่างข้างต้น เรากำหนดคลาสพื้นฐานที่เรียกว่า Toy ซึ่งมีวิธีการเล่น วิธีการเล่นมีไว้เพื่อแทนที่โดยคลาสย่อย จากนั้นเราจะสร้างคลาสย่อยของเล่นเฉพาะ เช่น รถยนต์ หุ่นยนต์ และตุ๊กตาหมี โดยแต่ละคลาสมีวิธีการเล่นของตัวเอง
ต่อไป เราสร้างคอลเลกชันที่เรียกว่าของเล่นซึ่งเก็บตัวอย่างสิ่งของของเล่นต่างๆ (รถยนต์ หุ่นยนต์ และตุ๊กตาหมี)
สุดท้ายนี้ เราจะวนซ้ำของเล่นแต่ละชิ้นในคอลเลกชันของเล่นและเรียกวิธีการเล่นของของเล่นแต่ละชิ้น นี่คือจุดที่ความหลากหลายเข้ามามีบทบาท แม้ว่าเราจะเรียกวิธีการเดียวกัน (เล่น) แต่วัตถุของเล่นแต่ละชิ้นก็มีพฤติกรรมแตกต่างกันไปตามการใช้งานของมันเอง ผลลัพธ์สุดท้ายคือ:
#Vroom! I'm a fast car! #Beep boop! I'm a dancing robot! #Hug me! I'm a cuddly teddy bear!
ระบบปลั๊กอิน:
ระบบปลั๊กอินเปรียบเสมือนการมีเครื่องมือต่าง ๆ ที่สามารถใส่ลงในช่องพิเศษในเครื่องได้ เครื่องมือแต่ละอันมีคุณสมบัติเฉพาะของตัวเอง แต่เครื่องมือทั้งหมดก็ปฏิบัติตามกฎหรือคำแนะนำเพื่อให้ทำงานได้อย่างถูกต้อง
ความหลากหลายนั้นมีประโยชน์เมื่อสร้างระบบปลั๊กอิน เนื่องจากเราสามารถกำหนดชุดกฎมาตรฐานหรืออินเทอร์เฟซที่ปลั๊กอินทั้งหมดควรปฏิบัติตาม อินเทอร์เฟซนี้สรุปวิธีการหรือการดำเนินการที่ปลั๊กอินควรมี เช่น “execute” หรือ “performTask”
ด้วยการยึดตามอินเทอร์เฟซนี้ ปลั๊กอินต่างๆ จึงสามารถใส่ลงในเครื่องได้อย่างง่ายดายโดยไม่ต้องเปลี่ยนโครงสร้างหลักของเครื่อง ผสานรวมและมอบคุณสมบัติเพิ่มเติมได้อย่างราบรื่นโดยไม่จำเป็นต้องแก้ไขโค้ดหลักของเครื่อง
เหมือนกับการมีชุดเครื่องมือที่ใช้แทนกันได้ซึ่งสามารถเพิ่มขีดความสามารถของเครื่องจักรได้โดยไม่ต้องสร้างใหม่ เราสามารถเสียบปลั๊กอินต่างๆ ได้ และปลั๊กอินเหล่านั้นจะทำงานได้เนื่องจากปลั๊กอินเหล่านี้ทำตามกฎชุดเดียวกัน ความยืดหยุ่นนี้ช่วยให้เราขยายฟังก์ชันการทำงานของแอปพลิเคชันของเราได้โดยไม่ต้องทำการเปลี่ยนแปลงโค้ดเบสหลักมากนัก
ดังนั้น ความหลากหลายในระบบปลั๊กอินคือทั้งหมดที่เกี่ยวกับการสร้างพื้นฐานทั่วไปหรือชุดคำสั่งที่ปลั๊กอินสามารถปฏิบัติตามได้ ทำให้ง่ายต่อการเพิ่มคุณสมบัติใหม่โดยไม่ยุ่งกับแกนหลักของโปรแกรม
- ลองนึกภาพกล่องบล็อกสีสันสดใสที่สามารถต่อเข้าด้วยกันได้ แต่ละบล็อกมีรูปร่างและสีของตัวเอง ด้วยความหลากหลาย เราสามารถสร้างกฎที่ระบุว่า “หากเป็นบล็อก ก็สามารถเชื่อมต่อกับบล็อกอื่นได้” ซึ่งหมายความว่าเราสามารถผสมและจับคู่บล็อกต่างๆ เพื่อสร้างโครงสร้างที่เป็นเอกลักษณ์โดยไม่จำเป็นต้องใช้คำแนะนำพิเศษสำหรับแต่ละบล็อก เราสามารถมีบล็อกที่มีรูปร่างและขนาดต่างกันได้ แต่ทั้งหมดสามารถเชื่อมต่อเข้าด้วยกันได้เนื่องจากเป็นไปตามกฎเดียวกัน
class Block:
def connect(self):
pass
class BlueBlock(Block):
def connect(self):
print("Connecting the blue block...")
class RedBlock(Block):
def connect(self):
print("Connecting the red block...")
class YellowBlock(Block):
def connect(self):
print("Connecting the yellow block...")
# Create a collection of blocks
blocks = [BlueBlock(), RedBlock(), YellowBlock()]
# Connect each block in the collection
for block in blocks:
block.connect()
ในตัวอย่างนี้ เรากำหนดคลาสพื้นฐานที่เรียกว่า Block ซึ่งมีวิธีการเชื่อมต่อ วิธีการนี้มีไว้เพื่อแทนที่โดยคลาสย่อย จากนั้นเราสร้างคลาสย่อยของบล็อกเฉพาะ เช่น BlueBlock, RedBlock และ YellowBlock โดยแต่ละคลาสมีวิธีการเชื่อมต่อของตัวเอง
ต่อไป เราจะสร้างคอลเลกชันที่เรียกว่าบล็อกซึ่งเก็บอินสแตนซ์ของวัตถุบล็อกต่างๆ เรามีบล็อกสีน้ำเงิน บล็อกสีแดง และบล็อกสีเหลืองในคอลเลกชัน
สุดท้าย เราวนซ้ำแต่ละบล็อกในคอลเลกชันบล็อกและเรียกวิธีเชื่อมต่อในแต่ละบล็อก นี่คือจุดที่ความหลากหลายเข้ามามีบทบาท แม้ว่าเราจะเรียกใช้เมธอดเดียวกัน (เชื่อมต่อ) แต่ออบเจ็กต์บล็อกแต่ละรายการจะมีพฤติกรรมแตกต่างกันตามการใช้งานของตัวเอง ผลลัพธ์จะเป็น:
#Connecting the blue block... #Connecting the red block... #Connecting the yellow block...
ในตัวอย่างเหล่านี้ ความหลากหลายช่วยให้เราจัดกลุ่มสิ่งต่างๆ เข้าด้วยกันตามลักษณะหรือพฤติกรรมที่มีร่วมกัน มันช่วยให้เราไม่ต้องเขียนคำสั่งซ้ำๆ และช่วยให้เราทำงานกับวัตถุต่างๆ ได้อย่างยืดหยุ่นและสร้างสรรค์มากขึ้น เช่นเดียวกับที่สัตว์สร้างเสียงได้ ของเล่นสามารถเล่นได้ และสามารถเชื่อมต่อบล็อกได้ ความหลากหลายช่วยให้เราปฏิบัติต่อสิ่งต่าง ๆ ในลักษณะเดียวกัน และทำให้โปรแกรมของเราสนุกและปรับตัวได้มากขึ้น!
การจัดการคอลเลกชันและระบบปลั๊กอินมีลักษณะคล้ายกันว่าให้อะไร
มาดูความแตกต่างที่ชัดเจนกัน:
การจัดการคอลเลกชัน:เมื่อเราจัดการคอลเลกชันโดยใช้ความหลากหลาย เราจะจัดกลุ่มวัตถุต่างๆ ไว้ด้วยกัน เช่น ของเล่นในกล่องของเล่น เราปฏิบัติต่อพวกเขาทั้งหมดราวกับว่าพวกเขาอยู่ในหมวดหมู่เดียวกัน แม้ว่าพวกเขาจะแตกต่างกันก็ตาม เราสามารถดำเนินการกับวัตถุเหล่านี้ได้โดยไม่ต้องกังวลกับประเภทเฉพาะของวัตถุเหล่านั้น ตัวอย่างเช่น เราสามารถทำให้ของเล่นแต่ละชิ้นในคอลเลคชันเล่นได้ แม้ว่าของเล่นเหล่านั้นจะเป็นของเล่นที่แตกต่างกันและมีการกระทำที่เป็นเอกลักษณ์ของตัวเองก็ตาม
ระบบปลั๊กอิน:ระบบปลั๊กอินที่ใช้ความหลากหลายนั้นเปรียบเสมือนการเพิ่มคุณสมบัติพิเศษให้กับโปรแกรมหลักโดยไม่ต้องเปลี่ยนรหัสหลัก เรากำหนดชุดกฎหรือข้อกำหนดที่คุณสมบัติพิเศษ (ปลั๊กอิน) เหล่านี้ควรปฏิบัติตาม ปลั๊กอินแต่ละตัวสามารถมีการนำกฎเหล่านี้ไปใช้ของตนเองได้ ซึ่งช่วยให้เราสามารถเสียบปลั๊กอินต่างๆ เข้ากับโปรแกรมหลักได้ และปลั๊กอินเหล่านี้ทำงานร่วมกันได้อย่างราบรื่นโดยปฏิบัติตามกฎชุดเดียวกัน มันเหมือนกับการเพิ่มเครื่องมือใหม่ลงในกล่องเครื่องมือโดยไม่ต้องแก้ไขกล่องเครื่องมือเอง
โดยสรุป การจัดการคอลเลกชั่นที่มีความหลากหลายนั้นเป็นการรักษาอ็อบเจ็กต์ต่างๆ ในคอลเลกชั่นราวกับว่าพวกมันอยู่ในกลุ่มเดียวกัน ในขณะที่ระบบปลั๊กอินที่มีความหลากหลายนั้นเกี่ยวข้องกับการเพิ่มคุณสมบัติพิเศษให้กับโปรแกรมด้วยวิธีที่ยืดหยุ่นและสม่ำเสมอ
บทสรุป:
ความหลากหลายใน Python คือการทำให้โค้ดของคุณมีความยืดหยุ่น ใช้ซ้ำได้ และทำงานได้ง่ายขึ้น คุณลักษณะการพิมพ์แบบไดนามิกของ Python พร้อมด้วยการสืบทอดคลาสและการแทนที่เมธอด ช่วยให้เราสามารถบรรลุความยืดหยุ่นนี้ได้ ยอมรับพลังของความหลากหลายและคุณจะปลดล็อกความเป็นไปได้ใหม่ ๆ ในเส้นทางการเขียนโปรแกรม Python ของคุณ!
ทรัพยากร:
https://towardsdatascience.com/polymorphism-in-python-fundamentals-for-data-scientists-9dc19071da55
