2.5. מתודות מחרוזת ועיצוב

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

2.5.1. בדיקת מחרוזות

  • str.startswith() / str.endswith() – בדיקת תחילית או סיומת; מחזירה bool.

  • str.find() – מיקום ההופעה הראשונה של תת-מחרוזת, או -1 אם אינה קיימת. str.index() עושה את אותו דבר אך מעוררת ValueError בהיעדרות.

  • str.count() – מספר ההופעות שאינן חופפות.

  • מילת המפתח in – "MV" in name מחזירה True אם תת-המחרוזת נמצאת בכל מקום במחרוזת.

>>> name = "OpenMV Cam"
>>> name.startswith("Open")
True
>>> name.find("MV")
4
>>> name.count("m")
1
>>> "Cam" in name
True

2.5.2. ניקוי ורישיות

  • str.strip() – הסרת רווח לבן מתחילת ומסוף המחרוזת. העבירו מחרוזת של תווים כדי להסיר קבוצה מותאמת אישית (s.strip("/")).

  • str.lower() / str.upper() – המרת רישיות.

  • str.replace() – החלפת תת-מחרוזת.

>>> "  hello  ".strip()
'hello'
>>> "abc-123".replace("-", "_")
'abc_123'
>>> "OpenMV".lower()
'openmv'

2.5.3. פיצול וחיבור

  • str.split() – פירוק מחרוזת לרשימה בכל הופעה של מפריד (ברירת מחדל: כל רצף רווח לבן).

  • str.join() – ההפך: הדבקת רצף של מחרוזות יחד כאשר המקבל משמש כמפריד. זוהי הדרך היעילה לבנות מחרוזת ארוכה מחלקים.

>>> "1,2,3".split(",")
['1', '2', '3']
>>> "hello world".split()
['hello', 'world']
>>> ", ".join(["a", "b", "c"])
'a, b, c'

2.5.4. f-strings

הדרך הפשוטה ביותר לשבץ ערכים לתוך מחרוזת היא ה-f-string – מחרוזת מילולית עם התחילית f. כל ביטוי בתוך {} מחושב ומוכנס:

>>> name = "OpenMV"
>>> count = 42
>>> f"{name} saw {count} blobs"
'OpenMV saw 42 blobs'

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

  • {x:.2f} – מספר עשרוני עם 2 ספרות אחרי הנקודה העשרונית.

  • {x:>10} – יישור לימין בשדה בן 10 תווים.

  • {x:<10} – יישור לשמאל.

  • {x:0>4} – ריפוד באפסים מובילים לרוחב 4.

  • {x:#x} – הקסדצימלי עם תחילית 0x.

  • {x:b} – ייצוג בינארי.

>>> f"pi is roughly {3.14159:.3f}"
'pi is roughly 3.142'
>>> f"reg = {0xAB:#x}"
'reg = 0xab'
>>> for i in range(3):
...     print(f"line {i:0>3}")
line 000
line 001
line 002

סימן = יחיד אחרי שם הביטוי מדפיס גם את השם וגם את הערך – שימושי להדפסות ניפוי באגים מהירות:

>>> v = 3.14
>>> print(f"{v=}")
v=3.14

2.5.4.1. המרות בסיס של מספרים שלמים

שלושה פונקציות מובנות עושות את אותה עבודה כמו מפרטי העיצוב :b / :o / :x אך מחזירות את המחרוזת המומרת ישירות:

  • bin() – בסיס 2, עם תחילית "0b".

  • oct() – בסיס 8, עם תחילית "0o".

  • hex() – בסיס 16, עם תחילית "0x".

>>> hex(255)
'0xff'
>>> bin(10)
'0b1010'
>>> oct(8)
'0o10'

הכיוון ההפוך – הפיכת מחרוזת בבסיס N בחזרה למספר שלם – משתמש בבנאי int עם בסיס מפורש:

>>> int("ff", 16)
255
>>> int("0b1010", 2)         # the "0b" prefix is allowed
10

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

2.5.5. סגנונות עיצוב ישנים יותר

f-strings הם הסגנון המומלץ, אך שתי גישות ישנות יותר עדיין פועלות ומופיעות בקוד קיים:

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

>>> "Hello, {}".format(name)
'Hello, OpenMV'
>>> "{0} + {0} = {1}".format(2, 4)
'2 + 2 = 4'
>>> "{name}: {value}".format(name="frames", value=42)
'frames: 42'

מפרטי עיצוב ({:.2f}, {:>10}, …) פועלים באותו אופן כמו ב-f-strings; ההבדל היחיד הוא היכן הערך מסופק.

עיצוב % (בסגנון printf) – אופרטור % יחיד משבץ ערכים לתוך קודי עיצוב, ערך אחד לכל קוד. העבירו ערכים מרובים כ-tuple:

>>> "Hello, %s" % name
'Hello, OpenMV'
>>> "%d + %d = %d" % (2, 2, 4)
'2 + 2 = 4'
>>> "%.2f" % 3.14159
'3.14'

קודי הסוג הנפוצים ביותר הם %s (מחרוזת), %d (מספר שלם), %f (מספר עשרוני) ו-%x (הקסדצימלי).

כל קוד % יכול לשאת משנים בין ה-% לאות הסוג. הצורה המלאה היא %[flags][width][.precision]type:

  • width – מספר התווים המינימלי שהשדה חייב לתפוס. ערכים קצרים יותר מרופדים ברווחים; ערכים ארוכים יותר עולים על גדותיהם. %10d שומר 10 תווים ומיישר את המספר לימין.

  • precision – המשמעות תלויה בסוג. עבור מספרים עשרוניים, מספר הספרות אחרי הנקודה העשרונית. %.2f נותן שתי ספרות אחרי הנקודה. עבור מחרוזות, מספר התווים המרבי שיש לקחת (%.5s קוטם לחמישה).

  • יישור לשמאל – הדגל - ממקם את השדה בצד שמאל. %-10d ממקם את הספרות בצד שמאל עם רווחים נגררים.

  • ריפוד באפסים – הדגל 0 מרפד באפסים מובילים במקום ברווחים (עבור סוגים מספריים). %05d מרפד באפסים לחמש ספרות.

  • סימן – הדגל + מציג תמיד את הסימן על מספרים, כולל + עבור חיוביים.

  • צורה חלופית – הדגל #. עבור %x זה מוסיף לפלט את התחילית 0x; עבור %o זה מוסיף את התחילית 0o.

ניתן לשלב דגלים, רוחב ודיוק:

>>> "%10d" % 42
'        42'                 # width 10, space-padded, right-aligned
>>> "%-10d|" % 42
'42        |'                # width 10, left-aligned
>>> "%05d" % 42
'00042'                      # width 5, zero-padded
>>> "%8.2f" % 3.14159
'    3.14'                   # width 8, 2 decimal places
>>> "%08.2f" % 3.14159
'00003.14'                   # width 8, zero-padded
>>> "%+d" % 42
'+42'                        # explicit sign
>>> "%#06x" % 0xAB
'0x00ab'                     # 0x prefix, zero-pad to 6 chars total

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