Como outras linguagens de programação, o operador módulo Python faz o mesmo trabalho para encontrar o módulo de um determinado número. O operador é um símbolo matemático usado para realizar diferentes operações, como (+, -, * /) adição, subtração, multiplicação e divisão nos dois números fornecidos para retornar o resultado na forma de um número inteiro, bem como o número flutuante . Um operador informa ao compilador para executar certas ações com base no símbolo do operador passado para o número fornecido.
Operador de Módulo
Pitão Operador Módulo é um operador embutido que retorna os números restantes dividindo o primeiro número do segundo. Também é conhecido como Módulo Python . Em Python, o símbolo do módulo é representado como a porcentagem ( % ) símbolo. Portanto, é chamado de operador de resto.
Sintaxe
A seguir está a sintaxe que representa o operador módulo na linguagem Python, ele é usado para obter o resto quando dividimos o primeiro número pelo segundo.
tipos de dados primitivos em java
Rem = X % Y
Aqui, X e Y são dois números inteiros, e o módulo (%) é usado entre eles para obter o resto onde o primeiro número (X) é dividido pelo segundo número (Y).
Por exemplo, temos dois números, 24 e 5. E podemos obter o resto usando o módulo ou operador de módulo entre os números 24% 5. Aqui 24 é dividido por 5 que retorna 4 como resto e 4 como quociente . Quando o primeiro número é completamente divisível por outro número sem deixar resto, o resultado será 0. Por exemplo, temos dois números, 20 e 5. E podemos obter o resto usando o módulo ou operador módulo entre os números 20 % 5. Aqui 20 é dividido por 5 que retorna 0 como resto e 4 como quociente.
Obtenha o módulo de dois números inteiros usando o loop while
Vamos escrever um programa para obter o restante de dois números usando o loop while e o operador módulo (%) em 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
Saída:
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
Explicação:
- while True: Isso cria um loop infinito. O código dentro do loop continuará em execução até que o loop seja explicitamente quebrado.
- a = input('Deseja continuar ou não (S/N)? '): O usuário é solicitado a inserir 'S' ou 'N' para decidir se deseja continuar ou sair do programa.
- if a.upper() != 'Y': break: Se o usuário inserir algo diferente de 'Y' (sem distinção entre maiúsculas e minúsculas), o loop será encerrado e o programa será encerrado.
- a = int(input('O primeiro número é: ')) e b = int(input('O segundo número é: ')): O usuário é solicitado a inserir dois números inteiros.
- print('O resultado após realizar o operador de módulo é: ', a, ' % ', b, ' = ', a % b): Calcula e imprime o resultado da operação de módulo (a % b) para o primeiro par de números inseridos.
- print('O resultado após realizar o operador de módulo é:', b, ' % ', a, ' = ', b % a): Calcula e imprime o resultado da operação de módulo (b % a) para o segundo par de números inseridos.
- O programa perguntará ao usuário se queremos continuar ou parar o programa, fornecendo uma entrada como (S/N), aqui Y é a entrada para continuar o programa e o 'N' é usado para interromper o programa .
Obtenha o módulo de dois números flutuantes
Vamos escrever um programa para encontrar o resto de dois números de ponto flutuante usando o operador módulo em Python.
Mod.py
método java
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 = ' ')
Saída:
First number: 40.5 Second number: 20.5 Modulus of two float number is: 40.5 % 20.5 = 20.0
Explicação:
- x = float(input('First number: ')): O cliente é provocado a inserir um número float para a variável primária, e a informação é guardada na variável x.
- y = float(input('Segundo número: ')): O cliente é solicitado a inserir um número flutuante para a variável subsequente, e a informação é guardada na variável y.
- res = x% y: A atividade do módulo é realizada em x e y, e o resultado é guardado na variável res.
- print('O módulo de dois números flutuantes é: ', x, '%', y, ' = ', res, sep=' '): A consequência da atividade do módulo é impressa com organização adequada, isolando as qualidades por espaços ( set=' ').
Obtenha o módulo de um número negativo
Vamos escrever um programa para obter o restante de dois números negativos usando o loop while e o operador módulo (%) em 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 = ' ')
Saída:
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
Explicação:
- while True: Faz um círculo sem fim. O código dentro do círculo continuará a ser executado até que o cliente opte por sair inserindo alguma opção diferente de 'Y' quando incitado.
- x = input('Você precisa continuar (S/N)? '): O cliente é incitado a inserir 'S' ou 'N' para escolher se deseja prosseguir ou sair do programa.
- if x.upper() != 'Y': break: Supondo que o cliente insira algo além de 'Y' (caso indiferente), o círculo é deixado e o programa termina.
- x = int(input('Primeiro número: ')) e y = int(input('Segundo número: ')): O cliente é incitado a inserir dois números inteiros.
- print('Módulo do número negativo é: ', x, '%', y, ' = ', x % y, sep=' '): Funciona e imprime o efeito posterior da atividade do módulo (x % y) para os principais conjuntos de números inseridos.
- print('O módulo do número negativo é: ', y, '%', x, ' = ', y % x, sep=' '): verifica e imprime o efeito posterior da atividade do módulo (y % x) para o segundos conjuntos de números inseridos.
Obtenha o módulo de dois números usando a função fmod()
Vamos escrever um programa para obter o restante de dois números flutuantes usando a função fmod() em 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)
Saída:
removendo da arraylist
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
Explicação:
- importar matemática: esta linha importa o módulo numérico, que fornece recursos numéricos, incluindo fmod().
- res = math.fmod(25,5, 5,5): O recurso math.fmod() é utilizado para calcular o módulo de dois números de ponto de deriva (25,5 e 5,5 para esta situação), e o resultado é armazenado na variável res.
- print('Módulo utilizando fmod() é:', res): Esta linha imprime o resultado da atividade do módulo determinada usando math.fmod().
- ft = math.fmod(75,5, 15,5): Como o modelo principal, ele verifica o módulo de dois números de ponto de deriva (75,5 e 15,5) e armazena o resultado na variável ft.
- print('Módulo utilizando fmod() é:', ft): Esta linha imprime a consequência da atividade do segundo módulo.
- x = int(input('O primeiro número é ')) e y = int(input('O segundo número é ')): O cliente é solicitado a inserir dois números inteiros, que são então transformados completamente em números e guardados nos fatores x e y.
- out = math.fmod(x, y): O recurso math.fmod() é utilizado novamente para calcular o módulo dos dois números inseridos pelo cliente, e o resultado é armazenado na variável out.
- print('O módulo de dois números utilizando o recurso fmod() é', x, ' % ', y, ' = ', out): Esta linha imprime o efeito posterior da atividade do módulo determinada utilizando math.fmod() para o cliente inserido números inteiros.
Obtenha o módulo de n números usando a função
Vamos escrever um programa Python para encontrar o módulo do número n usando a função e o loop for.
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)
Saída:
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
Explicação:
- def getRemainder(n, k): Esta linha caracteriza um recurso chamado getRemainder que assume dois limites (n e k).
- for I in range(1, n + 1):: Esta linha inicia um círculo for que enfatiza de 1 a n (abrangente).
- rem = I % k: Dentro do círculo, o resto de I particionado por k é determinado e guardado na variável rem.
- print(i, ' % ', k, ' = ', rem, sep=' '): Esta linha imprime a consequência da atividade do módulo para cada ênfase, mostrando o valor de I, o divisor k e a porção restante determinada .
- if __name__ == '__main__':: Esta linha verifica se o conteúdo está sendo executado como o programa primário.
- n = int(input('Defina um número até que você precise mostrar o resto e k = int(input('Digite o número subsequente ')): O cliente é solicitado a inserir dois números inteiros, n e k.
- getRemainder(n, k): O recurso getRemainder é chamado com o cliente fornecendo valores para n e k. A capacidade funciona e imprime o resto de cada ciclo do círculo.
Obtenha o módulo de determinado array usando a função mod()
Vamos escrever um programa para demonstrar a função mod() em 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))
Saída:
The modulus of the given array is [0 3 4 3]
Explicação:
- import numpy as np: esta linha importa a biblioteca NumPy e atribui a ela o apelido np. NumPy é uma biblioteca poderosa para tarefas matemáticas em Python e oferece tarefas de exibição eficazes.
- x = np.array([40, - 25, 28, 35]): Cria um cluster NumPy chamado x com as qualidades predeterminadas.
- y = np.array([20, 4, 6, 8]): Cria outro cluster NumPy chamado y com as qualidades predeterminadas.
- print('O módulo do cluster fornecido é ', np.mod(x, y)): Chama o recurso NumPy mod(), que executa o procedimento de módulo de componente na comparação de componentes das exposições x e y. O resultado é impresso utilizando print().
Obtenha o módulo de dois números usando numpy.
Vamos considerar um programa para importar um entorpecido pacote da biblioteca Python e, em seguida, use a função restante para obter o módulo em 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
Saída:
Modulus is 38 % 8 = 6
Explicação:
- import numpy as np: esta linha importa a biblioteca NumPy e atribui a ela o apelido np.
- num = 38: introduz a variável num com o valor 38.
- num2 = 8: Instala a variável num2 com valor 8.
- res = np.remainder(num, num2): Chama o recurso restante da parte() do NumPy, que verifica se o resto de num está separado por num2. O resultado é guardado na variável res.
- print('Modulus is', num, ' % ', num2, ' = ', res): Imprime o efeito posterior da atividade do módulo utilizando print(). Ele mostra as vantagens de num, num2 e a porção restante determinada (res).
Exceções no operador Python Modulus
Em Python, quando um número é dividido por zero, ele lança uma exceção, e a exceção é chamada de Erro ZeroDivision . Em outras palavras, retorna uma exceção quando um número é divisível por um divisor igual a zero. Portanto, se quisermos remover a exceção do operador módulo Python, o divisor não deve ser zero.
Vamos escrever um programa para demonstrar o operador Python Exception in Modulus.
exceto.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.')
Saída:
caractere para int em java
The first number is: 24 The second number is: 0
Não é possível dividir um número por zero! Portanto, altere o valor do operando certo.
Como podemos ver no resultado acima, é exibido: 'Não é possível dividir um número por zero! Então, altere o valor do operando certo'. Portanto, podemos dizer que quando dividimos o primeiro número por zero, ele retorna uma exceção.
Explicação:
- x = int(input('O primeiro número é: ')) e y = int(input('O segundo número é: ')): O cliente é solicitado a inserir dois números inteiros, que são então alterados completamente para números inteiros e colocados nos fatores x e y.
- try:: Inicia o bloco de tentativa onde é definido o código que pode gerar uma isenção.
- print(x, ' % ', y, ' = ', x % y): Dentro do bloco de tentativa, o código se esforça para verificar e imprimir a consequência da atividade do módulo (x % y).
- com exceção de ZeroDivisionError como erro:: Na eventualidade de ocorrer um ZeroDivisionError (ou seja, assumindo que o cliente insira zero como o número subsequente), o código dentro do bloco aparte é executado.
- print('Não é possível particionar um número por nada! ' + 'Assim, altere o valor do operando certo.'): Esta linha imprime uma mensagem de erro demonstrando que a divisão por zero não é permitida e propõe alterar o valor do operando certo .