TechCodeview

במדריך הבא, נלמד על פעולת Floor Division באמצעות שפת התכנות Python.

אבל לפני שנתחיל, הבה נבין בקצרה מהי חלוקת הרצפה.

הבנת חלוקת הרצפה

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

פונקציית הרצפה מסומנת בסמל ⌊ ⌋ במונחים מתמטיים.

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

⌊36/5⌋

שלב 1: ביצוע החלוקה תחילה. אנחנו נתחלק 36 על ידי 5 .

36 ÷ 5 = 7.2

שלב 2: כעת, נבצע את פונקציית הרצפה על הערך שנקבל לאחר החלוקה, כלומר, 7.2 .

⌊7.2⌋=7

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

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

1. אנחנו יכולים להשתמש ב קוֹמָה() שיטה בשפת התכנות C++.
2. אנחנו יכולים להשתמש ב קוֹמָה() שיטה בשפת התכנות Java.
3. אנחנו יכולים להשתמש ב // אופרטור בשפת התכנות Python.

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

הבנת חלוקת הרצפה באמצעות Python

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

לפני שנצלול עמוק יותר למושג חלוקת הרצפה, הבה נזכיר לעצמנו בקצרה את המשמעות של חלוקה ופעולה של math.floor() פונקציה ב- Python.

ביצוע חלוקה רגילה בפייתון

נוכל לחלק שני מספרים באמצעות הקו הנטוי האחורי ( / ) אופרטור חטיבה ב- Python. הבה נבחן את הדוגמה הבאה המדגימה את אותו הדבר:

דוגמה 1:

 # declaring variables a = 13 b = 4 # performing regular division c = a / b # printing the result print(a, '/', b, '=', c) 

תְפוּקָה:

 13 / 4 = 3.25 

הֶסבֵּר:

בקטע הקוד שלמעלה, הגדרנו שני משתנים בתור a = 13 ו b = 4 . לאחר מכן ביצענו פעולת חלוקה באמצעות הקו הנטוי האחורי ( / ) אופרטור חלוקה ואחסן את הערך המתקבל במשתנה חדש, ג . סוף סוף, הדפסנו את הערך של ג .

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

הבנת הפונקציה math.floor() ב-Python

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

פונקציה אחת כזו מובנית של מתמטיקה מודול הוא ה math.floor() פוּנקצִיָה. פונקציה זו מקבלת קלט מספרי ומחזירה את ערך הרצפה על ידי עיגול מטה למספר השלם הקרוב ביותר.

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

דוגמה 2:

 # importing the floor() function from the math module from math import floor # declaring the variables a = 5.34 b = -5.34 # using the floor() function c = floor(a) d = floor(b) # printing the values print('Floor value of', a, '=', c) print('Floor value of', b, '=', d) 

תְפוּקָה:

 Floor value of 5.34 = 5 Floor value of -5.34 = 6 

הֶסבֵּר:

בקטע הקוד שלמעלה, ייבאנו את קוֹמָה() פונקציה מה מתמטיקה מודול. לאחר מכן הכרזנו על שני משתנים כ a = 5.34 ו b = -5.34 . לאחר מכן השתמשנו ב- קוֹמָה() פונקציה לחישוב ערכי הרצפה של שני המשתנים ולאחסן אותם במשתנים חדשים, ג ו ד . סוף סוף, הדפסנו את התוצאות עבור המשתמשים.

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

ביצוע Floor Division ב- Python

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

תחביר:

 res = var_1 // var_2 

איפה:

מילואיםהוא הערך המתקבל של חלוקת הרצפההיה_1הוא הדיבידנדהיה_2הוא המחלק

אנו יכולים לחשוב על חלוקת הרצפה כעל החלוקה הרגילה בשילוב עם math.floor() קריאת פונקציה.

הערה: חלוקת הקומה יכולה לעגל כל מספר כלפי מטה למספר השלם הקרוב ביותר. לדוגמה, 3.99 עדיין יעוגל כלפי מטה ל-3.

הבה נבחן כעת דוגמה המדגימה את פעולת חלוקת הרצפה.

דוגמה 3:

 # declaring the variables a = 13 b = 5 # using the // operator c = a // b # comparing the floor value with regular division d = a / b # printing the values print('Floor Division:', a, '//', b, '=', c) print('Regular Division:', a, '/', b, '=', d) 

תְפוּקָה:

 Floor Division: 13 // 5 = 2 Regular Division: 13 / 5 = 2.6 

הֶסבֵּר:

בקטע הקוד שלמעלה, הכרזנו על שני משתנים בתור a = 13 ו b = 5 . לאחר מכן השתמשנו ב- // מפעיל כדי לחשב את ערך חלוקת הרצפה ואחסן את ערך הרצפה במשתנה חדש, ג . לאחר מכן ביצענו את החלוקה הרגילה באמצעות ה / אופרטור ואחסנה את הערך במשתנה אחר, ד . סוף סוף, הדפסנו את שתי התוצאות והשווינו ביניהן.

כעת, הבה נבחן דוגמה נוספת באמצעות ה math.floor() פוּנקצִיָה.

דוגמה 4:

 # importing the floor() function from the math module from math import floor # declaring the variables a = 17 b = 5 # using the floor() function c = floor(a / b) # comparing the floor() function with // operator d = a // b # printing the values print('Floor Division using floor() function:', c) print('Floor Division using // operator:', d) 

תְפוּקָה:

 Floor Division using floor() function: 3 Floor Division using // operator: 3 

הֶסבֵּר:

ייבאנו את קוֹמָה() פונקציה מה מתמטיקה מודול בקטע הקוד שלמעלה. לאחר מכן הכרזנו על שני משתנים כ a = 17 ו b = 5 . לאחר מכן השתמשנו ב- קוֹמָה() פונקציה, מחולקת א על ידי ב , ואחסנה אותו במשתנה c. לאחר מכן חישבנו את ערך הרצפה באמצעות ה- // אופרטור ואחסנה את הערך במשתנה חדש, ד . סוף סוף, הדפסנו את שני הערכים והשווינו ביניהם.

ביצוע חלוקת קומה עם מספרים שליליים

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

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

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

דוגמה 5:

 # declaring the variables a = -10 b = 4 # calculating floor value using // operator c = a // b # printing the value print('Floor Division:', a, '//', b, '=', c) 

תְפוּקָה:

 Floor Division: -10 // 4 = -3 

הֶסבֵּר:

בקטע הקוד שלמעלה, הכרזנו על שני משתנים בתור a = -10 ו b = 4 . לאחר מכן השתמשנו ב- // מפעיל כדי לחשב את ערך הרצפה ואחסן אותו במשתנה חדש, ג . סוף סוף, הדפסנו את הערך עבור המשתמש.

עם חלוקה קבועה, -10/4 יחזור -2.5 ; עם זאת, עם חלוקת קומה, מספר זה מעוגל כלפי מטה למספר השלילי השלילי הקרוב ביותר, כלומר ל -3 .

ביצוע חלוקת רצפה עם מצופים

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

הבה נבחן את הדוגמה הבאה המדגימה את חלוקת הרצפה באמצעות מצופים.

דוגמה 6:

 # initializing the lists a = [17.5, 10, 13.4] b = [3.3, 2.5, 3] # using for-loop to iterate through the list for i in range(0, 3): # calculating the floor division value c = a[i] // b[i] # printing the result print(a[i], '//', b[i], '=', c) 

תְפוּקָה:

 17.5 // 3.3 = 5.0 10 // 2.5 = 4.0 13.4 // 3 = 4.0 

הֶסבֵּר:

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

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

Floor Division ו- Modulo ב- Python

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

אנו יכולים לחשב מודולו ב-Python באמצעות האחוז ( % ) מפעיל.

הבה נבחן דוגמה הממחישה את הקשר בין חלוקת הרצפה למודולו ב- Python.

דוגמה 7.1:

בהינתן 13 סוכריות ו-4 אוכלים, נוכל לחשב את מספר הסוכריות שכל אוכלין מקבל בעזרת חלוקת הקומה.

קוד:

 # declaring variables numberOfCandies = 13 numberOfEaters = 4 # using floor division to calculate the number of candies each eater gets candiesPerEater = numberOfCandies // numberOfEaters # printing values print('Number of Candies:', numberOfCandies) print('Number of Eaters:', numberOfEaters) print('The number of candies each eater gets:', candiesPerEater) 

תְפוּקָה:

 Number of Candies: 13 Number of Eaters: 4 The number of candies each eater gets: 3 

הֶסבֵּר:

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

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

דוגמה 7.2:

נכפיל את מספר הממתקים לאדם במספר האוכלים.

קוד:

 # calculating the total number of candies being shared among the group totalCandiesShared = candiesPerEater * numberOfEaters # printing values print('The total number of candies being shared among the group:', totalCandiesShared) 

תְפוּקָה:

 The total number of candies being shared among the group: 12 

הֶסבֵּר:

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

המספר הכולל של סוכריות מלאות ששותפו הוא 12 . עם זאת, המספר הכולל של ממתקים הוא 13 . אמירה זו מרמזת שיישאר ממתק אחד ולא יאכל.

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

דוגמה 7.3:

בהינתן 13 סוכריות ו-4 אוכלים, מה מספר הממתקים שנותרו?

קוד:

 # declaring variables numberOfCandies = 13 numberOfEaters = 4 # using modulo to calculate the leftover candies leftoverCandies = numberOfCandies % numberOfEaters # printing values print('Number of Candies:', numberOfCandies) print('Number of Eaters:', numberOfEaters) print('Total number of Leftover Candies:', leftoverCandies) 

תְפוּקָה:

 Number of Candies: 13 Number of Eaters: 4 Total number of Leftover Candies: 1 

הֶסבֵּר:

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

a = b * (a // b) + (a % b)

בפייתון, חלוקת הרצפה והמודולו קשורים במשוואה הבאה:

איפה:

אהוא הדיבידנד.בהוא המחלק.

לדוגמה, הבה נוודא שהמשוואה שלמעלה מתקיימת עם 13 הסוכריות ו-4 האוכלים.

13 = 4 * (13 // 4) + (13% 4)
13 = 4 * 3 + 1
13 = 13

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

הבנת הפונקציה divmod() ב- Python

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

התחביר עבור ה divmod() הפונקציה מוצגת להלן:

תחביר:

 res = divmod(var_1, var_2) 

איפה:

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

הבה נבחן כעת את הדוגמה הבאה המדגימה את divmod() פוּנקצִיָה.

דוגמה 8:

בהינתן 13 סוכריות ו-4 אוכלים, כמה סוכריות מלאות מקבל כל אוכל, וכמה סוכריות נשארו?

קוד:

 # declaring variables numberOfCandies = 13 numberOfEaters = 4 # using the divmod() function nCandies, nLeftovers = divmod(numberOfCandies, numberOfEaters) # printing values print('Number of Candies:', numberOfCandies) print('Number of Eaters:', numberOfEaters) print('Number of Candies per eater:', nCandies) print('Total number of Leftover Candies:', nLeftovers) 

תְפוּקָה:

 Number of Candies: 13 Number of Eaters: 4 Number of Candies per eater: 3 Total number of Leftover Candies: 1 

הֶסבֵּר:

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

הבנת קדימות חלוקת הרצפה

בפייתון, מפעיל חלוקת הרצפה // יש רמת קדימות דומה כמו כפל ( * ), חלוקה ( / ), ומודולו ( % ).

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

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

הבה נבחן דוגמה המדגימה את אותו הדבר.

דוגמה 9.1:

 # declaring some variables a = 3 b = 5 c = 6 d = 7 # performing an operation e = a * b // c - d # printing the result print(a, '*', b, '//', c, '-', d, '=', e) 

תְפוּקָה:

 3 * 5 // 6 - 7 = -5 

הֶסבֵּר:

בקטע הקוד שלמעלה, הכרזנו על כמה משתנים בתור a = 3, b = 5, c = 6 , ו d = 7 . לאחר מכן ביצענו פעולה ואחסנו את הערך המתקבל במשתנה חדש, זה . סוף סוף, הדפסנו את הערך הזה עבור המשתמשים.

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

הדוגמה המוצגת להלן מתארת ​​את אותו הדבר:

דוגמה 9.2:

 # declaring some variables a = 3 b = 5 c = 6 d = 7 # performing an operation e = ((a * b) // c) - d # printing the result print('((', a, '*', b, ') //', c, ') -', d, '=', e) 

תְפוּקָה:

 (( 3 * 5 ) // 6 ) - 7 = -5 

הֶסבֵּר:

בקטע הקוד שלמעלה, הכרזנו על כמה משתנים בתור a = 3, b = 5, c = 6 , ו d = 7 . לאחר מכן ביצענו את אותה פעולה אך עם סוגריים ואחסנו את הערך המתקבל במשתנה חדש, זה . סוף סוף, הדפסנו את הערך הזה עבור המשתמשים.

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

כפל ← חלוקת קומה ← חיסור

להלן החישוב המדרגתי של האמור לעיל:

3 * 5 // 6 - 7
((3 * 5) // 6) - 7
(15 // 6) - 7
2 - 7
-5

הבנו נכון את חלוקת הקומה ואת השימוש בה בשפת התכנות Python.

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

הבנת השימוש המתקדם בחלוקת הרצפה

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

כיצד למרכז תמונה ב-CSS

שיטת __floordiv__() ב- Python

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

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

ב-Python, אנו יכולים גם לקרוא ישירות ל- __floordiv__() שיטה. הבה נבחן את הדוגמה הבאה המדגימה את אותו הדבר:

דוגמה 10:

 # declaring some variables a = 31 b = 7 # performing floor division using the // operator c = a // b # performing floor division using the __floordiv__() method d = (a).__floordiv__(b) # printing the results of both operations print('Using the // operator:
', a, '//', b, '=', c) print('Using the __floordiv__() method:
 (', a, ').__floordiv__(', b, ') =', c) 

תְפוּקָה:

 Using the // operator: 31 // 7 = 4 Using the __floordiv__() method: ( 31 ).__floordiv__( 7 ) = 4 

הֶסבֵּר:

בקטע הקוד שלמעלה, הכרזנו על שני משתנים בתור a = 31 ו b = 7 . לאחר מכן ביצענו חלוקת רצפה באמצעות ה // מפעיל ו __floordiv__() שיטה ואחסנה את הערכים המתקבלים שלהם בשני משתנים, ג ו ד . סוף סוף, הדפסנו את התוצאות עבור המשתמשים.

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

עכשיו, דברים יהיו מעניינים. הבה נבחן את הדוגמה הבאה.

דוגמה 11.1:

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

קוד:

 # creating a class representing integer values as string class IntStr: def __init__(self, val): self.val = val # instantiating the class with two objects intOne = IntStr('17') intTwo = IntStr('4') # printing the result of the floor division operation print(intOne // intTwo) 

תְפוּקָה:

 Traceback (most recent call last): File 'D:Python_programspycase.py', line 11, in print(intOne // intTwo) TypeError: unsupported operand type(s) for //: 'IntStr' and 'IntStr' 

הֶסבֵּר:

בקטע הקוד שלמעלה, הגדרנו מחלקה בתור IntStr שמייצג את ערכי המספרים השלמים כמחרוזות. לאחר מכן יצרנו שני אובייקטים של IntStr מעמד. סוף סוף יש לנו חלוקת קומה לְהַטְעִים חפץ על ידי ה intwo אובייקט וניסיתי להדפיס את התוצאה.

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

עם זאת, כפי שמתברר, אנחנו יכולים לעשות את IntStr חלוקת רצפת תמיכת חפצים.

בעבר, למדנו בכל פעם שאנו מתקשרים ל- // מפעיל, אנו מכנים את __floordiv__() שיטה. שיטה זו מבוצעת איפשהו במחלקה של האובייקט. לדוגמה, אובייקטי int תומכים בחלוקת רצפה מכיוון שהמחלקה int החילה את __floordiv__() שיטה.

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

הבה נבחן כעת את הדוגמה הבאה המדגימה את אותו הדבר.

דוגמה 11.2:

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

קוד:

 # creating a class representing integer values as string class IntStr: def __init__(self, val): self.val = val def __floordiv__(self, other): intOne = int(self.val) intTwo = int(other.val) res = intOne // intTwo return IntStr(str(res)) # instantiating the class with two objects intOne = IntStr('17') intTwo = IntStr('4') # performing floor division operation res = intOne // intTwo # printing the result of the floor division operation print(intOne.val, '//', intTwo.val, '=', res.val) 

תְפוּקָה:

 17 // 4 = 4 

הֶסבֵּר:

בקטע הקוד שלמעלה, הגדרנו מחלקה בתור IntStr שמייצג את ערכי המספרים השלמים כמחרוזות. יישמנו גם את __floordiv__() שיטה בתוך מחלקה זו. שיטה זו מקבלת את ערך המחרוזת המספרי מעצמה ומאובייקט אחר. המרנו את ערכי המחרוזת האלה למספרים שלמים וביצענו ביניהם חלוקת קומה. לאחר מכן המרנו את התוצאה בחזרה למחרוזת ויצרנו חדשה IntStr לְהִתְנַגֵד. הצגנו את ה IntStr כיתה עם שני חפצים וביצע פעולת חלוקת רצפה ביניהם. סוף סוף, הדפסנו את הערך המתקבל עבור המשתמשים.

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

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

הבה נבחן את הדוגמה הבאה המדגימה את אותו הדבר.

דוגמה 11.3:

 # creating a class representing integer values as string class IntStr: def __init__(self, val): self.val = val def __floordiv__(self, other): intOne = int(self.val) intTwo = int(other.val) res = intOne // intTwo return IntStr(str(res)) def __str__(self): return self.val # instantiating the class with two objects intOne = IntStr('17') intTwo = IntStr('4') # performing floor division operation res = intOne // intTwo # printing the result of the floor division operation print(intOne, '//', intTwo, '=', res) 

תְפוּקָה:

 17 // 4 = 4 

הֶסבֵּר:

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