Обрезать до трех знаков после запятой в Python
В случае, если комментарий Карла недостаточно ясен: в двоичной переменной с плавающей запятой нет такого числа, как 1324343032.324. Если вы переключитесь на более высокую версию Python (2.7 или 3.1 или более позднюю), интерпретатор покажет вам 1324343032.324. Но на самом деле число, с которым вы вычисляете, не равно ни 1324343032.324, ни 1324343032.3239999, независимо от версии Python. Единственный способ получить ровно 1324343032.324 — это использовать decimal модуль или некоторую другую математическую библиотеку произвольной точности, например, gmpy .
Принятый ответ ниже является правильным, если вы хотите округлить (до) до заданного числа десятичных знаков. Однако, что задает вопрос, и что я хотел знать, это как урезать до определенного числа десятичных знаков. Для меня ‘%.3f’%(1324343032.3243) и ‘%.3f’%(1324343032.3245) дают разные результаты. (Я использую Python 2.7.8).
@AbhranilDas этот вопрос дублирует тот, на который вы указали. Поскольку оба вопроса имеют вводящие в заблуждение ответы, я отметил этот вопрос как дубликат, чтобы все вопросы, связанные с усечением, можно было решать в одном месте. Также ознакомьтесь с моими комментариями и предлагаемыми ответами на оригинальный вопрос.
12 ответов
Используйте дополнительный float() вокруг него, если вы хотите сохранить его как float.
Это в основном правильный ответ, просто используйте val = ‘%.3f’%(1324343032.324325235) вместо print .
Я понимаю. Но я думаю, что вопрос здесь был простым усечением. Поскольку @SuperString использовал str() в одной из своих попыток, я предположил, что он просто искал усеченный дисплей.
Ну, если вы понимаете, то вы также знаете, что «сохранять это как поплавок» — это неправильно. У него уже есть поплавок. float(‘%.3f’%(1324343032.324325235)) — это то же самое, что и round(1324343032.324325235, 3) . Поскольку его первый комментарий здесь: «Я не хочу его печатать . Я хочу сохранить его», ясно, что он ничего не получил, выполняя то, что вы предлагаете.
Этот ответ верен, если вы хотите округлить (увеличить) до заданного числа десятичных знаков. Однако, что задает вопрос, и что я хотел знать, это как урезать до определенного числа десятичных знаков. Для меня ‘%.3f’%(1324343032.3243) и ‘%.3f’%(1324343032.3245) дают разные результаты. (Я использую Python 2.7.8).
Вы можете использовать следующую функцию для усечения числа до заданного числа десятичных знаков:
import math def truncate(number, digits) -> float: stepper = pow(10.0, digits) return math.trunc(stepper * number) / stepper >> truncate(1324343032.324325235, 3) >> 1324343032.324 Это действительно должен быть принятый ответ. Код прост, элегантен и имеет смысл. Используйте стандартную функцию усечения, однако сначала сдвиньте десятичную запятую, сдвинув десятичную запятую назад после выполнения усечения.
обратите внимание, что ошибки точности с плавающей запятой truncate(-1.13, 2) == -1.12 , я немного изменил его (с горьким вкусом во рту) на math.trunc(round(stepper * number, digits * 3)) / stepper
Я нашел другое решение (оно должно быть более эффективным, чем обходные методы «string witchcraft» ):
>>> import decimal # By default rounding setting in python is decimal.ROUND_HALF_EVEN >>> decimal.getcontext().rounding = decimal.ROUND_DOWN >>> c = decimal.Decimal(34.1499123) # By default it should return 34.15 due to '99' after '34.14' >>> round(c,2) Decimal('34.14') >>> float(round(c,2)) 34.14 >>> print(round(c,2)) 34.14 In [1]: '%.3f' % round(1324343032.324325235 * 1000 / 1000,3) Out[1]: '1324343032.324' Учитывая дополнительные комментарии, которые, как я полагаю, вы захотите сделать:
In : Decimal('%.3f' % (1324343032.324325235 * 1000 / 1000)) Out: Decimal('1324343032.324') Точность с плавающей запятой не будет такой, какой вы хотите:
In : 3.324 Out: 3.3239999999999998 (все примеры относятся к Python 2.6.5)
Используйте десятичный модуль. Но если вы должны использовать float и все равно каким-то образом принуждать их к заданному числу десятичных знаков, преобразование в строку назад обеспечивает (довольно неуклюжий, я боюсь) способ сделать это.
>>> q = 1324343032.324325235 * 1000 / 1000 >>> a = "%.3f" % q >>> a '1324343032.324' >>> b = float(a) >>> b 1324343032.324 Хорошо, что вы сначала упомянули десятичный модуль, потому что это единственный полностью правильный ответ. С остальными нужно быть немного осторожнее, так как b в вашем примере будет отображаться как 1324343032.3239999 в версиях Python до 2.7. И действительно, это значение, которое видит OP, когда пытается. Конечно, оба значения неразличимы с точки зрения двоичной плавающей запятой.
Это нормально только в этом конкретном случае.
Просто немного измените номер:
1324343032.324 7 25235
дает вам 1324343032.325
Попробуйте это вместо этого:
def trun_n_d(n,d): s=repr(n).split('.') if (len(s)==1): return int(s[0]) return float(s[0]+'.'+s[1][:d]) Другой вариант для trun_n_d:
def trun_n_d(n,d): dp = repr(n).find('.') #dot position if dp == -1: return int(n) return float(repr(n)[:dp+d+1]) Еще один вариант (единственный) для trun_n_d [это предполагает, что ‘ n ‘ — это str, а ‘ d ‘ — это int]:
def trun_n_d(n,d): return ( n if not n.find('.')+1 else n[:n.find('.')+d+1] ) trun_n_d дает вам желаемый результат в Python 2.7 и Python 3.6
trun_n_d (1324343032.324325235,3) возвращает 1324343032.324
Аналогично, trun_n_d (1324343032.324 7 25235,3) возвращает 1324343032.324
Примечание 1 В Python 3.6 (и, возможно, в Python 3.x) что-то вроде этого работает просто отлично:
def trun_n_d(n,d): return int(n*10**d)/10**d Но, таким образом, призрак закругления всегда скрывается вокруг.
Примечание 2 В подобных ситуациях из-за внутренних чисел Python, таких как округление и отсутствие точности, работать с n как с str намного лучше, чем с использованием его аналога int; Вы всегда можете бросить свой номер на поплавок в конце.
Ссылка Almo объясняет, почему это происходит. Чтобы решить проблему, используйте десятичную библиотеку.
Я считаю, что использование функции format — плохая идея. Пожалуйста, смотрите ниже. Это округляет значение. Я использую Python 3.6.
Вместо этого используйте регулярное выражение:
>>> re.match(r'\d+.\d', str(1.999999)).group(0) '1.999' def myTrunc(theNumber, theDigits): myDigits = 10 ** theDigits return (int(theNumber * myDigits) / myDigits) На первый взгляд, это работает на Python 3, но не на Python 2, из-за изменений в том, как / работает.
После поиска способа решения этой проблемы, не загружая ни один модуль Python 3 или дополнительные математические операции, я решил проблему, используя только str.format() e.float(). Я думаю, что этот путь быстрее, чем использование других математических операций, например, в большинстве решений commom. Мне нужно быстрое решение, потому что я работаю с очень большим набором данных, поэтому для его работы здесь очень хорошо.
def truncate_number(f_number, n_decimals): strFormNum = "" trunc_num = float(strFormNum.format(f_number)[:-5]) return(trunc_num) # Testing the 'trunc_num()' function test_num = 1150/252 [(idx, truncate_number(test_num, idx)) for idx in range(0, 20)] Он возвращает следующий вывод:
[(0, 4.0), (1, 4.5), (2, 4.56), (3, 4.563), (4, 4.5634), (5, 4.56349), (6, 4.563492), (7, 4.563492), (8, 4.56349206), (9, 4.563492063), (10, 4.5634920634), (11, 4.56349206349), (12, 4.563492063492), (13, 4.563492063492), (14, 4.56349206349206), (15, 4.563492063492063), (16, 4.563492063492063), (17, 4.563492063492063), (18, 4.563492063492063), (19, 4.563492063492063)] Можно ли в Python во float отбросить k знаков после запятой?
Здравствуйте, вопрос следующий.
Допустим, есть число 17.212123445.
А нужно записать в память только первую цифру после запятой. Каким образом сделать это при помощи вещественных и целочисленных операций?
Простой 1 комментарий
Попробуйте через ф-ию round(укажите сколько значков после запятой надо вывести)
>>>a=5.4323321
>>>a.__round__(2)
5.43
>>>a
5.4323321
>>>a.__round__(4)
5.4323
>>> a=13.946 >>> print(a) 13.946 >>> print("%.2f" % a) 13.95Не совсем, тем не менее, спасибо за ответ, это я некорректно вопрос сформулировал, видимо.
Нужно не выводить на печать последние две цифры, а хранить в памяти число с двумя последними цифрами
О_о вместо того чтоб воспользоваться хотя бы функцией round для округления до нужной точности, вы серьёзно предлагаете сначала преобразовать в строку а потом обратно в число?
Артём Клименко: да мне похеру, я могу и scipy зафигачить чтоб число округлить, и да, я предлогаю именно это, потому что это самый что ни на есть стандартнейший способ, быстро сделать то что в ввопросе описано, и при этом следующий прогер который будет это читать сразу поймет о чем речь. а не будет ебсти себе мозг чо там у нас раунд возвращает, да и приведение в строку и обрато способ куда шустрей по ресурсам)
Михаил: round — стандартная bult-in функция, существующая для выполнения конкретной задачи, именно она и является стандартным способом, впрочем, таки да, вы не обязаны со мной соглашаться, но указанный вами способ вызывает у меня стойкое чувство жжения в районе поясницы.
Как удалить дробную часть десятичного числа в Python
Мы работали с разными типами чисел в Python и модифицировали их тип в соответствии с нашими потребностями. В этом руководстве мы обсудим, как мы можем удалить десятичную дробную часть числа в Python.
Начнем с простой программы,
a = 24 print(type(a)) b = 19.4 print(type(b)) c = 3+4j print(type(c))
В приведенной выше программе мы объявили a, b и c как 24, 19,4 и 3 + 4j соответственно.
Проверив их тип, мы узнали, что a принадлежит классу int, b принадлежит классу float, а c принадлежит классу complex.
Здесь нам нужно произвести действия с числами с плавающей запятой, поэтому давайте перечислим различные методы удаления десятичных знаков из чисел.
Давайте подробно обсудим каждый из них.
Функция trunc()
В первой программе мы воспользуемся функцией trunc() и удалим десятичную часть, присутствующую в числах.
import math num_value1 = math.trunc(523.771) print(num_value1) print(type(num_value1)) num_value2 = math.trunc(21.67) print(num_value2) print(type(num_value2)) num_value3 = math.trunc(182.33) print(num_value3) print(type(num_value3)) num_value4 = math.trunc(211.54) print(num_value4) print(type(num_value4)) num_value5 = math.trunc(19.1) print(num_value5) print(type(num_value5))
- Поскольку нам нужно использовать функцию trunc(), мы импортировали математический модуль.
- Мы предоставили пять различных десятичных значений пяти переменным и проверили их тип после их передачи в функцию trunc().
- При выполнении программы отображается требуемый результат.
Использование int()
Пришло время узнать о втором подходе, который удаляет десятичную дробь с помощью int().
Программа, представленная ниже, показывает, как это можно сделать:
num_value1 = 523.771 num_value2 = 21.67 num_value3 = 182.33 print(type(num_value1)) print(type(num_value2)) print(type(num_value3)) new_value1 = int(num_value1) new_value2 = int(num_value2) new_value3 = int(num_value3) print(new_value1) print(new_value2) print(new_value3) print(type(new_value1))
Давайте разберемся, что мы здесь сделали:
- На первом этапе мы предоставили значения с плавающей запятой для трех переменных и проверили их тип.
- После этого мы передали каждую переменную в int() и сохранили их в новой переменной.
- Наконец, мы распечатали значения, хранящиеся в этих переменных.
- При выполнении этой программы отображается ожидаемый результат.
Использование split()
Наконец, в последнем подходе мы будем использовать интересную функцию split() для получения целочисленных значений.
num_values=[523.771,21.67,182.33,211.54,19.1] sp_lst = [] for ele in num_values: sp_lst.append(str(ele).split('.')[0]) res_list = [int(i) for i in sp_lst] print("The resultant list is: ",res_list) The resultant list is: [523, 21, 182, 211, 19]
- На первом этапе мы создали список, содержащий все десятичные значения.
- После этого мы объявили пустой список и добавили в него значения.
- На следующем шаге мы взяли каждый элемент из этого списка и передали его в int().
- Наконец, мы отобразили результирующий список, содержащий числа без десятичной дроби.
Вывод
В этом руководстве мы начали с общего представления о типах чисел, которые мы используем в Python, а затем изучили различные методы удаления десятичных знаков из чисел.