คลาสและออบเจ็กต์ใน Python สำหรับผู้เริ่มต้น

วันนี้เราจะพูดถึงคลาส (Classes) ไม่ใช่ห้องเรียนในโรงเรียนนะ

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

Python เป็นภาษาโปรแกรมมิ่งแบบเชิงออบเจ็กต์ (Object-Oriented) หมายความว่ามันใช้รูปแบบการพัฒนาที่ใช้ออบเจ็กต์และคลาสในการจัดเก็บข้อมูล

แนวทางเชิงออบเจ็กต์ช่วยลดการซ้ำซ้อนในโค้ดของคุณ ทำให้อ่านและบำรุงรักษาโค้ดได้ง่ายขึ้น คลาสและออบเจ็กต์เป็นส่วนหนึ่งของภาษาโปรแกรมมิ่งหลายภาษา เช่น Java, Python, และ C++

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

Class คืออะไร?

Class คือแผนผังที่คุณใช้เพื่อกำหนดออบเจ็กต์

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

คลาสถูกกำหนดโดยใช้คีย์เวิร์ด class มาเริ่มต้นด้วยการกำหนดคลาสชื่อ Player ที่มีสองฟังก์ชัน:

class Player:
    """ This is a class for a player """
    name = "Luke"
    def wield_sword(self):
        print("You have wielded your sword.")
    def drink_health_potion(self):
        print("You have consumed a health potion.")

คลาสนี้แทนผู้เล่นในเกมวิดีโอ มันประกอบด้วยทั้งแอตทริบิวต์และเมธอด แอตทริบิวต์มักเรียกว่า instance variables (ตัวแปรอินสแตนซ์) เมื่ออยู่ภายในคลาส

เมธอดหนึ่งช่วยให้คุณใช้ดาบได้ และอีกเมธอดช่วยให้คุณดื่มยาเพิ่มชีวิตได้ คลาสมี class variable หนึ่งตัว: name มันเก็บชื่อเริ่มต้นสำหรับผู้เล่นของเรา

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

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

Object คืออะไร?

Object เป็นอินสแตนซ์เดียวของคลาส มันถูกกำหนดโดยใช้แผนผังที่สร้างโดยคลาส

มาสร้างออบเจ็กต์สำหรับผู้เล่นใหม่ในเกมของเรา คือ Luke:

luke = Player()

เราเพิ่งสร้างออบเจ็กต์ชื่อ Luke ออบเจ็กต์ของเราตอนนี้สามารถเข้าถึงข้อมูลทั้งหมดที่จัดเก็บภายในคลาสของเรา รวมถึงเมธอดที่เกี่ยวข้องกับคลาสของเรา:

luke = Player()
print(luke.name)
luke.wield_sword()

โค้ดของเราคืนค่า:

Luke

You have wielded your sword.

ในโค้ดของเรา เราพิมพ์ค่าของแอตทริบิวต์ name ในออบเจ็กต์ Luke ของเรา เพื่อเข้าถึงแอตทริบิวต์ในคลาส คุณต้องระบุชื่อของคลาส ตามด้วยจุด แล้วตามด้วย instance attribute ที่คุณต้องการเข้าถึง นี้มักเรียกว่า dot notation (การเขียนแบบจุด)

โดยค่าเริ่มต้น ค่าของ name ถูกตั้งค่าเป็น Luke เราจะพูดถึงวิธีเปลี่ยนในภายหลัง

เรายังเรียกคลาส wield_sword() ของเรา เมื่อเราเรียกคลาสนี้ เนื้อหาของเมธอด wield_sword() ภายในคลาส Player ของเราถูกดำเนินการ ส่งผลให้ข้อความถูกพิมพ์ทางคอนโซลระบุว่า "You have wielded your sword."

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

Class Constructors (คอนสตรัคเตอร์ของคลาส)

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

ชื่อของคอนสตรัคเตอร์คือ __init__() คุณอาจเคยเห็นฟังก์ชันที่มี underscore คู่ (__) ในโค้ดของคุณ ฟังก์ชันเหล่านี้เรียกว่า Special Functions (ฟังก์ชันพิเศษ) เพราะมีวัตถุประสงค์ที่กำหนดไว้ล่วงหน้า ในกรณีนี้ วัตถุประสงค์ของ __init__ คือเพื่อเริ่มต้นคลาสของเรา

อัปเดตคลาส Player ที่เราสร้างก่อนหน้านี้เพื่อรวมเมธอดนี้ไว้ที่ด้านบนของคลาส:

def __init__(self):
    print("Your character has been created.")

เมธอดนี้ต้องมาก่อนตัวแปรหรือเมธอดใดๆ ที่กำหนดในคลาสของคุณ มารันโค้ดหลักของเราจากก่อนหน้านี้อีกครั้ง:

luke = Player()
print(luke.name)
luke.wield_sword()

โค้ดของเราคืนค่า:

Your character has been created.

Luke

You have wielded your sword.

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

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

นั่นคือที่มาของ Constructors มาสร้าง Constructor ที่อนุญาตให้เรากำหนดชื่อให้ผู้เล่นของเรา:

class Player:
    def __init__(self, name):
        self.name = name

โค้ดนี้ช่วยให้เราส่งพารามิเตอร์เข้าไปในแต่ละออบเจ็กต์ Player พารามิเตอร์นี้จะแทนชื่อของผู้เล่น เราจะสร้างเมธอดที่บอกชื่อผู้เล่นของเรา:

class Player:
    def __init__(self, name):
        self.name = name
    def get_name(self):
        print("Your name is " + self.name)

มาสร้างอินสแตนซ์ใหม่ของคลาส Player สำหรับผู้เล่นชื่อ Leah:

leah = Player("Leah")
leah.get_name()

โค้ดของเราคืนค่า:

Your name is Leah.

เรากำหนดค่าของตัวแปร name ในออบเจ็กต์ของเราเป็น Leah นี่หมายความว่าทุกที่ที่เราอ้างอิงมันในคลาสของเรา ค่าของมันคือ Leah Constructor ถูกดำเนินการทันทีที่เราสร้างออบเจ็กต์ของคลาส ดังนั้นเราไม่ต้องกังวลเรื่องการเรียกมัน

เราจึงเรียกเมธอด get_name() ซึ่งพิมพ์ชื่อที่เกี่ยวข้องกับผู้เล่นของเรา

คุณสามารถเพิ่มพารามิเตอร์ให้คลาสได้ไม่จำกัดจำนวน:

class Player:
    def __init__(self, name, player_type):
        self.name = name
        self.player_type = player_type
    def get_name(self):
        print("Your name is " + self.name)
    def get_player_type(self):
        print(self.name + " is a " + self.player_type + ".")

ในตัวอย่างนี้ คลาส Player ของเรารองรับสองพารามิเตอร์ หนึ่งแทนชื่อของ Player (name) และอีกอันแทนประเภทของผู้เล่นนั้น (player_type) มาสร้างออบเจ็กต์ของคลาสนี้:

leah = Player("Leah", "Mage")
leah.get_name()
leah.get_player_type()

โค้ดของเราคืนค่า:

Your name is Leah.

Leah is a Mage.

ค่าเริ่มต้นทั้งสองที่เราระบุสามารถเข้าถึงได้ในคลาสของเรา

สรุป

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

ตอนนี้คุณพร้อมที่จะเริ่มเขียนคลาส Python ของคุณเองอย่างมืออาชีพแล้ว!