ಪರಿವಿಡಿ[ಮರೆಮಾಡಿ][ತೋರಿಸಿ]
ಈ ಉಪನ್ಯಾಸವು ಪೈಥಾನ್ನಲ್ಲಿ ಟ್ಯೂಪಲ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಮತ್ತೊಂದು ಅಗತ್ಯ ರಚನೆಯ ಕುರಿತಾಗಿದೆ.
ಟುಪಲ್ಸ್
Tuples ಪಟ್ಟಿಗಳನ್ನು ಹೋಲುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾವು ಐಟಂಗಳ ಪಟ್ಟಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಅವುಗಳನ್ನು ಬಳಸಬಹುದು. ಆದರೆ ಪಟ್ಟಿಗಳಂತೆ, ನಾವು ಅವುಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಹೊಸ ಐಟಂಗಳನ್ನು ಸೇರಿಸಲು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಐಟಂಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ. ಟ್ಯೂಪಲ್ಸ್ ಬದಲಾಗುವುದಿಲ್ಲ ಎಂದು ನಾವು ಹೇಳಬಹುದು.
ನಾನು ನಿನಗೆ ತೋರಿಸುತ್ತೇನೆ. ಟ್ಯೂಪಲ್ಸ್ ಅನ್ನು ಪಟ್ಟಿಗಳಲ್ಲಿ ಚೌಕಾಕಾರದ ಆವರಣಗಳ ಬದಲಿಗೆ ಆವರಣದಿಂದ ಗುರುತಿಸಲಾಗುತ್ತದೆ.
numbers = (4, 1, 7, 5, 0, 9)
ಈಗ, ನಾವು tuples ವಿಧಾನಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊರತೆಗೆದರೆ, ನಾವು ಅನುಬಂಧ ಅಥವಾ ಸೇರಿಸುವ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿಲ್ಲ ಎಂದು ನೀವು ನೋಡಬಹುದು ಆದ್ದರಿಂದ ಈ tuple ಗೆ ಹೊಸ ಐಟಂಗಳನ್ನು ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ. ನಮಗೆ ಕೇವಲ ಎರಡು ವಿಧಾನಗಳಿವೆ: ಎಣಿಕೆ ಮತ್ತು ಸೂಚ್ಯಂಕ.
ಐಟಂನ ಸಂಭವಿಸುವಿಕೆಯ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸಲು ನಾವು "ಎಣಿಕೆ" ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಐಟಂನ ಮೊದಲ ಸಂಭವದ ಸೂಚಿಯನ್ನು ಕಂಡುಹಿಡಿಯಲು "ಸೂಚ್ಯಂಕ" ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಾವು ಟುಪಲ್ ಬಗ್ಗೆ ಮಾತ್ರ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಬಹುದು ಮತ್ತು ನಾವು ಅದನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಮೂಲಕ, ನೀವು ಇಲ್ಲಿ ನೋಡುವ ಈ ಇತರ ವಿಧಾನಗಳು, ಎರಡು ಅಂಡರ್ಸ್ಕೋರ್ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ.
ನಾವು ಇದನ್ನು ಮ್ಯಾಜಿಕ್ ವಿಧಾನಗಳು ಎಂದು ಕರೆಯುತ್ತೇವೆ. ಅವು ಹೆಚ್ಚು ಸುಧಾರಿತ ವಿಷಯವಾಗಿದೆ ಮತ್ತು ನಮ್ಮ ಮುಂದಿನ ಸರಣಿಯಲ್ಲಿ ನಾವು ಅವುಗಳನ್ನು ಸ್ಪರ್ಶಿಸುತ್ತೇವೆ.
ಅಸ್ಥಿರವಾಗಿರುವುದನ್ನು ಹೊರತುಪಡಿಸಿ, ಟುಪಲ್ಗಳು ಪಟ್ಟಿಯ ಹೆಚ್ಚಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ.
ಪ್ರಾಯೋಗಿಕವಾಗಿ ಹೇಳುವುದಾದರೆ, ಹೆಚ್ಚಿನ ಸಮಯ ನೀವು ಪಟ್ಟಿಗಳನ್ನು ಬಳಸುತ್ತೀರಿ, ಆದರೆ ಟುಪಲ್ಸ್ ಸಹ ಉಪಯುಕ್ತವಾಗಿದೆ. ನೀವು ಐಟಂಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಎಲ್ಲಿಯೂ ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಆ ಪಟ್ಟಿಯನ್ನು ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ, ನಂತರ ಟುಪಲ್ ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮ.
ಅನ್ಪ್ಯಾಕ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾನು ನಿಮಗೆ ಶಕ್ತಿಯುತವಾದ ವೈಶಿಷ್ಟ್ಯವನ್ನು ತೋರಿಸಲಿದ್ದೇನೆ, ನಾವು ಅನ್ಪ್ಯಾಕ್ ಮಾಡುವ ಪೈಥಾನ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ.
ಟ್ಯೂಪಲ್ "ಕೋಆರ್ಡಿನೇಟ್" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ
coordinate = (1, 2, 3)
ಈಗ, ಇವುಗಳು 'x', 'y' ಮತ್ತು 'z' ಗಾಗಿ ನಿರ್ದೇಶಾಂಕಗಳಾಗಿವೆ ಎಂದು ಊಹಿಸಿ. ಈಗ ನಾವು ಈ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ಮತ್ತು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಕೆಲವು ಸಂಕೀರ್ಣ ಅಭಿವ್ಯಕ್ತಿಗಳಲ್ಲಿ ಬಳಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ. ಬಹುಶಃ, ನಾವು ಅವುಗಳನ್ನು ದೊಡ್ಡ ಸಂಕೀರ್ಣ ಸೂತ್ರದ ಭಾಗವಾಗಿ ಸೇರಿಸಲು ಬಯಸುತ್ತೇವೆ.
ಆದ್ದರಿಂದ, ಒಟ್ಟಿಗೆ ನಾವು ಈ ರೀತಿಯ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ:
coordinate[0] * coordinate[1] * coordinate[2]
ಈ ಕೋಡ್ ಸಾಲು ಎಲ್ಲಾ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಗುಣಿಸುತ್ತದೆ ಆದರೆ ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಈ ರೀತಿ ಬರೆಯುವುದು ಅಸಮರ್ಥವಾಗಿದೆ. ಮೊದಲಿಗೆ, ನಾವು ಉತ್ತಮ ವಿಧಾನವನ್ನು ಬಳಸೋಣ ಮತ್ತು ಈ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಅಸ್ಥಿರಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸೋಣ.
x = coordinate[0]
y = coordinate[1]
z = coordinate[2]
ಅದು ಉತ್ತಮ. ಸರಿ? ಹಾಗಾಗಿ ಇಲ್ಲಿಯವರೆಗೆ ಹೊಸದೇನೂ ಇಲ್ಲ. ಈಗ, ಅನ್ಪ್ಯಾಕ್ ಮಾಡುವಿಕೆ ಎಂಬ ಪ್ರಬಲ ವೈಶಿಷ್ಟ್ಯವನ್ನು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ ಮತ್ತು ಅದರೊಂದಿಗೆ, ನಾವು ಕಡಿಮೆ ಕೋಡ್ನೊಂದಿಗೆ ಅದೇ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಬಹುದು.
x, y, z, = coordinate
ಈಗ, ಈ ಒಂದೇ ಸಾಲಿನ ಕೋಡ್ ನಿಖರವಾಗಿ ಮೇಲೆ ಬರೆದ ಮೂರು ಸಾಲುಗಳ ಕೋಡ್ಗೆ ಸಮನಾಗಿರುತ್ತದೆ. ಅದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಾನು ನಿಮಗೆ ವಿವರಿಸುತ್ತೇನೆ.
ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಈ ಹೇಳಿಕೆಯನ್ನು ನೋಡಿದಾಗ, ಅದು ಈ ಟುಪಲ್ನಲ್ಲಿ ಮೊದಲ ಐಟಂ ಅನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ವೇರಿಯೇಬಲ್ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ. ಅಂತೆಯೇ, ಎರಡನೇ ಮತ್ತು ಮೂರನೇ ಐಟಂಗಳನ್ನು ಅಸ್ಥಿರಗಳಿಗೆ ನಿಯೋಜಿಸಲಾಗುವುದು. ಇದನ್ನು ಮಾಡುವಾಗ, ನಾವು ಈ ಟುಪಲ್ ಅನ್ನು 3 ಅಸ್ಥಿರಗಳಾಗಿ ಅನ್ಪ್ಯಾಕ್ ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಮ್ಮ ಔಟ್ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸೋಣ.
ಪಟ್ಟಿಗಳೊಂದಿಗೆ ಅನ್ಪ್ಯಾಕ್ ಮಾಡುವುದನ್ನು ಸಹ ಮಾಡಬಹುದು.
ನಿಘಂಟುಗಳು
ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ನಿಘಂಟುಗಳ ಬಗ್ಗೆ ಕಲಿಯಲಿದ್ದೇವೆ. ಕೀ-ಮೌಲ್ಯದ ಜೋಡಿಯಾಗಿ ಬರುವ ಮಾಹಿತಿಯನ್ನು ನಾವು ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಾವು ನಿಘಂಟುಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.
ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ. ಹೆಸರು, ಇಮೇಲ್, ಫೋನ್ ಸಂಖ್ಯೆ, ವಿಳಾಸ, ಮತ್ತು ಮುಂತಾದ ಗುಣಲಕ್ಷಣಗಳ ಗುಂಪಿನೊಂದಿಗೆ ಗ್ರಾಹಕರ ಬಗ್ಗೆ ಯೋಚಿಸಿ. ಈಗ ಈ ಪ್ರತಿಯೊಂದು ಗುಣಲಕ್ಷಣಗಳು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿವೆ. ಉದಾಹರಣೆಗೆ:
name = Jay
email = [email protected]
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಮ್ಮ ಕೀಗಳು ಹೆಸರು, ಇಮೇಲ್ ಮತ್ತು ಫೋನ್. ಪ್ರತಿಯೊಂದು ಕೀಲಿಯು ಮೌಲ್ಯದೊಂದಿಗೆ ಸಂಯೋಜಿತವಾಗಿದೆ ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ನಿಘಂಟನ್ನು ಬಳಸುತ್ತೇವೆ. ನಿಘಂಟಿನೊಂದಿಗೆ, ನಾವು ಕೀ-ಮೌಲ್ಯದ ಜೋಡಿಗಳ ಗುಂಪನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ಪೈಥಾನ್ನಲ್ಲಿ ನಿಘಂಟನ್ನು ಹೇಗೆ ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಎಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ.
customer = {
"name": "Jay",
"email": "[email protected]",
"age": 30,
"is_verified": True
}
ಕೀಲಿಯನ್ನು ತಂತಿಗಳು, ಸಂಖ್ಯೆಗಳು, ಬೂಲಿಯನ್ ಅಥವಾ ಯಾವುದಕ್ಕೂ ಹೊಂದಿಸಬಹುದು. ಕೀಗಳು ಅನನ್ಯವಾಗಿವೆ ಮತ್ತು ಒಮ್ಮೆ ಮಾತ್ರ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಅಂದರೆ ನಾನು "ವಯಸ್ಸು" ಅನ್ನು ಮತ್ತೆ ಕೆಲವು ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಅವರು ಕೇಸ್-ಸೆನ್ಸಿಟಿವ್ ಕೂಡ.
ಈಗ, ನಾನು ಟೈಪ್ ಮಾಡಿದರೆ customer["name"],
ಇದು ಗ್ರಾಹಕರ ಹೆಸರನ್ನು ಕರೆಯುತ್ತದೆ. ಅದನ್ನು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಮುದ್ರಿಸೋಣ:
ನಾವು ನಿಘಂಟುಗಳೊಂದಿಗೆ ವಿಧಾನಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು. ಮೇಲೆ ಪ್ರದರ್ಶಿಸಿದ ಅದೇ ಕಾರ್ಯವನ್ನು "ಗೆಟ್" ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಪುನರಾವರ್ತಿಸಬಹುದು.
ಮೇಲಿನ ಎರಡು ವಿಧಾನಗಳ ನಡುವೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ವ್ಯತ್ಯಾಸವಿದೆ. ಅದನ್ನು ನಾನು ಪ್ರದರ್ಶಿಸಲಿ.
ನಾವು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಕೀಲಿಯನ್ನು ಸರಳವಾಗಿ ಮುದ್ರಿಸಿದಾಗ ಅದು ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ ಎಂದು ನೀವು ನೋಡಬಹುದು. ಮತ್ತೊಂದೆಡೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಕೀಲಿಯನ್ನು ಕರೆಯುವ ವಿಧಾನವನ್ನು ಬಳಸುವುದರಿಂದ "ಯಾವುದೂ ಇಲ್ಲ" ಫಲಿತಾಂಶವು ಮೌಲ್ಯದ ಅನುಪಸ್ಥಿತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. "ಗೆಟ್" ವಿಧಾನವನ್ನು ಬಳಸುವಾಗ, ನಾವು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಸಹ ಪೂರೈಸಬಹುದು.
ಉದಾಹರಣೆಗೆ, ಈ ನಿಘಂಟಿನಲ್ಲಿ “ಜನ್ಮದಿನಾಂಕ” ಕೀ ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಅದನ್ನು ಈ ರೀತಿ ಪೂರೈಸಬಹುದು:
customer.get("birthdate", "Jan 01, 1994")
ನಾವು ನಿಘಂಟಿನಲ್ಲಿರುವ ಯಾವುದೇ ಕೀಲಿಯನ್ನು ಸಹ ನವೀಕರಿಸಬಹುದು, ಪಟ್ಟಿಯಂತೆಯೇ. ನಾವು ನಮ್ಮ ನಿಘಂಟಿನಲ್ಲಿ ಹೆಸರಿನ ಕೀಲಿಯನ್ನು ನವೀಕರಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ. ನಾವು ಅದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೇವೆ ಎಂಬುದು ಇಲ್ಲಿದೆ.
customer["name"] = "Shahbaz"
ನಮ್ಮ ನಿಘಂಟಿನಲ್ಲಿಯೂ ಹೊಸ ಕೀಲಿಯನ್ನು ಸೇರಿಸಲು ಇದೇ ರೀತಿಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು. ಇದೇ ಮಾದರಿಯಲ್ಲಿ “ಜನ್ಮದಿನಾಂಕ” ಕೀಲಿಯನ್ನು ಸೇರಿಸೋಣ.
customer["birthdate"] = "Jan 01, 1994"
ಆದ್ದರಿಂದ, ಇದು ಪೈಥಾನ್ನಲ್ಲಿ ನಿಘಂಟುಗಳನ್ನು ಬಳಸುವ ಮೂಲವಾಗಿದೆ. ಅವು ಅತ್ಯಂತ ಮುಖ್ಯವಾದವು ಮತ್ತು ನೈಜ ಜಗತ್ತಿನಲ್ಲಿ ಅವುಗಳು ಬಹಳಷ್ಟು ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಹೊಂದಿವೆ.
ವ್ಯಾಯಾಮ
ಅಂಕಿಗಳನ್ನು ಈ ರೀತಿಯ ಪದಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನೀವು ಬರೆಯಲಿದ್ದೀರಿ:
ಪರಿಹಾರ
ನಿಮಗಾಗಿ ಇಲ್ಲಿದೆ ಪರಿಹಾರ.
phone = input("Phone: ")
digits_mapping = {
"1": "One",
"2": "Two",
"3": "Three",
"4": "Four",
"5": "Five",
"6": "Six",
"7": "Seven",
"8": "Eight",
"9": "Nine",
"0": "Zero"
}
output = " "
for ch in phone:
output += digits_mapping.get(ch, "!") + " "
print(output)
ಅಂತೆಯೇ, ನೀವು "ಎಮೋಜಿ ಪರಿವರ್ತಕ" ನಂತಹ ಇತರ ಮೋಜಿನ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು ಪೈಥಾನರ್ಗಳನ್ನು ಆನಂದಿಸಿ!
ಅಂತಿಮಗೊಳಿಸು!
ನೀವು ಈ ಉಪನ್ಯಾಸವನ್ನು ಆನಂದಿಸಿದ್ದೀರಿ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಮುಂದೆ, ನಾವು ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್, ಕಾರ್ಯಗಳು ಮತ್ತು ನಿಯತಾಂಕಗಳ ಮಹತ್ವದ ಅಂಶಕ್ಕೆ ಧುಮುಕುತ್ತೇವೆ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ