המרת סוג פירושה שינוי סוג הנתונים של ערך. לְדוּגמָה המרת מספר שלם (5) ל-float (5.0) או מחרוזת ('10') למספר שלם (10). ב-Python ישנם שני סוגים של המרת סוג:

1. המרה מרומזת: Python משנה את סוג הנתונים בעצמו תוך כדי הפעלת הקוד כדי למנוע טעויות או אובדן נתונים.
2. המרה מפורשת: אתה משנה את סוג הנתונים בכוונה באמצעות פונקציות כמו int() float() או str().

המרת סוג מרומז

ב המרה מרומזת Python ממירה אוטומטית סוג נתונים אחד לאחר במהלך הערכת ביטוי. זה קורה בדרך כלל כאשר סוג נתונים קטן יותר כמו int משולב עם אחד גדול יותר כמו float בפעולה. דוּגמָה:

x = 10 # Integer y = 10.6 # Float z = x + y print('x:' type(x)) print('y:' type(y)) print('z =' z) print('z :' type(z)) 

x:  y:  z = 20.6 z :  

הסבר: x הוא מספר שלם ו ו הוא צף. ב z = x + y Python ממיר אוטומטית x לצוף כדי למנוע אובדן נתונים עִם ציפה 0.6.

המרת סוג מפורש

המרה מפורשת (או סוג ליהוק) הוא כאשר אתה ממיר ידנית את סוג הנתונים של ערך באמצעות Python's פונקציות מובנות . זה מועיל כאשר אתה רוצה לשלוט באופן שבו הנתונים מתפרשים או מטופלים בקוד שלך. כמה פונקציות ליהוק נפוצות כוללות:

• int() ממירה ערך למספר שלם
• לָצוּף() ממירה ערך למספר נקודה צפה
• str() ממירה ערך למחרוזת
• bool() ממירה ערך לבוליאנית (נכון/לא נכון)

דוּגמָה:

s = '100' # String a = int(s) print(a) print(type(a)) 

100  

הסבר: a = int(s) אנו ממירים אותו במפורש למספר שלם. שינוי סוג ידני זה נקרא המרת סוג מפורש ו-a הופך ל-100 של סוג.

דוגמאות לפונקציות המרה נפוצות של סוגים

דוגמה 1: המרת מחרוזת בינארית

s = '10010' a = int(s 2) print(a) b= float(s) print(b) 

18 10010.0 

הֶסבֵּר:

• int(s 2) מפרש את המחרוזת הבינארית '10010' כמספר השלם 18.
• צפים ממירה את המחרוזת למספר נקודה צפה.

דוגמה 2: המרת ASCII הקסדצימלית ואוקטלית

c = '4' print('ASCII of '4':' ord(c)) print('56 in Hex:' hex(56)) print('56 in Octal:' oct(56)) 

ASCII of '4': 52 56 in Hex: 0x38 56 in Octal: 0o70 

הֶסבֵּר:

• מילים מחזירה את קוד ASCII של התו '4'.
• hex() ו אוקטובר() המר את המספר השלם 56 לייצוגים ההקסדצימליים והאוקטליים שלו בהתאמה.

דוגמה 3 : מחרוזת ל-Tuple Set ו- List

s = 'geeks' print('To tuple:' tuple(s)) print('To set:' set(s)) print('To list:' list(s)) 

To tuple: ('g' 'e' 'e' 'k' 's') To set: {'e' 'g' 'k' 's'} To list: ['g' 'e' 'e' 'k' 's'] 

הֶסבֵּר:

• טופל(ים) שומר על הסדר של כל התווים כולל כפילויות.
• סט(ים) מסיר כפילויות ומחזיר אוסף לא מסודר.
• רשימות מחזירה רשימה של תווים מהמחרוזת.

דוגמה 4: המרות אחרות - מילון מחרוזות מורכב

a = 1 tup = (('a' 1) ('f' 2) ('g' 3)) print('To complex:' complex(1 2)) print('To string:' str(a)) print('To dict:' dict(tup)) 

To complex: (1+2j) To string: 1 To dict: {'a': 1 'f': 2 'g': 3} 

הֶסבֵּר:

• מורכב(1 2) יוצר מספר מרוכב עם חלק 1 אמיתי וחלק 2 דמיוני.
• str(a) ממירה את המספר השלם 1 למחרוזת '1'.
• dict (tup) יוצר מילון מרצף של טפולים של ערך מפתח.