ಪರಿವಿಡಿ[ಮರೆಮಾಡಿ][ತೋರಿಸಿ]
ಈ ಉಪನ್ಯಾಸದಲ್ಲಿ, ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ತರಗತಿಗಳು, ಕನ್ಸ್ಟ್ರಕ್ಟರ್ಗಳು ಮತ್ತು ಆನುವಂಶಿಕತೆಯ ಬಗ್ಗೆ ಕಲಿಯುತ್ತೇವೆ.
ವಿಭಿನ್ನ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕಾದ ದೊಡ್ಡ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಈ ಪರಿಕಲ್ಪನೆಗಳು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯವಾಗಿವೆ.
ತರಗತಿಗಳು
ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ತರಗತಿಗಳು ಅತ್ಯಗತ್ಯ ಮತ್ತು ಅವು ಪೈಥಾನ್ಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿಲ್ಲ. ಅನೇಕ ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ವರ್ಗಗಳ ಕಲ್ಪನೆಯನ್ನು ಬೆಂಬಲಿಸಿ. ಹೊಸ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಾವು ತರಗತಿಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.
ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ಸಂಖ್ಯೆಗಳು, ತಂತಿಗಳು ಮತ್ತು ಬೂಲಿಯನ್ಗಳಂತಹ ಮೂಲ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೇವೆ. ಇವುಗಳು ಪೈಥಾನ್ನಲ್ಲಿನ ಮೂಲ ಅಥವಾ ಸರಳ ಡೇಟಾ ಪ್ರಕಾರಗಳಾಗಿವೆ. ಪಟ್ಟಿಗಳು ಮತ್ತು ನಿಘಂಟುಗಳಂತಹ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ.
ಈ ಪ್ರಕಾರಗಳು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, ಅವುಗಳನ್ನು ಯಾವಾಗಲೂ ಸಂಕೀರ್ಣ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ರೂಪಿಸಲು ಬಳಸಲಾಗುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಬಿಂದು ಅಥವಾ ಶಾಪಿಂಗ್ ಕಾರ್ಟ್ನ ಕಲ್ಪನೆಯ ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಶಾಪಿಂಗ್ ಕಾರ್ಟ್ ಬೂಲಿಯನ್ ಅಥವಾ ಪಟ್ಟಿ ಅಲ್ಲ. ಇದು ವಿಭಿನ್ನ ರೀತಿಯ ಡೇಟಾ. ಆದ್ದರಿಂದ ನಾವು ನೈಜ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ರೂಪಿಸಲು ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ತರಗತಿಗಳನ್ನು ಬಳಸಬಹುದು.
ಈಗ, ಪಾಯಿಂಟ್ ಎಂಬ ಹೊಸ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ. ನಾವು ಮೊದಲು ಪರಿಶೀಲಿಸಿದಂತೆ ಈ ಹೊಸ ಪ್ರಕಾರವು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.
ನೀವು ಇದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೀರಿ:
ನಾವು "ವರ್ಗ" ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ಅದರ ನಂತರ ನಾವು ನಮ್ಮ ವರ್ಗಕ್ಕೆ ಹೆಸರನ್ನು ನೀಡುತ್ತೇವೆ.
class Point
ಈಗ, ನಾನು ಇಲ್ಲಿ ಬಳಸಿರುವ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯವನ್ನು ನೋಡಿ. ನಾನು ಇಲ್ಲಿ ಮೊದಲ ಅಕ್ಷರವನ್ನು ದೊಡ್ಡಕ್ಷರ ಮಾಡಿದ್ದೇನೆ, ಇದನ್ನೇ ನಾವು ಪ್ಯಾಸ್ಕಲ್ ಹೆಸರಿಸುವ ಸಮಾವೇಶ ಎಂದು ಕರೆಯುತ್ತೇವೆ. ಈ ಸಮಾವೇಶವು ನಮ್ಮ ವೇರಿಯೇಬಲ್ಗಳು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಹೆಸರಿಸಲು ನಾವು ಬಳಸುವುದಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿದೆ, ಇದಕ್ಕಾಗಿ ನಾವು ಯಾವಾಗಲೂ ಸಣ್ಣ ಅಕ್ಷರಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಅಂಡರ್ಸ್ಕೋರ್ ಬಳಸಿ ಬಹು ಪದಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತೇವೆ. ಆದರೆ ತರಗತಿಗಳನ್ನು ಹೆಸರಿಸುವಾಗ, ನಾವು ಅನೇಕ ಪದಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಅಂಡರ್ಸ್ಕೋರ್ ಅನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಪ್ರತಿ ಪದದ ಮೊದಲ ಅಕ್ಷರವನ್ನು ನಾವು ದೊಡ್ಡಕ್ಷರ ಮಾಡುತ್ತೇವೆ.
ನಮ್ಮ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ನಂತರ, ಕೊಲೊನ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಅಂದರೆ ಈಗ ಒಂದು ಬ್ಲಾಕ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.
class Point:
def move (self):
ಈ ಬ್ಲಾಕ್ನಲ್ಲಿ, ಬಿಂದುಗಳಿಗೆ ಸೇರಿದ ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಅಥವಾ ವಿಧಾನಗಳನ್ನು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಬಿಂದುವನ್ನು ಚಲಿಸಲು "ಮೂವ್" ಎಂಬ ಕಾರ್ಯವನ್ನು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ನಾವು ತೆರೆದ ಆವರಣವನ್ನು ಟೈಪ್ ಮಾಡಿದ ತಕ್ಷಣ, PyCharm ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇಲ್ಲಿ "ಸ್ವಯಂ" ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಇದು ವಿಶೇಷ ಕೀವರ್ಡ್ ಆಗಿದೆ ಮತ್ತು ನಾನು ಇದನ್ನು ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ ಹಿಂತಿರುಗಿಸುತ್ತೇನೆ. ಟರ್ಮಿನಲ್ನಲ್ಲಿ "ಮೂವ್" ಅನ್ನು ಮುದ್ರಿಸೋಣ.
print("move")
"ಡ್ರಾ" ನಂತಹ ಇನ್ನೊಂದು ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ ಮತ್ತು ಅದನ್ನು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಮುದ್ರಿಸೋಣ.
def draw(self):
print("draw")
ನಮ್ಮ "ಪಾಯಿಂಟ್" ವರ್ಗದ ವ್ಯಾಖ್ಯಾನವನ್ನು ನಾವು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೇವೆ. ಈ ಹೊಸ ಪ್ರಕಾರದೊಂದಿಗೆ, ನಾವು ಹೊಸ ವಸ್ತುಗಳನ್ನು ರಚಿಸಬಹುದು. ಒಂದು ವರ್ಗವು ಆ ಬ್ಲೂಪ್ರಿಂಟ್ ಅನ್ನು ಆಧರಿಸಿದ ನೈಜ ನಿದರ್ಶನಗಳಾಗಿರುವ ವಸ್ತುಗಳನ್ನು ರಚಿಸಲು ಬ್ಲೂಪ್ರಿಂಟ್ ಅಥವಾ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಸರಳವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಲು, ನಾವು ನಮ್ಮ ವರ್ಗದ ಹೆಸರನ್ನು ಟೈಪ್ ಮಾಡಿ ನಂತರ ಅದನ್ನು ಫಂಕ್ಷನ್ನಂತೆ ಕರೆಯುತ್ತೇವೆ. ಇದು ಹೊಸ ವಸ್ತುವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನಂತರ ನಾವು ಆ ವಸ್ತುವನ್ನು ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು. ನಾನು ನಿನಗೆ ತೋರಿಸುತ್ತೇನೆ:
ಇಲ್ಲಿ ನಾವು "ಪಾಯಿಂಟ್ 1" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ ಅದು ಮೂರು ಆಯಾಮದ ಬಿಂದುವಾಗಿದೆ. ನೀವು ಅದನ್ನು ನೋಡಬಹುದು, ನಾವು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಪ್ರತ್ಯೇಕ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಮುದ್ರಿಸಬಹುದು.
ಈ ಹಂತದೊಂದಿಗೆ ನಾವು "ಡ್ರಾ" ಮತ್ತು "ಮೂವ್" ಎಂಬ ಎರಡು ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು.
ಆದ್ದರಿಂದ ರೀಕ್ಯಾಪ್ ಮಾಡಲು, ನಾವು ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ತರಗತಿಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಈ ಪ್ರಕಾರಗಳು ನಾವು ವರ್ಗದ ದೇಹದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸುವ ವಿಧಾನಗಳನ್ನು ಹೊಂದಬಹುದು. ತರಗತಿಗಳು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಎಲ್ಲಿ ಬೇಕಾದರೂ ಹೊಂದಿಸಬಹುದಾದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿರಬಹುದು.
ಕನ್ಸ್ಟ್ರಕ್ಟರ್ಸ್
ಇಲ್ಲಿಯವರೆಗೆ, ತರಗತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ನಾವು ಕಲಿತಿದ್ದೇವೆ. ಈಗ ಈ ಅನುಷ್ಠಾನದಲ್ಲಿ ಸಣ್ಣ ಸಮಸ್ಯೆ ಇದೆ. ತರಗತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು x ಅಥವಾ y ನಿರ್ದೇಶಾಂಕವಿಲ್ಲದೆ ನಾವು ಪಾಯಿಂಟ್ ವಸ್ತುವನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅದು ಸೂಕ್ತವಲ್ಲ. ನಾನು ನಿನಗೆ ತೋರಿಸುತ್ತೇನೆ.
ನಾವು x ನಿರ್ದೇಶಾಂಕವನ್ನು ಹೊಂದಿಸುವ ಮೊದಲು ಬಿಂದುವನ್ನು ರಚಿಸೋಣ ಮತ್ತು ಅದನ್ನು ಮುದ್ರಿಸೋಣ. ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡುವುದರಿಂದ ಈ ರೀತಿಯ ಗುಣಲಕ್ಷಣ ದೋಷ ಉಂಟಾಗುತ್ತದೆ:
ಇದರರ್ಥ ಪಾಯಿಂಟ್ ವಸ್ತುವು x ಎಂಬ ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿಲ್ಲ. ಈಗ ಸಮಸ್ಯೆಯೆಂದರೆ x ಅಥವಾ y ನಿರ್ದೇಶಾಂಕಗಳಿಲ್ಲದೆ ಪಾಯಿಂಟ್ ವಸ್ತುವನ್ನು ಹೊಂದಲು ಸಾಧ್ಯವಿದೆ. ನಾವು ಒಂದು ಹಂತದ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ ಇದು ಅರ್ಥವಿಲ್ಲ, ಆ ಬಿಂದು ಎಲ್ಲಿದೆ ಎಂದು ನಾವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಎನ್ನುವುದು ವಸ್ತುವನ್ನು ರಚಿಸುವ ಸಮಯದಲ್ಲಿ ಕರೆಯಲಾಗುವ ಒಂದು ಕಾರ್ಯವಾಗಿದೆ.
ನಾವು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುತ್ತೇವೆ ಎಂಬುದು ಇಲ್ಲಿದೆ. ಮೊದಲಿಗೆ, ಮೇಲಿನ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ x ಮತ್ತು y ನಿರ್ದೇಶಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸೋಣ.
point = Point(10, 20)
print(point.x)
ಈಗ, ನಾವು ಈ ವರ್ಗದಲ್ಲಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಎಂಬ ವಿಶೇಷ ವಿಧಾನವನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಇದರ ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೀಗಿದೆ:
def __init__(self, x, y):
init
ಆರಂಭಿಸಲು ಚಿಕ್ಕದಾಗಿದೆ, ಮತ್ತು ಇದು ಹೊಸ ಪಾಯಿಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿದಾಗ ಕರೆಯಲಾಗುವ ಕಾರ್ಯ ಅಥವಾ ವಿಧಾನವಾಗಿದೆ. x ಮತ್ತು y ಅನ್ನು ತಕ್ಷಣವೇ ಸೇರಿಸಲಾಗುತ್ತದೆ self
ಎರಡು ಹೆಚ್ಚುವರಿ ನಿಯತಾಂಕಗಳನ್ನು ಸೇರಿಸಲು.
ಅದರ ನಂತರ, ನಾವು x ಮತ್ತು y ಅನ್ನು ಪಾಸ್ ಮಾಡಿದ ಮೌಲ್ಯಗಳಿಗೆ ಅಂದರೆ 10 ಮತ್ತು 20 ಗೆ ಮ್ಯಾಪ್ ಮಾಡಬೇಕು
self.x = x
self.y = y
ನಾವು ಬಳಸುತ್ತೇವೆ self
ಪ್ರಸ್ತುತ ವಸ್ತುವನ್ನು ಉಲ್ಲೇಖಿಸಲು ಮತ್ತು ನಂತರ ನಾವು "x" ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲಾದ x ಆರ್ಗ್ಯುಮೆಂಟ್ಗೆ x ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ಈ ರೀತಿಯಲ್ಲಿ, ಬಳಸುವುದು init
ವಿಧಾನ, ನಾವು ನಮ್ಮ ವಸ್ತುಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಈ ವಿಧಾನವನ್ನು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸೋಣ.
ಈಗ, ನಾವು x ಮತ್ತು y ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ನಂತರ ಬದಲಾಯಿಸಬಹುದು. x ನಿರ್ದೇಶಾಂಕವನ್ನು ನವೀಕರಿಸೋಣ:
point = Point(10, 20)
point.x = 11
print(point.x)
ಈಗ, x ನಿರ್ದೇಶಾಂಕವನ್ನು ಮೌಲ್ಯ 11 ಕ್ಕೆ ನವೀಕರಿಸಲಾಗಿದೆ.
ವ್ಯಾಯಾಮ
ನಿಮಗಾಗಿ ಆಸಕ್ತಿದಾಯಕ ವ್ಯಾಯಾಮ ಇಲ್ಲಿದೆ.
ಒಬ್ಬ ವ್ಯಕ್ತಿ ಎಂಬ ಹೊಸ ಪ್ರಕಾರವನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕೆಂದು ನಾನು ಬಯಸುತ್ತೇನೆ. ಈ "ವ್ಯಕ್ತಿ" ವಸ್ತುಗಳು "" ಅನ್ನು ಹೊಂದಿರಬೇಕುname
"ಗುಣಲಕ್ಷಣ ಹಾಗೂ ಒಂದು"talk()
”ವಿಧಾನ.
ಇದು ಸರಳವಾದ ಕಾರ್ಯವಾಗಿದೆ ಮತ್ತು ಒಂದೆರಡು ನಿಮಿಷಗಳಿಗಿಂತ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಾರದು.
ಪರಿಹಾರ
"ವ್ಯಕ್ತಿ" ವರ್ಗವನ್ನು ಈ ರೀತಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಪ್ರಾರಂಭಿಸಿ:
class Person:
self.name = name
ನಾವು ನಂತರ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಈಗ, ನಾವು "ವ್ಯಕ್ತಿ" ವಸ್ತುವನ್ನು ರಚಿಸಬಹುದು. ಅದನ್ನು ಜಾನ್ ಎಂದು ಕರೆಯೋಣ
john = Person("John Smith")
print(john.name)
john.talk()
ಈಗ, ಕೋಡ್ನ ಮೊದಲ ಭಾಗಕ್ಕೆ ಹೋಗಿ ಮತ್ತು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ರಚಿಸಿ.
def __init__(self, name):
ಅಂತಿಮ ಕೋಡ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ತರಗತಿಗಳು ಮತ್ತು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ಗಳ ಜೊತೆಯಲ್ಲಿ ನೀವು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ಗಳು ಮತ್ತು ಇತರ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು.
ಇನ್ಹೆರಿಟೆನ್ಸ್
ಆನುವಂಶಿಕತೆಯು ತರಗತಿಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಮತ್ತೊಂದು ಪರಿಕಲ್ಪನೆಯಾಗಿದ್ದು ಅದು ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ.
ಈ ಕೋಡ್ನ ತುಣುಕನ್ನು ಪರಿಗಣಿಸಿ.
class Dog:
def walk(self):
print("walk")
ನಾವು "ವಾಕ್" ವಿಧಾನದೊಂದಿಗೆ "ಡಾಗ್" ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಈ ವಿಧಾನದಲ್ಲಿ, ನಾವು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ವಾಕ್ ಸಂದೇಶವನ್ನು ಸರಳವಾಗಿ ಮುದ್ರಿಸುತ್ತಿದ್ದೇವೆ. ನಿಜವಾದ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, ಇಲ್ಲಿ ಕೇವಲ ಒಂದು ಸಾಲಿನ ಬದಲಿಗೆ 10 ಸಾಲುಗಳ ಕೋಡ್ ಇದೆ ಎಂದು ಹೇಳೋಣ. ಭವಿಷ್ಯದಲ್ಲಿ, "ವಾಕ್" ವಿಧಾನವನ್ನು ಹೊಂದಲು ಇನ್ನೊಂದು ವರ್ಗ ಅಗತ್ಯವಿದ್ದರೆ, ನಾವು ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಸೂಕ್ತವಲ್ಲ.
ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ, ನಾವು DRY ಎಂಬ ತತ್ವವನ್ನು ಹೊಂದಿದ್ದೇವೆ ಅದು ನಿಮ್ಮನ್ನು ಪುನರಾವರ್ತಿಸಬೇಡಿ ಎಂಬುದಕ್ಕೆ ಚಿಕ್ಕದಾಗಿದೆ. ಭವಿಷ್ಯದಲ್ಲಿ ಎಂದಾದರೂ ಹೇಳೋಣ, ನಮ್ಮ "ನಡಿಗೆ" ವಿಧಾನದಲ್ಲಿ ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ನಾವು ಈ ವಿಧಾನವನ್ನು ಹಲವಾರು ಸ್ಥಳಗಳಲ್ಲಿ ಪುನರಾವರ್ತಿಸಿದ್ದರೆ ಅಥವಾ ನಕಲು ಮಾಡಿದ್ದರೆ, ನಾವು ಹಿಂತಿರುಗಿ ಮತ್ತು ನಾವು ಇದನ್ನು ನಕಲು ಮಾಡಿದ ಪ್ರತಿಯೊಂದು ಸ್ಥಳದಲ್ಲಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬೇಕಾಗುತ್ತದೆ. ಕೋಡ್. ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ನಾವು ಏನನ್ನಾದರೂ ಎರಡು ಬಾರಿ ವ್ಯಾಖ್ಯಾನಿಸಬಾರದು.
ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ವಿವಿಧ ವಿಧಾನಗಳಿವೆ ಆದರೆ ಇಲ್ಲಿ ನಾವು ಆರಂಭಿಕರಿಗಾಗಿ ಸುಲಭವಾದದನ್ನು ಕಲಿಯಲಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು ಉತ್ತರಾಧಿಕಾರ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಇನ್ನೊಂದು ವರ್ಗ "ಸಸ್ತನಿ" ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಆ ವರ್ಗದಲ್ಲಿ ನಮ್ಮ "ವಾಕ್" ಗುಣಲಕ್ಷಣವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
class Mammal:
def walk(self):
print("walk")
ನಮ್ಮ "ಸಸ್ತನಿ" ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ನಂತರ ನಾವು ಈ ರೀತಿಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ರವಾನಿಸಲು ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಬಹುದು:
ನಾಯಿ ಮತ್ತು ಬೆಕ್ಕು ಎರಡೂ ವರ್ಗಗಳು ತಮ್ಮ ಪೋಷಕ ವರ್ಗದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಎಲ್ಲಾ ವರ್ಗ ವಿಧಾನಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತಿವೆ. ಈಗ, ನಾವು ಈ ರೀತಿಯ ನಾಯಿಗಳಿಗೆ ನಿರ್ದಿಷ್ಟವಾದ ವಿಧಾನಗಳನ್ನು ಸೇರಿಸಬಹುದು:
class Dog:
def bark(self):
print("bark")
ಅಂತಿಮಗೊಳಿಸು!
ಇದು ತರಗತಿಗಳು, ಕನ್ಸ್ಟ್ರಕ್ಟರ್ಗಳು ಮತ್ತು ಆನುವಂಶಿಕ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ ತರಗತಿಗಳಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುವುದು. ಈಗ ನಾವು ನಮ್ಮ ಸರಣಿಯ ಅಂತ್ಯವನ್ನು ಸಮೀಪಿಸುತ್ತಿದ್ದೇವೆ. ಈ ಹಂತದಲ್ಲಿ, ನೀವು ಪೈಥಾನ್ನಲ್ಲಿ ಉತ್ತಮ, ಓದಬಲ್ಲ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಕೋಡ್ಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ಮುಂದಿನ ಉಪನ್ಯಾಸದಲ್ಲಿ ಮಾಡ್ಯೂಲ್ಗಳು ಮತ್ತು ಪ್ಯಾಕೇಜ್ಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ