איבערזעצונג פון טעקסט צו אַ נייַע שורה אין פּיטהאָן. ווי צו אַריבערפירן טעקסט צו אַ נייַע שורה - ינסטראַקשאַנז

אין Python, צו צייכן די סוף פון איין שורה און אָנהייבן אַ נייַע, איר דאַרפֿן צו נוצן אַ ספּעציעל כאַראַקטער. אין דער זעלביקער צייט, עס איז וויכטיק צו וויסן ווי צו נוצן עס ריכטיק ווען ארבעטן מיט פאַרשידן פּיטהאָן טעקעס, און ווייַזן עס אין די קאַנסאָול אין די פארלאנגט מאָומאַנץ. עס איז נייטיק צו פֿאַרשטיין אין דעטאַל ווי צו נוצן די דעלימיטער פֿאַר נייַע שורות ווען איר אַרבעט מיט פּראָגראַם קאָד, צי עס איז מעגלעך צו לייגן טעקסט אָן ניצן עס.

אַלגעמיינע אינפֿאָרמאַציע וועגן די נעווליין כאַראַקטער

n איז דער סימבאָל פֿאַר ראַפּינג אינפֿאָרמאַציע אויף אַ נייַע שורה און פאַרמאַכן די אַלט שורה אין פּיטהאָן. דער סימבאָל באשטייט פון צוויי עלעמענטן:

• פאַרקערט אַבליק;
• n איז אַ קליין אותיות.

צו נוצן דעם כאַראַקטער, איר קענען נוצן די אויסדרוק "פּרינט(f" העללאָנוואָרלד!") ", רעכט צו וואָס איר קענען אַריבערפירן אינפֿאָרמאַציע אין F-שורות.

וואָס איז די דרוק פֿונקציע

אָן נאָך סעטטינגס, די דאַטן אַריבערפירן כאַראַקטער צו דער ווייַטער שורה איז מוסיף אין פאַרבאָרגן מאָדע. דערפֿאַר קען מען עס נישט זען צווישן די שורות אָן אַקטאַווייטינג אַ זיכער פֿונקציע. א ביישפּיל פון ווייַזנדיק אַ סעפּאַראַטאָר בילדל אין די פּראָגראַם קאָד:

דרוק ("העלא, וועלט") - "העלא, וועלט!" ן

אין דער זעלביקער צייַט, אַזאַ אַ דערגייונג פון דעם כאַראַקטער איז געשריבן אין די גרונט קעראַקטעריסטיקס פון פּיטהאָן. די "פּרינט" פֿונקציע האט אַ פעליקייַט ווערט פֿאַר די "סוף" פּאַראַמעטער - n. עס איז דאַנק צו דעם פֿונקציע אַז דער כאַראַקטער איז באַשטימט אין די סוף פון די שורות צו אַריבערפירן דאַטן צו די ווייַטער שורות. דערקלערונג פון די "פּרינט" פֿונקציע:

print(*objects, sep=' ', end='n', file=sys.stdout, flush=false)

די ווערט פון די "סוף" פּאַראַמעטער פון די "פּרינט" פֿונקציע איז גלייַך צו די כאַראַקטער "n". לויט די אָטאַמאַטיק אַלגערידאַם פון די פּראָגראַם קאָד, עס קאַמפּליץ די שורות אין די סוף, איידער וואָס די "דרוקן" פֿונקציע איז געשריבן. ווען איר נוצן אַ איין "פּרינט" פֿונקציע, איר קען נישט באַמערקן די עסאַנס פון זיין אַרבעט, ווייַל בלויז איין שורה וועט זיין געוויזן אויף דעם עקראַן. אָבער, אויב איר לייגן עטלעכע סטייטמאַנץ ווי דאָס, דער רעזולטאַט פון די פֿונקציע ווערט מער יקספּליסאַט:

print("העלא, וועלט 1!") print("העלא, וועלט 2!") print("העלא, וועלט 3!") print("העלא, וועלט 4!")

א ביישפּיל פון דער רעזולטאַט פון די קאָד אויבן:

העלא, וועלט 1! העלא, וועלט 2! העלא, וועלט 3! העלא, וועלט 4!

ריפּלייסינג אַ נעווליין כאַראַקטער מיט דרוקן

ניצן די "פּרינט" פֿונקציע, עס איז מעגלעך נישט צו נוצן אַ סעפּאַראַטאָר כאַראַקטער צווישן שורות. צו טאָן דאָס, איר דאַרפֿן צו טוישן די "סוף" פּאַראַמעטער אין די פונקציע זיך. אין דעם פאַל, אַנשטאָט פון די "סוף" ווערט, איר דאַרפֿן צו לייגן אַ פּלאַץ. רעכט צו דעם, עס איז דער פּלאַץ וואָס וועט פאַרבייַטן די "סוף" כאַראַקטער. רעזולטאַט מיט פעליקייַט סעטטינגס שטעלן:

>>> דרוק ("העלא") >>> דרוק ("וועלט") העלא וועלט

ווייַזנדיק די רעזולטאַט נאָך ריפּלייסינג די כאַראַקטער "n" מיט אַ פּלאַץ:

>>> דרוק ("העלא", ענד=" ") >>> דרוק ("וועלט") העלא וועלט

א ביישפּיל פון ניצן דעם אופֿן פון ריפּלייסינג אותיות צו ווייַזן אַ סיקוואַנס פון וואַלועס אין איין שורה:

פֿאַר איך אין קייט (15): אויב איך <14: דרוק (איך, סוף = ", ") אַנדערש: דרוק (איך)

ניצן סעפּאַראַטאָר כאַראַקטער אין טעקעס

דער סימבאָל נאָך וואָס די טעקסט פון די פּראָגראַם קאָד איז טראַנספערד צו דער ווייַטער שורה קענען זיין געפֿונען אין די פאַרטיק טעקעס. אָבער, אָן וויוינג די דאָקומענט זיך דורך די פּראָגראַם קאָד, עס איז אוממעגלעך צו זען עס, ווייַל אַזאַ אותיות זענען פאַרבאָרגן דורך פעליקייַט. אין סדר צו נוצן די נעווליין כאַראַקטער, איר דאַרפֿן צו שאַפֿן אַ טעקע אָנגעפילט מיט נעמען. נאָך עפן עס, איר קענען זען אַז אַלע נעמען וועט אָנהייבן אויף אַ נייַע שורה. בייַשפּיל:

names = ['Petr', 'Dima', 'Artem', 'Ivan'] מיט אָפֿן("names.txt", "w") ווי f: פֿאַר נאָמען אין נעמען[:-1]: f.write(f) "{נאָמען}n") f.write(נעמען[-1])

נעמען וועט זיין געוויזן דעם וועג בלויז אויב די טעקסט טעקע איז באַשטימט צו באַזונדער אינפֿאָרמאַציע אין באַזונדער שורות. דאָס וועט אויטאָמאַטיש שטעלן די פאַרבאָרגן כאַראַקטער "n" אין די סוף פון יעדער פריערדיקן שורה. צו זען די פאַרבאָרגן צייכן, איר דאַרפֿן צו אַקטאַווייט די פֿונקציע - ".readlines ()". נאָך דעם, אַלע פאַרבאָרגן אותיות וועט זיין געוויזן אויף דעם עקראַן אין די פּראָגראַם קאָד. פונקציע אַקטאַוויישאַן בייַשפּיל:

מיט עפֿן ("נאַמעס.טקסט", "ר") ווי f: print (f.readlines ())

עצה! אַקטיוולי ארבעטן מיט Python, ניצערס אָפט טרעפן סיטואַטיאָנס ווו די פּראָגראַם קאָד מוזן זיין געשריבן אין איין לאַנג שורה, אָבער עס איז גאָר שווער צו אָפּשאַצן עס און ידענטיפיצירן ינאַקיעראַסיז אָן צעשיידונג. אַזוי אַז נאָך דיוויידינג אַ לאַנג שורה אין באַזונדער פראַגמאַנץ, דער קאָמפּיוטער האלט עס גאַנץ, אין יעדער פריי ריס צווישן די וואַלועס, איר מוזן אַרייַנלייגן די כאַראַקטער "" - אַ באַקקלאַש. נאָך אַדינג אַ כאַראַקטער, איר קענען מאַך צו אן אנדער שורה, פאָרזעצן שרייבן קאָד. בעשאַס קאַטער, די פּראָגראַם זיך וועט אַסעמבאַל די יחיד פראַגמאַנץ אין אַ איין שורה.

שפּאַלטן אַ שטריקל אין סובסטרינגס

צו שפּאַלטן איין לאַנג שטריקל אין עטלעכע סובסטרינגס, איר קענען נוצן די שפּאַלטן אופֿן. אויב קיין ווייַטער עדיטינג זענען געמאכט, די פעליקייַט דעלימיטער איז אַ פּלאַץ. נאָך עקסאַקיוטינג דעם אופֿן, די אויסגעקליבן טעקסט איז צעטיילט אין באַזונדער ווערטער דורך סובסטרינגס, קאָנווערטעד אין אַ רשימה פון סטרינגס. ווי אַ בייַשפּיל:

string = "עטלעכע נייַע טעקסט" סטרינגס = string.split() דרוקן (סטרינגס) ['עטלעכע', 'נייַ', 'טעקסט']

אין סדר צו דורכפירן די פאַרקערט טראַנספאָרמאַציע, מיט די הילף פון וואָס די רשימה פון סובסטרינגס וועט ווערן אַ לאַנג שטריקל, איר מוזן נוצן די פאַרבינדן אופֿן. אן אנדער נוציק אופֿן פֿאַר ארבעטן מיט סטרינגס איז פּאַס. מיט עס, איר קענען אַראָפּנעמען ספּייסאַז וואָס זענען ליגן אויף ביידע זייטן פון די שורה.

סאָף

אין סדר צו רעזולטאַט זיכער דאַטן פון אַ נייַע שורה ווען איר אַרבעט אין פּיטהאָן, עס איז נייטיק צו ענדיקן די אַלט שורה מיט די כאַראַקטער "n". מיט זייַן הילף, די אינפֿאָרמאַציע נאָך די צייכן איז טראַנספערד צו דער ווייַטער שורה, און די אַלט איינער איז פֿאַרמאַכט. אָבער, עס איז ניט נייטיק צו נוצן דעם סימבאָל צו אַריבערפירן דאַטן. צו טאָן דאָס, איר קענען נוצן דעם פּאַראַמעטער סוף = "". די ווערט "כאַראַקטער" איז דער סעפּאַראַטאָר כאַראַקטער.