ಪೈಥಾನ್ ಮತ್ತು ಸುಧಾರಿತ ವಿಧಾನಗಳು, ಉತ್ತಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ ಡಂಡರ್ ಕಾರ್ಯಗಳು

ಪೈಥಾನ್ ಒಂದು ಅದ್ಭುತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ ಮತ್ತು ಅದಕ್ಕೆ ಸಾಕ್ಷಿಯಾಗಿದೆ GitHub, 2022 ರಲ್ಲಿ ಎರಡನೇ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಭಾಷೆಯಾಗಿದೆ.

ಪೈಥಾನ್‌ನ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಪ್ರಯೋಜನಗಳೆಂದರೆ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳ ದೊಡ್ಡ ಸಮುದಾಯ.

ಯಾವುದೇ ಬಳಕೆಯ ಸಂದರ್ಭಕ್ಕಾಗಿ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಹೊಂದಿರುವಂತೆ ತೋರುತ್ತಿದೆ.

ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ವಿಶಾಲ ಜಗತ್ತಿನಲ್ಲಿ, ಆರಂಭಿಕರಿಗಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಗಮನಿಸದೇ ಇರುವ ವೈಶಿಷ್ಟ್ಯಗಳ ಒಂದು ಸೆಟ್ ಇದೆ, ಆದರೆ ಭಾಷೆಯ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಗಮನಾರ್ಹ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಹೊಂದಿದೆ.

ಮ್ಯಾಜಿಕ್ ವಿಧಾನಗಳು ಪೂರ್ವ ವಿಧಾನಗಳ ಒಂದು ಗುಂಪಾಗಿದೆdefiವಿಶೇಷ ವಾಕ್ಯರಚನೆಯ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುವ ಪೈಥಾನ್‌ನಲ್ಲಿ ನೈಟ್ಸ್. ಆರಂಭದಲ್ಲಿ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಅವರ ಡಬಲ್ ಡ್ಯಾಶ್‌ಗಳಿಂದ ಅವುಗಳನ್ನು ಸುಲಭವಾಗಿ ಗುರುತಿಸಲಾಗುತ್ತದೆ __init__, __call__, __len__ … ಇತ್ಯಾದಿ.

ಮಾಂತ್ರಿಕ ವಿಧಾನಗಳು

ಮ್ಯಾಜಿಕ್ ವಿಧಾನಗಳು ಕಸ್ಟಮ್ ವಸ್ತುಗಳು ಅಂತರ್ನಿರ್ಮಿತ ಪೈಥಾನ್ ಪ್ರಕಾರಗಳಂತೆಯೇ ವರ್ತಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಶಕ್ತಿಯುತ ಡಂಡರ್ ಕಾರ್ಯಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ. ನಾವು ಅವರ ಉದ್ದೇಶವನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.

ನೀವು ಪೈಥಾನ್ ಅನನುಭವಿ ಅಥವಾ ಅನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ ಆಗಿರಲಿ, ಈ ಲೇಖನವು ನಿಮಗೆ ಡಂಡರ್ ಕಾರ್ಯಗಳ ಸಮಗ್ರ ತಿಳುವಳಿಕೆಯನ್ನು ಒದಗಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ, ಇದು ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡಿಂಗ್ ಅನುಭವವನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಆನಂದದಾಯಕವಾಗಿಸುತ್ತದೆ.

ನೆನಪಿಡಿ, ಪೈಥಾನ್‌ನ ಮಾಂತ್ರಿಕತೆಯು ಅದರ ಸರಳತೆ ಮತ್ತು ಬಹುಮುಖತೆಯಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ, ಡಂಡರ್ ಕಾರ್ಯಗಳಂತಹ ಅದರ ಪ್ರಬಲ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿಯೂ ಇದೆ.

__init__

ಬಹುಶಃ ಎಲ್ಲಕ್ಕಿಂತ ಮೂಲಭೂತವಾದ ಡಂಡರ್ ಕಾರ್ಯ. ನಾವು ಹೊಸ ವಸ್ತುವನ್ನು ರಚಿಸಿದಾಗ (ಅಥವಾ ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಪ್ರಾರಂಭಿಸಿದಾಗ) ಪೈಥಾನ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರೆಯುವ ಮ್ಯಾಜಿಕ್ ವಿಧಾನ ಇದು.__init__

ವರ್ಗ ಪಿಜ್ಜಾ:
    def __init__(ಸ್ವಯಂ, ಗಾತ್ರ, ಮೇಲೋಗರಗಳು):
        self.size = ಗಾತ್ರ
        self.toppings = ಮೇಲೋಗರಗಳು

# ಈಗ ನಾವು ಪಿಜ್ಜಾವನ್ನು ರಚಿಸೋಣ
my_pizza = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು'])

print(my_pizza.size) # ಇದು ಮುದ್ರಿಸುತ್ತದೆ: ದೊಡ್ಡದು
ಪ್ರಿಂಟ್(my_pizza.toppings) # ಇದು ಮುದ್ರಿಸುತ್ತದೆ: ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು']

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

ಇಲ್ಲಿ, ವರ್ಗದ ನಿದರ್ಶನವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ನಾವು self.size = ಗಾತ್ರವನ್ನು ಬರೆಯುವಾಗ, ನಾವು ಹೇಳುತ್ತೇವೆ, "ಹೇ, ಈ ಪಿಜ್ಜಾ ವಸ್ತುವು ಗುಣಲಕ್ಷಣದ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ size, ಮತ್ತು ನಾನು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿದಾಗ ನಾನು ಒದಗಿಸಿದ ಯಾವುದೇ ಗಾತ್ರವಾಗಿರಬೇಕೆಂದು ನಾನು ಬಯಸುತ್ತೇನೆ".

__str__ ಮತ್ತು __repr__

__Str__

ಇದು ಪೈಥಾನ್‌ನ ಮ್ಯಾಜಿಕ್ ವಿಧಾನವಾಗಿದ್ದು ಅದು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ defiನಮ್ಮ ಕಸ್ಟಮ್ ಐಟಂಗೆ ವಿವರಣೆಯನ್ನು ನೀಡಿ.

ನೀವು ವಸ್ತುವನ್ನು ಮುದ್ರಿಸಿದಾಗ ಅಥವಾ ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿದಾಗ str(), ನೀವು ಹೊಂದಿದ್ದರೆ ಪೈಥಾನ್ ಪರಿಶೀಲಿಸಿ defiನಾನು ಒಂದು ವಿಧಾನದೊಂದಿಗೆ ಬಂದಿದ್ದೇನೆ __str__ ಆ ವಸ್ತುವಿನ ವರ್ಗಕ್ಕೆ.

ಹಾಗಿದ್ದಲ್ಲಿ, ವಸ್ತುವನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪರಿವರ್ತಿಸಲು ಆ ವಿಧಾನವನ್ನು ಬಳಸಿ.

ಕಾರ್ಯವನ್ನು ಸೇರಿಸಲು ನಾವು ನಮ್ಮ ಪಿಜ್ಜಾ ಉದಾಹರಣೆಯನ್ನು ವಿಸ್ತರಿಸಬಹುದು __str__ ಈ ಕೆಳಗಿನಂತೆ:

ವರ್ಗ ಪಿಜ್ಜಾ: ಡೆಫ್ __init__(ಸ್ವಯಂ, ಗಾತ್ರ, ಮೇಲೋಗರಗಳು): self.size = ಗಾತ್ರ self.toppings = ಮೇಲೋಗರಗಳು def __str__(self): {', '.join(self.toppings ಜೊತೆಗೆ f"A {self.size} ಪಿಜ್ಜಾ ಹಿಂತಿರುಗಿ )}" my_pizza = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಮಶ್ರೂಮ್ಸ್']) ಪ್ರಿಂಟ್(my_pizza) # ಇದು ಮುದ್ರಿಸುತ್ತದೆ: ಪೆಪ್ಪೆರೋನಿ, ಅಣಬೆಗಳೊಂದಿಗೆ ದೊಡ್ಡ ಪಿಜ್ಜಾ

__repr__

__str__ ಕಾರ್ಯವು ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ವಿವರಿಸುವ ಅನೌಪಚಾರಿಕ ಮಾರ್ಗವಾಗಿದೆ. ಮತ್ತೊಂದೆಡೆ, ಕಸ್ಟಮ್ ವಸ್ತುವಿನ ಹೆಚ್ಚು ಔಪಚಾರಿಕ, ವಿವರವಾದ ಮತ್ತು ನಿಸ್ಸಂದಿಗ್ಧವಾದ ವಿವರಣೆಯನ್ನು ಒದಗಿಸಲು __repr__ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ನೀವು ಕರೆ ಮಾಡಿದರೆ repr() ವಸ್ತುವಿನ ಮೇಲೆ ಅಥವಾ ನೀವು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ವಸ್ತುವಿನ ಹೆಸರನ್ನು ಟೈಪ್ ಮಾಡಿ, ಪೈಥಾನ್ ವಿಧಾನವನ್ನು ಹುಡುಕುತ್ತದೆ __repr__.

Se __str__ ಅದು ಅಲ್ಲ defiರಾತ್ರಿ, ಪೈಥಾನ್ ಬಳಸುತ್ತದೆ __repr__ ವಸ್ತುವನ್ನು ಮುದ್ರಿಸಲು ಅಥವಾ ಅದನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಬ್ಯಾಕಪ್ ಆಗಿ. ಆದ್ದರಿಂದ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಒಳ್ಳೆಯದು defiಕನಿಷ್ಠ ಮುಗಿಸಿ __repr__, ನೀವು ಮಾಡದಿದ್ದರೂ ಸಹ defiಹೊರಗೆ ಬರುತ್ತದೆ __str__.

ನಾವು ಹೇಗೆ ಸಾಧ್ಯವೋ ಎಂಬುದು ಇಲ್ಲಿದೆ defiಮುಗಿಸಿ __repr__ ನಮ್ಮ ಪಿಜ್ಜಾ ಉದಾಹರಣೆಗಾಗಿ:

ವರ್ಗ ಪಿಜ್ಜಾ:
    def __init__(ಸ್ವಯಂ, ಗಾತ್ರ, ಮೇಲೋಗರಗಳು):
        self.size = ಗಾತ್ರ
        self.toppings = ಮೇಲೋಗರಗಳು

    def __repr__(ಸ್ವಯಂ):
        f"ಪಿಜ್ಜಾ('{self.size}', {self.toppings})" ಹಿಂತಿರುಗಿ

my_pizza = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು'])
ಮುದ್ರಣ(repr(my_pizza)) # ಇದು ಮುದ್ರಿಸುತ್ತದೆ: ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು'])

__repr__ ಪಿಜ್ಜಾ ವಸ್ತುವನ್ನು ಮರುಸೃಷ್ಟಿಸಲು ನೀವು ಪೈಥಾನ್ ಆಜ್ಞೆಯಂತೆ ಚಲಾಯಿಸಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಿಮಗೆ ನೀಡುತ್ತದೆ, ಆದರೆ __str__ ನಿಮಗೆ ಹೆಚ್ಚು ಮಾನವ ವಿವರಣೆಯನ್ನು ನೀಡುತ್ತದೆ. ಈ ಡಂಡರ್ ವಿಧಾನಗಳನ್ನು ಸ್ವಲ್ಪ ಉತ್ತಮವಾಗಿ ಅಗಿಯಲು ಇದು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ!

__ಸೇರಿಸು__

ಪೈಥಾನ್‌ನಲ್ಲಿ, ಆಪರೇಟರ್ ಬಳಸಿ ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಿಸುವುದು ಸಾಧ್ಯ ಎಂದು ನಮಗೆಲ್ಲರಿಗೂ ತಿಳಿದಿದೆ +, ಹಾಗೆ 3 + 5.

ಆದರೆ ನಾವು ಕೆಲವು ಕಸ್ಟಮ್ ವಸ್ತುವಿನ ನಿದರ್ಶನಗಳನ್ನು ಸೇರಿಸಲು ಬಯಸಿದರೆ ಏನು?

ಡಂಡರ್ ಕಾರ್ಯ __add__ ಅದು ನಮಗೆ ಹಾಗೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಇದು ನಮಗೆ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ defiನಿರ್ವಾಹಕರ ವರ್ತನೆಯನ್ನು ನಿಶ್ಶಕ್ತಗೊಳಿಸಿ + ನಮ್ಮ ವೈಯಕ್ತಿಕಗೊಳಿಸಿದ ವಸ್ತುಗಳ ಮೇಲೆ.

ಸ್ಥಿರತೆಯ ಆಸಕ್ತಿಯಲ್ಲಿ, ನಾವು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸೋಣ defiನ ನಡವಳಿಕೆಯನ್ನು ಮುಗಿಸಿ + ನಮ್ಮ ಪಿಜ್ಜಾ ಉದಾಹರಣೆಯಲ್ಲಿ. ನಾವು ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಪಿಜ್ಜಾಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಿದಾಗ, ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅವುಗಳ ಎಲ್ಲಾ ಮೇಲೋಗರಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ ಎಂದು ಹೇಳೋಣ. ಅದು ಹೇಗಿರಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

ವರ್ಗ ಪಿಜ್ಜಾ:
    def __init__(ಸ್ವಯಂ, ಗಾತ್ರ, ಮೇಲೋಗರಗಳು):
        self.size = ಗಾತ್ರ
        self.toppings = ಮೇಲೋಗರಗಳು

    def __add__(ಸ್ವಯಂ, ಇತರೆ):
        ಒಂದು ವೇಳೆ ಇಲ್ಲದಿದ್ದರೆ (ಇತರೆ, ಪಿಜ್ಜಾ):
            TypeError ಅನ್ನು ಹೆಚ್ಚಿಸಿ ("ನೀವು ಇನ್ನೊಂದು ಪಿಜ್ಜಾವನ್ನು ಮಾತ್ರ ಸೇರಿಸಬಹುದು!")
        new_toppings = self.toppings + other.toppings
        ಮರಳಿ ಪಿಜ್ಜಾ(self.size, new_toppings)

# ಎರಡು ಪಿಜ್ಜಾಗಳನ್ನು ರಚಿಸೋಣ
ಪಿಜ್ಜಾ1 = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು'])
ಪಿಜ್ಜಾ2 = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಆಲಿವ್ಗಳು', 'ಅನಾನಸ್'])

# ಮತ್ತು ಈಗ ಅವುಗಳನ್ನು "ಸೇರಿಸೋಣ"
ಸಂಯೋಜಿತ_ಪಿಜ್ಜಾ = ಪಿಜ್ಜಾ1 + ಪಿಜ್ಜಾ2

ಪ್ರಿಂಟ್ (ಸಂಯೋಜಿತ_ಪಿಜ್ಜಾ.ಟಾಪಿಂಗ್ಸ್) # ಇದು ಮುದ್ರಿಸುತ್ತದೆ: ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು', 'ಆಲಿವ್‌ಗಳು', 'ಅನಾನಸ್']

ಅದೇ ರೀತಿ ಡಂಡರ್ ಗೆ __add__, ನಾವು ಕೂಡ ಮಾಡಬಹುದು defiಇತರ ಅಂಕಗಣಿತದ ಕಾರ್ಯಗಳನ್ನು ಮುಗಿಸಿ __sub__ (ಆಪರೇಟರ್ ಬಳಸಿ ಕಳೆಯುವ ಮೂಲಕ -) ಇ __mul__ (ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಗುಣಾಕಾರಕ್ಕಾಗಿ *).

__len__

ಈ ಡಂಡರ್ ವಿಧಾನವು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ defiಕಾರ್ಯವನ್ನು ಮುಗಿಸಿ len() ನಮ್ಮ ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ ಐಟಂಗಳಿಗೆ ಹಿಂತಿರುಗಬೇಕು.

ಪೈಥಾನ್ ಬಳಸುತ್ತದೆ len() ಪಟ್ಟಿ ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ನಂತಹ ಡೇಟಾ ರಚನೆಯ ಉದ್ದ ಅಥವಾ ಗಾತ್ರವನ್ನು ಪಡೆಯಲು.

ನಮ್ಮ ಉದಾಹರಣೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ಪಿಜ್ಜಾದ "ಉದ್ದ"ವು ಅದು ಹೊಂದಿರುವ ಟಾಪಿಂಗ್‌ಗಳ ಸಂಖ್ಯೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು. ನಾವು ಅದನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

ವರ್ಗ ಪಿಜ್ಜಾ:
    def __init__(ಸ್ವಯಂ, ಗಾತ್ರ, ಮೇಲೋಗರಗಳು):
        self.size = ಗಾತ್ರ
        self.toppings = ಮೇಲೋಗರಗಳು

    ಡೆಫ್ __ಲೆನ್__(ಸ್ವಯಂ):
        ರಿಟರ್ನ್ ಲೆನ್ (self.toppings)

# ಪಿಜ್ಜಾವನ್ನು ರಚಿಸೋಣ
my_pizza = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು', 'ಆಲಿವ್‌ಗಳು'])

print(len(my_pizza)) # ಇದು ಮುದ್ರಿಸುತ್ತದೆ: 3

__len__ ವಿಧಾನದಲ್ಲಿ, ನಾವು ಪಟ್ಟಿಯ ಉದ್ದವನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ toppings. ಈಗ, len(my_pizza) ಅದರ ಮೇಲೆ ಎಷ್ಟು ಮೇಲೋಗರಗಳಿವೆ ಎಂದು ಅದು ನಮಗೆ ತಿಳಿಸುತ್ತದೆ my_pizza.

__ ಪ್ರಕ್ರಿಯೆ __

ಈ ಡಂಡರ್ ವಿಧಾನವು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಅಂದರೆ ಇದನ್ನು ಫಾರ್ ಲೂಪ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು.

ಇದನ್ನು ಮಾಡಲು, ನಾವು ಸಹ ಮಾಡಬೇಕು defiಕಾರ್ಯವನ್ನು ಮುಗಿಸಿ __next__, ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ defiಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಮುಂದಿನ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕಾದ ನಡವಳಿಕೆಯನ್ನು ನಿಶ್ ಮಾಡಿ. ಅನುಕ್ರಮದಲ್ಲಿ ಯಾವುದೇ ಹೆಚ್ಚಿನ ಅಂಶಗಳಿಲ್ಲ ಎಂದು ಈವೆಂಟ್‌ನಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಸಹ ಇದು ಸಂಕೇತಿಸುತ್ತದೆ. ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯುವ ಮೂಲಕ ಇದನ್ನು ಸಾಧಿಸುತ್ತೇವೆ StopIteration.

ನಮ್ಮ ಪಿಜ್ಜಾ ಉದಾಹರಣೆಗಾಗಿ, ನಾವು ಮೇಲೋಗರಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ. ನಾವು ನಮ್ಮ ಪಿಜ್ಜಾ ವರ್ಗವನ್ನು ಪುನರಾವರ್ತನೀಯವಾಗಿಸಬಹುದು definendo ಒಂದು ವಿಧಾನ __iter__:

ವರ್ಗ ಪಿಜ್ಜಾ:
    def __init__(ಸ್ವಯಂ, ಗಾತ್ರ, ಮೇಲೋಗರಗಳು):
        self.size = ಗಾತ್ರ
        self.toppings = ಮೇಲೋಗರಗಳು

    ಡೆಫ್ __ಐಟರ್__(ಸ್ವಯಂ):
        self.n = 0
        ಸ್ವಯಂ ಹಿಂತಿರುಗಿ

    ಡೆಫ್ __ಮುಂದೆ__(ಸ್ವಯಂ):
        self.n < len(self.toppings):
            ಫಲಿತಾಂಶ = self.toppings[self.n]
            self.n += 1
            ಫಲಿತಾಂಶ ಹಿಂತಿರುಗಿ
        ಬೇರೆ:
            StopIteration ಅನ್ನು ಹೆಚ್ಚಿಸಿ

# ಪಿಜ್ಜಾವನ್ನು ರಚಿಸೋಣ
my_pizza = ಪಿಜ್ಜಾ('ದೊಡ್ಡದು', ['ಪೆಪ್ಪೆರೋನಿ', 'ಅಣಬೆಗಳು', 'ಆಲಿವ್‌ಗಳು'])

# ಮತ್ತು ಈಗ ನಾವು ಅದರ ಮೇಲೆ ಪುನರಾವರ್ತಿಸೋಣ
my_pizza ನಲ್ಲಿ ಅಗ್ರಸ್ಥಾನಕ್ಕಾಗಿ:
    ಮುದ್ರಣ (ಮೇಲ್ಭಾಗ)

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಫಾರ್ ಲೂಪ್ ಕರೆಗಳು __iter__, ಇದು ಕೌಂಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (self.n) ಮತ್ತು ಪಿಜ್ಜಾ ವಸ್ತುವನ್ನೇ ಹಿಂದಿರುಗಿಸುತ್ತದೆ (self).

ನಂತರ, ಫಾರ್ ಲೂಪ್ ಕರೆಗಳು __next__ ಪ್ರತಿಯಾಗಿ ಅಗ್ರಸ್ಥಾನವನ್ನು ಪಡೆಯಲು.

ಯಾವಾಗ __next__ ಎಲ್ಲಾ ಮಸಾಲೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ, StopIteration ಇದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯುತ್ತದೆ ಮತ್ತು ಫಾರ್ ಲೂಪ್ ಈಗ ಯಾವುದೇ ಹೆಚ್ಚಿನ ಮೇಲೋಗರಗಳಿಲ್ಲ ಎಂದು ತಿಳಿದಿದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಪುನರಾವರ್ತನೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ಥಗಿತಗೊಳಿಸುತ್ತದೆ.

Ercole Palmeri