Liksom andra programmeringsspråk gör Python-moduloperatorn samma arbete för att hitta modulen för det givna numret. Operatorn är en matematisk symbol som används för att utföra olika operationer såsom (+, -, * /) addition, subtraktion, multiplikation och division på de givna två talen för att returnera resultatet i form av ett heltal såväl som flyttalet . En operatör säger åt kompilatorn att utföra vissa åtgärder baserat på den passerade operatörssymbolen till det givna numret.

Modulus Operatör

Pytonorm Modulus Operator är en inbyggd operatör som returnerar de återstående talen genom att dividera det första talet från det andra. Det är också känt som Python-modul . I Python representeras modulsymbolen som procenten ( % ) symbol. Därför kallas det resterande operatör.

Syntax

Nedan är syntaxen som representerar moduloperatorn i Python-språket, den används för att få resten när vi delar det första talet med det andra.

b plus träd

 Rem = X % Y 

Här är X och Y två heltal, och modulen (%) används däremellan för att få resten där det första talet (X) delas med det andra talet (Y).

Vi har till exempel två tal, 24 och 5. Och vi kan få resten genom att använda modul- eller moduloperatorn mellan talen 24 % 5. Här delas 24 med 5 som returnerar 4 som resten, och 4 som kvoten . När det första talet är helt delbart med ett annat tal utan att lämna någon rest blir resultatet 0. Vi har till exempel två tal, 20 och 5. Och vi kan få resten genom att använda modul- eller modulooperatorn mellan talen 20 % 5. Här delas 20 med 5 som returnerar 0 som resten och 4 som kvoten.

Få modulen för två heltal med while-loop

Låt oss skriva ett program för att få resten av två siffror med hjälp av while-loopen och modulus (%) operatorn i 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 

Produktion:

 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 

Förklaring:

• medan True: Detta skapar en oändlig loop. Koden inuti slingan fortsätter att köras tills slingan explicit bryts.
• a = input('Vill du fortsätta eller inte (Y / N)? '): Användaren uppmanas att ange 'Y' eller 'N' för att bestämma om programmet ska fortsätta eller avslutas.
• if a.upper() != 'Y': break: Om användaren anger något annat än 'Y' (skiftlägeskänsligt), avslutas loopen och programmet avslutas.
• a = int(input('Första numret är: ')) och b = int(input('Andra numret är: ')): Användaren uppmanas att ange två heltal.
• print('Resultatet efter att ha utfört moduloperatorn är: ', a, ' % ', b, ' = ', a % b): Den beräknar och skriver ut resultatet av moduloperationen (a % b) för det första paret av angivna nummer.
• print('Resultatet efter att ha utfört moduloperatorn är:', b, ' % ', a, ' = ', b % a): Den beräknar och skriver ut resultatet av moduloperationen (b % a) för det andra paret av angivna nummer.
• Programmet kommer att fråga användaren väder vi vill fortsätta eller vi vill stoppa programmet genom att ge ingången som (J/N), här är Y ingången för att fortsätta programmet och 'N' används för att stoppa programmet .

Få modulen för två flyttal

Låt oss skriva ett program för att hitta resten av två flyttalstal med hjälp av moduloperatorn i 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 = ' ') 

Produktion:

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

Förklaring:

• x = float(input('Första nummer: ')): Klienten provoceras att ange ett flytnummer för den primära variabeln, och informationen läggs undan i variabeln x.
• y = float(input('Andra nummer: ')): Klienten provoceras att ange ett flytnummer för den efterföljande variabeln, och informationen läggs undan i variabeln y.
• res = x % y: Modulaktiviteten utförs på x och y, och utfallet läggs bort i variabeln res.
• print('Modul av två flyttal är: ', x, '%', y, ' = ', res, sep=' '): Konsekvensen av modulaktiviteten skrivs ut med rätt arrangemang, vilket isolerar kvaliteterna med mellanslag ( sep=' ').

Få modulen för ett negativt tal

Låt oss skriva ett program för att få resten av två negativa tal genom att använda while-loop och modul (%) operator i Python.

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

Produktion:

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 

Förklaring:

• medan True: Gör en oändlig cirkel. Koden inuti cirkeln kommer att fortsätta att köras tills klienten väljer att avsluta genom att ange något annat alternativ än 'Y' när den hettas.
• x = input('Behöver du fortsätta (J/N)? '): Klienten uppmanas att ange 'Y' eller 'N' för att välja om han vill fortsätta eller lämna programmet.
• if x.upper() != 'Y': break: Förutsatt att klienten anger något förutom 'Y' (case-uncaring), lämnas cirkeln och programmet avslutas.
• x = int(input('Första numret: ')) och y = int(input('Andra siffran: ')): Klienten uppmanas att ange två heltal.
• print('Modul för negativt tal är: ', x, '%', y, ' = ', x % y, sep=' '): Det fungerar och skriver ut efterverkan av modulaktiviteten (x % y) för de primära nummeruppsättningarna som angetts.
• print('Modul för negativt tal är: ', y, '%', x, ' = ', y % x, sep=' '): Den fastställer och skriver ut efterverkan av modulaktiviteten (y % x) för andra uppsättningar siffror angivna.

Få modulen för två tal med funktionen fmod().

Låt oss skriva ett program för att få resten av två flyttal med funktionen fmod() i Python.

1 miljon hur många 0

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) 

Produktion:

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 

Förklaring:

• import math: Denna rad importerar den numeriska modulen, som ger numeriska funktioner, inklusive fmod().
• res = math.fmod(25.5, 5.5): Math.fmod()-förmågan används för att beräkna modulen för två driftpunkttal (25,5 och 5,5 för denna situation), och resultatet läggs bort i variabeln res.
• print('Modulus use fmod() is:', res): Denna rad skriver ut eftereffekten av modulaktiviteten som bestämts med hjälp av math.fmod().
• ft = math.fmod(75.5, 15.5): Liksom huvudmodellen fastställer den modulen för två driftpunkttal (75.5 och 15.5) och lagrar resultatet i variabeln ft.
• print('Modul som använder fmod() är:', ft): Denna rad skriver ut konsekvensen av den andra modulaktiviteten.
• x = int(input('Första siffran är ')) och y = int(input('Andra numret är ')): Klienten provoceras att ange två heltal, som sedan ändras helt till siffror och läggs undan i faktorerna x och y.
• out = math.fmod(x, y): Math.fmod()-förmågan används igen för att beräkna modulen för de två siffrorna som angetts av klienten, och resultatet läggs bort i variabeln out.
• print('Modul av två tal som använder fmod()-förmågan är', x, ' % ', y, ' = ', ut): Den här raden skriver ut eftereffekten av modulaktiviteten som fastställts med hjälp av math.fmod() för den angivna klienten heltal.

Få modulen för n tal med hjälp av funktion

Låt oss skriva ett Python-program för att hitta modulen för n tal med hjälp av funktion och för loop.

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) 

Produktion:

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 

Förklaring:

• def getRemainder(n, k): Denna rad kännetecknar en funktion som heter getRemainder som tar två gränser (n och k).
• for I in range(1, n + 1):: Denna rad börjar en för cirkel som betonar från 1 till n (omfattande).
• rem = I % k: Inuti cirkeln bestäms resten av I som är partitionerat med k och läggs bort i variabeln rem.
• print(i, ' % ', k, ' = ', rem, sep=' '): Denna rad skriver ut konsekvensen av modulaktiviteten för varje betoning, och visar värdet av I, divisorn k och den fastställda återstående delen .
• if __name__ == '__main__':: Denna rad kontrollerar om innehållet körs som det primära programmet.
• n = int(input('Definiera ett tal till som du behöver visa resten av och k = int(input('Ange det efterföljande numret')): Klienten provoceras att ange två heltal, n och k.
• getRemainder(n, k): GetRemainder-förmågan anropas med klientens värden till n och k. Förmågan fungerar och skriver ut resten av varje cirkel i cirkeln.

Få modulen för given array med mod()-funktionen

Låt oss skriva ett program för att demonstrera mod()-funktionen i Python.

mod_fun.py

java-operatörer

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

Produktion:

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

Förklaring:

• importera numpy som np: Den här raden importerar NumPy-biblioteket och tilldelar det monikern np. NumPy är ett starkt bibliotek för matematiska uppgifter i Python, och det ger effektiva utställningsuppgifter.
• x = np.array([40, - 25, 28, 35]): Gör ett NumPy-kluster som heter x med de förutbestämda egenskaperna.
• y = np.array([20, 4, 6, 8]): Gör ett annat NumPy-kluster som heter y med de förutbestämda egenskaperna.
• print('Modulen för det givna klustret är ', np.mod(x, y)): Anropar NumPy mod()-förmågan, som utför en komponentvis modulprocedur för att jämföra komponenter i exhibitionerna x och y. Resultatet skrivs ut med print().

Få modulen för två tal med hjälp av numpy.

Låt oss överväga ett program för att importera en numpy paket från Python-biblioteket och använd sedan restfunktionen för att få modulen i 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 

Produktion:

Modulus is 38 % 8 = 6 

Förklaring:

• importera numpy som np: Den här raden importerar NumPy-biblioteket och tilldelar det monikern np.
• num = 38: Introducerar variabeln num med värdet 38.
• num2 = 8: Inställer variabeln num2 med värdet 8.
• res = np.remainder(num, num2): Anropar NumPy leftover portion()-förmågan, som säkerställer att resten av num separeras av num2. Utfallet läggs undan i variabeln res.
• print('Modul är', num, ' % ', num2, ' = ', res): Skriver ut eftereffekten av modulaktiviteten med hjälp av print(). Den visar uppsidorna av num, num2 och den fastställda återstående delen (res).

Undantag i Python Modulus operator

I Python, när ett tal delas med noll, ger det ett undantag, och undantaget kallas för ZeroDivisionError . Med andra ord, det returnerar ett undantag när ett tal är delbart med en divisor som är noll. Därför, om vi vill ta bort undantaget från Python-moduloperatorn, bör divisorn inte vara noll.

Låt oss skriva ett program för att demonstrera Python-undantaget i Modulus-operatorn.

rakhi sawant

utom.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.') 

Produktion:

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

Kan inte dividera ett tal med noll! Så ändra värdet på den högra operanden.

Som vi kan se i ovanstående resultat, visas: 'Kan inte dividera ett tal med noll! Så ändra värdet på den högra operanden'. Därför kan vi säga, när vi dividerar det första talet med noll, returnerar det ett undantag.

Förklaring:

• x = int(input('Första numret är: ')) och y = int(input('Det andra numret är: ')): Klienten provoceras att ange två heltal, som sedan ändras helt till heltal och lägg bort i faktorerna x och y.
• försök:: Detta startar försöksblocket där koden som kan ge ett undantag sätts.
• print(x, ' % ', y, ' = ', x % y): Inuti försöksblocket strävar koden efter att fastställa och skriva ut konsekvensen av modulaktiviteten (x % y).
• med undantag för ZeroDivisionError som blunder:: Om chansen att ett ZeroDivisionError inträffar (dvs. om man antar att klienten anger noll som efterföljande nummer), exekveras koden inuti aside from-blocket.
• print('Kan inte partitionera ett nummer med ingenting! ' + 'Ändra alltså värdet på den högra operanden.'): Den här raden skriver ut ett misstag som visar att division med noll inte är tillåtet och föreslår att värdet på den högra operanden ändras. .