Ответ 1
'%.3f'%(1324343032.324325235)
Используйте дополнительный float()
вокруг него, если вы хотите сохранить его как float.
Как мне получить 1324343032.324?
Как вы можете видеть ниже, следующее не работает:
>>1324343032.324325235 * 1000 / 1000
1324343032.3243253
>>int(1324343032.324325235 * 1000) / 1000.0
1324343032.3239999
>>round(int(1324343032.324325235 * 1000) / 1000.0,3)
1324343032.3239999
>>str(1324343032.3239999)
'1324343032.32'
'%.3f'%(1324343032.324325235)
Используйте дополнительный float()
вокруг него, если вы хотите сохранить его как float.
Вы можете использовать следующую функцию для усечения числа до заданного числа десятичных знаков:
import math
def truncate(number, digits) -> float:
stepper = 10.0 ** digits
return math.trunc(stepper * number) / stepper
Использование:
>> truncate(1324343032.324325235, 3)
>> 1324343032.324
Я нашел другое решение (оно должно быть более эффективным, чем обходные методы "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'
Возможный дубликат round() в Python, похоже, не округляется правильно
[EDIT]
Учитывая дополнительные комментарии, которые, как я полагаю, вы захотите сделать:
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
Итак:
float("%3.f" % q)
'%.3f' % (+1324343032,324325235)
Это нормально только в этом конкретном случае.
Просто немного измените номер:
1324343032.324 7 25235
А потом:
'%.3f'%(1324343032.324725235)
дает вам 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.
>>> '%.3f'%(1.9999999)
'2.000'
Вместо этого используйте регулярное выражение:
>>> re.match(r'\d+.\d{3}', str(1.999999)).group(0)
'1.999'
Может быть, так:
def myTrunc(theNumber, theDigits):
myDigits = 10 ** theDigits
return (int(theNumber * myDigits) / myDigits)
Вы также можете использовать:
import math
nValeur = format(float(input('Quelle valeur ? ')), '.3f')
В Python 3.6 это будет работать.
После поиска способа решения этой проблемы, не загружая ни один модуль Python 3 или дополнительные математические операции, я решил проблему, используя только str.format() e.float(). Я думаю, что этот путь быстрее, чем использование других математических операций, например, в большинстве решений commom. Мне нужно быстрое решение, потому что я работаю с очень большим набором данных, поэтому для его работы здесь очень хорошо.
def truncate_number(f_number, n_decimals):
strFormNum = "{0:." + str(n_decimals+5) + "f}"
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)]
Хорошо, это просто еще один подход, чтобы решить эту проблему, работая с числом как строкой и выполняя простой его фрагмент. Это дает усеченный вывод числа вместо округленного.
num = 1324343032.324325235
truncated = ""
for i, digit in enumerate(str(num)):
if digit == '.':
truncated = str(num)[:i+4]
print(truncated)
Выход:
'1324343032.324'
Конечно, тогда вы можете разобрать:
float(truncated)
a = 1.0123456789
dec = 3 # keep this many decimals
p = 10 # raise 10 to this power
a * 10 ** p // 10 ** (p - dec) / 10 ** dec
>>> 1.012
>>> float(1324343032.324325235) * float(1000) / float(1000)
1324343032.3243253
>>> round(float(1324343032.324325235) * float(1000) / float(1000), 3)
1324343032.324