המרות

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

שרשור ערכים

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

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

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

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

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

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

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

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

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

חלוקת מספרים

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

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

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

Python 3

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

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

בסיסי ספירה

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

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

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

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

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

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

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

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

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