Float modulo python что это

Python Modulo – % Operator, math.fmod() Examples

Python modulo operator (%) is used to get the remainder of a division. The modulo operation is supported for integers and floating point numbers.

If both “a” and “b” are integers, then the remainder is also an integer. If one of them is float, the result is also a floating point number.

Python Module Operator Example

Let’s look at some examples of modulo operator.

1. Modulo with integers

2. Modulo with float

3. Modulo with user inputs

When we get the user entered data, it’s in the form of string. We are using the float() built-in function to convert them to floating point number. That’s why the remainder is 1.0 and not 1.

4. ZeroDivisionError Example

5. Modulo with Negative Numbers

Python modulo operator always return the remainder having the same sign as the divisor. This can lead to some confusion with the output.

6. Python Modulo math.fmod()

The behavior of % operator with negative numbers is different from the platform C library. If you want the modulo operation to behave like C programming, you should use math module fmod() function. This is the recommended function for getting modulo with floating point numbers.

Overloading Modulo Operator

We can overload modulo operator by implementing __mod__() function in our class definition.

Output:

Quick word on Floating Point Arithmetic Issues

We use binary format to store values in computers. When it comes to fractions, most of the times we can’t represent them exactly as binary fractions. For example, 1/3 can’t be represented in exact binary format and it will always be an approximate value.

That’s why you can get unexpected results when performing arithmetic operations with floating point numbers. It’s clear from the output of below modulo operations.

The output should be 0 because 3.2*3 is 9.6. But, the float fraction values are not exactly represented and the approximation is causing this error. It’s clear from this example too.

So, you should give extra care when working with floating point numbers. It’s advisable to perform a rounding and then only compare two floating point numbers.

Источник

Оператор Modulo Python (%) используется для того, чтобы получить оставшуюся часть подразделения. Операция по модулю поддерживается для целых чисел и плавающих точек.

Оператор Modulo Python (%) используется для того, чтобы получить оставшуюся часть подразделения. Операция по модулю поддерживается для целых чисел и плавающих точек.

Синтаксис модульного оператора – % b Отказ Здесь «A» – это дивиденды и «Б» – это делитель. Выход – остаток, когда A разделен на б.

Если оба «а» и «B» являются целыми числами, то остаток также является целым числом. Если один из них плавает, результат также имеет номер с плавающей запятой.

Пример оператора модуля Python

Давайте посмотрим на несколько примеров модульного оператора.

1. Модуло с целыми числами

2. Модуло с поплавком

3. Модуло с пользовательскими входами

Когда мы получаем введенные данные, это в форме строки. Мы используем встроенную функцию float (), чтобы преобразовать их в номер с плавающей запятой. Вот почему остаток составляет 1,0, а не 1.

Рекомендуется читать : Функция ввода Python ()

4. Пример ZerodivisionError

Если делитель 0, оператор модуля бросит ZerodivisionError Отказ Мы можем использовать попробуйте за исключением блока Чтобы поймать ошибку.

5. Модуло с отрицательными числами

Оператор Modulo Python всегда возвращает остаток, имеющий тот же знак, что и делитель. Это может привести к некоторой путанице с выходом.

6. Python Modulo Math.fmod ()

Поведение% оператора с отрицательными числами отличается от библиотеки платформы C. Если вы хотите, чтобы операция по модулю вести себя как программирование C, вы должны использовать функцию Math Module FMOD (). Это рекомендуемая функция для получения модуля с номерами плавающих точек.

Перегрузка модульного оператора

Мы можем перегружать оператор модуло, реализуя __mod __ () Функция в нашем классе определение.

Быстрое слово о арифметических проблемах с плавающей точкой

Мы используем двоичный формат для хранения значений на компьютерах. Когда дело доходит до фракций, большую часть времени мы не можем представлять их именно в качестве двоичных фракций. Например, 1/3 не может быть представлен в точном двоичном формате, и он всегда будет приблизительным значением.

Вот почему вы можете получить неожиданные результаты при выполнении арифметических операций с номерами плавающих точек. Это ясно из выхода ниже модульных операций.

Вывод должен быть 0, потому что 3.2 * 3 – 9,6. Но значения фракции поплавка не точно представлены, и приближение вызывает эту ошибку. Это ясно из этого примера тоже.

Итак, вы должны дать дополнительную помощь при работе с цифрами плавающих точек. Целесообразно выполнять округление, а затем только сравнивать две числа плавающих точек.

Источник

Оператор модуля: modulo Python – примеры получения остатка

Оператор указывает компилятору выполнить определенные действия на основе переданного символа оператора для данного числа.

Оператор модуля

Оператор модуля Python – это встроенный оператор, который возвращает оставшиеся числа путем деления первого числа на второе. Он также известен как Python modulo. В Python символ модуля представлен в виде символа процента(%). И называется он оператором остатка.

Ниже приведен синтаксис для получения остатка путем деления первого числа на второе.

Здесь X и Y – два целых числа, а модуль(%) используется между ними, чтобы получить остаток, где первое число(X) делится на второе число(Y).

Например, у нас есть два числа, 24 и 5. И мы можем получить остаток, используя модуль или оператор по модулю между числами 24% 5. Здесь 24 делится на 5, что возвращает 4 в качестве остатка и 4 в качестве частного. Когда первое число полностью делится на другое число, не оставляя остатка, результатом будет 0.

Получение остатка двух целых чисел с помощью цикла while

Давайте напишем программу для получения остатка от двух чисел, используя цикл while и оператор модуля(%) в Python.

Остаток двух чисел с плавающей запятой

Напишем программу, чтобы найти остаток от двух целых чисел, используя оператор модуля в Python.

Отрицательного числа

Давайте напишем программу, чтобы получить остаток от двух отрицательных чисел, используя цикл while и оператор модуля(%) в Python.

Нахождение остатка двух чисел с помощью функции fmod()

Рассмотрим программу, как получить остаток от двух чисел с плавающей запятой, используя функцию fmod() в Python.

n чисел с помощью функции

Давайте напишем программу на Python, чтобы найти модуль n чисел с помощью функции и цикла for.

Заданного массива с помощью функции mod()

Напишем программу для демонстрации функции mod() в Python.

Как мы видим в приведенной выше программе, переменные x и y содержат массивы. После этого мы используем функцию mod() для передачи x и y в качестве параметра массива, который делит первый массив(x) на второй массив(y), а затем возвращает остаток чисел.

Нахождение модуля двух чисел, используя numpy

Давайте рассмотрим программу для импорта пакета numpy из библиотеки Python, а затем воспользуемся функцией остатка для получения модуля в Python.

Исключения в операторе модуля Python

В Python, когда число делится на ноль, возникает исключение, которое называется ZeroDivisionError. Другими словами, он возвращает исключение, когда число делится на делитель, равный нулю. Следовательно, если мы хотим удалить исключение из оператора модуля Python, делитель не должен быть равен нулю.

Напишем программу для демонстрации оператора Python Exception in Modulus.

Как видно из приведенного выше результата, он отображает: «Невозможно разделить число на ноль! Поэтому измените значение правого операнда». Следовательно, мы можем сказать, что когда мы делим первое число на ноль, оно возвращает исключение.

Источник

Python Modulo in Practice: How to Use the % Operator

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Python Modulo: Using the % Operator

Python supports a wide range of arithmetic operators that you can use when working with numbers in your code. One of these operators is the modulo operator ( % ), which returns the remainder of dividing two numbers.

In this tutorial, you’ll learn:

The Python modulo operator can sometimes be overlooked. But having a good understanding of this operator will give you an invaluable tool in your Python tool belt.

Free Bonus: Click here to get a Python Cheat Sheet and learn the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.

Modulo in Mathematics

The term modulo comes from a branch of mathematics called modular arithmetic. Modular arithmetic deals with integer arithmetic on a circular number line that has a fixed set of numbers. All arithmetic operations performed on this number line will wrap around when they reach a certain number called the modulus.

A classic example of modulo in modular arithmetic is the twelve-hour clock. A twelve-hour clock has a fixed set of values, from 1 to 12. When counting on a twelve-hour clock, you count up to the modulus 12 and then wrap back to 1. A twelve-hour clock can be classified as “modulo 12,” sometimes shortened to “mod 12.”

The modulo operator is used when you want to compare a number with the modulus and get the equivalent number constrained to the range of the modulus.

For example, say you want to determine what time it would be nine hours after 8:00 a.m. On a twelve-hour clock, you can’t simply add 9 to 8 because you would get 17. You need to take the result, 17, and use mod to get its equivalent value in a twelve-hour context:

Now, if you think about it, 17 and 5 are equivalent in a mod 12 context. If you were to look at the hour hand at 5:00 and 17:00, it would be in the same position. Modular arithmetic has an equation to describe this relationship:

You can confirm this using division:

Python Modulo Operator Basics

Modulo Operator With int

Most of the time you’ll use the modulo operator with integers. The modulo operator, when used with two positive integers, will return the remainder of standard Euclidean division:

Be careful! Just like with the division operator ( / ), Python will return a ZeroDivisionError if you try to use the modulo operator with a divisor of 0 :

Modulo Operator With float

An alternative to using a float with the modulo operator is to use math.fmod() to perform modulo operations on float values:

Just like other arithmetic operators, the modulo operator and math.fmod() may encounter rounding and precision issues when dealing with floating-point arithmetic:

Modulo Operator With a Negative Operand

All modulo operations you’ve seen up to this point have used two positive operands and returned predictable results. When a negative operand is introduced, things get more complicated.

As it turns out, the way that computers determine the result of a modulo operation with a negative operand leaves ambiguity as to whether the remainder should take the sign of the dividend (the number being divided) or the sign of the divisor (the number by which the dividend is divided). Different programming languages handle this differently.

For example, in JavaScript, the remainder will take the sign of the dividend:

There are three variables this equation:

floor() in this equation means that it uses floor division. With positive numbers, floor division will return the same result as truncated division. But with a negative number, floor division will round the result down, away from zero:

Now that you understand where the difference in the remainder comes from, you may be wondering why this matters if you only use Python. Well, as it turns out, not all modulo operations in Python are the same. While the modulo used with the int and float types will take the sign of the divisor, other types will not.

Modulo Operator and divmod()

Below is an example of using divmod() with 37 and 5 :

Now that you’ve had a chance to see the modulo operator used in several scenarios, it’s important to take a look at how Python determines the precedence of the modulo operator when used with other arithmetic operators.

Modulo Operator Precedence

Like other Python operators, there are specific rules for the modulo operator that determine its precedence when evaluating expressions. The modulo operator ( % ) shares the same level of precedence as the multiplication ( * ), division ( / ), and floor division ( // ) operators.

Take a look at an example of the modulo operator’s precedence below:

Both the multiplication and modulo operators have the same level of precedence, so Python will evaluate them from left to right. Here are the steps for the above operation:

If you want to override the precedence of other operators, then you can use parentheses to surround the operation you want to be evaluated first:

Python Modulo Operator in Practice

Now that you’ve gone through the basics of the Python modulo operator, you’ll look at some examples of using it to solve real-world programming problems. At times, it can be hard to determine when to use the modulo operator in your code. The examples below will give you an idea of the many ways it can be used.

How to Check if a Number Is Even or Odd

Take a look at is_even() which checks to see if the num parameter is even:

Here num % 2 will equal 0 if num is even and 1 if num is odd. Checking against 0 will return a Boolean of True or False based on whether or not num is even.

Checking for odd numbers is quite similar. To check for an odd number, you invert the equality check:

The answer to this question is yes and no. Technically, this function will work with the way Python calculates modulo with integers. That said, you should avoid comparing the result of a modulo operation with 1 as not all modulo operations in Python will return the same remainder.

You can see why in the following examples:

In the next section, you’ll take a look at how you can use the modulo operator with loops to control the flow of your program.

How to Run Code at Specific Intervals in a Loop

With the Python modulo operator, you can run code at specific intervals inside a loop. This is done by performing a modulo operation with the current index of the loop and a modulus. The modulus number determines how often the interval-specific code will run in the loop.

Before breaking down the function in more detail, take a look at it in action:

Without getting into too much detail, the :-^15 syntax tells print() to do the following:

Now that the name has been printed to the row, take a look at the main part of split_names_into_rows() :

The above code is only one example. Using the pattern index % modulus == 0 allows you to run different code at specific intervals in your loops. In the next section, you’ll take this concept a bit further and look at cyclic iteration.

How to Create Cyclic Iteration

Cyclic iteration describes a type of iteration that will reset once it gets to a certain point. Generally, this type of iteration is used to restrict the index of the iteration to a certain range.

You can use the modulo operator to create cyclic iteration. Take a look at an example using the turtle library to draw a shape:

The important parts of this code are highlighted below:

You can see the steps of the iteration below for more clarification:

How to Convert Units

In this section, you’ll look at how you can use the modulo operator to convert units. The following examples take smaller units and convert them into larger units without using decimals. The modulo operator is used to determine any remainder that may exist when the smaller unit isn’t evenly divisible by the larger unit.

In this first example, you’ll convert inches into feet. The modulo operator is used to get the remaining inches that don’t evenly divide into feet. The floor division operator ( // ) is used to get the total feet rounded down:

Here’s an example of the function in use:

Breaking this down, you can see that the function does the following:

You can see how it works below:

While the above examples only deal with converting inches to feet and minutes to days, you could use any type of units with the modulo operator to convert a smaller unit into a larger unit.

Note: Both of the above examples could be modified to use divmod() to make the code more succinct. If you remember, divmod() returns a tuple containing the results of floor division and modulo using the supplied parameters.

Below, the floor division and modulo operators have been replaced with divmod() :

If you try this updated function, then you’ll receive the same results as before:

You receive the same outcome, but now the code is more concise. You could update convert_minutes_to_days() as well:

Using divmod() isn’t necessary for all situations, but it makes sense here as the unit conversion calculations use both floor division and modulo.

Now that you’ve seen how to use the modulo operator to convert units, in the next section you’ll look at how you can use the modulo operator to check for prime numbers.

How to Determine if a Number Is a Prime Number

The code below is an implementation for determining the primality of a number using the modulo operator:

Note: The above code isn’t the most efficient way to check for prime numbers. If you’re interested in digging deeper, then check out the Sieve of Eratosthenes and Sieve of Atkin for examples of more performant algorithms for finding prime numbers.

Before you look more closely at the function, here are the results using some different numbers:

Here’s the main part of the function:

There’s a lot to unpack here, so let’s take it step by step.

Inside the while loop, the modulo operator checks if num is evenly divisible by i :

Once the while loop is complete, the code checks to see if any additional factors were found:

If more than one tuple exists in the factors list, then num can’t be a prime number. For nonprime numbers, the factors are printed out. For prime numbers, the function prints a message stating that num is a prime number.

How to Implement Ciphers

The Python modulo operator can be used to create ciphers. A cipher is a type of algorithm for performing encryption and decryption on an input, usually text. In this section, you’ll look at two ciphers, the Caesar cipher and the Vigenère cipher.

Caesar Cipher

The first cipher that you’ll look at is the Caesar cipher, named after Julius Caesar, who used it to secretly communicate messages. It’s a substitution cipher that uses letter substitution to encrypt a string of text.

The Caesar cipher works by taking a letter to be encrypted and shifting it a certain number of positions to the left or right in the alphabet. Whichever letter is in that position is used as the encrypted character. This same shift value is applied to all characters in the string.

Decrypting the cipher is done by reversing the shift. Both the encryption and decryption processes can be described with the following expressions, where char_index is the index of the character in the alphabet:

This cipher uses the modulo operator to make sure that, when shifting a letter, the index will wrap around if the end of the alphabet is reached. Now that you know how this cipher works, take a look at an implementation:

decrypt is included so that a single function can be used to handle both encryption and decryption. This implementation can handle only alphabetic characters, so the function first checks that text is an alphabetic character in the ASCII encoding:

The function then defines three variables to store the lowercase ASCII characters, the uppercase ASCII characters, and the results of the encryption or decryption:

Finally, caesar_cipher() loops over the individual characters in text and performs the following actions for each char :

After the loop finishes iterating over the text value, the result is returned:

Here’s the full code again:

Now run the code in the Python REPL using the text meetMeAtOurHideOutAtTwo with a shift of 10 :

The Caesar cipher is fun to play around with for an introduction to cryptography. While the Caesar cipher is rarely used on its own, it’s the basis for more complex substitution ciphers. In the next section, you’ll look at one of the Caesar cipher’s descendants, the Vigenère cipher.

Vigenère Cipher

The Vigenère cipher is a polyalphabetic substitution cipher. To perform its encryption, it employs a different Caesar cipher for each letter of the input text. The Vigenère cipher uses a keyword to determine which Caesar cipher should be used to find the cipher letter.

You can see an example of the encryption process in the following image. In this example, the input text REALPYTHON is encrypted using the keyword MODULO :

Below is an implementation of the Vigenère cipher. As you’ll see, the modulo operator is used twice in the function:

You may have noticed that the signature for vigenere_cipher() is quite similar to caesar_cipher() from the previous section:

In the above code, you can see the function’s first use of the modulo operator:

For each letter of the input text, several steps determine how to encrypt or decrypt it:

Take a look at these steps in the code below:

You can see that the indices for decryption and encryption are calculated differently. That’s why decrypt is used in this function. This way, you can use the function for both encryption and decryption.

After the index is determined, you find the function’s second use of the modulo operator:

Here’s the full code the Vigenère cipher again:

Now go ahead and run it in the Python REPL:

Nice! You now have a working Vigenère cipher for encrypting text strings.

Python Modulo Operator Advanced Uses

Using the Python Modulo Operator With decimal.Decimal

Here are some examples of using whole integers with decimal.Decimal and the modulo operator:

Here are some floating-point numbers used with decimal.Decimal and the modulo operator:

Take a look at the examples below comparing the results of using the modulo operator with standard int and float values and with decimal.Decimal :

As you can see from the above examples, working with decimal.Decimal and the modulo operator is similar to working with other numeric types. You just need to keep in mind how it determines the sign of the result when working with a negative operand.

In the next section, you’ll look at how you can override the modulo operator in your classes to customize its behavior.

Using the Python Modulo Operator With Custom Classes

For this example, you’ll be working with a Student class. This class will track the amount of time a student has studied. Here’s the initial Student class:

Now, if you remember from the converting units section above, convert_minutes_to_day() used the Python modulo operator to convert total_mins into days, hours, and minutes. You’ll now implement a modified version of that method to see how you can use your custom class with the modulo operator:

You can use this function with the Student class to display the total hours a Student has studied. Combined with the Student class above, the code will look like this:

If you load this module in the Python REPL, then you can use it like this:

Here’s how you can modify the Student class to simplify the code:

Here’s the full code after modifications:

Now, calling the code in the Python REPL, you can see it’s much more succinct:

Conclusion

At first glance, the Python modulo operator may not grab your attention. Yet, as you’ve seen, there’s so much to this humble operator. From checking for even numbers to encrypting text with ciphers, you’ve seen many different uses for the modulo operator.

In this tutorial, you’ve learned how to:

With the knowledge you’ve gained in this tutorial, you can now start using the modulo operator in your own code with great success. Happy Pythoning!

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Python Modulo: Using the % Operator

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About Jason Van Schooneveld

Jason is a software developer based in Taipei. When he’s not tinkering with electronics or building Django web apps, you can find him hiking the mountains of Taiwan or brushing up on his Chinese.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas:

Master Real-World Python Skills
With Unlimited Access to Real Python

Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas:

Real Python Comment Policy: The most useful comments are those written with the goal of learning from or helping out other readers—after reading the whole article and all the earlier comments. Complaints and insults generally won’t make the cut here.

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Related Tutorial Categories: basics python

Источник