ಪರಿವಿಡಿ[ಮರೆಮಾಡಿ][ತೋರಿಸಿ]
ಕ್ರ್ಯಾಶ್ ಕೋರ್ಸ್ನಲ್ಲಿ ಮೂರನೇ ಉಪನ್ಯಾಸಕ್ಕೆ ಸುಸ್ವಾಗತ.
ಈ ಉಪನ್ಯಾಸದಲ್ಲಿ, ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ತಂತಿಗಳನ್ನು ಎದುರಿಸಲು ಕಲಿಯುತ್ತೇವೆ. ನಿಮ್ಮ ಪಾಪ್ಕಾರ್ನ್ ರೆಡಿ ಮಾಡಿ ಮತ್ತು ಬಿಗಿಯಾಗಿ ಕುಳಿತುಕೊಳ್ಳಿ.
ತಂತಿಗಳು
ಮೊದಲಿಗೆ, ಉಲ್ಲೇಖಗಳ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ ಮತ್ತು ಪೈಥಾನ್ನಲ್ಲಿ ಅವರು ಪರಿಚಯಿಸಬಹುದಾದ ಗೊಂದಲವನ್ನು ನಿವಾರಿಸೋಣ.
ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಪೈಥಾನ್ನಲ್ಲಿನ ಕಾರ್ಯದ ನಂತರ ನಾವು ಏಕ ಮತ್ತು ಡಬಲ್ ಉಲ್ಲೇಖಗಳನ್ನು ಬಳಸಬಹುದು. ಇದರ ಒಂದು ನಿರ್ದಿಷ್ಟ ಉಪಯುಕ್ತತೆ ಇದೆ. ನೀವು ಈ ರೀತಿಯದನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ.
print('This is Shahbaz's computer')
ಈಗ ಮೇಲಿನ ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ, "Shahbaz's" ನಲ್ಲಿರುವಂತೆ ಎರಡನೇ ಉಲ್ಲೇಖದ ನಂತರದ ಎಲ್ಲವೂ ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ನಿಂದ ಗುರುತಿಸಲ್ಪಡುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಪೈಥಾನ್ ಎರಡನೇ ಉಲ್ಲೇಖವನ್ನು ಸ್ಟ್ರಿಂಗ್ನ ಅಂತ್ಯವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಘೋಷಿಸಲು ನೀವು ಡಬಲ್ ಕೋಟ್ಗಳನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೀರಿ:
print("This is Shahbaz's computer")
ಇದನ್ನು ಬೇರೆ ರೀತಿಯಲ್ಲಿಯೂ ಅನ್ವಯಿಸಬಹುದು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಎರಡು ಉದ್ಧರಣಗಳಿದ್ದರೆ ನಾವು ಒಂದೇ ಉಲ್ಲೇಖಗಳನ್ನು ಬಳಸಬಹುದು. ಉದಾ
print('This "computer" belongs to Shahbaz')
ಈಗ ನೀವು ಬಹು ಸಾಲುಗಳನ್ನು ವ್ಯಾಪಿಸಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮುದ್ರಿಸಲು ಬಯಸಿದರೆ, ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸುತ್ತುವರಿಯಲು ನೀವು ಟ್ರಿಪಲ್ ಕೋಟ್ಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್ನ ವಿಷಯವನ್ನು ಅವಲಂಬಿಸಿ ಈ ಉಲ್ಲೇಖಗಳು ಏಕ ಅಥವಾ ಎರಡು ಆಗಿರಬಹುದು. ಉದಾಹರಣೆಗೆ:
ಈಗ ನೀವು ಸ್ಟ್ರಿಂಗ್ನಿಂದ ನಿರ್ದಿಷ್ಟ ಅಕ್ಷರವನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಹೇಳೋಣ. ನೀವು ಅದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೀರಿ?
ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿರುವ ಅಕ್ಷರಗಳನ್ನು ಈ ರೀತಿ ಸೂಚಿಕೆ ಮಾಡುತ್ತದೆ:
ನೀವು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ನೋಡುವಂತೆ, 'h' ಅನ್ನು ಮಾತ್ರ ಮುದ್ರಿಸಲಾಗಿದೆ. ಏಕೆಂದರೆ ನಾವು ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಮೂರನೇ ಅಕ್ಷರವನ್ನು ಮಾತ್ರ ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಮುದ್ರಿಸಲು ಆಯ್ಕೆ ಮಾಡಿದ್ದೇವೆ, 3 ಚದರ ಬ್ರಾಕೆಟ್ಗಳಲ್ಲಿ ವೇರಿಯೇಬಲ್ ನಂತರ ಬರೆಯಿರಿ. ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ದೊಡ್ಡ ತಂತಿಗಳನ್ನು ಸರಳಗೊಳಿಸಲು ಋಣಾತ್ಮಕ ಅಕ್ಷರಗಳನ್ನು ಸೂಚಿಕೆ ಮಾಡುತ್ತದೆ. ಅಂದರೆ '-1' ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಕೊನೆಯ ಸಂಖ್ಯೆ ಮತ್ತು ಹೀಗೆ. ಸ್ಪೇಸ್ಗಳನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾಗಿಲ್ಲ ಅಂದರೆ ಮೇಲಿನ ಸ್ಟ್ರಿಂಗ್ ಕೇವಲ 21 ಇಂಡೆಕ್ಸ್ಡ್ ಸ್ಪೇಸ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ನೀವು ಸ್ಟ್ರಿಂಗ್ನಿಂದ ಅಕ್ಷರಗಳ ಸರಣಿಯನ್ನು ಸಹ ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಉದಾ
HashDork = ('Python Course by Shahbaz')
print(HashDork[0:3])
ಈ ಪ್ರೋಗ್ರಾಂ ಟರ್ಮಿನಲ್ನಲ್ಲಿ 'Pyt' ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಸೂಚ್ಯಂಕ 3 ಅನ್ನು ಇದರಿಂದ ಹೊರಗಿಡಲಾಗಿದೆ.
HashDork = ('Python Course by Shahbaz')
print(HashDork[2:])
ಅದೇ ರೀತಿಯಲ್ಲಿ, ನಾವು ಅಂತಿಮ ಸೂಚ್ಯಂಕವನ್ನು ಪೂರೈಸದಿದ್ದರೆ, ಪೈಥಾನ್ ಮೊದಲ ಸೂಚ್ಯಂಕದ ನಂತರ ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಈ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್ 'ಥಾನ್ ಕೋರ್ಸ್ ಬೈ ಶಹಬಾಜ್' ಆಗಿರುತ್ತದೆ. ಇದು ಪ್ರತಿಯಾಗಿ ಹೊಂದಿದೆ. ಅಂದರೆ ನಾವು ಮೊದಲ ಸೂಚ್ಯಂಕವನ್ನು ತಪ್ಪಿಸಿಕೊಂಡರೆ, ಪ್ರಾರಂಭದಿಂದ ಕೊನೆಯ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸೂಚ್ಯಂಕದವರೆಗೆ ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.
ಇಂಡೆಕ್ಸಿಂಗ್ ಬ್ರಾಕೆಟ್ಗಳಲ್ಲಿ ಕೊಲೊನ್ ಅನ್ನು ಹೊಂದಿರುವ ಪ್ರೋಗ್ರಾಂ ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನೀಡುತ್ತದೆ.
ವ್ಯಾಯಾಮ
ಇಲ್ಲಿ ಆಸಕ್ತಿದಾಯಕ ವ್ಯಾಯಾಮವಿದೆ
[1:-1] ನ ಸೂಚ್ಯಂಕ ಮಧ್ಯಂತರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಿರಿ. ಔಟ್ಪುಟ್ ಏನಾಗುತ್ತದೆ ಎಂದು ನೀವು ಯೋಚಿಸುತ್ತೀರಿ. ನೀವೇ ಪ್ರಯತ್ನಿಸಿ.
ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ಸ್
ನಿಮ್ಮ ವೇರಿಯೇಬಲ್ಗಳೊಂದಿಗೆ ನೀವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಕೆಲವು ಪಠ್ಯವನ್ನು ರಚಿಸುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ಗಳು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿವೆ. ನಾನು ನಿನಗೆ ತೋರಿಸುತ್ತೇನೆ.
ನಾವು ಎರಡು ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ, ಮೊದಲ ಹೆಸರು ಮತ್ತು ಕೊನೆಯ ಹೆಸರು.
first_name = 'Shahbaz'
last_name = 'Bhatti'
ಈಗ ನಾವು ಟರ್ಮಿನಲ್ನಲ್ಲಿ 'ಶಹಬಾಜ್ [ಭಟ್ಟಿ] ಒಂದು ಕೋಡರ್' ಎಂದು ಮುದ್ರಿಸಲು ಬಯಸುತ್ತೇವೆ. ನಾವು ಅದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೇವೆ? ನಾವು ಈ ರೀತಿಯ ಮೂರನೇ ವೇರಿಯಬಲ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತೇವೆ:
message = 'first_name + ' [' + last_name + '] is a coder'
ಈಗ ನಾವು ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮುದ್ರಿಸಿ ರನ್ ಮಾಡಿದರೆ, ಟರ್ಮಿನಲ್ನಲ್ಲಿ ನಮಗೆ 'ಶಹಬಾಜ್ [ಭಟ್ಟಿ] ಒಂದು ಕೋಡರ್' ಸಿಗುತ್ತದೆ.
ಈ ವಿಧಾನವು ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವಾಗ, ಇದು ಸೂಕ್ತವಲ್ಲ ಏಕೆಂದರೆ ನಮ್ಮ ಪಠ್ಯವು ಹೆಚ್ಚು ಜಟಿಲವಾದಂತೆ ಔಟ್ಪುಟ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸುವುದು ಕಷ್ಟವಾಗುತ್ತದೆ. ಇಲ್ಲಿ ನಾವು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ, ಅವು ಔಟ್ಪುಟ್ ಅನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ನಮಗೆ ಸುಲಭವಾಗಿಸುತ್ತದೆ.
ಮೂರನೇ ವೇರಿಯೇಬಲ್ 'ಸಂದೇಶ'ವನ್ನು ಬದಲಾಯಿಸೋಣ ಮತ್ತು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪರಿಚಯಿಸೋಣ. ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು, ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು 'f' ನೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯ ಮಾಡಿ ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ಗಳಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಸೇರಿಸಲು ಕರ್ಲಿ ಬ್ರೇಸ್ಗಳನ್ನು ಬಳಸಿ. ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
first_name = 'Shahbaz'
last_name = 'Bhatti'
message = f'{first_name} [{last_name}] is a coder'
ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು, ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಎಫ್ನೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯ ಮಾಡಿ ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ಗಳಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಸೇರಿಸಲು ಕರ್ಲಿ ಬ್ರೇಸ್ಗಳನ್ನು ಬಳಸಿ.
ಪೈಥಾನ್ ಸ್ಟ್ರಿಂಗ್ಗಳೊಂದಿಗೆ ನೀವು ಮಾಡಬಹುದಾದ ತಂಪಾದ ವಿಷಯಗಳು
ಪೈಥಾನ್ ತಂತಿಗಳೊಂದಿಗೆ ನೀವು ಮಾಡಬಹುದಾದ ಕೆಲವು ಉತ್ತಮ ವಿಷಯಗಳನ್ನು ನಾನು ನಿಮಗೆ ತೋರಿಸಲಿದ್ದೇನೆ.
1. ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿರುವ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆ
ಆದ್ದರಿಂದ ವೇರಿಯಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸೋಣ:
message = 'Shahbaz Bhatti is a Coder '
ಈಗ ನಾನು ಮೇಲಿನ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಬಯಸಿದರೆ, ಪೈಥಾನ್ನಲ್ಲಿ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯ ”ಲೆನ್” ಇದೆ. ಈ ಕಾರ್ಯದೊಂದಿಗೆ ವೇರಿಯಬಲ್ ಅನ್ನು ಈ ರೀತಿ ಮುದ್ರಿಸಿ
print(len(message))
ನೀವು ಬಳಕೆದಾರರಿಂದ ಇನ್ಪುಟ್ ಸ್ವೀಕರಿಸಿದಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಆನ್ಲೈನ್ನಲ್ಲಿ ಫಾರ್ಮ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡಿದಾಗ, ಪ್ರತಿ ಇನ್ಪುಟ್ ಕ್ಷೇತ್ರವು ಸಾಮಾನ್ಯವಾಗಿ ಮಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ಎಂದು ನೀವು ಗಮನಿಸಿದ್ದೀರಿ. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಹೆಸರಿಗೆ ನೀವು 50 ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಆದ್ದರಿಂದ ಈ "ಲೆನ್" ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಇನ್ಪುಟ್ ಕ್ಷೇತ್ರದಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯ ಮೇಲೆ ಮಿತಿಯನ್ನು ಜಾರಿಗೊಳಿಸಬಹುದು.
2. ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿರುವ ಅಕ್ಷರಗಳನ್ನು ದೊಡ್ಡಕ್ಷರ ಅಥವಾ ಸಣ್ಣಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು
ಡಾಟ್ ಆಪರೇಟರ್ ಮೂಲಕ ನಾವು ಸ್ಟ್ರಿಂಗ್-ಸಂಬಂಧಿತ ಕಾರ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ನಿಮ್ಮ ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ನೀವು ಟೈಪ್ ಮಾಡಬಹುದು ಮತ್ತು ಅದರ ಮುಂದೆ ಚುಕ್ಕೆ ಹಾಕುವ ಮೂಲಕ, ಅಂತಹ ಎಲ್ಲಾ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ನೋಡಬಹುದು.
ಈಗ ಹೆಚ್ಚು ನಿಖರವಾದ ಪರಿಭಾಷೆಯಲ್ಲಿ, ನೀವು ಈ ಕಾರ್ಯಗಳನ್ನು ವಿಧಾನಗಳಾಗಿ ಉಲ್ಲೇಖಿಸುತ್ತೀರಿ, ಇದು ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ ನಾವು ಭವಿಷ್ಯದಲ್ಲಿ ನೋಡಲು ಬಯಸುವ ಪದವಾಗಿದೆ, ಆದರೆ ಇದೀಗ, ನೀವು ತೆಗೆದುಹಾಕಲು ನಾನು ಬಯಸುತ್ತೇನೆ, ಅದು ಯಾವಾಗ ಯಾವುದೋ ಒಂದು ವಸ್ತುವಿಗೆ ಸಂಬಂಧಿಸಿದೆ ಅಥವಾ ಕೆಲವು ರೀತಿಯ ವಸ್ತುಗಳಿಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿದೆ, ನಾವು ಆ ಕಾರ್ಯವನ್ನು ಒಂದು ವಿಧಾನವಾಗಿ ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ನಾವು "ಮೇಲಿನ" ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.
ಈ ಕಾರ್ಯವು ಸ್ಟ್ರಿಂಗ್ಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿರುವುದರಿಂದ, ನಾವು ಇದನ್ನು ಒಂದು ವಿಧಾನ ಎಂದು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ "ಲೆನ್" ಮತ್ತು "ಪ್ರಿಂಟ್" ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಕಾರ್ಯಗಳಾಗಿವೆ, ಅವು ತಂತಿಗಳು ಅಥವಾ ಸಂಖ್ಯೆಗಳು ಅಥವಾ ಇತರ ರೀತಿಯ ವಸ್ತುಗಳಿಗೆ ಸಂಬಂಧಿಸಿರುವುದಿಲ್ಲ. ಇದು ಒಂದು ಕಾರ್ಯ ಮತ್ತು ವಿಧಾನದ ನಡುವಿನ ಮೂಲಭೂತ ವ್ಯತ್ಯಾಸವಾಗಿದೆ.
ಈಗ, ಇದನ್ನು ಮುದ್ರಿಸೋಣ.
message = 'Shahbaz Bhatti is a coder'
print(message.upper())
ಮತ್ತು ನಾವು ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ದೊಡ್ಡಕ್ಷರದಲ್ಲಿ ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ ಎಂದು ನಾವು ನೋಡಬಹುದು. ಅಂತೆಯೇ, ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಲೋವರ್ಕೇಸ್ ಆಗಿ ಪರಿವರ್ತಿಸಲು ನಾವು "ಕಡಿಮೆ" ವಿಧಾನವನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಸ್ಟ್ರಿಂಗ್ನ ಪ್ರತಿಯೊಂದು ಪದವನ್ನು ದೊಡ್ಡಕ್ಷರಗೊಳಿಸಲು ನೀವು "ಶೀರ್ಷಿಕೆ" ವಿಧಾನವನ್ನು ಸಹ ಬಳಸಬಹುದು.
ವಿಧಾನವು ನಮ್ಮ ಮೂಲ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ ಅಥವಾ ಮಾರ್ಪಡಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ವಾಸ್ತವವಾಗಿ, ಇದು ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
3. ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಅಕ್ಷರಗಳ ಅನುಕ್ರಮವನ್ನು ಹುಡುಕಿ
ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಅಕ್ಷರದ ಸೂಚಿಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಇನ್ನೊಂದು ವಿಧಾನವನ್ನು ಪ್ರಯತ್ನಿಸೋಣ.
ಕೌಟುಂಬಿಕತೆ:
message.find('b')
ಅದೇ ವೇರಿಯಬಲ್ ನಂತರ ಮತ್ತು ಅದನ್ನು ಮುದ್ರಿಸಿ. ಇದು ಈ ಸಂದರ್ಭದಲ್ಲಿ 4 ಆಗಿರುವ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ 'b' ಅಕ್ಷರದ ಮೊದಲ ಸಂಭವದ ಸೂಚಿಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.
ಈ ವಿಧಾನವು ಕೇಸ್ ಸೆನ್ಸಿಟಿವ್ ಆಗಿರುತ್ತದೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಅಕ್ಷರವು ಕಂಡುಬರದಿದ್ದರೆ ಅದು -1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಇದನ್ನು ಅಕ್ಷರಗಳ ಅನುಕ್ರಮಕ್ಕೆ ಸಹ ಬಳಸಬಹುದು.
ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ:
message = 'Shahbaz Bhatti is a coder'
print(message.find('coder'))
"ಕೋಡರ್" ಅನುಕ್ರಮವು ಸೂಚ್ಯಂಕ 20 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವುದರಿಂದ "20" ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
4. ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಅಕ್ಷರವನ್ನು ಬದಲಾಯಿಸುವುದು
ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಅಕ್ಷರ ಅಥವಾ ಅಕ್ಷರಗಳ ಅನುಕ್ರಮವನ್ನು ಬದಲಾಯಿಸಲು ನೀವು "ಬದಲಿ" ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು. ಇದನ್ನು ಕ್ರಿಯೆಯಲ್ಲಿ ನೋಡೋಣ.
message = 'Shahbaz Bhatti is a coder'
print(message.replace('coder', 'programmer'))
ಈ ಪ್ರೋಗ್ರಾಂ "ಕೋಡರ್" ಪದವನ್ನು "ಪ್ರೋಗ್ರಾಮರ್" ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಮುದ್ರಿಸುತ್ತದೆ.
5. ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿನ ಪಾತ್ರದ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸಿ
ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಅಕ್ಷರದ ಅಸ್ತಿತ್ವವನ್ನು ಅಥವಾ ಅಕ್ಷರದ ಅನುಕ್ರಮವನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು ಬಯಸಿದಾಗ ಈಗ ನಿದರ್ಶನಗಳಿವೆ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಈ ರೀತಿ ನಿಮ್ಮ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬಹುದು:
message = 'Shahbaz Bhatti is a coder'
ಮುದ್ರಣ (ಸಂದೇಶದಲ್ಲಿ 'ಪೈಥಾನ್')
ಈಗ ಇದು ಬೂಲಿಯನ್ ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅಂದರೆ "ನಿಜ" ಅಥವಾ "ಸುಳ್ಳು". ಹೀಗೆ;
ಈ ಎಲ್ಲಾ ವಿಧಾನಗಳು ಮತ್ತು ಕಾರ್ಯಗಳು ಕೇಸ್-ಸೆನ್ಸಿಟಿವ್ ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.
ಅಂತಿಮಗೊಳಿಸು!
ಸ್ಟ್ರಿಂಗ್ಗಳಿಗೆ ಇನ್ನೂ ಹೆಚ್ಚಿನವುಗಳಿವೆ, ನಾವು ಮುಂದೆ ಹೋದಂತೆ ನಾವು ಕ್ರಮೇಣ ಕಲಿಯುತ್ತೇವೆ. ಮುಂದೆ, ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಲು ಕಲಿಯುತ್ತೇವೆ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ