ವಿಷಯಕ್ಕೆ ತೆರಳಿ

ಕ್ಲಾಸ್ ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್ (Class and Object)

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಎಲ್ಲವೂ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಾಗಿವೆ. ಕ್ಲಾಸ್ ಎನ್ನುವುದು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಬ್ಲೂಪ್ರಿಂಟ್ ಆಗಿದೆ. ಇದು ಡೇಟಾ (ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ attributes) ಮತ್ತು ಆ ಡೇಟಾದ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿಧಾನಗಳನ್ನು (methods) ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಕ್ಲಾಸ್ (Class)

ಒಂದು ಕ್ಲಾಸ್ ಎನ್ನುವುದು ಬಳಕೆದಾರ-ನಿರ್ಧರಿತ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿದೆ. class ಕೀವರ್ಡ್ ಬಳಸಿ ಕ್ಲಾಸ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್: 

class ClassName:
    # ಗುಣಲಕ್ಷಣಗಳು (attributes)
    # ವಿಧಾನಗಳು (methods)

ಉದಾಹರಣೆ: ಒಂದು Car ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸೋಣ.

class Car:
    # ಕ್ಲಾಸ್ ಗುಣಲಕ್ಷಣ (class attribute)
    wheels = 4

    def __init__(self, brand, model, color):
        # ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗುಣಲಕ್ಷಣಗಳು (instance attributes)
        self.brand = brand
        self.model = model
        self.color = color

    def display_info(self):
        print(f"ಬ್ರಾಂಡ್: {self.brand}, ಮಾಡೆಲ್: {self.model}, ಬಣ್ಣ: {self.color}")

    def start_engine(self):
        print("ಎಂಜಿನ್ ಚಾಲೂ ಆಯಿತು.")

__init__ ಮೆಥಡ್

__init__ ಎನ್ನುವುದು ಒಂದು ವಿಶೇಷ ಮೆಥಡ್ ಆಗಿದೆ, ಇದನ್ನು "ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಒಂದು ಕ್ಲಾಸ್‌ನಿಂದ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿದಾಗ ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯಲ್ಪಡುತ್ತದೆ. self ಪ್ಯಾರಾಮೀಟರ್ ಆಬ್ಜೆಕ್ಟ್‌ನ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಆಬ್ಜೆಕ್ಟ್ (Object)

ಆಬ್ಜೆಕ್ಟ್ ಎನ್ನುವುದು ಕ್ಲಾಸ್‌ನ ಒಂದು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಆಗಿದೆ. ಒಂದು ಕ್ಲಾಸ್‌ನಿಂದ ನಾವು ಅನೇಕ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.

ಉದಾಹರಣೆ: Car ಕ್ಲಾಸ್‌ನಿಂದ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸೋಣ.

# Car ಕ್ಲಾಸ್‌ನಿಂದ ಎರಡು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು
car1 = Car("Toyota", "Fortuner", "ಬಿಳಿ")
car2 = Car("Ford", "Mustang", "ಕೆಂಪು")

# ಆಬ್ಜೆಕ್ಟ್‌ನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು
print(f"Car 1 ಬ್ರಾಂಡ್: {car1.brand}")
print(f"Car 2 ಬಣ್ಣ: {car2.color}")

# ಆಬ್ಜೆಕ್ಟ್‌ನ ಮೆಥಡ್‌ಗಳನ್ನು ಕರೆಯುವುದು
car1.display_info()  # ಔಟ್‌ಪುಟ್: ಬ್ರಾಂಡ್: Toyota, ಮಾಡೆಲ್: Fortuner, ಬಣ್ಣ: ಬಿಳಿ
car2.start_engine()  # ಔಟ್‌ಪುಟ್: ಎಂಜಿನ್ ಚಾಲೂ ಆಯಿತು.

ಕ್ಲಾಸ್ ಮತ್ತು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗುಣಲಕ್ಷಣಗಳು (Class and Instance Attributes)

  • ಕ್ಲಾಸ್ ಗುಣಲಕ್ಷಣ (Class Attribute): ಕ್ಲಾಸ್‌ನ ಎಲ್ಲಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಹಂಚಿಕೆಯಾಗುವ ಗುಣಲಕ್ಷಣ. ಇದನ್ನು ಕ್ಲಾಸ್‌ನ ಒಳಗೆ ಆದರೆ ಯಾವುದೇ ಮೆಥಡ್‌ನ ಹೊರಗೆ ಡಿಫೈನ್ ಮಾಡಲಾಗುತ್ತದೆ.

    • ಉದಾಹರಣೆ: wheels = 4

  • ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗುಣಲಕ್ಷಣ (Instance Attribute): ಪ್ರತಿ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ವಿಶಿಷ್ಟವಾದ ಗುಣಲಕ್ಷಣ. ಇದನ್ನು __init__ ಮೆಥಡ್‌ನೊಳಗೆ self ಬಳಸಿ ಡಿಫೈನ್ ಮಾಡಲಾಗುತ್ತದೆ.

    • ಉದಾಹರಣೆ: self.brand, self.model

ಉದಾಹರಣೆ: 

class Dog:
    # ಕ್ಲಾಸ್ ಗುಣಲಕ್ಷಣ
    species = "Canis lupus familiaris"

    def __init__(self, name, age):
        # ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗುಣಲಕ್ಷಣಗಳು
        self.name = name
        self.age = age

# ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು
dog1 = Dog("ಚಾರ್ಲಿ", 3)
dog2 = Dog("ಮ್ಯಾಕ್ಸ್", 5)

# ಕ್ಲಾಸ್ ಗುಣಲಕ್ಷಣವನ್ನು ಪ್ರವೇಶಿಸುವುದು
print(f"{dog1.name} is a {dog1.species}") # ಔಟ್‌ಪುಟ್: ಚಾರ್ಲಿ is a Canis lupus familiaris
print(f"{dog2.name} is also a {dog2.species}") # ಔಟ್‌ಪುಟ್: ಮ್ಯಾಕ್ಸ್ is also a Canis lupus familiaris

# ಇನ್‌ಸ್ಟೆನ್ಸ್ ಗುಣಲಕ್ಷಣವನ್ನು ಪ್ರವೇಶಿಸುವುದು
print(f"{dog1.name} is {dog1.age} years old.") # ಔಟ್‌ಪುಟ್: ಚಾರ್ಲಿ is 3 years old.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, species ಎಲ್ಲಾ ನಾಯಿಗಳಿಗೆ ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಆದರೆ name ಮತ್ತು age ಪ್ರತಿ ನಾಯಿಗೆ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ.

ಇನ್ಹೆರಿಟೆನ್ಸ್ (Inheritance)

ಇನ್ಹೆರಿಟೆನ್ಸ್ ಎನ್ನುವುದು ಒಂದು ಕ್ಲಾಸ್‌ (ಚೈಲ್ಡ್ ಕ್ಲಾಸ್ ಅಥವಾ ಡೆರಿವ್ಡ್ ಕ್ಲಾಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಇತರ ಕ್ಲಾಸ್‌ (ಪ್ಯಾರೆಂಟ್ ಕ್ಲಾಸ್ ಅಥವಾ ಬೇಸಿಕ್ ಕ್ಲಾಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಪರಿಗಣಿಸುವ ಸಾಮರ್ಥ್ಯವಾಗಿದೆ. ಇದು ಕೋಡ್ ಪುನರ್‌ಬಳಕೆ ಮತ್ತು ಹೈರಾರ್ಕಿಕ ಕ್ಲಾಸ್ ರಚನೆಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ: 

# ಪ್ಯಾರೆಂಟ್ ಕ್ಲಾಸ್
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("ಈ ಮೆಥಡ್ ಅನ್ನು ಉಪವರ್ಗದಲ್ಲಿ ನಿರ್ಧರಿಸಬೇಕು")

# ಚೈಲ್ಡ್ ಕ್ಲಾಸ್
class Dog(Animal):
    def speak(self):
        return "ಬಾರ್ಕ್"

class Cat(Animal):
    def speak(self):
        return "ಮ್ಯಾವು"

# ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು
dog = Dog("ರಾಕಿ")
cat = Cat("ಮ್ಯಾವೋ")

print(f"{dog.name} ಹೇಳುತ್ತದೆ: {dog.speak()}")  # ಔಟ್‌ಪುಟ್: ರಾಕಿ ಹೇಳುತ್ತದೆ: ಬಾರ್ಕ್
print(f"{cat.name} ಹೇಳುತ್ತದೆ: {cat.speak()}")  # ಔಟ್‌ಪುಟ್: ಮ್ಯಾವೋ ಹೇಳುತ್ತದೆ: ಮ್ಯಾವು

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Dog ಮತ್ತು Cat ಕ್ಲಾಸ್‌ಗಳು Animal ಕ್ಲಾಸ್ ಅನ್ನು ಇನ್ಹೆರಿಟ್ ಮಾಡುತ್ತವೆ ಮತ್ತು ತಮ್ಮದೇ ಆದ speak ಮೆಥಡ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ.

ಪಾಲಿಮಾರ್ಫಿಸಮ್ (Polymorphism)

ಪಾಲಿಮಾರ್ಫಿಸಮ್ ಎನ್ನುವುದು ವಿಭಿನ್ನ ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಸೇರಿದ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಒಂದೇ ಹೆಸರು ಹೊಂದಿರುವ ಆದರೆ ವಿಭಿನ್ನ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೆಥಡ್ ಅನ್ನು ಹೊಂದಿರುವ ಸಾಮರ್ಥ್ಯವಾಗಿದೆ. ಇದು ಇನ್ಹೆರಿಟೆನ್ಸ್ ಮತ್ತು ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಧಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ಮೇಲಿನ ಉದಾಹರಣೆಯ ಮುಂದುವರಿದಂತೆ, Dog ಮತ್ತು Cat ಕ್ಲಾಸ್‌ಗಳಲ್ಲಿ speak ಎಂಬ ಸಾಮಾನ್ಯ ಮೆಥಡ್ ಇದೆ, ಆದರೆ ಅದು ಪ್ರತಿ ಕ್ಲಾಸ್‌ನಲ್ಲಿ ವಿಭಿನ್ನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

animals = [Dog("ರಾಕಿ"), Cat("ಮ್ಯಾವೋ")]

for animal in animals:
    print(f"{animal.name} ಹೇಳುತ್ತದೆ: {animal.speak()}")

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ವಿಭಿನ್ನ ಪ್ರಾಣಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಪಟ್ಟಿಯಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಪ್ರಾಣಿಯ ಹೆಸರು ಮತ್ತು ಧ್ವನಿಯನ್ನು ಮುದ್ರಣ ಮಾಡಲು ಒಂದೇ ರೀತಿಯ ಲೂಪ್ ಅನ್ನು ಬಳಸಬಹುದು.

ಎಂಕ್ಯಾಪ್ಸುಲೇಶನ್ (Encapsulation)

ಎಂಕ್ಯಾಪ್ಸುಲೇಶನ್ ಎನ್ನುವುದು ಡೇಟಾ ಮತ್ತು ಅದಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ವಿಧಾನಗಳನ್ನು ಒಂದು ಏಕಕೋಷ್ಟಕದಲ್ಲಿ (ಕ್ಲಾಸ್) ಒಟ್ಟುಗೂಡಿಸುವುದು. ಇದು ಡೇಟಾ ಹಕ್ಕುಗಳನ್ನು ಮತ್ತು ಸುರಕ್ಷಿತವಾದ ಕೋಡ್ ಅನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ, ನಾವು _ ಅಥವಾ __ ಪ್ರೀಫಿಕ್ಸ್ ಅನ್ನು ಬಳಸಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಖಾಸಗಿ (private) ಅಥವಾ ರಕ್ಷಿತ (protected) ಎಂದು ಗುರುತಿಸಬಹುದು.

ಉದಾಹರಣೆ: 

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # ಖಾಸಗಿ ಗುಣಲಕ್ಷಣ

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

account = BankAccount("ಜಾನ್ ಡೋ")
account.deposit(1000)
print(account.get_balance())  # ಔಟ್‌ಪುಟ್: 1000

account.withdraw(500)
print(account.get_balance())  # ಔಟ್‌ಪುಟ್: 500

# ನೇರವಾಗಿ ಖಾಸಗಿ ಗುಣಲಕ್ಷಣವನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುವುದು (ಅನುಮೋದಿತವಲ್ಲ)
# print(account.__balance)  # AttributeError

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, __balance ಗುಣಲಕ್ಷಣವು ಖಾಸಗಿ ಮತ್ತು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದರೆ, ನಾವು ಸಾರ್ವಜನಿಕ ಮೆಥಡ್‌ಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, deposit, withdraw, get_balance) ಬಳಸಿಕೊಂಡು ಅದನ್ನು ನಿರ್ವಹಿಸಬಹುದು.

ಮೆಥಡ್‌ಗಳು (Methods)

ಮೆಥಡ್‌ಗಳು ಕ್ಲಾಸ್‌ನ ಒಳಗೆ ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯಗಳು. ಇವು ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತವೆ. ಮೆಥಡ್‌ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡಲು, ನಾವು ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡುವಂತೆ def ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದರೆ ಇವು ಕ್ಲಾಸ್‌ನ ಒಳಗೆ ಇರಬೇಕು.

ಉದಾಹರಣೆ: ಮೇಲಿನ Car ಕ್ಲಾಸ್‌ನಲ್ಲಿ, display_info ಮತ್ತು start_engine ಎಂಬ ಎರಡು ಮೆಥಡ್‌ಗಳಿವೆ.

my_car = Car("Honda", "Civic", "ಕಪ್ಪು")

# display_info ಮೆಥಡ್ ಅನ್ನು ಕರೆಯುವುದು
my_car.display_info()  # ಔಟ್‌ಪುಟ್: ಬ್ರಾಂಡ್: Honda, ಮಾಡೆಲ್: Civic, ಬಣ್ಣ: ಕಪ್ಪು

# start_engine ಮೆಥಡ್ ಅನ್ನು ಕರೆಯುವುದು
my_car.start_engine()  # ಔಟ್‌ಪುಟ್: ಎಂಜಿನ್ ಚಾಲೂ ಆಯಿತು.

ಸ್ಟ್ಯಾಟಿಕ್ ಮತ್ತು ಕ್ಲಾಸ್ ಮೆಥಡ್‌ಗಳು (Static and Class Methods)

  • ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್‌ಗಳು: ಈ ಮೆಥಡ್‌ಗಳು ಕ್ಲಾಸ್ ಅಥವಾ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತವೆ. ಇವು ಕ್ಲಾಸ್‌ನಲ್ಲಿಯೇ ಡಿಫೈನ್ ಮಾಡಲಾಗುತ್ತದೆ ಆದರೆ ಇವುಗಳಿಗೆ self ಅಥವಾ cls ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲ.

    ಉದಾಹರಣೆ: 

    class Math:
    @staticmethod
    def add(x, y):
        return x + y

# ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್ ಅನ್ನು ಕರೆಯುವುದು
result = Math.add(5, 3)
print(result)  # ಔಟ್‌ಪುಟ್: 8

  • ಕ್ಲಾಸ್ ಮೆಥಡ್‌ಗಳು: ಈ ಮೆಥಡ್‌ಗಳು ಕ್ಲಾಸ್‌ನ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಪರಿಷ್ಕರಿಸಲು ಬಳಸಲಾಗುತ್ತವೆ. ಇವುಗಳಿಗೆ ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್‌ವಾಗಿ cls ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

    ಉದಾಹರಣೆ: 

    class Employee:
    raise_amount = 1.04

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    @classmethod
    def set_raise_amount(cls, amount):
        cls.raise_amount = amount

# ಕ್ಲಾಸ್ ಮೆಥಡ್ ಅನ್ನು ಕರೆಯುವುದು
Employee.set_raise_amount(1.05)
print(Employee.raise_amount)  # ಔಟ್‌ಪುಟ್: 1.05

ಈ ಎಲ್ಲಾ ತತ್ವಗಳು ಮತ್ತು ವೈಶಿಷ್ಟ್ಯಗಳು ಪೈಥಾನ್‌ನಲ್ಲಿ ಕ್ಲಾಸ್‌ಗಳು ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸುವಾಗ ನಮಗೆ ಹೆಚ್ಚು ನಿಯಂತ್ರಣ ಮತ್ತು ಲವಚಿಕತೆಯನ್ನು ನೀಡುತ್ತವೆ.