ಪರಿವಿಡಿ
ಪೈಥಾನ್‌ನಲ್ಲಿ, ಒಂದು ಸಾಲಿನ ಅಂತ್ಯವನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಹೊಸದನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ವಿಶೇಷ ಅಕ್ಷರವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ವಿವಿಧ ಪೈಥಾನ್ ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಅದನ್ನು ಸರಿಯಾಗಿ ಬಳಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯುವುದು ಮುಖ್ಯವಾಗಿದೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಕ್ಷಣಗಳಲ್ಲಿ ಅದನ್ನು ಕನ್ಸೋಲ್ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಿ. ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಹೊಸ ಸಾಲುಗಳಿಗಾಗಿ ಡಿಲಿಮಿಟರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು, ಅದನ್ನು ಬಳಸದೆಯೇ ಪಠ್ಯವನ್ನು ಸೇರಿಸುವುದು ಸಾಧ್ಯವೇ ಎಂಬುದನ್ನು ವಿವರವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ.
ಹೊಸ ಸಾಲಿನ ಅಕ್ಷರದ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಮಾಹಿತಿ
n ಎಂಬುದು ಹೊಸ ಸಾಲಿನಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಸುತ್ತುವ ಮತ್ತು ಪೈಥಾನ್‌ನಲ್ಲಿ ಹಳೆಯ ರೇಖೆಯನ್ನು ಮುಚ್ಚುವ ಸಂಕೇತವಾಗಿದೆ. ಈ ಚಿಹ್ನೆಯು ಎರಡು ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:
- ಹಿಮ್ಮುಖ ಓರೆ;
- n ಒಂದು ಸಣ್ಣ ಅಕ್ಷರವಾಗಿದೆ.
ಈ ಅಕ್ಷರವನ್ನು ಬಳಸಲು, ನೀವು "ಪ್ರಿಂಟ್ (ಎಫ್" ಹೆಲೋನ್ ವರ್ಲ್ಡ್!") "ಎಂಬ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಬಳಸಬಹುದು, ಇದರಿಂದಾಗಿ ನೀವು ಎಫ್-ಲೈನ್‌ಗಳಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ವರ್ಗಾಯಿಸಬಹುದು.
ಮುದ್ರಣ ಕಾರ್ಯ ಏನು
ಹೆಚ್ಚುವರಿ ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಲ್ಲದೆಯೇ, ಮುಂದಿನ ಸಾಲಿಗೆ ಡೇಟಾ ವರ್ಗಾವಣೆ ಪಾತ್ರವನ್ನು ಗುಪ್ತ ಮೋಡ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಈ ಕಾರಣದಿಂದಾಗಿ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸದೆ ಅದನ್ನು ರೇಖೆಗಳ ನಡುವೆ ನೋಡಲಾಗುವುದಿಲ್ಲ. ಪ್ರೋಗ್ರಾಂ ಕೋಡ್‌ನಲ್ಲಿ ವಿಭಜಕ ಐಕಾನ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುವ ಉದಾಹರಣೆ:
ಮುದ್ರಿಸು ("ಹಲೋ, ವರ್ಲ್ಡ್"!") - "ಹಲೋ, ವರ್ಲ್ಡ್!"nಅದೇ ಸಮಯದಲ್ಲಿ, ಈ ಪಾತ್ರದ ಅಂತಹ ಆವಿಷ್ಕಾರವನ್ನು ಪೈಥಾನ್ನ ಮೂಲಭೂತ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. "ಮುದ್ರಣ" ಕಾರ್ಯವು "ಅಂತ್ಯ" ನಿಯತಾಂಕಕ್ಕಾಗಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ - n. ಮುಂದಿನ ಸಾಲುಗಳಿಗೆ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು ಸಾಲುಗಳ ಕೊನೆಯಲ್ಲಿ ಈ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಈ ಕಾರ್ಯಕ್ಕೆ ಧನ್ಯವಾದಗಳು. "ಮುದ್ರಣ" ಕಾರ್ಯದ ವಿವರಣೆ:
ಪ್ರಿಂಟ್(*ಆಬ್ಜೆಕ್ಟ್ಸ್, ಸೆಪ್=' ', ಎಂಡ್='ಎನ್', ಫೈಲ್=sys.stdout, ಫ್ಲಶ್ = ತಪ್ಪು)
"ಮುದ್ರಣ" ಕಾರ್ಯದಿಂದ "ಅಂತ್ಯ" ನಿಯತಾಂಕದ ಮೌಲ್ಯವು "n" ಅಕ್ಷರಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ನ ಸ್ವಯಂಚಾಲಿತ ಅಲ್ಗಾರಿದಮ್ ಪ್ರಕಾರ, ಇದು ಕೊನೆಯಲ್ಲಿ ಸಾಲುಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ, ಅದರ ಮೊದಲು "ಮುದ್ರಣ" ಕಾರ್ಯವನ್ನು ಬರೆಯಲಾಗುತ್ತದೆ. ಒಂದೇ "ಮುದ್ರಣ" ಕಾರ್ಯವನ್ನು ಬಳಸುವಾಗ, ಅದರ ಕೆಲಸದ ಸಾರವನ್ನು ನೀವು ಗಮನಿಸದೇ ಇರಬಹುದು, ಏಕೆಂದರೆ ಪರದೆಯ ಮೇಲೆ ಕೇವಲ ಒಂದು ಸಾಲು ಮಾತ್ರ ಪ್ರದರ್ಶಿಸಲ್ಪಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನೀವು ಈ ರೀತಿಯ ಕೆಲವು ಹೇಳಿಕೆಗಳನ್ನು ಸೇರಿಸಿದರೆ, ಕಾರ್ಯದ ಫಲಿತಾಂಶವು ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ:
ಪ್ರಿಂಟ್("ಹಲೋ, ವರ್ಲ್ಡ್ 1!") ಪ್ರಿಂಟ್("ಹಲೋ, ವರ್ಲ್ಡ್ 2!") ಪ್ರಿಂಟ್("ಹಲೋ, ವರ್ಲ್ಡ್ 3!") ಪ್ರಿಂಟ್("ಹಲೋ, ವರ್ಲ್ಡ್ 4!")ಮೇಲಿನ ಕೋಡ್ನ ಫಲಿತಾಂಶದ ಉದಾಹರಣೆ:
ಹಲೋ, ವರ್ಲ್ಡ್ 1! ಹಲೋ, ವರ್ಲ್ಡ್ 2! ಹಲೋ, ವರ್ಲ್ಡ್ 3! ಹಲೋ, ವರ್ಲ್ಡ್ 4!
ಮುದ್ರಣದೊಂದಿಗೆ ಹೊಸ ಸಾಲಿನ ಅಕ್ಷರವನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತಿದೆ
"ಮುದ್ರಣ" ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು, ಸಾಲುಗಳ ನಡುವೆ ವಿಭಜಕ ಅಕ್ಷರವನ್ನು ಬಳಸದಿರಲು ಸಾಧ್ಯವಿದೆ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಕಾರ್ಯದಲ್ಲಿಯೇ "ಅಂತ್ಯ" ನಿಯತಾಂಕವನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, "ಅಂತ್ಯ" ಮೌಲ್ಯದ ಬದಲಿಗೆ, ನೀವು ಜಾಗವನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ. ಈ ಕಾರಣದಿಂದಾಗಿ, ಇದು "ಅಂತ್ಯ" ಅಕ್ಷರವನ್ನು ಬದಲಿಸುವ ಸ್ಥಳವಾಗಿದೆ. ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಫಲಿತಾಂಶವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ:
>>> ಪ್ರಿಂಟ್("ಹಲೋ") >>> ಪ್ರಿಂಟ್("ವರ್ಲ್ಡ್") ಹಲೋ ವರ್ಲ್ಡ್"n" ಅಕ್ಷರವನ್ನು ಜಾಗದಿಂದ ಬದಲಾಯಿಸಿದ ನಂತರ ಫಲಿತಾಂಶವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತಿದೆ:
>>> ಪ್ರಿಂಟ್("ಹಲೋ", ಎಂಡ್=" ") >>> ಪ್ರಿಂಟ್("ವರ್ಲ್ಡ್") ಹಲೋ ವರ್ಲ್ಡ್ಒಂದು ಸಾಲಿನಲ್ಲಿ ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಅಕ್ಷರಗಳನ್ನು ಬದಲಿಸುವ ಈ ವಿಧಾನವನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ:
i ಗಾಗಿ (15): i <14: print(i, end=", ") else: print(i)
ಫೈಲ್‌ಗಳಲ್ಲಿ ವಿಭಜಕ ಅಕ್ಷರವನ್ನು ಬಳಸುವುದು
ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ನ ಪಠ್ಯವನ್ನು ಮುಂದಿನ ಸಾಲಿಗೆ ವರ್ಗಾಯಿಸಿದ ಚಿಹ್ನೆಯನ್ನು ಸಿದ್ಧಪಡಿಸಿದ ಫೈಲ್‌ಗಳಲ್ಲಿ ಕಾಣಬಹುದು. ಆದಾಗ್ಯೂ, ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಮೂಲಕ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಸ್ವತಃ ನೋಡದೆ, ಅದನ್ನು ನೋಡಲು ಅಸಾಧ್ಯ, ಏಕೆಂದರೆ ಅಂತಹ ಅಕ್ಷರಗಳನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಮರೆಮಾಡಲಾಗಿದೆ. ಹೊಸ ಸಾಲಿನ ಅಕ್ಷರವನ್ನು ಬಳಸಲು, ನೀವು ಹೆಸರುಗಳಿಂದ ತುಂಬಿದ ಫೈಲ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಅದನ್ನು ತೆರೆದ ನಂತರ, ಎಲ್ಲಾ ಹೆಸರುಗಳು ಹೊಸ ಸಾಲಿನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುವುದನ್ನು ನೀವು ನೋಡಬಹುದು. ಉದಾಹರಣೆ:
ಹೆಸರುಗಳು = ['Petr', 'Dima', 'Artem', 'Ivan'] ಜೊತೆಗೆ ತೆರೆದ ("names.txt", "w") f: ಹೆಸರುಗಳಲ್ಲಿ ಹೆಸರಿಗಾಗಿ[:-1]: f.write(f "{name}n") f.write(ಹೆಸರುಗಳು[-1])ಟೆಕ್ಸ್ಟ್ ಫೈಲ್ ಅನ್ನು ಮಾಹಿತಿಯನ್ನು ಪ್ರತ್ಯೇಕ ಸಾಲುಗಳಾಗಿ ಹೊಂದಿಸಿದರೆ ಮಾತ್ರ ಹೆಸರುಗಳನ್ನು ಈ ರೀತಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಇದು ಪ್ರತಿ ಹಿಂದಿನ ಸಾಲಿನ ಕೊನೆಯಲ್ಲಿ ಗುಪ್ತ ಅಕ್ಷರ "n" ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಂದಿಸುತ್ತದೆ. ಗುಪ್ತ ಚಿಹ್ನೆಯನ್ನು ನೋಡಲು, ನೀವು ಕಾರ್ಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು - ".readlines()". ಅದರ ನಂತರ, ಎಲ್ಲಾ ಗುಪ್ತ ಅಕ್ಷರಗಳನ್ನು ಪ್ರೋಗ್ರಾಂ ಕೋಡ್‌ನಲ್ಲಿ ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಕಾರ್ಯ ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಯ ಉದಾಹರಣೆ:
ತೆರೆದ ("names.txt", "r") ಜೊತೆಗೆ f: print(f.readlines())
ಸಲಹೆ! ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಸಕ್ರಿಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವಾಗ, ಬಳಕೆದಾರರು ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಅನ್ನು ಒಂದು ದೀರ್ಘ ಸಾಲಿನಲ್ಲಿ ಬರೆಯಬೇಕಾದ ಸಂದರ್ಭಗಳನ್ನು ಆಗಾಗ್ಗೆ ಎದುರಿಸುತ್ತಾರೆ, ಆದರೆ ಅದನ್ನು ಪರಿಶೀಲಿಸುವುದು ಮತ್ತು ಪ್ರತ್ಯೇಕಿಸದೆ ತಪ್ಪುಗಳನ್ನು ಗುರುತಿಸುವುದು ತುಂಬಾ ಕಷ್ಟ. ಆದ್ದರಿಂದ ದೀರ್ಘ ರೇಖೆಯನ್ನು ಪ್ರತ್ಯೇಕ ತುಣುಕುಗಳಾಗಿ ವಿಂಗಡಿಸಿದ ನಂತರ, ಕಂಪ್ಯೂಟರ್ ಅದನ್ನು ಸಂಪೂರ್ಣ ಪರಿಗಣಿಸುತ್ತದೆ, ಮೌಲ್ಯಗಳ ನಡುವಿನ ಪ್ರತಿ ಉಚಿತ ಅಂತರದಲ್ಲಿ, ನೀವು "" ಅಕ್ಷರವನ್ನು ಸೇರಿಸಬೇಕು - ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್. ಅಕ್ಷರವನ್ನು ಸೇರಿಸಿದ ನಂತರ, ನೀವು ಇನ್ನೊಂದು ಸಾಲಿಗೆ ಹೋಗಬಹುದು, ಕೋಡ್ ಬರೆಯುವುದನ್ನು ಮುಂದುವರಿಸಿ. ಉಡಾವಣೆಯ ಸಮಯದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂ ಸ್ವತಃ ಪ್ರತ್ಯೇಕ ತುಣುಕುಗಳನ್ನು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಜೋಡಿಸುತ್ತದೆ.
ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಬ್ಸ್ಟ್ರಿಂಗ್ಗಳಾಗಿ ವಿಭಜಿಸುವುದು
ಒಂದು ಉದ್ದವಾದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಲವಾರು ಸಬ್ಸ್ಟ್ರಿಂಗ್ಗಳಾಗಿ ವಿಭಜಿಸಲು, ನೀವು ಸ್ಪ್ಲಿಟ್ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು. ಯಾವುದೇ ಹೆಚ್ಚಿನ ಸಂಪಾದನೆಗಳನ್ನು ಮಾಡದಿದ್ದರೆ, ಡಿಫಾಲ್ಟ್ ಡಿಲಿಮಿಟರ್ ಒಂದು ಸ್ಪೇಸ್ ಆಗಿದೆ. ಈ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ಆಯ್ದ ಪಠ್ಯವನ್ನು ಸಬ್ಸ್ಟ್ರಿಂಗ್ಗಳ ಮೂಲಕ ಪ್ರತ್ಯೇಕ ಪದಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ, ತಂತಿಗಳ ಪಟ್ಟಿಯಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಯಾಗಿ:
ಸ್ಟ್ರಿಂಗ್ = "ಕೆಲವು ಹೊಸ ಪಠ್ಯ" ತಂತಿಗಳು = string.split() ಮುದ್ರಣ(ಸ್ಟ್ರಿಂಗ್ಸ್) ['ಕೆಲವು', 'ಹೊಸ', 'ಪಠ್ಯ']
ರಿವರ್ಸ್ ರೂಪಾಂತರವನ್ನು ಕೈಗೊಳ್ಳಲು, ಅದರ ಸಹಾಯದಿಂದ ಸಬ್ಸ್ಟ್ರಿಂಗ್ಗಳ ಪಟ್ಟಿಯು ಒಂದು ಉದ್ದವಾದ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಬದಲಾಗುತ್ತದೆ, ನೀವು ಸೇರುವ ವಿಧಾನವನ್ನು ಬಳಸಬೇಕು. ತಂತಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಮತ್ತೊಂದು ಉಪಯುಕ್ತ ವಿಧಾನವೆಂದರೆ ಸ್ಟ್ರಿಪ್. ಇದರೊಂದಿಗೆ, ನೀವು ರೇಖೆಯ ಎರಡೂ ಬದಿಗಳಲ್ಲಿ ಇರುವ ಸ್ಥಳಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು.
ತೀರ್ಮಾನ
ಪೈಥಾನ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಹೊಸ ಸಾಲಿನಿಂದ ಕೆಲವು ಡೇಟಾವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಲು, ಹಳೆಯ ಸಾಲನ್ನು "n" ಅಕ್ಷರದೊಂದಿಗೆ ಕೊನೆಗೊಳಿಸುವುದು ಅವಶ್ಯಕ. ಅದರ ಸಹಾಯದಿಂದ, ಚಿಹ್ನೆಯ ನಂತರದ ಮಾಹಿತಿಯನ್ನು ಮುಂದಿನ ಸಾಲಿಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಹಳೆಯದನ್ನು ಮುಚ್ಚಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು ಈ ಚಿಹ್ನೆಯನ್ನು ಬಳಸುವುದು ಅನಿವಾರ್ಯವಲ್ಲ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಪ್ಯಾರಾಮೀಟರ್ ಅಂತ್ಯವನ್ನು ಬಳಸಬಹುದು = "