Más programozási nyelvekhez hasonlóan a Python modulus operátor is ugyanazt a munkát végzi el, hogy megtalálja az adott szám modulusát. Az operátor egy matematikai szimbólum, amelyet különböző műveletek végrehajtására használnak, például (+, -, * /) összeadást, kivonást, szorzást és osztást a megadott két számon, hogy az eredményt egész szám és lebegőszám formájában adja vissza. . Egy operátor utasítja a fordítót, hogy hajtson végre bizonyos műveleteket az adott számnak átadott operátorszimbólum alapján.

Modulus kezelő

Piton A Modulus Operator egy beépített operátor, amely úgy adja vissza a fennmaradó számokat, hogy elosztja az első számot a másodikkal. Más néven a Python modul . Pythonban a modulus szimbólumot százalékban ( % ) szimbólum. Ezért hívják maradék operátornak.

Szintaxis

Az alábbiakban látható a Python nyelvben a modulus operátort reprezentáló szintaxis, ez arra szolgál, hogy megkapjuk a maradékot, amikor az első számot elosztjuk a másodikkal.

konvertáljon egy int karakterláncra c++

 Rem = X % Y 

Itt X és Y két egész szám, és a modulus (%) felhasználásával kapjuk meg a maradékot, ahol az első számot (X) elosztjuk a második számmal (Y).

Például két számunk van, a 24 és az 5. A maradékot pedig úgy kaphatjuk meg, hogy a modulus vagy modulo operátort használjuk a 24 % 5 számok között. Itt a 24 el van osztva 5-tel, ami 4-et ad vissza maradékként, és 4-et hányadosként. . Ha az első szám teljesen osztható egy másik számmal anélkül, hogy maradékot hagyna, az eredmény 0 lesz. Például két számunk van, 20 és 5. A maradékot pedig a modulus vagy modulo operátor használatával kaphatjuk meg a 20-as számok között. % 5. Itt a 20 el van osztva 5-tel, ami 0-t ad vissza maradékként, és 4-et a hányadosként.

Szerezze meg két egész szám modulusát a while ciklus használatával

Írjunk egy programot, amely két szám maradékát megkapja a while ciklus és a modulus (%) operátor használatával a Pythonban.

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 

Kimenet:

 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 

Magyarázat:

• míg igaz: Ez végtelen hurkot hoz létre. A cikluson belüli kód addig fut, amíg a ciklus kifejezetten meg nem szakad.
• a = input('Folytatni akarja vagy sem (I / N)? '): A felhasználónak meg kell adnia az 'Y' vagy 'N' betűt, hogy eldöntse, folytatja-e vagy kilép a programból.
• if a.upper() != 'Y': break: Ha a felhasználó mást ír be, mint az 'Y' (kis- és nagybetűk közötti különbség), akkor a ciklus kilép, és a program leáll.
• a = int(input('Az első szám: ')) és b = int(input('A második szám: ')): A felhasználónak két egész számot kell megadnia.
• print('Az eredmény a modulus operátor végrehajtása után: ', a, ' % ', b, ' = ', a % b): Kiszámolja és kiírja a modulus művelet eredményét (a % b) az első párra beírt számok.
• print('Az eredmény a modulus operátor végrehajtása után:', b, ' % ', a, ' = ', b % a): Kiszámolja és kiírja a modulus művelet eredményét (b % a) a második párra beírt számok.
• A program megkérdezi a felhasználó időjárását, ha folytatni akarjuk, vagy le akarjuk állítani a programot az (I/N) bevitellel, itt Y a program folytatásának bemenete, az 'N' pedig a program leállítására szolgál. .

Szerezd meg két lebegőszám modulusát

Írjunk egy programot két lebegőpontos szám maradékának megkeresésére a Python modulus operátorával.

fülke algoritmus

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 = ' ') 

Kimenet:

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

Magyarázat:

• x = float(input('Első szám: ')): A klienst arra késztetik, hogy adjon meg egy float számot az elsődleges változóhoz, és az információ az x változóba kerül.
• y = float(input('Második szám: ')): A klienst arra késztetik, hogy adjon meg egy float számot a következő változóhoz, és az információ az y változóba kerül.
• res = x % y: A modulus aktivitást végrehajtjuk x-en és y-n, és az eredményt a res változóba helyezzük.
• print('Két lebegőszám modulusa: ', x, '%', y, ' = ', res, sep=' '): A modulus tevékenység következménye megfelelő elrendezéssel kerül kinyomtatásra, szóközökkel elválasztva a minőségeket ( szep=' ').

Szerezd meg egy negatív szám modulusát

Írjunk egy programot, amely két negatív szám maradékát megkapja a while ciklus és a modulus (%) operátor használatával a Pythonban.

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 = ' ') 

Kimenet:

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 

Magyarázat:

• míg Igaz: Végtelen kört tesz. A körön belüli kód mindaddig futni fog, amíg a kliens úgy dönt, hogy kilép az „Y”-től eltérő opció beírásával, amikor felbujt.
• x = input('Kell folytatni (I/N)? '): A kliens 'Y' vagy 'N' beírására késztet, hogy eldöntse, hogy folytatja-e vagy kilép a programból.
• if x.upper() != 'Y': break: Feltételezve, hogy a kliens beír valamit az 'Y' mellett (kis- és nagybetűk nélküli), a kört elhagyjuk, és a program véget ér.
• x = int(input('Első szám: ')) és y = int(input('Második szám: ')): Az ügyfél két egész szám beírására késztet.
• print('A negatív szám modulusa: ', x, '%', y, ' = ', x % y, sep=' '): Kidolgozza és kiírja a modulus tevékenység utóhatását (x % y) a beírt elsődleges számkészletek.
• print('A negatív szám modulusa: ', y, '%', x, ' = ', y % x, sep=' '): Megállapítja és kiírja a modulus aktivitásának (y % x) utóhatását a második beírt számkészlet.

Szerezze meg két szám modulusát az fmod() függvény segítségével

Írjunk egy programot a két float szám maradékának lekérésére a Python fmod() függvényével.

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) 

Kimenet:

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 

Magyarázat:

• import math: Ez a sor importálja a numerikus modult, amely numerikus képességeket ad, beleértve az fmod()-t is.
• res = math.fmod(25.5, 5.5): A math.fmod() képességet két sodródó pontszám modulusának kiszámítására használják (ebben a helyzetben 25.5 és 5.5), és az eredményt a res változóba helyezzük.
• print('Modulus using fmod() is:', res): Ez a sor a math.fmod() segítségével meghatározott modulus tevékenység utóhatását írja ki.
• ft = math.fmod(75.5, 15.5): A főmodellhez hasonlóan ez is megállapítja két sodródó pontszám modulusát (75.5 és 15.5), és az eredményt az ft változóban tárolja.
• print('Modulus using fmod() is:', ft): Ez a sor a második modulus tevékenység következményét írja ki.
• x = int(input('Első szám ')) és y = int(input('Második szám ')): A klienst két egész szám beírására késztetik, amelyeket ezután teljesen számokká alakítanak át és elteszik. az x és y tényezőkben.
• out = math.fmod(x, y): A math.fmod() képességet ismét felhasználják a kliens által beírt két szám modulusának kiszámításához, és az eredményt az out változóba helyezzük.
• print('Két szám modulusa az fmod() képességet használva is', x, ' % ', y, ' = ', out): Ez a sor a math.fmod() segítségével meghatározott modulus tevékenység utóhatását írja ki a beírt kliens számára egész számok.

Szerezd meg n szám modulusát a függvény segítségével

Írjunk Python programot, amely a függvény és a for ciklus segítségével megkeresi n szám modulusát.

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) 

Kimenet:

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 

Magyarázat:

• def getRemainder(n, k): Ez a sor a getRemainder nevű képességet jellemzi, amely két határt (n és k) vesz fel.
• for I in range(1, n + 1):: Ezzel a sorral kezdődik a for circle, amely 1-től n-ig emeli ki (átfogó).
• rem = I % k: A körön belül a k által felosztott I többi részét meghatározzuk és a rem változóban elhelyezzük.
• print(i, ' % ', k, ' = ', rem, sep=' '): Ez a sor minden hangsúlyra kiírja a modulus tevékenység következményét, megmutatva az I értékét, a k osztót és a meghatározott maradék részt. .
• if __name__ == '__main__':: Ez a sor ellenőrzi, hogy a tartalom elsődleges programként fut-e.
• n = int(input('Határozzon meg egy számot addig, amíg meg kell mutatnia a többit, és k = int(input('Írja be a következő számot')): A kliens két egész számot, az n-t és a k-t, arra készteti.
• getRemainder(n, k): A getRemainder képesség meghívása úgy történik, hogy a kliens értéket adott n-nek és k-nek. A képesség működik, és kinyomtatja a kör minden ciklusának hátralévő részét.

Szerezd meg az adott tömb modulusát a mod() függvény segítségével

Írjunk egy programot a mod() függvény bemutatására Pythonban.

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)) 

Kimenet:

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

Magyarázat:

parancs chown

• import numpy as np: Ez a sor importálja a NumPy könyvtárat, és hozzárendeli az np becenevet. A NumPy egy erős könyvtár a matematikai feladatokhoz Pythonban, és hatékony kiállítási feladatokat ad.
• x = np.array([40, - 25, 28, 35]): Létrehoz egy x nevű NumPy-fürtöt az előre meghatározott tulajdonságokkal.
• y = np.array([20, 4, 6, 8]): Egy másik NumPy klasztert hoz létre y néven előre meghatározott tulajdonságokkal.
• print('Az adott klaszter modulusa ', np.mod(x, y)): Meghívja a NumPy mod() képességet, amely komponensenkénti modulus eljárást hajt végre az x és y mutatók komponenseinek összehasonlítására. Az eredmény a print() használatával kerül kinyomtatásra.

Kapja meg két szám modulusát a numpy segítségével.

Vegyünk egy programot az importáláshoz a zsibbadt csomagot a Python könyvtárból, majd használja a maradék függvényt a modulus beszerzéséhez a Pythonban.

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 

Kimenet:

Modulus is 38 % 8 = 6 

Magyarázat:

rekurzió java-ban

• import numpy as np: Ez a sor importálja a NumPy könyvtárat, és hozzárendeli az np becenevet.
• num = 38: Bevezeti a num változót, amelynek értéke 38.
• num2 = 8: A szám2 változót 8-as értékkel állítja be.
• res = np.remainder(num, num2): Meghívja a NumPy maradék partion() képességet, amely biztosítja, hogy a többi számot num2 választja el. Az eredmény a res változóba kerül.
• print('Modulus is', num, ' % ', num2, ' = ', res): Kiírja a modulus tevékenység utóhatását a print() használatával. Megmutatja a num, num2 és a meghatározott maradék rész (res) felfelé irányuló részét.

Kivételek a Python Modulus operátorban

Pythonban, ha egy számot elosztunk nullával, kivételt dob, és a kivételt a ZeroDivisionError . Más szavakkal, kivételt ad vissza, ha egy szám osztható nulla osztóval. Ezért, ha el akarjuk távolítani a kivételt a Python modulus operátorból, akkor az osztó ne legyen nulla.

Írjunk egy programot a Python-kivétel bemutatására a Modulus operátorban.

kivéve.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.') 

Kimenet:

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

Egy szám nem osztható nullával! Tehát változtassa meg a megfelelő operandus értékét.

Amint a fenti eredményből láthatjuk, a következőt jeleníti meg: „Egy szám nem osztható nullával! Tehát változtassa meg a megfelelő operandus értékét. Ezért azt mondhatjuk, hogy amikor az első számot elosztjuk nullával, az kivételt ad vissza.

Magyarázat:

• x = int(input('Az első szám: ')) és y = int(input('A második szám: ')): A kliens két egész szám beírására késztet, amelyeket ezután teljesen átváltoz egész számokat, és tedd el az x és y tényezőkben.
• kísérlet:: Ez elindítja a kísérlet blokkot, ahol be van állítva a kód, amely felmentést adhat.
• print(x, ' % ', y, ' = ', x % y): A kísérlet blokkon belül a kód arra törekszik, hogy megállapítsa és kinyomtassa a modulus tevékenység (x % y) következményét.
• a ZeroDivisionError kivételével, mint baklövés:: ZeroDivisionError előfordulása esetén (vagyis feltételezve, hogy a kliens nullát ír be a következő számként), a blokkon belüli kód végrehajtásra kerül.
• print('Nem lehet egy számot semmivel particionálni! ' + 'Így változtassa meg a megfelelő operandus értékét.'): Ez a sor hibaüzenetet nyomtat, amely azt mutatja, hogy a nullával való osztás nem megengedett, és a megfelelő operandus értékének módosítását javasolja .