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

מפעיל מודולוס

פִּיתוֹן Modulus Operator הוא אופרטור מובנה שמחזיר את המספרים הנותרים על ידי חלוקת המספר הראשון מהשני. זה ידוע גם בשם מודול פייתון . ב- Python, סמל המודולוס מיוצג כאחוז ( % ) סמל. לפיכך, הוא נקרא אופרטור השאר.

תחביר

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

קובץ tif

 Rem = X % Y 

כאן X ו-Y הם שני מספרים שלמים, והמודלוס (%) משמש ביניהם כדי לקבל את היתרה כאשר המספר הראשון (X) מחולק במספר השני (Y).

לדוגמה, יש לנו שני מספרים, 24 ו-5. ונוכל לקבל את היתרה על ידי שימוש באופרטור המודולוס או המודולו בין המספרים 24% 5. כאן 24 מחולק ב-5 שמחזיר 4 כשארית, ו-4 כמנה . כאשר המספר הראשון מתחלק לחלוטין במספר אחר מבלי להשאיר שארית כלשהי, התוצאה תהיה 0. לדוגמה, יש לנו שני מספרים, 20 ו-5. ונוכל לקבל את היתרה על ידי שימוש באופרטור המודולוס או המודולו בין המספרים 20 % 5. כאן 20 מחולק ב-5 שמחזיר 0 כשארית, ו-4 כמנה.

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

בוא נכתוב תוכנית כדי לקבל את שאר שני המספרים באמצעות האופרטור while לולאת ו-modulus (%) ב- Python.

Get_rem.py

 # Here, we are writing a Python program to calculate the remainder from the given numbers while True: # here, if the while condition is true then if block will be executed a = input ('Do you want to continue or not (Y / N)? ') if a.upper() != 'Y': # here, If the user pass 'Y', the following statement is executed. break a = int(input (' First number is: ')) # here, we are taking the input for first number b = int(input (' Second number is: ')) # Here, we are taking the input for second number print('The result after performing modulus operator is: ', a, ' % ', b, ' = ', a % b) # Here, we are performing the modulus a % b print('The result after performing modulus operator is:', b, ' % ', a, ' = ', b % a) # Here, we are performing the modulus b % a 

תְפוּקָה:

 Do you want to continue or not (Y / N)? Y First number is: 37 Second number is: 5 The result after performing modulus operator is: 37 % 5 = 2 The result after performing modulus operator is: 5 % 37 = 5 Do you want to continue or not (Y / N)? Y First number is: 37 Second number is: 5 The result after performing modulus operator is: 24 % 5 = 4 The result after performing modulus operator is: 5 % 24 = 5 Do you want to continue or not (Y / N)? Y First number is: 37 Second number is: 5 The result after performing modulus operator is: 28 % 5 = 3 The result after performing modulus operator is: 5 % 28 = 5 

הֶסבֵּר:

• בעוד נכון: זה יוצר לולאה אינסופית. הקוד בתוך הלולאה ימשיך לפעול עד שהלולאה תישבר במפורש.
• a = input('האם אתה רוצה להמשיך או לא (Y / N)? '): המשתמש מתבקש להזין 'Y' או 'N' כדי להחליט אם להמשיך או לצאת מהתוכנית.
• if a.upper() != 'Y': break: אם המשתמש מזין משהו אחר מלבד 'Y' (לא תלוי רישיות), הלולאה יוצאת, והתוכנית מסתיימת.
• a = int(input('מספר ראשון הוא: ')) ו-b = int(input('מספר שני הוא: ')): המשתמש מתבקש להזין שני מספרים שלמים.
• print('התוצאה לאחר ביצוע אופרטור מודולוס היא: ', a, ' % ', b, ' = ', a % b): הוא מחשב ומדפיס את התוצאה של פעולת המודולוס (a % b) עבור הזוג הראשון של מספרים שהוזנו.
• print('התוצאה לאחר ביצוע אופרטור מודולוס היא:', b, ' % ', a, ' = ', b % a): הוא מחשב ומדפיס את התוצאה של פעולת המודולוס (b % a) עבור הזוג השני של מספרים שהוזנו.
• התוכנית תשאל את מזג האוויר של המשתמש שאנחנו רוצים להמשיך או שאנחנו רוצים לעצור את התוכנית על ידי מתן הקלט כמו (Y/N), כאן Y הוא הקלט להמשך התוכנית וה-'N' משמש לעצירת התוכנית .

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

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

Mod.py

 x = float(input ('First number: ')) # Here, we are taking the input of a float variable for the first number y = float(input (' Second number: ')) # Here, we are taking the input of a float variable for the second number res = x % y # Here, we are storing the remainder in a new res variable print('Modulus of two float number is: ', x, '%', y, ' = ', res, sep = ' ') 

תְפוּקָה:

First number: 40.5 Second number: 20.5 Modulus of two float number is: 40.5 % 20.5 = 20.0 

הֶסבֵּר:

• x = float(input('First number: ')): הלקוח מתגרה להזין מספר float עבור המשתנה הראשוני, והמידע מונח במשתנה x.
• y = float(input('Second number: ')): הלקוח מתגרה להזין מספר float עבור המשתנה העוקב, והמידע מוחלף במשתנה y.
• res = x % y: פעילות המודולוס מתבצעת על x ו- y, והתוצאה מונחת במשתנה res.
• print('מודול של שני מספרי צפים הוא: ', x, '%', y, ' = ', res, sep=' '): התוצאה של פעילות המודולוס מודפסת בסידור נכון, תוך בידוד האיכויות לפי רווחים ( sep=' ').

קבל את המודולוס של מספר שלילי

בוא נכתוב תוכנית כדי לקבל את השארית של שני מספרים שליליים באמצעות אופרטור while לולאה ומודולוס (%) בפייתון.

Mod.py

 while True: x = input(' Do you want to continue (Y / N)? ') if x.upper() != 'Y': break # Here, we are taking input two integer number and store it into x and y x = int(input (' First number: ')) # Here, we are taking the input for the first number y = int(input (' Second number: ')) # Here, we are taking the input for the second number print('Modulus of negative number is: ', x, '%', y, ' = ', x % y, sep = ' ') print('Modulus of negative number is: ', y, '%', x, ' = ', y % x, sep = ' ') 

תְפוּקָה:

First number: -10 Second number: 3 Modulus of negative number is: -10 % 3 = 2 Modulus of negative number is: 3 % -10 = -7 Do you want to continue (Y / N)? N 

הֶסבֵּר:

• בעוד נכון: עושה מעגל אינסופי. הקוד בתוך המעגל ימשיך לפעול עד שהלקוח יבחר לצאת על ידי הזנת אפשרות שונה מ-'Y' כאשר הוא מסתית.
• x = input('האם אתה צריך להמשיך (Y/N)? '): הלקוח מוסת להזין 'Y' או 'N' כדי לבחור אם להמשיך או לעזוב את התוכנית.
• if x.upper() != 'Y': break: בהנחה שהלקוח מזין משהו מלבד 'Y' (לא אכפת מקרים), המעגל נשאר, והתוכנית מסתיימת.
• x = int(input('מספר ראשון: ')) ו-y = int(input('מספר שני: ')): הלקוח מוסת להזין שני מספרים שלמים.
• print('מודול של מספר שלילי הוא: ', x, '%', y, ' = ', x % y, sep=' '): זה מסתדר ומדפיס את ההשפעה שלאחר פעילות המודולוס (x% y) עבור קבוצות המספרים העיקריות שהוזנו.
• print('מודול של מספר שלילי הוא: ', y, '%', x, ' = ', y % x, sep=' '): הוא מוודא ומדפיס את ההשפעה שלאחר פעילות המודולוס (y % x) עבור קבוצות שניות של מספרים שהוזנו.

קבל את המודולוס של שני מספרים באמצעות הפונקציה fmod()

בוא נכתוב תוכנית כדי לקבל את השארית של שני מספרים צפים באמצעות הפונקציה fmod() ב-Python.

jquery את הקליק הזה

Fmod.py

 import math # here, we are importing the math package to use fmod() function. res = math.fmod(25.5, 5.5) # here, we are passing the parameters print ('Modulus using fmod() is:', res) ft = math.fmod(75.5, 15.5) print (' Modulus using fmod() is:', ft) # Here, we are taking two integers from the user x = int( input( 'First number is')) # Here, we are taking the input for the first number y = int (input ('Second number is ')) # Here, we are taking the input for the second number out = math.fmod(x, y) # here, we are passing the parameters print('Modulus of two numbers using fmod() function is', x, ' % ', y, ' = ', out) 

תְפוּקָה:

Modulus using fmod() is: 3.5 Modulus using fmod() is: 13.5 First number is 24 Second number is 5 Modulus of two numbers using fmod() function is 24 % 5 = 4.0 

הֶסבֵּר:

• import math: שורה זו מייבאת את המודול הנומרי, שנותן יכולות מספריות, כולל fmod().
• res = math.fmod(25.5, 5.5): יכולת math.fmod() מנוצלת כדי לחשב את המודולוס של שני מספרי נקודות סחיפה (25.5 ו-5.5 במצב זה), והתוצאה מונחת במשתנה res.
• print('Modulus use fmod() is:', res): שורה זו מדפיסה את ההשפעה שלאחר פעילות המודול שנקבעה תוך שימוש ב-math.fmod().
• ft = math.fmod(75.5, 15.5): כמו המודל הראשי, הוא מוודא את המודולוס של שני מספרי נקודות סחיפה (75.5 ו-15.5) ומאחסן את התוצאה במשתנה ft.
• print('Modulus using fmod() is:', ft): שורה זו מדפיסה את התוצאה של פעילות המודולוס השני.
• x = int(input('המספר הראשון הוא ')) ו-y = int(input('המספר השני הוא ')): הלקוח מתגרה להזין שני מספרים שלמים, אשר לאחר מכן מוחלפים לחלוטין למספרים ומורחקים בגורמים x ו-y.
• out = math.fmod(x, y): יכולת ה-math.fmod() מנוצלת שוב כדי לחשב את המודולוס של שני המספרים שהוזן על ידי הלקוח, והתוצאה מועברת במשתנה out.
• print('מודול של שני מספרים המשתמשים ביכולת fmod() הוא', x, ' % ', y, ' = ', out): שורה זו מדפיסה את ההשפעה שלאחר פעילות המודולוס שנקבעה באמצעות math.fmod() עבור הלקוח שהוזן מספרים שלמים.

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

בוא נכתוב תוכנית Python כדי למצוא את המודולוס של מספר n באמצעות פונקציה ועבור לולאה.

getRemainder.py

 def getRemainder(n, k): # here, we are creating a function for i in range(1, n + 1): # here, we are declaring a for loop # Here, we are storing remainder in the rem variable when i is divided by k number rem = i % k print(i, ' % ', k, ' = ', rem, sep = ' ') # Here, the code for use _name_ driver if __name__ == '__main__': # Here, we define the first number for displaying the number up to desired number. n = int(input ('Define a number till that you want to display the remainder ')) k = int( input (' Enter the second number ')) # here, we are defining the divisor # Here, we are calling the define function getRemainder(n, k) 

תְפוּקָה:

Define a number till that you want to display the remainder 7 Enter the second number 5 1 % 5 = 1 2 % 5 = 2 3 % 5 = 3 4 % 5 = 4 5 % 5 = 0 6 % 5 = 1 7 % 5 = 2 

הֶסבֵּר:

• def getRemainder(n, k): שורה זו מאפיינת יכולת בשם getRemainder שלוקחת שני גבולות (n ו-k).
• עבור I in range(1, n + 1):: שורה זו מתחילה מעגל עבור המדגיש מ-1 עד n (מקיף).
• rem = I % k: בתוך המעגל, שאר ה-I המחולק על-ידי k נקבע ומניחים במשתנה rem.
• print(i, ' % ', k, ' = ', rem, sep=' '): שורה זו מדפיסה את התוצאה של פעילות המודולוס עבור כל דגש, מראה את הערך של I, המחלק k והחלק הנותר שנקבע .
• if __name__ == '__main__':: שורה זו בודקת אם התוכן מופעל כתוכנית הראשית.
• n = int(input('הגדר מספר עד שאתה צריך להראות את השאר של ו-k = int(input('הזן את המספר הבא ')): הלקוח מתגרה להזין שני מספרים שלמים, n ו-k.
• getRemainder(n, k): יכולת getRemainder נקראת כאשר הלקוח נתן ערכים ל-n ו-k. היכולת מסתדרת ומדפיסה את שאר כל מחזור של המעגל.

קבל את המודולוס של מערך נתון באמצעות פונקציית mod()

בוא נכתוב תוכנית כדי להדגים את הפונקציה mod() ב- Python.

mod_fun.py

חסרונות לאינטרנט

 import numpy as np # here, we are importing the numpy package x = np.array([40, -25, 28, 35]) # here, we are define the first array y = np.array([20, 4, 6, 8]) # here, we are define the second array # Here, we are calling the mod() function and pass x and y as the parameter print('The modulus of the given array is ', np.mod (x, y)) 

תְפוּקָה:

The modulus of the given array is [0 3 4 3] 

הֶסבֵּר:

• ייבוא ​​numpy כ-np: שורה זו מייבאת את ספריית NumPy ומקצה לה את הכינוי np. NumPy היא ספרייה חזקה למשימות מתמטיות ב- Python, והיא נותנת משימות תצוגה יעילות.
• x = np.array([40, - 25, 28, 35]): יוצר אשכול NumPy בשם x עם האיכויות שנקבעו מראש.
• y = np.array([20, 4, 6, 8]): יוצר אשכול NumPy נוסף בשם y עם האיכויות שנקבעו מראש.
• print('המודוס של האשכול הנתון הוא ', np.mod(x, y)): קורא ליכולת NumPy mod() אשר מבצעת הליך מודול חכם של רכיב בהשוואת רכיבים של מוצגים x ו-y. התוצאה מודפסת באמצעות print().

קבל את המודולוס של שני מספרים באמצעות numpy.

הבה נשקול תוכנית לייבוא ​​א רדום חבילה מספריית Python ולאחר מכן השתמש בפונקציה rester כדי לקבל את המודולוס ב- Python.

Num.py

 import numpy as np # here, we are importing the numpy package as np # Here, we are giving the declaration of the variables with their values num = 38 # here, we are initializing the num variable num2 = 8 # here, we are initializing the num2 variable res = np.remainder(num, num2) # here, we are using the np.remainder() function print('Modulus is', num, ' % ', num2, ' = ', res) # Here, we are displaying the modulus num % num2 

תְפוּקָה:

Modulus is 38 % 8 = 6 

הֶסבֵּר:

• ייבוא ​​numpy כ-np: שורה זו מייבאת את ספריית NumPy ומקצה לה את הכינוי np.
• num = 38: מציג את המשתנה num עם הערך 38.
• num2 = 8: מציג את המשתנה num2 עם הערך 8.
• res = np.remainder(num, num2): קורא ליכולת NumPy leftover portion(), אשר מוודאת ששאר num מופרד על ידי num2. התוצאה מונחת במשתנה res.
• print('Modulus is', num, ' % ', num2, ' = ', res): מדפיס את ההשפעה שלאחר פעילות המודולוס באמצעות print(). זה מראה את היתרונות של num, num2 והחלק הנותר שנקבע (res).

חריגים באופרטור Python Modulus

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

בואו נכתוב תוכנית כדי להדגים את החריגה של Python באופרטור Modulus.

יחסי ישות

למעט.py

 x = int(input (' The first number is: ')) # Here, we are taking the input for the first number y = int(input (' The second number is: ')) # Here, we are taking the input for the second number # Here, we are displaying the exception handling try: # here, we are defining the try block print (x, ' % ', y, ' = ', x % y) except ZeroDivisionError as err: # here, we are defining the exception block print ('Cannot divide a number by zero! ' + 'So, change the value of the right operand.') 

תְפוּקָה:

The first number is: 24 The second number is: 0 

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

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

הֶסבֵּר:

• x = int(input('המספר הראשון הוא: ')) ו-y = int(input('המספר השני הוא: ')): הלקוח מתגרה להזין שני מספרים שלמים, אשר לאחר מכן משתנים לחלוטין ל- מספרים שלמים ומניחים בגורמים x ו-y.
• try:: זה מתחיל את חסימת הניסיון שבו מוגדר הקוד שיכול להעלות פטור.
• print(x, ' % ', y, ' = ', x % y): בתוך בלוק הניסיון, הקוד שואף לברר ולהדפיס את התוצאה של פעילות המודולוס (x % y).
• למעט ZeroDivisionError כטעות:: בסיכוי לא מתרחשת ZeroDivisionError (כלומר, בהנחה שהלקוח יזין אפס כמספר העוקב), הקוד בתוך הבלוק הצדדי מבוצע.
• print('לא ניתן לחלק מספר בשום דבר! ' + 'לפיכך, שנה את הערך של האופרנד הנכון.'): שורה זו מדפיסה הודעת טעות המדגימה שחלוקה באפס אינה מותרת ומציעה לשנות את הערך של האופרנד הנכון. .