Как округлить double в java
Округление в Java
В Java есть целочисленные типы данных (long, int, char, short, byte) и есть типы с плавающей точкой (float, double), а по-русски — «с плавающей запятой» . Преобразование значений с дробной частью в целочисленные полезно для упрощения вычислений, последующего чтения и для сокращения объемов используемой памяти. Сделать это можно так:
Однако полученный результат может отличаться от ожидаемого. В частности, в данном случае y будет равно 5, несмотря на то, что по всем правилам округления должно быть 6. Чтобы избежать этой многозначности, можно воспользоваться «дедовским» способом, без привязки к возможностям языка.
Однако данная форма записи имеет множество недостатков, от неправильного результата в частных ситуациях до неудобочитаемой записи в целом. Классический метод округления до целого — round. Допустим, дано число n. Тогда для округления запишем:
Если n имеет дробную часть менее 0,5, то число округляется в меньшую сторону, в противном случае — в большую.
То есть стандартный математический алгоритм.
Если же вам требуется java округление в меньшую сторону — вместо дополнительной математической операции лучше сразу воспользоваться готовой функций FLOOR:
Java округление в большую сторону выполняется методом CEIL:
Как и в жизни, округлять можно не только до целого числа, но и до определенного знака после запятой. Как и в первом случае, в java округление до сотых можно сделать чисто математически:
Однако запись не слишком удобна, если вам требуется в java округление до плавающего числа знаков с заданным поведением. С помощью методов перечисления RoundingMode() у вас есть такая возможность. Методы следующие:
- UP — округление в сторону большего числа для положительных чисел и меньшего для отрицательных.
- DOWN — округление в сторону меньшего числа для положительных чисел и большего для отрицательных.
- CEILING — округление в сторону большего и для положительных, и для отрицательных чисел.
- FLOOR — округление в сторону меньшего и для положительных, и для отрицательных чисел.
- HALF_UP — округление в большую сторону в случае числа вида 0.5;
- HALF_DOWN — округление в меньшую сторону в случае числа вида 0.5;
- HALF_EVEN — классическое округление
Выглядит подобное округление чисел так:
Цифра в скобках указывает в java округление до 2 знаков double типа.
Специальные методы округления java позволяют разработчику решить любую задачу, не прибегая к грубым мультиязычным способам, содержащим ограничения и ошибки.
Округление чисел в Java
Числа с плавающей точкой (float, double) применяются при вычислении выражений, в которых требуется точность до десятичного знака. Высокая точность часто нужна в бухгалтерских и других вычислительных операциях. Но всегда ли нам нужен длинный “хвост” чисел после запятой? Может нам достаточно точности в три знака вещественной части? И есть нас такой вариант устраивает, как правильно выполнить округление? Именно об этом мы сегодня и поговорим: рассмотрим способы округления чисел в Java .
String format
В качестве первого способа мы рассмотрим округление double: В результате мы отформатируем наше число с плавающей запятой 34766674 с точностью до 3 десятичных разрядов , так как в инструкции для форматирования мы указали три знака после запятой «%.3f. В свою очередь %f при форматировании строки обозначает тип чисел с плавающей запятой, которое включает в себя тип данных double и float в Java. В примере выше мы выводили полученное значение в консоль. Теперь вопрос: как бы можно было это сократить? Все просто: нужно использовать printf, который в свою очередь является format + print. В итоге предыдущий пример у нас сократился бы до: У экземпляра out класса PrintStream помимо этого метода есть ещё метод format, который работает аналогично: Округление происходит по режиму HALF_UP — в сторону числа, которое ближе к обрезаемому (к 0 или 10). Если же эти числа равноудалены (в случае с 5), то округление выполняется в большую сторону. Пример: Более подробно режимы округления мы разберем чуть ниже.
n:
Округление чисел double
Примерное округление double
Всем Доброго Дня! Подскажите пожалуйста цифру, чтобы число округлялось до 4 или даже лучше 5.
Округление double в меньшую сторну
Всем привет! Сразу прошу палками не бить, так как полный новичок в Java 🙂 Подскажите люди.
Округление чисел
Здравствуйте! У меня вот такой вопрос, Как можно сделать чтоб выводило на экран косинусы углов 45 и.
Округлите число с плавающей запятой или двойное число с двумя знаками после запятой в Котлине.
В этой статье рассматриваются различные способы округления числа с плавающей запятой или двойного числа с двумя знаками после запятой в Kotlin.
1. Использование
roundToInt() функцияThe roundToInt() Функция округляет двойное значение до ближайшего целого числа. Его можно использовать следующим образом, чтобы округлить число с плавающей запятой или удвоить требуемые десятичные разряды.
1 2 3 4 5 6 7 8 9 | import kotlin.math.roundToInt
fun main() { val random = 0.8458215996440445
val roundoff = (random * 100.0).roundToInt() / 100.0
println(roundoff) // 0.85 } |
Скачать код
Количество нулей указывает количество десятичных разрядов в выводе. Следовательно, чтобы округлить до 4 знаков после запятой, используйте значение 10000.0:
1 2 3 4 5 6 7 8 9 | import kotlin.math.roundToInt
fun main() { val random = 0.037854093052263726
val roundoff = (random * 10000.0).roundToInt() / 10000.0
println(roundoff) // 0.0379 } |
Скачать код
Кроме того, рассмотрите эту альтернативную и эквивалентную версию приведенного выше кода:
1 2 3 4 5 6 7 8 9 | import kotlin. fun main() { val random = 0.797490220519589
val roundoff = (random * 10000).roundToInt().toDouble() / 10000
println(roundoff) // 0.7975 } |
math.roundToIntСкачать код
Стоит отметить, что арифметика с плавающей запятой очень сложна и не всегда может работать должным образом. Например, значение 295.335 округляется “в меньшую сторону” до 295.33 вместо округления “вверх” до 295.34.
1 2 3 4 5 6 7 8 | import kotlin.math.roundToInt
fun main() { val random = 295.335
println(random * 100.0) // 29533.499999999996 println((random * 100.0).roundToInt() / 100.0) // 295.33 } |
Скачать код
2. Использование
DecimalFormat. format() функция
format()В качестве альтернативы мы можем назвать DecimalFormat.format() функция для ограничения двойного числа до 2-х десятичных точек с использованием шаблона #.##. RoundingMode может быть предоставлена с помощью setRoundingMode() функция.
1 2 3 4 5 6 7 8 9 10 11 | import java.math.RoundingMode import java.text.DecimalFormat
fun main() { val random = 8435.21057752090819915
val df = DecimalFormat(«#.##») df.roundingMode = RoundingMode.DOWN val roundoff = df.format(random) println(roundoff) // 8435.21 } |
Скачать код
Обратите внимание, что количество # после точки указывается количество знаков после запятой.
Поэтому для округления до 3 знаков после запятой используйте шаблон
1 2 3 4 5 6 7 8 9 10 11 | import java.math.RoundingMode import java.text.DecimalFormat
fun main() { val random = 4732.8326486752163523
val df = DecimalFormat(«#.###») df.roundingMode = RoundingMode.DOWN val roundoff = df.format(random) println(roundoff) // 4732.832 } |
Скачать код
Это решение сталкивается с той же проблемой, что и roundToInt() функция, если режим округления не предусмотрен. т. е. значение 295.33 вместо округления “вверх” до 295.34.
1 2 3 4 5 6 7 8 9 | import java.
fun main() { val random = 295.335
val df = DecimalFormat(«#.##») val roundoff = df.format(random) println(roundoff) // 295.33 } |
text.DecimalFormat3. Использование
String.format() функцияМы также можем использовать String.format() функция для округления числа с плавающей запятой или двойного числа с определенным количеством знаков после запятой. Это отлично работает для значения 295.335, как показано ниже:
fun main() { val random = 295.335 val roundoff = String.format(«%.2f», random) println(roundoff) // 295.34 } |
Скачать код
4. Использование
BigDecimalНаконец, мы можем преобразовать двойное значение в BigDecimal и ограничьте двойное значение до 2 десятичных знаков, используя RoundingMode.
1 2 3 4 5 6 7 8 9 | import java.math.BigDecimal import java.math.RoundingMode
fun main() { val random = Math.random() val bd = BigDecimal(random) val roundoff = bd.setScale(2, RoundingMode.FLOOR) println(roundoff) } |
Скачать код
Это все об округлении числа с плавающей запятой или двойного числа с двумя знаками после запятой в Kotlin.
Оценить этот пост
Средний рейтинг 5/5. Подсчет голосов: 17
Голосов пока нет! Будьте первым, кто оценит этот пост.
Сожалеем, что этот пост не оказался для вас полезным!
Расскажите, как мы можем улучшить этот пост?
Спасибо за чтение.
Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.
Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂
Функции Int, Round, RoundDown, RoundUp и Trunc — Power Platform
Обратная связь
Twitter LinkedIn Facebook Адрес электронной почты
- Статья
- Чтение занимает 2 мин
Округление чисел.
Round, RoundDown и RoundUp
Функции Round, RoundDown и RoundUp округляют число до указанного количества знаков после запятой (десятичных разрядов).
- Функция Round округляет число в большую сторону, если следующая цифра после запятой больше или равна 5. В противном случае число округляется в меньшую сторону.
- Функция RoundDown всегда округляет число в меньшую сторону — до предыдущего (меньшего) числа, в сторону нуля.
- Функция RoundUp всегда округляет число в большую сторону — до следующего (большего) числа, в сторону от нуля.
Число десятичных знаков, допускаемых для этих функций:
| Число десятичных знаков | Описание | Пример |
|---|---|---|
| Больше 0 | Число округляется справа от десятичного разделителя. | Round( 12.37, 1 ) возвращает 12.4. |
| 0 | Число округляется до ближайшего целого числа. | Round( 12.37, 0 ) возвращает 12. |
| Меньше 0 | Число округляется слева от десятичного разделителя. | Round( 12.37, -1 ) возвращает 10. |
Int и Trunc
Функции Int и Trunc округляют число до целого (целое число без десятичной дроби):
- Int округляет значение вниз до ближайшего целого.
- Trunc усекает число до целой части, удаляя десятичную часть.
Разница между Int и Trunc заключается в обработке отрицательных чисел. Например, для аргумента -4.3 Int вернет целое число в сторону от нуля, -5, в то время как Trunc вернет целое число, близкое к нулю, -4. Int возвращает значения, которые уникальные среди пяти функций округления, а Trunc возвращает те же значения, что и RoundDown.
Используйте Trunc для извлечения десятичной части числа путем вычитания ее из оригинала, например X - Trunc(X).
Десятичные разряды нельзя указывать с помощью Trunc как это можно с Microsoft Excel. Вместо этого используйте RoundDown, когда это необходимо.
Эти функции поддерживают таблицы с одним столбцом. При передаче одного числа возвращаемое значение является округленной версией такого числа. При передаче таблицы, содержащей один столбец с числами, возвращаемое значение представляет таблицу из одного столбца с округленными числами. Параметр DecimalPlaces может быть одним значением или таблицей с одним столбцом. Если в таблице с одним столбцом меньше значений, чем Число, для остальных значений используется ноль. Используйте ShowColumns и другие функции формирования таблиц для извлечения таблицы с одним столбцом из таблицы большего размера.
Синтаксис
Round( Number, DecimalPlaces )
RoundDown( Number, DecimalPlaces )
RoundUp( Number, DecimalPlaces )
- Number — обязательный аргумент. Число для округления.
- DecimalPlaces — обязательный аргумент. Число десятичных знаков для округления. Используйте положительное значение, чтобы указать десятичные разряды справа от десятичного разделителя, отрицательное значение слева и ноль для целого числа.
Число для округления.Int(Число)
Trunc(Число)
- Number — обязательный аргумент. Число, которое нужно округлить до целого числа.
Примеры
Округление до целого числа.
X | Round( X, 0 ) | RoundUp( X, 0 ) | RoundDown( X, 0 ) | Int( X ) | Trunc( X ) |
|---|---|---|---|---|---|
| 7.9 | 8 | 8 | 7 | 7 | 7 |
| -7,9 | -8 | -8 | -7 | -8 | -7 |
| 7.5 | 8 | 8 | 7 | 7 | 7 |
| -7,5 | -8 | -8 | -7 | -8 | -7 |
7. 1 | 7 | 8 | 7 | 7 | 7 |
| -7,1 | -7 | -8 | -7 | -8 | -7 |
Округление до двух десятичных знаков справа от десятичного разделителя (0,01).
X | Round( X, 2 ) | RoundUp( X, 2 ) | RoundDown( X, 2 ) |
|---|---|---|---|
| 430.123 | 430.12 | 430.13 | 430.12 |
| 430.125 | 430.13 | 430.13 | 430.12 |
| 430.128 | 430.13 | 430.13 | 430.12 |
Округление до двух десятичных знаков слева от десятичного разделителя (100).
X | Round( X, -2 ) | RoundUp( X, -2 ) | RoundDown( X, -2 ) |
|---|---|---|---|
| 430.123 | 400 | 500 | 400 |
449. 942 | 400 | 500 | 400 |
| 450.000 | 500 | 500 | 400 |
| 450.124 | 500 | 500 | 400 |
| 479.128 | 500 | 500 | 400 |
Округление для таблицы значений с одним столбцом.
X | Int( X ) | Round( X, 2 ) | RoundDown( X, [ 0, 1, 2 ] ) | RoundUp( X, [ 2 ] ) |
|---|---|---|---|---|
| [ 123,456, 987,593, 542,639 ] | [ 123, 987, 542 ] | [ 123,46, 987,59, 542,64 ] | [ 123, 987,5, 542,63 ] | [ 123,46, 988, 543 ] |
Примечание
Каковы ваши предпочтения в отношении языка документации? Пройдите краткий опрос (обратите внимание, что этот опрос представлен на английском языке).
Опрос займет около семи минут. Личные данные не собираются (заявление о конфиденциальности).
Обратная связь
Отправить и просмотреть отзыв по
Этот продукт Эта страница
Просмотреть все отзывы по странице
Документация JDK 19 — Главная
- Главная
- Ява
- Java SE
- 19
Обзор
- Прочтите меня
- Примечания к выпуску
- Что нового
- Руководство по миграции
- Загрузить JDK
- Руководство по установке
- Формат строки версии
Инструменты
- Технические характеристики инструментов JDK
- Руководство пользователя JShell
- Руководство по JavaDoc
- Руководство пользователя средства упаковки
Язык и библиотеки
- Обновления языка
- Основные библиотеки
- HTTP-клиент JDK
- Учебники по Java
- Модульный JDK
- Руководство программиста API бортового регистратора
- Руководство по интернационализации
Технические характеристики
- Документация API
- Язык и ВМ
- Имена стандартных алгоритмов безопасности Java
- банок
- Собственный интерфейс Java (JNI)
- Инструментальный интерфейс JVM (JVM TI)
- Сериализация
- Проводной протокол отладки Java (JDWP)
- Спецификация комментариев к документации для стандартного доклета
- Прочие характеристики
Безопасность
- Руководство по безопасному кодированию
- Руководство по безопасности
Виртуальная машина HotSpot
- Руководство по виртуальной машине Java
- Настройка сборки мусора
Управление и устранение неполадок
- Руководство по устранению неполадок
- Руководство по мониторингу и управлению
- Руководство по JMX
Client Technologies
- Руководство по специальным возможностям Java
Режимы округления — Документация ICU
Содержание
- Сравнение режимов округления
- Половина даже
- Половина ODD
- Половина
- Half Up
- UP
- Half Up
- UP
- Half Up
- UP
- Half Up
- 5
- .
- Этаж
- Ненужный
- Другие ссылки/Сравнение
Следующие режимы округления используются с десятичным форматированием ICU. Обратите внимание, что использование ICU терминов «вниз» и «вверх» здесь несколько расходится с другими определениями, но эквивалентно тем же режимам, которые используются в Java JDK.
Сравнение режимов округления
На этой диаграмме показаны значения от -2,0 до 2,0 с шагом 0,1, а также показан результирующий формат ICU при форматировании без десятичных цифр.
Примечание. Некоторые из приведенных ниже параметров недоступны в ICU4J, поскольку мы используем JDK RoundingMode.
| # | CEILING | FLOOR | DOWN | UP | HALFEVEN | HALFODD | HALFCEILING | HALFFLOOR | HALFDOWN | HALFUP | # |
|---|---|---|---|---|---|---|---|---|---|---|---|
-2. 0 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -2.0 |
| -1.9 | -1 | -2 | -1 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -1.9 |
| -1.8 | -1 | -2 | -1 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -1.8 |
| -1.7 | -1 | -2 | -1 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -1.7 |
| -1.6 | -1 | -2 | -1 | -2 | -2 | -2 | -2 | -2 | -2 | -2 | -1.6 |
-1. 5 | -1 | -2 | -1 | -2 | -2 | -1 | -1 | -2 | -1 | -2 | -1.5 |
| -1.4 | -1 | -2 | -1 | -2 | -1 | -1 | -1 | -1 | -1 | -1 | -1,4 |
| -1,3 | -1 | -2 | -1 | -2 | -1 | -1 | -1 | -1 | -1 | -1 | -1.3 |
| -1.2 | -1 | -2 | -1 | -2 | -1 | -1 | -1 | -1 | -1 | -1 | -1.2 |
| -1.1 | -1 | -2 | -1 | -2 | -1 | -1 | -1 | -1 | -1 | -1 | -1.1 |
-1. 0 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -1.0 |
| -0.9 | -0 | -1 | -0 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -0.9 |
| -0.8 | -0 | -1 | -0 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -0.8 |
| -0.7 | -0 | -1 | -0 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -0,7 |
| -0.6 | -0 | -1 | -0 | -1 | -1 | -1 | -1 | -1 | -1 | -1 | -0.6 |
-0. 5 | -0 | -1 | -0 | -1 | -0 | -1 | -0 | -1 | -0 | -1 | -0.5 |
| -0,4 | -0 | -1 | -0 | -1 | -0 | -0 | -0 | -0 | -0 | -0 | -0.4 |
| -0.3 | -0 | -1 | -0 | -1 | -0 | -0 | -0 | -0 | -0 | -0 | -0.3 |
| -0.2 | -0 | -1 | -0 | -1 | -0 | -0 | -0 | -0 | -0 | -0 | -0.2 |
| -0.1 | -0 | -1 | -0 | -1 | -0 | -0 | -0 | -0 | -0 | -0 | -0.1 |
0. 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0.0 |
| 0.1 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0.1 |
| 0.2 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0.2 |
| 0.3 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0.3 |
| 0.4 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0.4 |
| 0.5 | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 1 | 0. 5 |
| 0.6 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0.6 |
| 0.7 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0.7 |
| 0.8 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0.8 |
| 0.9 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0.9 |
| 1.0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1.0 |
1. 1 | 2 | 1 | 1 | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1.1 |
| 1.2 | 2 | 1 | 1 | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1.2 |
| 1.3 | 2 | 1 | 1 | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1.3 |
| 1.4 | 2 | 1 | 1 | 2 | 1 | 1 | 1 | 1 | 1 | 1 | 1.4 |
| 1.5 | 2 | 1 | 1 | 2 | 2 | 1 | 2 | 1 | 1 | 2 | 1.5 |
| 1.6 | 2 | 1 | 1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 1. 6 |
| 1.7 | 2 | 1 | 1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 1.7 |
| 1.8 | 2 | 1 | 1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 1.8 |
| 1.9 | 2 | 1 | 1 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 1.9 |
| 2.0 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2.0 |
| # | CEILING | FLOOR | DOWN | UP | HALFEVEN | HALFODD | HALFCEILING | HALFFLOOR | HALFDOWN | HALFUP | # |
Half Even
Это режим округления ICU по умолчанию.
Значения точно на отметке 0,5 (половина) (показаны пунктиром на графике) округляются до ближайшей четной цифры. Это часто называют округлением банкира, потому что в среднем оно не содержит смещения. Это режим по умолчанию, указанный для операций с плавающей запятой IEEE 754.
Также известен как привязка к четному, округление к ближайшему, RN или RNE.
Половина нечетного
Аналогично половинному четному, но округление до ближайшего нечетного числа вместо четного числа.
Half Down
Значения точно на отметке 0,5 (половина) округляются в меньшую сторону (следующее меньшее абсолютное значение, ближе к нулю).
Half Up
Значения точно на отметке 0,5 (половина) округляются в большую сторону (следующее большее абсолютное значение, отличное от нуля).
Вниз
Все значения округляются до следующего меньшего абсолютного значения (округляются до нуля или RZ).
Также известен как усечение, потому что незначащие десятичные разряды просто удаляются.
Вверх
Все значения округляются до следующего большего абсолютного значения (от нуля).
Half Ceiling
Значения точно на отметке 0,5 (половина) округляются до положительной бесконечности (+∞).
Это режим округления по умолчанию в ECMAScript. В CSS он известен как «ближайший».
Half Floor
Значения точно на отметке 0,5 (половина) округляются до отрицательной бесконечности (-∞).
Потолок
Все значения округлены до положительной бесконечности (+∞). Также известен как RI для раундов до бесконечности.
Этаж
Все значения округлены до минус бесконечности (-∞). Также известен как RMI для раундов до минус бесконечности.
Ненужный
Режим «Ненужный» не выполняет никакого округления, а вместо этого возвращает ошибку, если значение не может быть точно представлено без округления.
Другие ссылки/сравнения- Документы по десятичному контексту (используются ICU4C для реализации округления): http://speleotrove. com/decimal/decifaq1.html#rounding
- Документация по Java 7: http://docs.oracle.com/javase/7/docs/api/java/math/RoundingMode.html
- Правила округления IEEE 754: http://en.wikipedia.org/wiki/ IEEE_754-2008#Rounding_rules
- Статья в Википедии об округлении: http://en.wikipedia.org/wiki/Rounding#Tie-breaking
- Таблица режимов округления в реальном времени: Диаграмма режимов округления и исходный код
com/decimal/decifaq1.html#roundingPython округление на практике примеры [5 методов]
Содержание
Как округлить число в Python — Введение
Процесс замены числа другим числом примерно того же значения, но с меньшим количеством цифр, в математике называется округлением. Если мы округлим число до целого числа, немного большего, чем исходное число, это называется округлением в большую сторону. В этом уроке мы узнаем о Python.
Мы обсудим различные методы округления числа с плавающей запятой, решая различные примеры. В общем, мы рассмотрим 4 способа округления числа с плавающей запятой в Python.
Вкратце, этот туториал будет содержать все необходимые и популярные методы, которые используются в Python для округления числа с плавающей запятой.
Advertisement
ТАКЖЕ ЧИТАЙТЕ: Методы группировки Pandas объяснены на ПРОСТЫХ примерах
Способ 1: Использование функции Python round() для округления числа в Python
Округление чисел делает их более простыми и удобными в использовании. Хотя они немного менее точны, их значения все еще относительно близки к тому, что было изначально. В Python у нас есть встроенный метод, известный как round(), который используется для округления числа до ближайшего целого числа. См. пример ниже:
# определение плавающих чисел
число1 = 3,4
число2 = 3,6
# применение метода округления
print("Число1 округляется до", round(num1))
print("Num2 округляется до ", round(num2)) Вывод:
Num1 округляется до 3 Num2 округляется до 4
Обратите внимание, что num1 округляется до 3, что является значением, немного меньшим, чем исходное значение, такой тип округления известен как округление в меньшую сторону.
В то время как num2 округляется до 4, что немного больше, чем исходное значение, и такой тип округления известен как округление вверх. Например, см. пример ниже:
5,5 Округлить до 6 7.7 Округлить до 8 3.1 Округление до 4
В Python мы округляем числа с плавающей запятой до ближайшего большего целого числа. В следующих разделах мы обсудим округление Python, что означает округление числа до ближайшего большего целого числа.
Пример 1. Округление числа до 2 десятичных знаков в Python
В Python может быть множество способов округления числа до 2 знаков после запятой. Например, один из методов заключается в использовании метода с плавающими числами и указании необходимого количества цифр. См. пример ниже:
# плавающий номер
число = 3,786847638
# Python округлить число
print("Число, округленное до 2-х десятичных цифр: {0:.2f}".format(num)) Вывод:
Реклама
Число, округленное до 2-х десятичных цифр: 3.79
Обратите внимание, что в приведенном выше примере мы должны округлить число до двух знаков после запятой.
Другой способ выполнить эту задачу — использовать метод округления и указать количество десятичных цифр. Например, см. пример ниже:
# число с плавающей запятой
число = 3,786847638
# Python округлить число
print("Число, округленное до двух знаков после запятой: " ,round(num, 2)) Вывод:
Число, округленное до 2 десятичных цифр, равно: 3,79
В приведенном выше примере мы указали десятичные цифры, передав 2 в качестве аргумента методу округления.
ТАКЖЕ ПРОЧИТАЙТЕ: Объяснение статического метода Python [Практические примеры]
Пример 2. Python округляет до ближайших 10
Существует два разных способа округления числа из ближайших 10. Первый способ — использовать метод круглый метод. Мы можем разделить значение на 10, округлить результат до нулевой точности и снова умножить на 10. Второй способ — передать отрицательное значение точности. Отрицательное значение означает, что округление происходит слева от десятичной точки.
См. пример ниже:
# определение номера
число = 457583
# Python округляет число до ближайших 10
округлено = округлено (число/10)*10
# Распечатать
print("Число, округленное до ближайших 10: ", округлено) Вывод:
Число, округленное до ближайших 10: 457580
Обратите внимание, что мы успешно округлили число до ближайших 10. Второй способ заключается в передаче отрицательного значения в качестве аргумента методу round. См. пример ниже:
Реклама
# определение номера
число = 457583
# Python округляет число до ближайших 10
print("Число, округленное до ближайших 10: " ,round(num, -1)) Выходные данные:
Число, округленное до ближайших 10, равно: 457580
Предоставление отрицательного значения в качестве аргумента метода округления приведет к округлению числа до ближайших 10, как показано в приведенном выше примере.
Пример 3 Python округляет число до ближайшего целого числа
Мы уже обсуждали и рассмотрели различные методы округления числа до ближайшего целого числа.
В основном метод округления используется для округления числа до ближайшего целого числа. Если мы не укажем количество знаков после запятой в аргументе, метод round округлит число до ближайшего целого значения. См. пример ниже:
# определение номера
число = 4,57583
# Python округляет число до ближайшего целого числа
print("Число, округленное до ближайшего целого: " ,round(num)) Вывод:
Число, округленное до ближайшего целого: 5
Обратите внимание, что мы не предоставили второй аргумент методу округления поэтому он автоматически округлял число до ближайшего целого числа.
ТАКЖЕ ПРОЧИТАЙТЕ: РЕШЕНО: Измерьте время выполнения в Python [5 методов]
Пример 4 Python округлить до ближайшего 5
Округление числа до кратного основания возвращает кратное, ближайшее к этому числу. Например, округление 11 до числа, кратного 5, дает 10. В этом разделе мы округлим число до ближайших 5. См. программу Python ниже:
Advertisement
# определение числа
число = 4343
# Python округляет число до ближайших 5
округлено = 5 * округлено (число/5)
# печать
print("Число, округленное до ближайших 5: " ,округлено) Вывод:
Число, округленное до ближайших 5: 4345
Обратите внимание, что в приведенном выше примере мы сначала делим число на 5, а затем округляем его до ближайшего целого числа, используя метод округления.
Затем мы умножаем значение на 5.
Пример 5 Python округлить деление
Мы можем использовать любой из вышеупомянутых методов округления для округления числа в делении. Мы можем применить деление, а затем округлить результат, используя любой из методов округления Python. Здесь мы будем использовать метод округления Python и метод math.ceil для округления числа. См. пример ниже:
импорт математики
# определение числа
число1 = 43,0
число2 = 10
# округление Python
print("Округлено методом округления:", round(num1/num2))
print("Округлено методом math.ceil: ", math.ceil(num1/num2)) Вывод:
Округлено методом округления: 4 Округление с использованием метода math.ceil: 5
Как мы уже обсуждали метод ceil, округляем число до ближайшего целого числа, большего или равного заданному числу, поэтому мы получаем 5 вместо 4.
ТАКЖЕ ЧИТАЙТЕ: Python цикл for в одну строку с простыми примерами
Пример 6 Python округляет число с плавающей запятой
До сих пор мы применяли все методы округления для числа с плавающей запятой.
Помимо этих методов, мы также можем округлить плавающие методы, указав количество цифр, которые мы хотим иметь. См. пример ниже:
Реклама
# определение номера
число1 = 43,947386493
# Python округляет число с плавающей запятой
print("Округлено до 5 десятичных цифр: {0:.5f}".format(num1))
print("Округлено до 0 десятичных цифр: {0:.0f}".format(num1)) Вывод:
Округление до 5 знаков после запятой: 43,94739 Округление до 0 десятичных цифр: 44
Это самый простой способ округлить число с плавающей запятой. Все, что нам нужно сделать, это указать количество десятичных цифр.
Пример 6 Python округляет numpy
Метод numpy round представляет собой математическую функцию, которая округляет массив до заданного числа десятичных знаков. Например, см. приведенную ниже программу Python, в которой используется метод раунда NumPy.
# импорт модуля numpy импортировать numpy как np # определение массива numpy Массив = [1.
1, 2.6, 4.6, 4.8, 10]
# печать массива без округления
print("Без округления значений: ", Массив)
# python округляет и печатает
print ("Округленные значения: ", np.round(Array)) Вывод:
Без округления значений: [1.1, 2.6, 4.6, 4.8, 10] Округленные значения: [ 1. 3. 5. 5. 10.]
Обратите внимание, что метод округления NumPy возвращает значения массива, округленные до ближайших целых значений.
Метод 2. Использование функции math.ceil() для округления числа в Python
Функция math.ceil() — это математическая функция, которая возвращает максимальное значение заданного числа. Максимальное значение означает ближайшее целое значение, большее или равное исходному числу. Подробнее о функции потолка можно прочитать в статье Функция потолка Python. В этом разделе мы просто изучим базовый синтаксис и решим несколько примеров, чтобы округлить число с помощью функции потолка Python.
Реклама
ТАКЖЕ ПРОЧИТАЙТЕ: Объяснение класса Python classmethod() [Простые примеры]
Синтаксис функции Python math.
ceil()Прежде чем использовать функцию ceil, мы должны сначала импортировать математический модуль, используя ключевое слово import . Ниже приведен простой синтаксис метода math.ceil().
импорт математики math.ceil(число)
Метод ceil принимает один аргумент (плавающее или целочисленное значение) и возвращает максимальное значение или ближайшее большее или равное целочисленное значение.
Пример метода math.ceil() для округления числа в Python в большую сторону
Теперь давайте рассмотрим несколько примеров и посмотрим, как мы можем использовать метод math.ceil() для округления числа в большую сторону. . См. пример ниже:
# импорт математического модуля
импортировать математику
# определяющие числа
число1 = 3,1
число2 = 3,8
число3 = 4
# округление Python с использованием метода ceil
print("Округленное значение num1:", math.ceil(num1))
print("Округленное значение num2:", math.ceil(num2))
print("Округленное значение num3:", math. ceil(num3)) 
ceil(num3)) Вывод:
Округлить значение num1 в большую сторону: 4 Округлить значение num2: 4 Округленное значение num3: 4
Обратите внимание, что плавающие значения в приведенных выше примерах были округлены до ближайшего большего целочисленного значения, в то время как целочисленное значение в качестве аргумента не было изменено. Число, возвращаемое методом math.ceil() , имеет тип int. См. пример ниже:
# импорт математического модуля
импортировать математику
число1 = 3,3
# округлить python, используя метод math ceil
число = math.ceil (num1)
# печать типа
print("Тип числа :", type(num)) Вывод:
Реклама
Тип числа:
Обратите внимание, что число, возвращаемое методом ceil, принадлежит классу int.
ТАКЖЕ ЧИТАЙТЕ: Python Compare Strings [10+ примеров]
Метод 3: использование функции Numpy.ceil() для округления числа в Python
NumPy расшифровывается как Numerical Python и представляет собой библиотеку, состоящую из многомерного массива объекты и набор подпрограмм для обработки этих массивов.
Используя NumPy, можно выполнять математические и логические операции с массивами. Он имеет множество встроенных методов, которые используются для выполнения различных математических операций, и одним из них является метод ceil, который используется для нахождения потолка числа. В этом разделе мы узнаем о numpy.ceil() метод.
Синтаксис numpy.ceil() для округления числа в Python
Перед использованием метода numpy.ceil() . Во-первых, мы должны установить модуль Python NumPy в нашей системе. Мы можем использовать команду pip для установки библиотеки NumPy, как показано ниже:
pip install numpy
После того, как мы установили модуль NumPy, мы можем получить доступ к его различным методам, импортировав модуль. Ниже приведен простой синтаксис numpy.ceil() метод.
импорт numpy numpy.ceil(число)
Метод ceil принимает один аргумент (плавающее или целочисленное значение) и возвращает потолок или ближайшее большее или равное целочисленное значение.
Пример метода numpy.ceil() для округления числа в большую сторону
Теперь давайте рассмотрим примеры и посмотрим, как мы можем использовать метод numpy.ceil() для округления числа в большую сторону. . См. приведенную ниже программу Python, в которой используется numpy.ceil() метод, чтобы найти округление числа.
# импорт модуля numpy
импортировать numpy как np
# определяющие числа
число1 = 3,1
число2 = 3,8
число3 = 4
# округление Python с использованием метода ceil
print("Округленное значение num1:", np.ceil(num1))
print("Округленное значение num2:", np.ceil(num2))
print("Округленное значение num1:", np.ceil(num3))
Вывод:
Значение округления num1: 4.0 Округлить значение num2: 4.0 Округление значения num1: 4,0
Обратите внимание, что метод ceil NumPy возвращает максимальное число, а не целочисленное значение. Он возвращает число с плавающей запятой, содержащее ноль после запятой. Давайте теперь подтвердим тип возвращаемого значения метода ceil NumPy, напечатав тип.
См. пример ниже:
# импорт модуля numpy
импортировать numpy как np
# определяющее число
число1 = 3,43
# округляем Python, используя метод numpy ceil
число = np.ceil (num1)
# печать типа
print("Тип возвращаемого значения:", type(num)) Выходные данные:
Тип возвращаемого значения:
Обратите внимание, что тип возвращаемого значения — NumPy float, а не целое число.
ТАКЖЕ ПРОЧИТАЙТЕ: список сортировки Python [2 метода и 8 примеров]
Метод 4. Использование простой арифметики для округления числа в Python
Число также можно округлить с помощью простой арифметики в Python. Он приводит первое выражение к целочисленному типу данных и добавляет 0 или 1 значение на основе результата другого выражения. Другое выражение находит модуль числа с тем же знаменателем и проверяет, больше ли оно 0 или нет. Если остаток больше 0, он добавляет единицу к первому выражению, а если он ложен, он добавляет 0 к первому выражению.
Преимущество этого метода в том, что нам не нужно импортировать какие-либо внешние библиотеки.
Примеры простой арифметики для округления числа в Python
Теперь давайте возьмем пример и посмотрим, как мы можем найти округление числа, используя простые арифметические правила. См. пример ниже:
# определяющие числа
число1 = 10,44
число2 = 10,6
число3 = 10
дел = 5
# Python округляет с помощью простого арифметического метода
print("число1/дел: ",int(число1/дел) + (число1% дел>0))
print("число2/дел: ",int(число2/дел) + (число2% дел>0))
print("число3/дел: ",int(число3/дел) + (число3% дел>0)) Вывод:
число1/дел: 3 число2/дел: 3 num3/div: 2
Обратите внимание, что этот метод возвращает округленное значение результата.
Метод 5. Использование оператора деления на пол для округления числа в Python
Символ оператора деления на пол — // . Он работает так же, как простой оператор деления / , но также округляет число в меньшую сторону.
Таким образом, он обычно используется для округления числа в Python. Однако мы можем изменить его использование, чтобы округлить число. Мы можем сделать это, отрицая ответ, разделив отрицательные числа. Недостатком этого метода является то, что его можно применять только к целым числам.
ТАКЖЕ ЧИТАЙТЕ: 10+ базовых примеров для изучения Python RegEx с нуля
Пример оператора деления пола для округления числа в Python
Теперь давайте рассмотрим примеры и посмотрим, как мы можем использовать оператор деления пола для округления до числа в Python. См. программу Python ниже:
# определение чисел
число1 = 10,44
число2 = 10,6
число3 = 10
дел = 5
# Python округляет, используя деление на пол
print("число1/дел: ",(-(-число1//дел)))
print("число2/дел: ",(-(-число2//дел)))
print("число3/дел: ",(-(-число3//дел))) Вывод:
число1/дел: 3,0 число2/дел: 3,0 num3/div: 2
Обратите внимание, что метод деления на пол также можно использовать для округления числа в большую сторону, как показано в приведенном выше примере.