Comme d'autres langages de programmation, l'opérateur de module Python effectue le même travail pour trouver le module du nombre donné. L'opérateur est un symbole mathématique utilisé pour effectuer différentes opérations telles que (+, -, * /) addition, soustraction, multiplication et division sur les deux nombres donnés pour renvoyer le résultat sous la forme d'un entier ainsi que du nombre flottant. . Un opérateur indique au compilateur d'effectuer certaines actions en fonction du symbole d'opérateur transmis au nombre donné.

Opérateur de module

Python L'opérateur Modulus est un opérateur intégré qui renvoie les nombres restants en divisant le premier nombre du second. Il est également connu sous le nom de Module Python . En Python, le symbole du module est représenté sous forme de pourcentage ( % ) symbole. C’est pourquoi on l’appelle l’opérateur reste.

Syntaxe

Ce qui suit est la syntaxe qui représente l'opérateur de module en langage Python, elle est utilisée pour obtenir le reste lorsque l'on divise le premier nombre par le second.

décoder le javascript base64

 Rem = X % Y 

Ici, X et Y sont deux nombres entiers, et le module (%) est utilisé entre les deux pour obtenir le reste où le premier nombre (X) est divisé par le deuxième nombre (Y).

Par exemple, nous avons deux nombres, 24 et 5. Et nous pouvons obtenir le reste en utilisant l'opérateur module ou modulo entre les nombres 24 % 5. Ici, 24 est divisé par 5 qui renvoie 4 comme reste et 4 comme quotient. . Lorsque le premier nombre est complètement divisible par un autre nombre sans laisser de reste, le résultat sera 0. Par exemple, nous avons deux nombres, 20 et 5. Et nous pouvons obtenir le reste en utilisant l'opérateur module ou modulo entre les nombres 20. % 5. Ici, 20 est divisé par 5 qui renvoie 0 comme reste et 4 comme quotient.

Obtenez le module de deux nombres entiers en utilisant la boucle while

Écrivons un programme pour obtenir le reste de deux nombres en utilisant la boucle while et l'opérateur module (%) en 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 

Sortir:

 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 

Explication:

• while True : cela crée une boucle infinie. Le code à l’intérieur de la boucle continuera à s’exécuter jusqu’à ce que la boucle soit explicitement interrompue.
• a = input('Voulez-vous continuer ou non (O / N) ? ') : L'utilisateur est invité à saisir 'Y' ou 'N' pour décider s'il doit continuer ou quitter le programme.
• if a.upper() != 'Y' : break : Si l'utilisateur entre autre chose que 'Y' (insensible à la casse), la boucle est quittée et le programme se termine.
• a = int(input('Le premier numéro est : ')) et b = int(input('Le deuxième numéro est : ')) : L'utilisateur est invité à saisir deux nombres entiers.
• print('Le résultat après avoir effectué l'opérateur de module est : ', a, ' % ', b, ' = ', a % b) : Il calcule et imprime le résultat de l'opération de module (a % b) pour la première paire de numéros saisis.
• print('Le résultat après avoir effectué l'opérateur de module est :', b, ' % ', a, ' = ', b % a) : Il calcule et imprime le résultat de l'opération de module (b % a) pour la deuxième paire de numéros saisis.
• Le programme demandera à l'utilisateur la météo que nous voulons continuer ou nous voulons arrêter le programme en donnant l'entrée comme (O/N), ici Y est l'entrée pour continuer le programme et le « N » est utilisé pour arrêter le programme. .

Obtenez le module de deux nombres flottants

Écrivons un programme pour trouver le reste de deux nombres à virgule flottante en utilisant l'opérateur module en 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 = ' ') 

Sortir:

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

Explication:

• x = float(input('First number: ')) : Le client est invité à saisir un nombre flottant pour la variable principale et les informations sont rangées dans la variable x.
• y = float(input('Second number: ')) : Le client est invité à saisir un nombre flottant pour la variable suivante, et les informations sont rangées dans la variable y.
• res = x % y : L'activité du module est réalisée sur x et y, et le résultat est rangé dans la variable res.
• print('Le module de deux nombres flottants est : ', x, '%', y, ' = ', res, sep=' ') : La conséquence de l'activité du module est imprimée avec une disposition appropriée, en isolant les qualités par des espaces ( sep=' ').

Obtenir le module d'un nombre négatif

Écrivons un programme pour obtenir le reste de deux nombres négatifs en utilisant la boucle while et l'opérateur module (%) en Python.

algorithme pour bfs

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

Sortir:

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 

Explication:

• while True : crée un cercle sans fin. Le code à l'intérieur du cercle continuera à s'exécuter jusqu'à ce que le client choisisse de quitter en entrant une option différente de « Y » lorsqu'il y est invité.
• x = input('Devez-vous continuer (O/N) ? ') : Le client est incité à saisir 'Y' ou 'N' pour choisir de continuer ou de quitter le programme.
• if x.upper() != 'Y' : break : En supposant que le client entre quelque chose d'autre que 'Y' (sans tenir compte de la casse), le cercle est laissé et le programme se termine.
• x = int(input('First number: ')) et y = int(input('Second number: ')) : Le client est incité à saisir deux nombres entiers.
• print('Le module du nombre négatif est : ', x, '%', y, ' = ', x % y, sep=' ') : Il calcule et imprime l'effet secondaire de l'activité du module (x % y) pour les principaux ensembles de nombres saisis.
• print('Le module du nombre négatif est : ', y, '%', x, ' = ', y % x, sep=' ') : Il vérifie et imprime l'effet secondaire de l'activité du module (y % x) pour le deuxième série de nombres saisis.

Obtenez le module de deux nombres en utilisant la fonction fmod()

Écrivons un programme pour obtenir le reste de deux nombres flottants en utilisant la fonction fmod() en Python.

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) 

Sortir:

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 

Explication:

• import math : Cette ligne importe le module numérique, qui donne des capacités numériques, notamment fmod().
• res = math.fmod(25.5, 5.5) : la capacité math.fmod() est utilisée pour calculer le module de deux nombres de points dérivants (25,5 et 5,5 pour cette situation), et le résultat est rangé dans la variable res.
• print('Modulus using fmod() is:', res) : Cette ligne imprime le résultat de l'activité du module déterminé à l'aide de math.fmod().
• ft = math.fmod(75,5, 15,5) : comme le modèle principal, il détermine le module de deux nombres de points dérivants (75,5 et 15,5) et stocke le résultat dans la variable ft.
• print('Modulus using fmod() is:', ft) : Cette ligne imprime la conséquence de la deuxième activité de module.
• x = int(input('Le premier nombre est ')) et y = int(input('Le deuxième nombre est ')) : le client est invité à saisir deux nombres entiers, qui sont ensuite complètement transformés en nombres et rangés dans les facteurs x et y.
• out = math.fmod(x, y) : la capacité math.fmod() est à nouveau utilisée pour calculer le module des deux nombres saisis par le client, et le résultat est rangé dans la variable out.
• print('Le module de deux nombres utilisant la capacité fmod() est', x, ' % ', y, ' = ', out) : Cette ligne imprime l'effet de l'activité du module déterminé à l'aide de math.fmod() pour le client entré nombres entiers.

Obtenez le module de n nombres en utilisant la fonction

Écrivons un programme Python pour trouver le module du nombre n en utilisant la fonction et la boucle for.

getRemainder.py

liste java vide

 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) 

Sortir:

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 

Explication:

• def getRemainder(n, k) : Cette ligne caractérise une capacité nommée getRemainder qui prend deux limites (n et k).
• for I in range(1, n + 1) : Cette ligne commence par un cercle for qui met l'accent sur 1 à n (complet).
• rem = I % k : A l'intérieur du cercle, le reste de I partitionné par k est déterminé et rangé dans la variable rem.
• print(i, ' % ', k, ' = ', rem, sep=' ') : Cette ligne imprime la conséquence de l'activité du module pour chaque accent, montrant la valeur de I, le diviseur k et la partie restante déterminée .
• if __name__ == '__main__' : : Cette ligne vérifie si le contenu est exécuté en tant que programme principal.
• n = int(input('Définissez un nombre jusqu'à ce que vous deviez afficher le reste et k = int(input('Entrez le numéro suivant')) : Le client est invité à saisir deux nombres entiers, n et k.
• getRemainder(n, k) : la capacité getRemainder est appelée lorsque le client a donné des valeurs à n et k. La capacité élabore et imprime le reste de chaque cycle du cercle.

Obtenez le module d'un tableau donné en utilisant la fonction mod()

Écrivons un programme pour démontrer la fonction mod() en 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)) 

Sortir:

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

Explication:

• import numpy as np : cette ligne importe la bibliothèque NumPy et lui attribue le surnom np. NumPy est une bibliothèque puissante pour les tâches mathématiques en Python et propose des tâches d'exposition efficaces.
• x = np.array([40, - 25, 28, 35]) : crée un cluster NumPy nommé x avec les qualités prédéterminées.
• y = np.array([20, 4, 6, 8]) : crée un autre cluster NumPy nommé y avec les qualités prédéterminées.
• print('Le module du cluster donné est ', np.mod(x, y)) : appelle la capacité NumPy mod(), qui exécute une procédure de module par composant pour comparer les composants des pièces x et y. Le résultat est imprimé à l’aide de print().

Obtenez le module de deux nombres en utilisant numpy.

Considérons un programme pour importer un numpy package de la bibliothèque Python, puis utilisez la fonction reste pour obtenir le module en 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 

Sortir:

Modulus is 38 % 8 = 6 

Explication:

• import numpy as np : cette ligne importe la bibliothèque NumPy et lui attribue le surnom np.
• num = 38 : Introduit la variable num valant 38.
• num2 = 8 : Institue la variable num2 avec la valeur 8.
• res = np.remainder(num, num2) : appelle la capacité NumPy leftover portion(), qui vérifie que le reste de num est séparé par num2. Le résultat est rangé dans la variable res.
• print('Modulus is', num, ' % ', num2, ' = ', res) : imprime le résultat de l'activité du module à l'aide de print(). Il montre les avantages de num, num2 et la partie restante déterminée (res).

Exceptions dans l'opérateur Python Module

En Python, lorsqu'un nombre est divisé par zéro, une exception est levée, et l'exception est appelée le ErreurDivisionZéro . En d’autres termes, il renvoie une exception lorsqu’un nombre est divisible par un diviseur nul. Par conséquent, si nous voulons supprimer l’exception de l’opérateur de module Python, le diviseur ne doit pas être nul.

Écrivons un programme pour démontrer l'opérateur Python Exception in Module.

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

Sortir:

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

Impossible de diviser un nombre par zéro ! Alors, changez la valeur de l’opérande de droite.

Comme nous pouvons le voir dans le résultat ci-dessus, il affiche : « Impossible de diviser un nombre par zéro ! » Alors, changez la valeur de l'opérande de droite. Par conséquent, nous pouvons dire que lorsque nous divisons le premier nombre par zéro, cela renvoie une exception.

fonctionnalités de Java

Explication:

• x = int(input('Le premier nombre est : ')) et y = int(input('Le deuxième nombre est : ')) : le client est invité à saisir deux nombres entiers, qui sont ensuite complètement transformés en nombres entiers et rangés dans les facteurs x et y.
• tentative : Cela démarre le bloc de tentative où le code qui pourrait déclencher une exemption est défini.
• print(x, ' % ', y, ' = ', x % y) : à l'intérieur du bloc de tentative, le code s'efforce de déterminer et d'imprimer la conséquence de l'activité du module (x % y).
• à l'exception de ZeroDivisionError comme blunder :: Au cas où une ZeroDivisionError se produirait (c'est-à-dire, en supposant que le client entre zéro comme numéro suivant), le code à l'intérieur du bloc apart from est exécuté.
• print('Impossible de partitionner un nombre par rien ! ' + 'Ainsi, changez la valeur de l'opérande de droite.') : Cette ligne affiche un message d'erreur démontrant que la division par zéro n'est pas autorisée et propose de changer la valeur de l'opérande de droite. .