Wie andere Programmiersprachen führt der Python-Modulus-Operator die gleiche Arbeit aus, um den Modulus der gegebenen Zahl zu ermitteln. Der Operator ist ein mathematisches Symbol, mit dem verschiedene Operationen wie (+, -, * /) Addition, Subtraktion, Multiplikation und Division an den gegebenen zwei Zahlen ausgeführt werden, um das Ergebnis sowohl in Form einer Ganzzahl als auch der Gleitkommazahl zurückzugeben . Ein Operator weist den Compiler an, bestimmte Aktionen basierend auf dem übergebenen Operatorsymbol für die angegebene Zahl auszuführen.

Moduloperator

Python Der Moduloperator ist ein integrierter Operator, der die verbleibenden Zahlen zurückgibt, indem er die erste Zahl durch die zweite dividiert. Es ist auch als bekannt Python-Modul . In Python wird das Modulsymbol als Prozentsatz dargestellt ( % )-Symbol. Daher wird er als Restoperator bezeichnet.

Syntax

Nachfolgend finden Sie die Syntax, die den Modulus-Operator in der Python-Sprache darstellt. Sie wird verwendet, um den Rest zu erhalten, wenn wir die erste Zahl durch die zweite dividieren.

String-Java-Array

 Rem = X % Y 

Hier sind X und Y zwei ganze Zahlen, und der Modul (%) wird dazwischen verwendet, um den Rest zu erhalten, bei dem die erste Zahl (X) durch die zweite Zahl (Y) geteilt wird.

Zum Beispiel haben wir zwei Zahlen, 24 und 5. Und wir können den Rest ermitteln, indem wir den Modulus- oder Modulo-Operator zwischen den Zahlen 24 % 5 verwenden. Hier wird 24 durch 5 dividiert, was 4 als Rest und 4 als Quotient ergibt . Wenn die erste Zahl vollständig durch eine andere Zahl teilbar ist, ohne dass ein Rest verbleibt, ist das Ergebnis 0. Wir haben beispielsweise zwei Zahlen, 20 und 5. Und wir können den Rest ermitteln, indem wir den Modulus- oder Modulo-Operator zwischen den Zahlen 20 verwenden % 5. Hier wird 20 durch 5 dividiert, was 0 als Rest und 4 als Quotient ergibt.

Ermitteln Sie den Modul zweier Ganzzahlen mithilfe der While-Schleife

Schreiben wir ein Programm, um den Rest zweier Zahlen mithilfe der While-Schleife und des Modulus-Operators (%) in Python zu ermitteln.

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 

Ausgabe:

 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 

Erläuterung:

• while True: Dies erzeugt eine Endlosschleife. Der Code innerhalb der Schleife läuft weiter, bis die Schleife explizit unterbrochen wird.
• a = input('Möchten Sie fortfahren oder nicht (J/N)?'): Der Benutzer wird aufgefordert, 'J' oder 'N' einzugeben, um zu entscheiden, ob das Programm fortgesetzt oder beendet werden soll.
• if a.upper() != 'Y': break: Wenn der Benutzer etwas anderes als 'Y' eingibt (ohne Berücksichtigung der Groß- und Kleinschreibung), wird die Schleife verlassen und das Programm beendet.
• a = int(input('Erste Zahl ist: ')) und b = int(input('Zweite Zahl ist: ')): Der Benutzer wird aufgefordert, zwei Ganzzahlen einzugeben.
• print('Das Ergebnis nach der Ausführung des Modulo-Operators ist: ', a, ' % ', b, ' = ', a % b): Es berechnet und druckt das Ergebnis der Modulo-Operation (a % b) für das erste Paar von Zahlen eingegeben.
• print('Das Ergebnis nach der Ausführung des Modulo-Operators ist:', b, ' % ', a, ' = ', b % a): Berechnet und druckt das Ergebnis der Modulo-Operation (b % a) für das zweite Paar von Zahlen eingegeben.
• Das Programm fragt den Benutzer, ob wir fortfahren oder das Programm stoppen möchten, indem wir eine Eingabe wie (J/N) geben. Hier ist Y die Eingabe zum Fortsetzen des Programms und „N“ wird verwendet, um das Programm zu stoppen .

Ermitteln Sie den Modul zweier Gleitkommazahlen

Schreiben wir ein Programm, um den Rest zweier Gleitkommazahlen mithilfe des Modulo-Operators in Python zu ermitteln.

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

Ausgabe:

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

Erläuterung:

• x = float(input('Erste Zahl: ')): Der Client wird aufgefordert, eine Gleitkommazahl für die Primärvariable einzugeben, und die Informationen werden in der Variablen x abgelegt.
• y = float(input('Second number: ')): Der Client wird aufgefordert, eine Float-Zahl für die nachfolgende Variable einzugeben, und die Informationen werden in der Variablen y abgelegt.
• res = x % y: Die Modulaktivität wird auf x und y ausgeführt und das Ergebnis wird in der Variablen res abgelegt.
• print('Modul von zwei Float-Zahlen ist: ', x, '%', y, ' = ', res, sep=' '): Die Konsequenz der Modulaktivität wird mit der richtigen Anordnung gedruckt, wobei die Eigenschaften durch Leerzeichen isoliert werden ( sep='').

Ermitteln Sie den Modul einer negativen Zahl

Schreiben wir ein Programm, um den Rest zweier negativer Zahlen mithilfe der While-Schleife und des Modulus-Operators (%) in Python zu ermitteln.

Mod.py

Linkliste in Java

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

Ausgabe:

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 

Erläuterung:

• while True: Bildet einen endlosen Kreis. Der Code innerhalb des Kreises wird so lange ausgeführt, bis der Client den Vorgang beendet, indem er bei Aufforderung eine andere Option als „Y“ eingibt.
• x = input('Müssen Sie fortfahren (J/N)? '): Der Client wird aufgefordert, 'J' oder 'N' einzugeben, um zu entscheiden, ob er fortfahren oder das Programm verlassen möchte.
• if x.upper() != 'Y': break: Unter der Annahme, dass der Client etwas anderes als 'Y' eingibt (ohne Rücksicht auf Groß- und Kleinschreibung), wird der Kreis verlassen und das Programm endet.
• x = int(input('Erste Zahl: ')) und y = int(input('Zweite Zahl: ')): Der Client wird aufgefordert, zwei ganze Zahlen einzugeben.
• print('Modul der negativen Zahl ist: ', x, '%', y, ' = ', x % y, sep=' '): Es berechnet und druckt den Effekt der Modulaktivität (x % y) für die primären eingegebenen Zahlenmengen.
• print('Modul der negativen Zahl ist: ', y, '%', x, ' = ', y % x, sep=' '): Es ermittelt und druckt den Effekt der Modulaktivität (y % x) für die zweite Zahlenreihe eingegeben.

Ermitteln Sie den Modul zweier Zahlen mit der Funktion fmod()

Schreiben wir ein Programm, um den Rest von zwei Gleitkommazahlen mithilfe der Funktion fmod() in Python zu ermitteln.

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) 

Ausgabe:

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 

Erläuterung:

• import math: Diese Zeile importiert das numerische Modul, das numerische Funktionen bereitstellt, einschließlich fmod().
• res = math.fmod(25,5, 5,5): Die Funktion math.fmod() wird verwendet, um den Modul zweier driftender Punktzahlen (25,5 und 5,5 für diesen Fall) zu berechnen, und das Ergebnis wird in der Variablen res abgelegt.
• print('Modulus using fmod() is:', res): Diese Zeile gibt das Ergebnis der Modulaktivität aus, die mit math.fmod() ermittelt wurde.
• ft = math.fmod(75,5, 15,5): Wie das Hauptmodell ermittelt es den Modul zweier driftender Punktzahlen (75,5 und 15,5) und speichert das Ergebnis in der Variablen ft.
• print('Modulus using fmod() is:', ft): Diese Zeile gibt die Konsequenz der zweiten Modulaktivität aus.
• x = int(input('Erste Zahl ist ')) und y = int(input('Zweite Zahl ist ')): Der Client wird aufgefordert, zwei ganze Zahlen einzugeben, die dann komplett in Zahlen umgewandelt und weggelegt werden in den Faktoren x und y.
• out = math.fmod(x, y): Die Funktion math.fmod() wird erneut verwendet, um den Modulus der beiden vom Client eingegebenen Zahlen zu berechnen, und das Ergebnis wird in der Variablen out abgelegt.
• print('Modul von zwei Zahlen mit der Funktion fmod() ist', x, ' % ', y, ' = ', out): Diese Zeile gibt den Effekt der Modulaktivität aus, die mit math.fmod() für den eingegebenen Client ermittelt wurde ganze Zahlen.

Ermitteln Sie den Modul von n Zahlen mithilfe der Funktion

Schreiben wir ein Python-Programm, um mithilfe der Funktion und der for-Schleife den Modul der Zahl n zu ermitteln.

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) 

Ausgabe:

Ersetzen Sie aus einer Zeichenfolge in Java

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 

Erläuterung:

• def getRemainder(n, k): Diese Zeile charakterisiert eine Funktion namens getRemainder, die zwei Grenzen (n und k) annimmt.
• for I in range(1, n + 1):: Diese Zeile beginnt mit einem for-Kreis, der von 1 bis n (umfassend) betont.
• rem = I % k: Innerhalb des Kreises wird der Rest von I, geteilt durch k, bestimmt und in der Variablen rem abgelegt.
• print(i, ' % ', k, ' = ', rem, sep=' '): Diese Zeile gibt die Konsequenz der Modulaktivität für jede Hervorhebung aus und zeigt den Wert von I, den Divisor k und den ermittelten verbleibenden Teil .
• if __name__ == '__main__':: Diese Zeile prüft, ob der Inhalt als primäres Programm ausgeführt wird.
• n = int(input('Definieren Sie eine Zahl, bis der Rest angezeigt werden soll, und k = int(input('Geben Sie die nächste Zahl ein')): Der Client wird aufgefordert, zwei ganze Zahlen einzugeben, n und k.
• getRemainder(n, k): Die getRemainder-Funktion wird aufgerufen, wenn der Client Werte für n und k angegeben hat. Die Funktion berechnet den Rest jedes Zyklus des Kreises und gibt ihn aus.

Ermitteln Sie den Modul des angegebenen Arrays mithilfe der Funktion mod()

Schreiben wir ein Programm, um die Funktion mod() in Python zu demonstrieren.

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

Ausgabe:

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

Erläuterung:

• numpy als np importieren: Diese Zeile importiert die NumPy-Bibliothek und weist ihr den Moniker np zu. NumPy ist eine leistungsstarke Bibliothek für mathematische Aufgaben in Python und bietet leistungsstarke Präsentationsaufgaben.
• x = np.array([40, - 25, 28, 35]): Erstellt einen NumPy-Cluster mit dem Namen x mit den vorgegebenen Eigenschaften.
• y = np.array([20, 4, 6, 8]): Erstellt einen weiteren NumPy-Cluster namens y mit den vorgegebenen Eigenschaften.
• print('Der Modul des angegebenen Clusters ist ', np.mod(x, y)): Ruft die Funktion NumPy mod() auf, die eine komponentenweise Modulprozedur beim Vergleich der Komponenten der Exponate x und y durchführt. Das Ergebnis wird mit print() gedruckt.

Ermitteln Sie den Modul zweier Zahlen mit Numpy.

Betrachten wir ein Programm zum Importieren von a Numpy Paket aus der Python-Bibliothek und verwenden Sie dann die Restfunktion, um den Modulus in Python abzurufen.

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 

Ausgabe:

Modulus is 38 % 8 = 6 

Erläuterung:

Mapping im Typoskript

• numpy als np importieren: Diese Zeile importiert die NumPy-Bibliothek und weist ihr den Moniker np zu.
• num = 38: Führt die Variable num mit dem Wert 38 ein.
• num2 = 8: Setzt die Variable num2 mit dem Wert 8 ein.
• res = np.remainder(num, num2): Ruft die Funktion NumPy leftover portion() auf, die sicherstellt, dass der Rest von num durch num2 getrennt ist. Das Ergebnis wird in der Variable res abgelegt.
• print('Modulus is', num, ' % ', num2, ' = ', res): Druckt das Ergebnis der Modulaktivität mit print(). Es zeigt die Vorteile von num, num2 und den ermittelten Restanteil (res).

Ausnahmen im Python-Modulus-Operator

Wenn in Python eine Zahl durch Null geteilt wird, wird eine Ausnahme ausgelöst, die als Ausnahme bezeichnet wird ZeroDivisionError . Mit anderen Worten: Es wird eine Ausnahme zurückgegeben, wenn eine Zahl durch einen Teiler, der Null ist, teilbar ist. Wenn wir die Ausnahme aus dem Python-Modulus-Operator entfernen möchten, sollte der Divisor daher nicht Null sein.

Schreiben wir ein Programm, um den Python-Ausnahme-in-Modulus-Operator zu demonstrieren.

außer.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.') 

Ausgabe:

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

Eine Zahl kann nicht durch Null geteilt werden! Ändern Sie also den Wert des rechten Operanden.

Wie wir im obigen Ergebnis sehen können, wird Folgendes angezeigt: „Eine Zahl kann nicht durch Null geteilt werden!“ Ändern Sie also den Wert des rechten Operanden. Daher können wir sagen: Wenn wir die erste Zahl durch Null dividieren, wird eine Ausnahme zurückgegeben.

Erläuterung:

• x = int(input('Die erste Zahl ist: ')) und y = int(input('Die zweite Zahl ist: ')): Der Client wird aufgefordert, zwei ganze Zahlen einzugeben, die dann vollständig auf umgestellt werden ganze Zahlen berechnen und in die Faktoren x und y einrechnen.
• Versuch:: Dies startet den Versuchsblock, in dem der Code festgelegt ist, der eine Ausnahme auslösen könnte.
• print(x, ' % ', y, ' = ', x % y): Innerhalb des Versuchsblocks versucht der Code, die Konsequenz der Modulaktivität (x % y) zu ermitteln und auszudrucken.
• mit Ausnahme von ZeroDivisionError als blunder:: Wenn ein ZeroDivisionError auftritt (d. h. vorausgesetzt, der Client gibt Null als nächste Zahl ein), wird der Code im Block aside from ausgeführt.
• print('Eine Zahl kann nicht durch nichts geteilt werden! ' + 'Ändern Sie also den Wert des rechten Operanden.'): Diese Zeile gibt eine Fehlermeldung aus, die zeigt, dass eine Division durch Null nicht zulässig ist, und schlägt vor, den Wert des rechten Operanden zu ändern .