Tāpat kā citas programmēšanas valodas, Python moduļu operators veic to pašu darbu, lai atrastu dotā skaitļa moduli. Operators ir matemātisks simbols, ko izmanto, lai veiktu dažādas darbības, piemēram, (+, -, * /) saskaitīšanu, atņemšanu, reizināšanu un dalīšanu ar dotajiem diviem skaitļiem, lai atgrieztu rezultātu vesela skaitļa formā, kā arī peldošo skaitli. . Operators liek kompilatoram veikt noteiktas darbības, pamatojoties uz norādītajam numuram nodoto operatora simbolu.
Moduļa operators
Python Modulus Operator ir iebūvēts operators, kas atgriež atlikušos skaitļus, dalot pirmo ciparu no otrā. Tas ir pazīstams arī kā Python modulis . Programmā Python moduļa simbols tiek attēlots procentos ( % ) simbols. Tāpēc to sauc par atlikuma operatoru.
Sintakse
Tālāk ir norādīta sintakse, kas attēlo moduļa operatoru Python valodā, to izmanto, lai iegūtu atlikumu, dalot pirmo skaitli ar otro.
jquery ar klikšķi
Rem = X % Y
Šeit X un Y ir divi veseli skaitļi, un modulis (%) tiek izmantots starp tiem, lai iegūtu atlikumu, kur pirmais skaitlis (X) tiek dalīts ar otro skaitli (Y).
Piemēram, mums ir divi skaitļi, 24 un 5. Un mēs varam iegūt atlikumu, izmantojot moduļa vai moduļa operatoru starp skaitļiem 24 % 5. Šeit 24 tiek dalīts ar 5, kas atgriež 4 kā atlikumu un 4 kā koeficientu. . Kad pirmais skaitlis ir pilnībā dalāms ar citu skaitli, neatstājot nevienu atlikumu, rezultāts būs 0. Piemēram, mums ir divi skaitļi, 20 un 5. Un mēs varam iegūt atlikumu, izmantojot modulis vai modulo operatoru starp skaitļiem 20. % 5. Šeit 20 tiek dalīts ar 5, kas atgriež 0 kā atlikumu un 4 kā koeficientu.
Iegūstiet divu veselu skaitļu skaitļu moduli, izmantojot cilpu while
Uzrakstīsim programmu, lai iegūtu atlikušo divu skaitļu daļu, izmantojot Python operatoru while un moduļa (%) operatoru.
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
Izvade:
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
Paskaidrojums:
- kamēr True: tas rada bezgalīgu cilpu. Cilpas iekšpusē esošais kods turpinās darboties, līdz cilpa tiks nepārprotami pārtraukta.
- a = input('Vai vēlaties turpināt vai nē (J / N)?'): Lietotājam tiek piedāvāts ievadīt 'Y' vai 'N', lai izlemtu, vai turpināt vai iziet no programmas.
- if a.upper() != 'Y': break: ja lietotājs ievada jebko, kas nav 'Y' (neatkarīgi no reģistriem), cilpa tiek aizvērta un programma tiek pārtraukta.
- a = int(input('Pirmais cipars ir:')) un b = int(input('Otrais cipars ir:')): lietotājam tiek piedāvāts ievadīt divus veselus skaitļus.
- print('Rezultāts pēc moduļa operatora izpildes ir: ', a, ' % ', b, ' = ', a % b): tas aprēķina un izdrukā moduļa darbības rezultātu (a % b) pirmajam pāri. ievadītie cipari.
- print('Rezultāts pēc moduļa operatora izpildes ir:', b, ' % ', a, ' = ', b % a): tas aprēķina un izdrukā moduļa operācijas rezultātu (b % a) otrajam pāri. ievadītie cipari.
- Programma jautās lietotāja laika ziņas, kuras mēs vēlamies turpināt vai mēs vēlamies apturēt programmu, ievadot ievadi, piemēram, (J/N), šeit Y ir ievade, lai turpinātu programmu, un 'N' tiek izmantots, lai apturētu programmu. .
Iegūstiet divu peldošo skaitļu moduli
Uzrakstīsim programmu, lai atrastu atlikušo divu peldošā komata skaitļu daļu, izmantojot Python moduļa operatoru.
Mod.py
ievietošanas pitons
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 = ' ')
Izvade:
First number: 40.5 Second number: 20.5 Modulus of two float number is: 40.5 % 20.5 = 20.0
Paskaidrojums:
- x = float(input('Pirmais numurs: ')): Klients tiek mudināts ievadīt primārā mainīgā mainīgo skaitli, un informācija tiek ievietota mainīgajā x.
- y = float(input('Otrais numurs: ')): Klients tiek mudināts ievadīt peldošo skaitli nākamajam mainīgajam, un informācija tiek ievietota mainīgajā y.
- res = x % y: moduļa aktivitāte tiek veikta x un y, un rezultāts tiek ievietots mainīgajā res.
- print('Divu peldošo skaitļu modulis ir: ', x, '%', y, ' = ', res, sep=' '): Moduļa aktivitātes rezultāts tiek izdrukāts ar pareizu izkārtojumu, īpašības izolējot ar atstarpēm ( sep='').
Iegūstiet negatīva skaitļa moduli
Uzrakstīsim programmu, lai iegūtu atlikušo divu negatīvo skaitļu daļu, izmantojot Python operatoru while cilpa un modulis (%).
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 = ' ')
Izvade:
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
Paskaidrojums:
- kamēr True: veido bezgalīgu loku. Kods apļa iekšpusē turpinās darboties, līdz klients izvēlēsies iziet, ievadot citu opciju no “Y”, kad tas tiek pamudināts.
- x = input('Vai jums ir jāturpina (J/N)?'): Klients tiek mudināts ievadīt 'Y' vai 'N', lai izvēlētos, vai turpināt vai iziet no programmas.
- if x.upper() != 'Y': break: Pieņemot, ka klients ievada kaut ko papildus 'Y' (neatkarīgi no reģistra), aplis tiek atstāts un programma beidzas.
- x = int(input('Pirmais cipars:')) un y = int(input('Otrais cipars:')): Klients tiek mudināts ievadīt divus veselus skaitļus.
- print('Negatīvā skaitļa modulis ir: ', x, '%', y, ' = ', x % y, sep=' '): Tas nostrādā un izdrukā moduļa aktivitātes (x % y) pēcefektu ievadītās primārās skaitļu kopas.
- print('Negatīvā skaitļa modulis ir: ', y, '%', x, ' = ', y % x, sep=' '): tas nosaka un izdrukā moduļa aktivitātes (y % x) sekas otrās ievadītās skaitļu kopas.
Iegūstiet divu skaitļu moduli, izmantojot funkciju fmod ().
Uzrakstīsim programmu, lai iegūtu atlikušo divu peldošo skaitļu daļu, izmantojot Python funkciju fmod().
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)
Izvade:
java šķēle
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
Paskaidrojums:
- importēt matemātiku: šī rinda importē skaitlisko moduli, kas nodrošina skaitliskās iespējas, tostarp fmod().
- res = math.fmod(25.5, 5.5): iespēja math.fmod() tiek izmantota, lai aprēķinātu divu dreifējošu punktu skaitļu moduli (25.5 un 5.5 šai situācijai), un rezultāts tiek ievietots mainīgajā res.
- print('Modulus izmantojot fmod() is:', res): Šī rinda drukā moduļa aktivitātes pēcefektu, kas noteikts, izmantojot math.fmod().
- ft = math.fmod(75.5, 15.5): tāpat kā galvenais modelis, tas nosaka divu dreifējošu punktu skaitļu moduli (75.5 un 15.5) un saglabā rezultātu mainīgajā ft.
- print ('Modulus izmantojot fmod() ir:', ft): šī rinda drukā otrās moduļa aktivitātes sekas.
- x = int(input('Pirmais cipars ir')) un y = int(input('Otrais cipars ir ')): Klients tiek pamudināts ievadīt divus veselus skaitļus, kas pēc tam tiek pilnībā pārveidoti par skaitļiem un nolikti. faktoros x un y.
- out = math.fmod(x, y): iespēja math.fmod() tiek izmantota vēlreiz, lai aprēķinātu divu klienta ievadīto skaitļu moduli, un rezultāts tiek ievietots mainīgajā out.
- print('Divu skaitļu modulis, izmantojot fmod() iespēju ir', x, ' % ', y, ' = ', out): šī rinda drukā moduļa aktivitātes, kas noteikta, izmantojot math.fmod() ievadīto klientu, sekas. veseli skaitļi.
Izmantojot funkciju, iegūstiet n skaitļu moduli
Uzrakstīsim Python programmu, lai atrastu n skaitļa moduli, izmantojot funkciju un for cilpu.
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)
Izvade:
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
Paskaidrojums:
- def getRemainder(n, k): šī rinda raksturo iespēju ar nosaukumu getRemainder, kurai ir divas robežas (n un k).
- I diapazonā (1, n + 1): Šī rinda sākas ar apli, kas uzsver no 1 līdz n (visaptveroši).
- rem = I % k: Apļa iekšpusē tiek noteikts pārējais I, kas sadalīts ar k, un novietots mainīgajā rem.
- print(i, ' % ', k, ' = ', rem, sep=' '): šī rinda drukā moduļa aktivitātes sekas katram uzsvaram, parādot I vērtību, dalītāju k un noteikto atlikušo daļu .
- if __name__ == '__main__':: Šī rinda pārbauda, vai saturs tiek palaists kā galvenā programma.
- n = int(input('Definējiet skaitli, līdz jums ir jāparāda pārējais un k = int(input('Ievadiet nākamo skaitli')): Klients tiek mudināts ievadīt divus veselus skaitļus: n un k.
- getRemainder(n, k): GetRemainder iespēja tiek izsaukta, klients piešķīra vērtības n un k. Iespēja darbojas un izdrukā atlikušo katra apļa cikla daļu.
Iegūstiet dotā masīva moduli, izmantojot funkciju mod ().
Uzrakstīsim programmu mod() funkcijas demonstrēšanai 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))
Izvade:
The modulus of the given array is [0 3 4 3]
Paskaidrojums:
- importēt numpy kā np: šī rinda importē NumPy bibliotēku un piešķir tai nosaukumu np. NumPy ir spēcīga Python matemātisko uzdevumu bibliotēka, un tā nodrošina efektīvus eksponēšanas uzdevumus.
- x = np.array([40, - 25, 28, 35]): izveido NumPy kopu ar nosaukumu x ar iepriekš noteiktām īpašībām.
- y = np.array([20, 4, 6, 8]): izveido citu NumPy kopu ar nosaukumu y ar iepriekš noteiktām īpašībām.
- print('Dotā klastera modulis ir ', np.mod(x, y)): izsauc NumPy mod() iespēju, kas veic komponentu moduļa procedūru, lai salīdzinātu eksponātu x un y komponentus. Rezultāts tiek izdrukāts, izmantojot print ().
Iegūstiet divu skaitļu moduli, izmantojot numpy.
Apskatīsim programmu importēšanai a nejutīgs pakotni no Python bibliotēkas un pēc tam izmantojiet atlikušo funkciju, lai iegūtu moduli 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
Izvade:
Modulus is 38 % 8 = 6
Paskaidrojums:
- importēt numpy kā np: šī rinda importē NumPy bibliotēku un piešķir tai nosaukumu np.
- num = 38: ievieš mainīgo num ar vērtību 38.
- num2 = 8: norāda mainīgo num2 ar vērtību 8.
- res = np.remainder(num, num2): izsauc NumPy atlikušās daļas() iespēju, kas nodrošina, ka pārējais skaitlis ir atdalīts ar num2. Rezultāts tiek ievietots mainīgajā res.
- print('Modulus is', num, ' % ', num2, ' = ', res): izdrukā moduļa aktivitātes pēcefektu, izmantojot print(). Tas parāda skaitli num, num2 un noteikto atlikušo daļu (res).
Izņēmumi Python Modulus operatorā
Python, kad skaitlis tiek dalīts ar nulli, tas rada izņēmumu, un izņēmumu sauc par ZeroDivision Error . Citiem vārdiem sakot, tas atgriež izņēmumu, ja skaitlis dalās ar dalītāju, kas ir nulle. Tāpēc, ja mēs vēlamies noņemt izņēmumu no Python moduļa operatora, dalītājs nedrīkst būt nulle.
Uzrakstīsim programmu Python izņēmuma demonstrēšanai Modulus operatorā.
izņemot.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.')
Izvade:
cik daudz pilsētu ASV
The first number is: 24 The second number is: 0
Skaitli nevar dalīt ar nulli! Tātad, mainiet labā operanda vērtību.
Kā redzams iepriekš minētajā rezultātā, tas parāda: “Ciparu nevar dalīt ar nulli! Tātad, mainiet labā operanda vērtību'. Tādējādi mēs varam teikt, ka dalot pirmo skaitli ar nulli, tas atgriež izņēmumu.
Paskaidrojums:
- x = int(input('Pirmais cipars ir:')) un y = int(input('Otrais cipars ir:')): Klients tiek pamudināts ievadīt divus veselus skaitļus, kas pēc tam tiek pilnībā mainīti uz veselus skaitļus un ielieciet faktoros x un y.
- mēģinājums:: Tiek sākts mēģinājumu bloks, kurā tiek iestatīts kods, kas varētu radīt atbrīvojumu.
- print(x, ' % ', y, ' = ', x % y): mēģinājuma blokā kods cenšas noskaidrot un izdrukāt moduļa aktivitātes (x % y) sekas.
- izņemot ZeroDivisionError kā kļūdu:: Ja notiek ZeroDivisionError (t.i., pieņemot, ka klients ievada nulli kā nākamo skaitli), tiek izpildīts kods, kas atrodas malā no bloka.
- print('Nevar sadalīt skaitli ar neko! ' + 'Tādējādi mainiet labā operanda vērtību.'): Šī rinda drukā kļūdas ziņojumu, kas parāda, ka dalīšana ar nulli nav atļauta, un ierosina mainīt labā operanda vērtību. .