אינטרפולציה של מחרוזת בפייתון: מדריך למתחילים

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

# הגדרת משתנים
name = 'Mark'
profession = 'Astronaut'
age = 7


# פלט מידע
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

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

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

# הגדרת משתנים
name = 'Mark'
profession = 'Astronaut'
age = 7


# פלט מידע
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

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

אינטרפולציה בסיסית של מחרוזות ב-Python

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

שיטה נוספת, שנראית בדרך כלל בקוד שנכתב לפני Python 3.6, היא שיטת .format() . אמנם שיטה זו היא יותר ארוכה מ- f-strings, לעיתים קרובות יש לה יתרונות (פרטים למטה).

לבסוף, ייתכן שתתקלו ב-% סגנון עיצוב בקוד מורשת.

שימוש ב-f-strings (Python 3.6+)

f-strings (מחרוזות מעוצבות בצורה) הן דרך עוצמתית וקצרה לעיצוב מחרוזות ב-Python. הן הוצגו ב-Python 3.6 ומספקות דרך קריאה ויעילה להכנסת משתנים, ביטויים וקריאות פונקציה ישירות לתוך מחרוזות.

דוגמה פשוטה לתחביר הבסיסי של מחרוזת f היא כדלקמן.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)

   My name is Mark.

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

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

import math


a = 3.0
b = 4.0


# השתמש באינטרפולציה למנופל
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.

הביטוי math.sqrt(a ** 2 + b ** 2) מוערך ישירות בתוך המיתר, מה שמבטל את הצורך לחשב את הערך בנפרד לפני ההכנסה שלו למיתר.

שימוש בשיטת .format()

כמו f-strings, השיטה .format() מאפשרת להכניס משתנים וביטויים לתוך מיתר. הסינטקס הבסיסי של השיטה .format() הוא כדלקמן.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)

   My name is Mark.

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

ארגומנטים מיקום

מה קורה אם אתה צריך מקומות שמורים מרובים עבור משתנים מרובים? שקול את הקוד הבא.

name = 'Mark'
age = 7


# המקומות השמורים מתמלאים לפי סדר הארגומנטים
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

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

מצייני מיקום ומצייני שם

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

name = 'Mark'
age = 7


# הדפס גיל פעמיים
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

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

name = 'Mark'
age = 7


# השתמש במקומות מחוונים
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

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

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

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))

   My name is Mark and I am 7 years old.

הארגומנט המזוהה מוערך בתוך סוגריים מסולסלים שמציינים את שמו. כתוצאה, המצוגת {name} מוחלפת בערך "Mark", וה {age} מוחלף בערך 30.

באמצעות אופרטור ה-%.

השיטה הסופית לאינטרפולציה של מחרוזות היא ה% אופרטור. הוא פועל באופן דומה לפקודת printf() בשפת C. השימוש בו מומלץ לא לעשות זאת ונעוץ בכל כוחך לטובת f-strings או לשיטת ה-.format(). זכרו כי הוא מוזכר כאן משום שיתכן ותיתקלו בו בקוד מורשת.

הפורמט הבסיסי עבור אופרטור ה-% הוא: "מחרוזת פורמט" % ערכים. מחרוזת הפורמט מכילה מצייני מיקום, כמו %s עבור מחרוזות, שמוחלפים על ידי הערכים. לדוגמה, בדוגמה הבאה מודפס "שלום, מארק."

'Hello %s' % 'Mark'

   'Hello Mark'

מפרטי פורמט נפוצים נראים בטבלה הבאה.

אופרטור ה-% מציג הרבה הגבלות. למשל, הוא פחות קריא מ- f-strings. שקול את קטע הקוד הבא.

name = "Alice"
age = 30
height = 5.6


# אופרטור ה-% קשה לסריקה
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

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

כעת, שקול קוד שקול באמצעות f-strings.

# זה הרבה יותר נקי
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

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

טכניקות מתקדמות של אינטרפולצית מחרוזת פייתון

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

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

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

name = 'Mark'
profession = 'Astronaut'
age = 7


# זהו דוגמה למחרוזת מרובת שורות
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

מחרטת רב-שורתית ניתן גם ליצור בעזרת השיטה .format().

name = 'Mark'
profession = 'Astronaut'
age = 7


# זוהי מחרטה רב-שורתית עם .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

מקרים של אינטרפולציה של מחרטה רב-שורתית

למה תרצה להשתמש באינטרפולציה של מחרטה רב-שורתית? ישנם הרבה שימושים לאינטרפולציה של מחרטה רב-שורתית. הנה כמה מקרים שימושיים:

• יצירת דואר אלקטרוני או הודעות רב-שורתיות
• לוגים ותיקון שגיאות
• יצירת שאילתות SQL דינמיות

יצירת דואר אלקטרוני או הודעות רב-שורתיות

נניח כי אתה שולח מכתב טופס למוזמנים רבים לכנס טכנולוגי.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event Team

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

לוגים ותיקון שגיאות

מחרטות רב-שורתיות שימושיות להדפסת הודעות שגיאה ללוגים.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.

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

יצירת שאילתות SQL דינמיות

שאילתות SQL יכולות להיות בנויות דינמית בעזרת מחרטות רב-שורתיות.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

שיטה זו עוזרת להפוך שאילתות SQL לנקראות ושומרת על הפרדת שורות. בנוסף, היא מורידה את הצורך להשתמש ב־+ עבור חיבור מחרוזות.

מקרים נוספים כוללים:

• כתיבת חוזים בפורמט מעוצב
• יצירת Markdown או מסמכים ב־$\LaTeX$
• תבניות HTML/XML רב־שורתיות
• יצירת תגובות API או טקסט בפורמט דומה ל-JSON

יתרונות של אינטרפולציה של מחרוזת מרובת שורות

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

• אינטרפולציית מחרוזת שומרת על העיצוב בלי צורך בתו הבריח \n. 
• אינטרפולציית מחרוזת משפרת את הנגישות לקריאה בהשוואה לעיצוב בשורה אחת. 
• אינטרפולציית מחרוזת מפחיתה בלם בעת עבודה עם טקסט מובנה (לדוגמה, לוגים, שאילתות, דוחות). 
• אינטרפולציית מחרוזת מאפשרת יצירת טקסט דינמי בלתי מפרקת את ההזחה.

עיצוב מספרים וערכים מיוחדים

כדי לשלוט במספר הספרות העשרוניות שיוצגות באמצעות מחרוזת f, יש להשתמש בתחביר: f'{value:.nf}', שבו value הוא מספר עשרוני, n הוא מספר הספרות העשרוניות, ו- f (האחד אחרי ה-.) מייצג עיצוב עשרוני.

להמחיש, הקוד הבא מדפיס $\pi$ למקומות עשרוניים שונים.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

עיצוב עם השיטה .format() דומה.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

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

score = 0.875
print(f"Success rate: {score:.2%}")

   Success rate: 87.50%

אתה יכול להשתמש ב-f-string כדי לעצב מטבע על ידי שימוש ב:, עבור מפרידי אלפים ו.nf כדי לשלוט במספר הספרות אחרי הנקודה. אתה יכול גם לכלול סימן מטבע כמו $, €, או £ ישירות בתוך המיתר.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

שימוש ב-f-strings עם מילונים ורשימות

כדי להשתמש ב-f-strings עם מילון בפייתון, גש לערכים של המילון בתוך סוגרי המעגל באמצעות נוטרציה של סוגרי מרובע (dict['key']) או על ידי פריסת המילון עם **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")

   My name is Alice, I am 30 years old, and I live in New York.

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

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))

   My name is Alice and I am 7 years old.

כדי להימנע מטעויות עבור מפתחות חסרים, השתמש בget() לגישה למילון.

person = {"name": "Alice"}


# שגיאה: המפתח 'city' חסר
print(f"City: {person['city']}") 

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # שגיאה: המפתח 'city' חסר

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'

print(f"City: {person.get('city', 'Not specified')}")

   City: Not specified

יתרונות וחסרונות של שיטות אינטרפולציה של מיתרים

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

מתי כדאי להשתמש ב-.format() במקום f-strings?

שגיאות נפוצות ושיטות מומלצות

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

מניעת שגיאות תחביר עם סוגריים מסולסלים

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

• וודא שלכל { יש זוג }

print('Hello, my name is {name!'}

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('

למרבה המזל, השגיאה פשוטה, והתיקון קל.

• השתמש ב{{ וב}} כדי להציג {} ליטרליים

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

print(f'Set notation: {a, b, c}')

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not defined

פייתון מעריך את a, b, c בתוך הסוגריים המסולסלים כטייפל, מנסה למצוא ערך הקשור ל-a. מאחר ואין משתנה כזה, הוא מעלה KeyError. התיקון הוא להשתמש בסוגריים מכפולים {{}}.

print("Set notation: {{a, b, c}}")

   סימון קבוצה: {{a, b, c}}

השוואת ביצועים: f-strings נגד .format()

בואו נשווה את ביצועי f-strings ו .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# קביעת ביצועי f-string
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# קביעת ביצועי .format()
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# קביעת ביצועי f-string עם ביטויים
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# קביעת ביצועי .format() עם ביטויים
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# הדפסת תוצאות
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

כפי שניתן לראות, מנקודת מבט של יעילות, עדיף להעדיף f-strings על .format().

שיטות מומלצות לאינטרפולצית מחרוזות נקיות ונקראות

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

• עדיף להשתמש ב-f-strings לקריאות (פייתון 3.6+)

# מומלץ
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# לא מומלץ (פחות קריא)
print("My name is {} and I am {} years old.".format(name, age))


# נמנע משימוש ב-% עיצוב (מיושן)
print("My name is %s and I am %d years old." % (name, age))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• השתמש במציינים מקובלים לבהירות

# מציינים מקום (נגיש לקריאה)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# שימוש באינדקסים ב-.format() (פחות נגיש לקריאה)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• שמרו על קריאות במחרוזות מרובות שורות.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  

• השתמשו ב-f-strings בלוגים לצורך דיבוג יעיל יותר

פייתון 3.8 ואילך תומך ב-= לצורך דיבוג ב-f-strings.

value = 42


# Output: value = 42
print(f"{value = }") 

   value = 42

מסקנה

ההכנסת מחרוזת היא יכולת עוצמתית בפייתון שמשפרת את עיצוב המחרוזת, הקריאות והיעילות שלה. בין השיטות הזמינות, f-strings הן השיטה המודרנית והמומלצת ביותר, המציעה ביצועים טובים יותר, בהירות וגמישות יותר משיטות ישנות כמו .format() ו-% formatting. 

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

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

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

• עיצוב f-string בפייתון מדריך
• הוספת מחרוזת בפייתון: 6 טכניקות חיבור בסיסיות
• תכנות בפייתון מסלול כישורים
• יסודות פייתון מסלול כישורים
• הקדמה למדע הנתונים בפייתון קורס