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

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ (OOP), ಮೆಥಡ್‌ಗಳು ಎಂದರೆ ಒಂದು ಕ್ಲಾಸ್‌ನೊಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಫಂಕ್ಷನ್‌ಗಳು. ಈ ಮೆಥಡ್‌ಗಳು ಆ ಕ್ಲಾಸ್‌ನ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಗುಣಲಕ್ಷಣಗಳನ್ನು (attributes) ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಮೆಥಡ್‌ಗಳು ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನ "ವರ್ತನೆ" (behavior) ಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ.

ಮೆಥಡ್‌ಗಳ ವಿಧಗಳು

ಪೈಥಾನ್‌ನಲ್ಲಿ ಮುಖ್ಯವಾಗಿ ಮೂರು ರೀತಿಯ ಮೆಥಡ್‌ಗಳಿವೆ:

1. ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್‌ಗಳು (Instance Methods): ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಥಿತಿಯನ್ನು (state) ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಬದಲಾಯಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
2. ಕ್ಲಾಸ್ ಮೆಥಡ್‌ಗಳು (Class Methods): ಕ್ಲಾಸ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಬದಲಾಯಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
3. ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್‌ಗಳು (Static Methods): ಕ್ಲಾಸ್ ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಥಿತಿಯೊಂದಿಗೆ ಯಾವುದೇ ಸಂಬಂಧವಿಲ್ಲದ ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

---

1. ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್‌ಗಳು (Instance Methods)

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

ಗುಣಲಕ್ಷಣಗಳು: * ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ self ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. * self ಮೂಲಕ ಇನ್‌ಸ್ಟೆನ್ಸ್ (ಆಬ್ಜೆಕ್ಟ್) ಮಟ್ಟದ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಬದಲಾಯಿಸಬಹುದು. * self.__class__ ಮೂಲಕ ಕ್ಲಾಸ್ ಮಟ್ಟದ ಡೇಟಾವನ್ನು ಸಹ ಪ್ರವೇಶಿಸಬಹುದು.

ಉದಾಹರಣೆ:

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

    # ಇದು ಒಂದು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್
    def get_average(self):
        return sum(self.marks) / len(self.marks)

    # ಮತ್ತೊಂದು ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್
    def display(self):
        print(f"ವಿದ್ಯಾರ್ಥಿ: {self.name}")
        print(f"ಸರಾಸರಿ ಅಂಕಗಳು: {self.get_average()}")

# ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
s1 = Student("ರವಿ ಕಿರಣ", [85, 90, 78, 92])
s2 = Student("ಪಾರ್ವತಮ್ಮ", [95, 88, 92, 97])

# ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್‌ಗಳನ್ನು ಕರೆಯುವುದು
s1.display()
print("-" * 20)
s2.display()

ಔಟ್‌ಪುಟ್:

ವಿದ್ಯಾರ್ಥಿ: ರವಿ ಕಿರಣ
ಸರಾಸರಿ ಅಂಕಗಳು: 86.25
--------------------
ವಿದ್ಯಾರ್ಥಿ: ಪಾರ್ವತಮ್ಮ
ಸರಾಸರಿ ಅಂಕಗಳು: 93.0

ಇಲ್ಲಿ, get_average ಮತ್ತು display ಮೆಥಡ್‌ಗಳು ಪ್ರತಿ ವಿದ್ಯಾರ್ಥಿಯ (s1, s2) ಸ್ವಂತ ಅಂಕಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

2. ಕ್ಲಾಸ್ ಮೆಥಡ್‌ಗಳು (Class Methods)

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

ಕ್ಲಾಸ್ ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸಲು @classmethod ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಗುಣಲಕ್ಷಣಗಳು: * ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ cls ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. * cls ಮೂಲಕ ಕ್ಲಾಸ್ ಮಟ್ಟದ ಡೇಟಾವನ್ನು (class variables) ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಬದಲಾಯಿಸಬಹುದು. * ಇವುಗಳನ್ನು ಫ್ಯಾಕ್ಟರಿ ಮೆಥಡ್‌ಗಳಾಗಿ (Factory Methods) ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಬೇರೆ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು.

ಉದಾಹರಣೆ:

class Car:
    # ಕ್ಲಾಸ್ ವೇರಿಯೇಬಲ್
    fuel_type = "ಪೆಟ್ರೋಲ್"

    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

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

    @classmethod
    def change_fuel_type(cls, new_fuel):
        # ಕ್ಲಾಸ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು
        cls.fuel_type = new_fuel
        print(f"ಎಲ್ಲಾ ಕಾರುಗಳ ಇಂಧನ ಪ್ರಕಾರವನ್ನು '{new_fuel}' ಗೆ ಬದಲಾಯಿಸಲಾಗಿದೆ.")

    @classmethod
    def from_string(cls, car_string):
        # ಫ್ಯಾಕ್ಟರಿ ಮೆಥಡ್: ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
        brand, model = car_string.split('-')
        return cls(brand, model)

# ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು
car1 = Car("ಮಾರುತಿ", "ಸ್ವಿಫ್ಟ್")
car2 = Car("ಹ್ಯುಂಡೈ", "ಕ್ರೆಟಾ")

car1.display_info()
car2.display_info()

print("-" * 20)

# ಕ್ಲಾಸ್ ಮೆಥಡ್ ಅನ್ನು ಕರೆಯುವುದು (ಕ್ಲಾಸ್ ಬಳಸಿ)
Car.change_fuel_type("ಡೀಸೆಲ್")

car1.display_info()
car2.display_info()

print("-" * 20)

# ಫ್ಯಾಕ್ಟರಿ ಮೆಥಡ್ ಬಳಸಿ ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸುವುದು
car3_string = "ಟಾಟಾ-ನೆಕ್ಸಾನ್"
car3 = Car.from_string(car3_string)
car3.display_info()

ಔಟ್‌ಪುಟ್:

ಬ್ರಾಂಡ್: ಮಾರುತಿ, ಮಾಡೆಲ್: ಸ್ವಿಫ್ಟ್, ಇಂಧನ: ಪೆಟ್ರೋಲ್
ಬ್ರಾಂಡ್: ಹ್ಯುಂಡೈ, ಮಾಡೆಲ್: ಕ್ರೆಟಾ, ಇಂಧನ: ಪೆಟ್ರೋಲ್
--------------------
ಎಲ್ಲಾ ಕಾರುಗಳ ಇಂಧನ ಪ್ರಕಾರವನ್ನು 'ಡೀಸೆಲ್' ಗೆ ಬದಲಾಯಿಸಲಾಗಿದೆ.
ಬ್ರಾಂಡ್: ಮಾರುತಿ, ಮಾಡೆಲ್: ಸ್ವಿಫ್ಟ್, ಇಂಧನ: ಡೀಸೆಲ್
ಬ್ರಾಂಡ್: ಹ್ಯುಂಡೈ, ಮಾಡೆಲ್: ಕ್ರೆಟಾ, ಇಂಧನ: ಡೀಸೆಲ್
--------------------
ಬ್ರಾಂಡ್: ಟಾಟಾ, ಮಾಡೆಲ್: ನೆಕ್ಸಾನ್, ಇಂಧನ: ಡೀಸೆಲ್

3. ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್‌ಗಳು (Static Methods)

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

ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್‌ಗಳನ್ನು ರಚಿಸಲು @staticmethod ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಗುಣಲಕ್ಷಣಗಳು: * self ಅಥವಾ cls ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. * ಕ್ಲಾಸ್ ಅಥವಾ ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಅಥವಾ ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. * ಇವುಗಳನ್ನು ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ:

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def is_even(num):
        return num % 2 == 0

    @staticmethod
    def info():
        print("ಇದು ಗಣಿತದ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಸಹಾಯ ಮಾಡುವ ಒಂದು ಯುಟಿಲಿಟಿ ಕ್ಲಾಸ್.")

# ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್‌ಗಳನ್ನು ಕರೆಯುವುದು (ಕ್ಲಾಸ್ ಬಳಸಿ)
sum_result = MathUtils.add(10, 5)
print(f"10 ಮತ್ತು 5 ರ ಮೊತ್ತ: {sum_result}")

check_even = MathUtils.is_even(7)
print(f"7 ಸಮ ಸಂಖ್ಯೆಯೇ? {check_even}")

MathUtils.info()

# ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸಿಯೂ ಕರೆಯಬಹುದು, ಆದರೆ ಇದು ಅಪ್ರಸ್ತುತ
math_obj = MathUtils()
print(f"ಆಬ್ಜೆಕ್ಟ್ ಮೂಲಕ ಮೊತ್ತ: {math_obj.add(2, 3)}")

ಔಟ್‌ಪುಟ್:

10 ಮತ್ತು 5 ರ ಮೊತ್ತ: 15
7 ಸಮ ಸಂಖ್ಯೆಯೇ? False
ಇದು ಗಣಿತದ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಸಹಾಯ ಮಾಡುವ ಒಂದು ಯುಟಿಲಿಟಿ ಕ್ಲಾಸ್.
ಆಬ್ಜೆಕ್ಟ್ ಮೂಲಕ ಮೊತ್ತ: 5

ಸಾರಾಂಶ

ಮೆಥಡ್ ಪ್ರಕಾರ	ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್	ಡೆಕೋರೇಟರ್	ಮುಖ್ಯ ಉದ್ದೇಶ
ಇನ್‌ಸ್ಟೆನ್ಸ್ ಮೆಥಡ್	self	ಇಲ್ಲ	ಆಬ್ಜೆಕ್ಟ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು.
ಕ್ಲಾಸ್ ಮೆಥಡ್	cls	@classmethod	ಕ್ಲಾಸ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು, ಫ್ಯಾಕ್ಟರಿ ಮೆಥಡ್‌ಗಳು.
ಸ್ಟ್ಯಾಟಿಕ್ ಮೆಥಡ್	ಇಲ್ಲ	@staticmethod	ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್‌ಗಳು.