כיצד להשתמש בפורמטרים של מחרוזות ב-Python 3

### הקדמה

שיטת str.format() במחלקת המחרוזות של פייתון מאפשרת לך לבצע החלפות משתנים ועיצוב של ערכים. זה מאפשר לך לשרשר אלמנטים יחד בתוך מחרוזת דרך עיצוב פוזיציונלי.

מדריך זה יכוון אותך דרך כמה משימושי הפורמטרים הנפוצים בפייתון, שיכולים לעזור לך להפוך את הקוד והתוכנית שלך לנקראים וידידותיים יותר למשתמש.

דרישות מוקדמות

עליך להתקין את פייתון 3 ולהגדיר סביבת תכנות במחשב או בשרת שלך. אם אין לך סביבת תכנות מוגדרת, תוכל להתייעץ עם מדריכי ההתקנה וההגדרה עבור סביבת תכנות מקומית או עבור סביבת תכנות על השרת שלך המתאימה למערכת ההפעלה שלך (אובונטו, CentOS, דביאן וכו').

##שימוש בפורמטרים

עובדי העיצוב פועלים על ידי הוספת שדות החלפה אחד או יותר או מצייני מיקום – הוגדרים על ידי זוג סוגריים מסולסלים – למחרוזת וקריאה לשיטת str.format(). תעבירו את הערך שברצונכם לחבר עם המחרוזת לשיטה. הערך הזה יועבר באותו המקום שבו הוא ממוקם כאשר תפעילו את התוכנית.

בואו נדפיס מחרוזת המשתמשת בעיצוב:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

בדוגמה לעיל, בנו מחרוזת עם זוג סוגריים מסולסלים כמציין מקום:

"Sammy has {} balloons."

אז הוספנו את השיטה str.format() והעברנו את ערך המספר השלם 5 אל השיטה. זה מניח את ערך 5 לתוך המחרוזת במקום שהיו הסוגריים המסולסלים:

Sammy has 5 balloons.

ניתן גם להקצות משתנה שיהיה שווה לערך של מחרוזת עם מצייני מיקום לעיצוב:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

בדוגמה השנייה זו, חיברנו את המחרוזת "open source" עם המחרוזת הגדולה, מחליפים את הסוגריים המסולסלים במחרוזת המקורית.

עיצובים בפייתון מאפשרים לך להשתמש בסוגריים מסולסלים כמצייני מיקום עבור ערכים שתעביר עם השיטה str.format().

##שימוש בעיצובים עם מצייני מיקום מרובים

אתה יכול להשתמש במספר זוגות של סוגריים מסולסלים כאשר אתה משתמש ב־formatters. אם נרצה להוסיף החלפת משתנים נוספת למשפט למעלה, נוכל לעשות זאת על ידי הוספת זוג נוסף של סוגריים מסולסלים ולהעביר ערך שני לאמצעי:

new_open_string = "Sammy loves {} {}."                      #2 סימני מיקום {}
print(new_open_string.format("open-source", "software"))    #העבר שני מחרוזות לשיטה, מופרדות בפסיק

Output
Sammy loves open-source software.

כדי להוסיף החלפה נוספת, הוספנו זוג שני של סוגריים מסולסלים למחרוזת המקורית. לאחר מכן, עברנו שני מחרוזות לשיטת str.format(), והפרדנו ביניהן בפסיק.

לפי התחביר אותו, אנו יכולים להוסיף החלפות נוספות:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 סימני מיקום {}
print(sammy_string.format("open-source", "software", 5, "balloons"))    #העבר 4 מחרוזות לשיטה

Output
Sammy loves open-source software, and has 5 balloons.

ב־sammy_string הוספנו 4 זוגות של סוגריים מסולסלים כסימני מיקום עבור החלפת משתנים. לאחר מכן, עברנו 4 ערכים לשיטת str.format(), מערבבים מחרוזות וסוגי נתונים של מספרים שלמים. כל אחד מהערכים הללו מופרד בפסיק.

##מידול סידור של ה־Formatters עם ארגומנטים מיקום ומילות מפתח

כאשר אנו משאירים סוגריים מסולסלים ריקים בלי פרמטרים, פייתון תחליף את הערכים שעברו דרך שיטת str.format() בסדר. כפי שראינו עד כה, תצורת פורמטר עם שני סוגריים מסולסלים ריקים וערכים שנעברו יראה כך:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

זוג הסוגריים הראשון מוחלף בערך המחרוזת של "shark", והזוג השני מוחלף בערך המחרוזת של "pilot fish".

הערכים שקיימים בתוך השיטה נראים כך:

("shark", "pilot fish")

הם בעצם מסוג הנתונים tuple וכל ערך יחיד המכיל בתוך הטאפל יכול להיקרא על ידי מספר האינדקס שלו, שמתחיל עם מספר האינדקס 0.

אנו יכולים להעביר את מספרי האינדקס האלה אל תוך הסוגריים הקימוריים שמשמשים כמחליפים במחרוזת המקורית:

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

בדוגמה שניתן למעלה, הפלט יהיה מה שאנו מקבלים בלעדיים מספרי האינדקס אל הסוגריים המסתובבים במידה ואנו קוראים על הערכים בטאפל בסדר:

Output
Sammy the shark has a pet pilot fish!

אך, אם נהפוך את מספרי האינדקס עם הפרמטרים של המחליפים, נוכל להפוך את הערכים שמועברים אל המחרוזת:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

כאשר אתה קורא למספר אינדקס של 2 בטאפל שיש לו ערכים במקומות האינדקס 0 ו-1, אז אתה קורא על ערך שמחוץ לטווח. כאשר אתה קורא למספר אינדקס שמחוץ לטווח, תקבל הודעת שגיאה:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

ההודעת שגיאה שאנו רואים מתייחסת לטאפל שיש לו ערכים במספרי אינדקס 0 ו-1 בלבד, לכן מקום האינדקס 2 מחוץ לטווח.

בואו נוסיף כמה מחליפים נוספים וערכים נוספים כדי שנוכל להבין כיצד אנחנו יכולים לסדר מחדש פורמטרים קצת יותר טוב. תחילה, הנה מחרוזת חדשה עם ארבעה מחליפים:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

בלעדי פרמטרים, הערכים שמועברים אל שיטת ה-str.format() מתווספים למחרוזת לפי הסדר.

ערכי המחרוזת המוכלים בטאפל תואמים למספרי אינדקס הבאים:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

בואו נשתמש במספרי האינדקס של הערכים כדי לשנות את הסדר שבו הם מופיעים במחרוזת:

מאז שהתחלנו עם מספר האינדקס 3, קראנו לערך האחרון של "כריש" תחילה. המספרים של האינדקס האחרים המופיעים כפרמטרים משנים את הסדר שבו המילים מופיעות בתוך המחרוזת המקורית.

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

בנוסף לארגומנטים מיקומיים, אנו יכולים גם להכניס ארגומנטים מילוליים שנקראים לפי שמם:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

דוגמה זו מציגה את שימוש בארגומנט מילולי המשמש עם ארגומנטים מיקומיים. אנו יכולים למלא את הארגומנט מילולי pr לצד ארגומנטים מיקומיים, ולהזיז את הארגומנטים הללו כדי לשנות את המחרוזת התוצאה:

ארגומנטים מיקומיים ומילוליים המשמשים עם מבני המחרוזות נותנים לנו יותר בקרה על שינוי המחרוזות המקוריות שלנו דרך המיון מחדש.

##ציון סוגאנו יכולים לכלול יותר פרמטרים בתוך הסוגריים המעוגלים של התחביר שלנו. נשתמש בתחביר הקוד פורמט {field_name:conversion}, שבו field_name מציין את מספר האינדקס של הארגומנט לשיטת str.format() שעברנו דרכו במדור המיון מחדש, ו-conversion מתייחס לקוד ההמרה של סוג הנתונים שאתה משתמש בו עם הפורמטר.

הסוג כולל קוד סוג בודד שבו משתמש Python. הקודים שנשתמש בהם כאן הם s עבור מחרוזת, d להצגת מספרים שלמים עשרוניים (בסיס 10), ו־f שנשתמש בו כדי להציג מספרים עשרוניים. אפשר לקרוא עוד על שפה מיני להגדרת פורמט דרך תיעוד הרשמי של Python 3.

בואו נסתכל על דוגמה בה העברנו מספר שלם דרך השיטה, אך רוצים להציג אותו כמספר עשרוני על ידי הוספת ארגומנט של סוג ההמרה f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

השתמשנו בתחביר של {שם_שדה:המרה} עבור שדה המחליף הסוגר סוגריים הראשון כדי להוציא מספר עשרוני. הסוגריים השניים משתמשים רק בפרמטר הראשון {שם_שדה}.

בדוגמה לעיל, ישנם הרבה מספרים מוצגים אחרי הנקודה העשרונית, אך אפשר להגביל אותם. כאשר אתה מציין f עבור ערכי מספרים עשרוניים, תוכל לציין גם את הדיוק של הערך על ידי כלול של נקודה מלאה . בעקבות מספר הספרות אחרי הנקודה העשרונית שברצונך לכלול.

אם סמי אכל 75.765367% מהפיצה, אך אין לנו צורך ברמת דיוק גבוהה, נוכל להגביל את המקומות אחרי הנקודה ל־3 על ידי הוספת .3 לפני סוג ההמרה f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

אם רוצים רק מקום עשרוני אחד, נוכל לכתוב מחדש את המחרוזת והשיטה כך:

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

שים לב ששינוי הדיוק יגרום לעגינה של המספר.

אם נציג מספר ללא נקודה עשרונית כfloat, אך ננסה לשנות את הfloat לinteger באמצעות הסוג המרה d, נקבל שגיאה:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

אם תרצה שלא יוצגו מיקומים עשרוניים, תוכל לכתוב את הפורמטר שלך בצורה הבאה:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

זה לא יהמיר את הfloat שלך לinteger, אלא יוגביל את מספר המקומות שמוצגים אחרי הנקודה העשרונית.

##ציוד משתנה לרילוקיות

מכיוון שהמציינים הם שדות החלפה, תוכל למלא או ליצור רווחים מסביב לרכיב על ידי הגדלת גודל השדה באמצעות פרמטרים נוספים. זה יכול להיות שימושי כאשר נצטרך לארגן הרבה מידע חזותית.

נוכל להוסיף מספר כדי לציין גודל שדה (במונחי תווים) אחרי הנקודתיים : בתוך הסוגריים הסיבוכיים של התחביר שלנו:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

בדוגמה לעיל, נתנו למספר 5 גודל שדה של 4 תווים, ולמחרוזת balloons גודל שדה של 16 תווים (מכיוון שהיא מחרוזת ארוכה).

כפי שרואים, ברירת המחדל מיישרת מחרוזות לשמאל בתוך השדה, ומספרים לימין. תוכל לשנות זאת על ידי הצבת קוד מיושר לאחר הנקודתיים. < ימיין את הטקסט לשמאל בשדה, ^ ימצר את הטקסט במרכז השדה, ו־> יימצר אותו לימין.

בואו נימיין את המספר לשמאל ונמצר את המחרוזת למרכז:

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

עכשיו אנו רואים ש-5 מיושר לשמאל, ומספק מרווח בשדה לפני red, ו־balloons ממורכז בשדה שלו עם מרווחים לשמאל ולימין ממנו.

באופן ברירת המחדל, כאשר אנו מגדילים שדה עם מעצבים, פייתון תמלא את השדה עם תווים רווח. אנו יכולים לשנות זאת כך שיהיה תו אחר על ידי ציון התו שברצוננו שיהיה ישירות אחרי הנקודתיים:

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

אנו מקבלים את המחרוזת שמועברת ל־str.format() במיקום האינדקס של 0 מאחר ולא ציינו אחרת, כולל את הנקודתיים, ומציינים שנשתמש ב־* במקום רווח למילוי השדה. אנו ממרכזים את המחרוזת עם ^, מציינים שהשדה בגודל של 20 תווים, וגם מציינים שאנו עובדים עם סוג המרה של מחרוזת על ידי כלול s.

אנו יכולים לשלב את הפרמטרים הללו עם פרמטרים אחרים שהשתמשנו בהם קודם:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

בפרמטרים בתוך הסוגריים המסולסלים, ציינו את מספר השדה של הפלוט וכללנו את הנקודתיים, הצבענו את מספר השדה וכללנו את הנקודה, כתבנו את מספר המקומות אחרי הנקודה העשרונית, ואז ציינו את סוג ההמרה של f.

##שימוש במשתנים

עד כה, עברנו מספרים שלמים, עשרות ומחרוזות לתוך שיטת str.format(), אך אנו יכולים גם להעביר משתנים דרך השיטה. זה עובד כמו כל משתנה אחר.

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

אנו יכולים להשתמש במשתנים עבור המחרוזת המקורית ומה שמועבר לשיטה :

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

המשתנים ניתנים להחלפה בקלות עבור כל חלק מהתחביר של הפורמטרים שלנו. זה מקל על העבודה כאשר אנו מקבלים קלט שנוצר על ידי המשתמש ומקצים את הערכים הללו למשתנים.

##שימוש בפורמטרים כדי לארגן נתונים

פורמטרים ניתן לראות באורה הטובה ביותר שלהם כאשר הם משמשים לארגן כמות גדולה של נתונים בדרך חזותית. אם אנו מציגים מסדי נתונים למשתמשים, שימוש בפורמטרים כדי להגדיל את גודל השדות ולשנות את היישור יכול להפוך את הפלט שלך לנקרא יותר.

בואו נסתכל על לולאת for טיפוסית בפייתון שתדפיס את i, i*i ו־i*i*i בטווח מ־3 עד 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

בעוד הפלט מאורגן בדרך מסוימת, המספרים משפכים אל תוך עמודות האחרות, מה שהופך את תחתית הפלט ללא קריאה. אם אתה עובד עם מערך נתונים גדול עם הרבה מספרים קטנים וגדולים, זה עשוי להיות בעיה.

בואו נשתמש בפורמטרים כדי להעניק יותר מקום למספרים אלה:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

כאן, בתוך הסוגריים המקומפלים שלנו, לא הוספנו את שם השדה עבור מספר האינדקס והתחלנו עם הנקודה הנקודה, לאחריה מספר הגודל של השדה, וסוג ההמרה d מאחר ואנו עובדים עם מספרים שלמים. בדוגמה זו, נכללנו את גודל הפלט הצפוי של כל אחד, נותנים 2 תווים ריקים נוספים עבור כל אחד, בהתאם לגודל המספר המרבי האפשרי, כך שהפלט שלנו נראה כך:

Output
  3    9    27
  4   16    64
  5   25   125
  6   36   216
  7   49   343
  8   64   512
  9   81   729
 10  100  1000
 11  121  1331
 12  144  1728

ניתן לציין מספר שדה קבוע על מנת לקבל עמודות אחידות, ולוודא שאנו מסתגלים למספרים הגדולים:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     3      9     27
     4     16     64
     5     25    125
     6     36    216
     7     49    343
     8     64    512
     9     81    729
    10    100   1000
    11    121   1331
    12    144   1728

ניתן גם לנהל את היישור של העמודות על ידי הוספת <, ^, ו־> ליישור הטקסט, שינוי d ל־f כדי להוסיף מקומות עשרוניים, שינוי מספרי מדד שם השדה, ועוד, כדי לוודא שאנו מציגים את הנתונים כפי שרוצים.

##מסקנה

שימוש במעצבים עבור החלפת משתנים יכול להיות דרך אפקטיבית לקיטומים מחרוזות ולארגן ערכים ונתונים. מעצבים מייצגים דרך בסיסית אך לא מתארת להעברת החלפות משתנים לתוך מחרוזת, והם מועילים לוודא שהפלט נקרא וידידותי למשתמש.