המרות

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

שרשור ערכים

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

אבל מה אם נכתוב פלוס בין מספר למחרוזת?

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

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

המרת ערכים שהתקבלו ממשתמש

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

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

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

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

חלוקת מספרים

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

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

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

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

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

Python 2

בפייתון 3 חלוקה של מספרים שלמים מחזירה ערך מדויק ולא מעוגל, תכונה זו נקראת "חלוקה אמיתית" (True Division). בפייתון 2 לעומת זאת חלוקה של מספרים שלמים מחזירה מספר שלם.

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

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

בסיסי ספירה

שיטת הספירה בה אנחנו משתמשים ביום יום נקראת השיטה העשרונית – שיטה המבוססת על הספרות 0-9. למרות שזאת השיטה הנפוצה ביותר כיום, קיימות שיטות ספירה רבות אחרות, אשר חלקן אפילו נמצאות בשימוש נרחב. דוגמה לשיטה כזאת היא השיטה הסקסגסימלית, שיטה אשר הומצאה בממלכת בבל העתיקה ומבוססת על בסיס ספירה של 60. אנחנו עדיין משתמשים בה בתחומי הגאומטריה (מעלות) ומדידת הזמן (שניות, דקות, שעות). בסיסי ספירה הוא תחום ענק שלא נכנס אליו כאן אבל פייתון תומכת בכמה וכמה שיטות כאלה ולכן אציג כאן המרה לשתי השיטות הנפוצות ביותר בעולם המחשבים

ערכים בינאריים

השיטה הבינארית היא שיטת ספירה המבוססת על בסיס ספירה של 2 (0 או 1) והיא השיטה הנפוצה ביותר באלקטרוניקה (משמשת לייצוג של מעגל פתוח או סגור) והשיטה הכמעט בלעדית בעולם המחשוב – יחידת הזיכרון הקטנה ביותר יכולה להכיל 0 או 1 ונקראת ביט (bit). אנחנו יכולים להמיר מספרים לערכים בינאריים בקלות ע"י שימוש בפונקציה bin.

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

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

ערכים הקסדצימאליים

השיטה ההקסדצימלית מבוססת על בסיס ספירה של 16 והיא נכתבת ע"י שילוב של ספרות והאותיות האנגליות A-F. כל יחידה הקסדצימלית יכולה להכיל 8 ביט ונקראת בייט (byte). בשל כך השיטה הזאת נפוצה מאוד במגוון תחומים שבהם נדרש ייצוג יותר נוח של ערכים מאשר השיטה הבינארית. כדי לבצע המרה של מספר לערךהקסדצימלי, נשתמש בפונקציה hex.

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

במידה והערך מגיע ללא קידומת 0 x עלינו לרשום אותו בתוך גרשיים ולספק את בסיס הספירה של הערך (במקרה הזה 16).