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

ಪೈಥಾನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ಸ್: ಸಂದರ್ಶನ ಪ್ರಶ್ನೆಗಳು

1. ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ (Context Manager) ಎಂದರೇನು?

ಉತ್ತರ: ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಎನ್ನುವುದು ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್. ಇದು with ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಒಂದು ಬ್ಲಾಕ್ ಕೋಡ್ ಅನ್ನು ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡುವ ಮೊದಲು ರಿಸೋರ್ಸ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಲು (enter) ಮತ್ತು ಆ ಬ್ಲಾಕ್ ಮುಗಿದ ನಂತರ ರಿಸೋರ್ಸ್ ಅನ್ನು ಕ್ಲೀನ್ ಅಪ್ ಮಾಡಲು (exit) ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಎರರ್ ಸಂಭವಿಸಿದರೂ ಸಹ.

ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್, ಡೇಟಾಬೇಸ್ ಕನೆಕ್ಷನ್, ಮತ್ತು ಥ್ರೆಡ್ ಲಾಕಿಂಗ್‌ನಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಅತ್ಯಂತ ಉಪಯುಕ್ತ.

2. with ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನ ಉಪಯೋಗವೇನು?

ಉತ್ತರ: with ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್‌ಗಳನ್ನು ಬಳಸಲು ಒಂದು ಸರಳವಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. with ಬ್ಲಾಕ್‌ನಿಂದ ಹೊರಬಂದ ತಕ್ಷಣ, ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್‌ನ "ಎಕ್ಸಿಟ್" ಮೆಥಡ್ ತಾನಾಗಿಯೇ ಕಾಲ್ ಆಗುತ್ತದೆ.

ಪ್ರಯೋಜನಗಳು:

  • ರಿಸೋರ್ಸ್‌ಗಳು (ಉದಾ: ಫೈಲ್‌ಗಳು) ಸರಿಯಾಗಿ ಮುಚ್ಚಲ್ಪಡುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
  • try...finally ಬ್ಲಾಕ್ ಅನ್ನು ಬರೆಯುವ ಅಗತ್ಯವನ್ನು ತಪ್ಪಿಸುತ್ತದೆ, ಇದರಿಂದ ಕೋಡ್ ಹೆಚ್ಚು ಕ್ಲೀನ್ ಆಗಿ ಕಾಣುತ್ತದೆ.

ಉದಾಹರಣೆ (ಫೈಲ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್):

# with ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಲ್ಲದೆ
file = open('hello.txt', 'w')
try:
    file.write('Hello, World!')
finally:
    file.close()

# with ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಬಳಸಿ
with open('hello.txt', 'w') as file:
    file.write('Hello, World!')
# ಇಲ್ಲಿ ಫೈಲ್ ತಾನಾಗಿಯೇ ಕ್ಲೋಸ್ ಆಗುತ್ತದೆ

3. ಕಸ್ಟಮ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು?

ಉತ್ತರ: ಕಸ್ಟಮ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಎರಡು ವಿಧಾನಗಳಲ್ಲಿ ರಚಿಸಬಹುದು:

  1. ಕ್ಲಾಸ್ ಬಳಸಿ: __enter__ ಮತ್ತು __exit__ ಎಂಬ ಎರಡು ಡಂಡರ್ ಮೆಥಡ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಕ್ಲಾಸ್ ಅನ್ನು ರಚಿಸುವ ಮೂಲಕ.
  2. @contextmanager ಡೆಕೋರೇಟರ್ ಬಳಸಿ: contextlib ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿರುವ ಈ ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಿ ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು.

4. ಕ್ಲಾಸ್ ಬಳಸಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ರಚಿಸುವುದನ್ನು ವಿವರಿಸಿ.

ಉತ್ತರ:

  • __enter__(self): with ಬ್ಲಾಕ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ ಈ ಮೆಥಡ್ ಕಾಲ್ ಆಗುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ರಿಸೋರ್ಸ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಿ, ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. as ಕೀವರ್ಡ್ ಬಳಸಿದರೆ, ಈ ಮೆಥಡ್‌ನ ರಿಟರ್ನ್ ವ್ಯಾಲ್ಯೂ ಆ ವೇರಿಯೇಬಲ್‌ಗೆ ಅಸೈನ್ ಆಗುತ್ತದೆ.
  • __exit__(self, exc_type, exc_value, traceback): with ಬ್ಲಾಕ್‌ನಿಂದ ಹೊರಬಂದಾಗ ಈ ಮೆಥಡ್ ಕಾಲ್ ಆಗುತ್ತದೆ.
    • exc_type, exc_value, traceback: ಬ್ಲಾಕ್‌ನೊಳಗೆ ಎಕ್ಸೆಪ್ಶನ್ ಸಂಭವಿಸಿದರೆ, ಈ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಎಕ್ಸೆಪ್ಶನ್‌ನ ವಿವರಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅವು None ಆಗಿರುತ್ತವೆ.
    • ಈ ಮೆಥಡ್ True ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡಿದರೆ, ಎಕ್ಸೆಪ್ಶನ್ ಸಪ್ರೆಸ್ (suppress) ಆಗುತ್ತದೆ.

ಉದಾಹರಣೆ:

class Timer:
    def __enter__(self):
        import time
        self.start_time = time.time()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        import time
        self.end_time = time.time()
        self.duration = self.end_time - self.start_time
        print(f"The block took {self.duration:.4f} seconds to execute.")


with Timer():
    # ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವ ಯಾವುದೇ ಕೋಡ್
    sum(range(1000000))

5. @contextmanager ಡೆಕೋರೇಟರ್ ಬಳಸಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ರಚಿಸುವುದನ್ನು ವಿವರಿಸಿ.

ಉತ್ತರ: contextlib ಮಾಡ್ಯೂಲ್‌ನ @contextmanager ಡೆಕೋರೇಟರ್ ಬಳಸಿ ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಆಗಿ ಸುಲಭವಾಗಿ ರಚಿಸಬಹುದು.

  • yield ಕೀವರ್ಡ್‌ಗಿಂತ ಮೊದಲು ಇರುವ ಕೋಡ್ __enter__ ಮೆಥಡ್‌ನಂತೆ ವರ್ತಿಸುತ್ತದೆ.
  • yield ಕೀವರ್ಡ್‌ನ ನಂತರ ಇರುವ ಕೋಡ್ __exit__ ಮೆಥಡ್‌ನಂತೆ ವರ್ತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

from contextlib import contextmanager


@contextmanager
def timer():
    import time
    start_time = time.time()
    try:
        yield
    finally:
        end_time = time.time()
        duration = end_time - start_time
        print(f"The block took {duration:.4f} seconds to execute.")


with timer():
    sum(range(1000000))

ಈ ವಿಧಾನವು ಕ್ಲಾಸ್ ಬರೆಯುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಸರಳ ಮತ್ತು ಕಾಂಪ್ಯಾಕ್ಟ್ ಆಗಿದೆ.