Точное значение после плавающей точки не округление [дубликат]

Я сделал что-то вроде этого:

from math import trunc


def truncate(number, decimals=0):
    if decimals < 0:
        raise ValueError('truncate received an invalid value of decimals ({})'.format(decimals))
    elif decimals == 0:
        return trunc(number)
    else:
        factor = float(10**decimals)
        return trunc(number*factor)/factor

def precision(value, precision):
    """
    param: value: takes a float
    param: precision: int, number of decimal places
    returns a float
    """
    x = 10.0**precision
    num = int(value * x)/ x
    return num
precision(1.923328437452, 3)

1.923

По-настоящему pythonic способ сделать это

from decimal import *

with localcontext() as ctx:
    ctx.rounding = ROUND_DOWN
    print Decimal('1.923328437452').quantize(Decimal('0.001'))

Что-то достаточно простое, чтобы вписываться в список, без библиотек или других внешних зависимостей. Для Python> = 3.6 очень просто писать с помощью f-строк.

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

>>> nout = 3  # desired number of digits in output
>>> [f'{x:.{nout+1}f}'[:-1] for x in [2/3, 4/5, 8/9, 9/8, 5/4, 3/2]]
['0.666', '0.800', '0.888', '1.125', '1.250', '1.500']

Конечно, здесь есть округление (именно для четвертой цифры), но округление в некоторой точке невозможно. В случае, если переход между усечением и округлением имеет значение, вот немного лучший пример:

>>> nacc = 6  # desired accuracy (maximum 15!)
>>> nout = 3  # desired number of digits in output
>>> [f'{x:.{nacc}f}'[:-(nacc-nout)] for x in [2.9999, 2.99999, 2.999999, 2.9999999]]
>>> ['2.999', '2.999', '2.999', '3.000']

Бонус: удаление нулей справа

>>> nout = 3  # desired number of digits in output
>>> [f'{x:.{nout+1}f}'[:-1].rstrip('0') for x in [2/3, 4/5, 8/9, 9/8, 5/4, 3/2]]
['0.666', '0.8', '0.888', '1.125', '1.25', '1.5']

В моем приглашении Python 2.7:

>>> int(1.923328437452 * 1000)/1000.0 1.923

Если вы представляете какую-то математику, это работает для + ve чисел:

>>> v = 1.923328437452
>>> v - v % 1e-3
1.923

Простой скрипт python -

n = 1.923328437452
n = float(int(n * 1000))
n /=1000

Результатом round является float, поэтому смотрите (пример из Python 2.6):

>>> round(1.923328437452, 3)
1.923
>>> round(1.23456, 3)
1.2350000000000001

Вам будет лучше при использовании форматированной строки:

>>> "%.3f" % 1.923328437452
'1.923'
>>> "%.3f" % 1.23456
'1.235'

Хотелось бы упомянуть, что старый метод make () с тэгом

round(f) = floor(f+0.5)

в стиле round () может быть повернут, чтобы сделать floor () из round ()

floor(f) = round(f-0.5)

Хотя оба эти правила ломаются вокруг отрицательных чисел, поэтому использование его меньше идеала:

def trunc(f, n):
    if f > 0:
        return "%.*f" % (n, (f - 0.5*10**-n))
    elif f == 0:
        return "%.*f" % (n, f)
    elif f < 0:
        return "%.*f" % (n, (f + 0.5*10**-n))

>>> floor ((1.23658945) * 10 ** 4) / 10 ** 4 1.2365

# делить и умножать на 10 ** количество желаемых цифр

n = 1.923328437452
str(n)[:4]

def trunc(f,n):
  return ('%.16f' % f)[:(n-16)]

round(1.923328437452, 3)

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

Существует простой способ обхода проблемы в python 3. Где вырезать I с помощью переменной help decPlace, чтобы упростить ее адаптацию.

f = 1.12345
decPlace= 4
f_cut = int(f * 10**decPlace) /10**decPlace

Выход:

f = 1.1234

Надеюсь, это поможет.

import math;

def trunc(invalue, digits):
    return int(invalue*math.pow(10,digits))/math.pow(10,digits);

# value  value to be truncated
# n  number of values after decimal

value = 0.999782
n = 3
float(int(value*1en))*1e-n

использовать numpy.round

import numpy as np
precision = 3
floats = [1.123123123, 2.321321321321]
new_float = np.round(floats, precision)

def trunc(num, digits):
   sp = str(num).split('.')
   return '.'.join([sp[0], sp[1][:digits]])

Это должно сработать. Он должен дать вам усечение, которое вы ищете.

Вот простой способ:

def truncate(num, res=3):
    return (floor(num*pow(10, res)+0.5))/pow(10, res)

для num = 1.923328437452, это выводит 1.923

Вы можете выполнить:

def truncate(f, n):
    return math.floor(f * 10 ** n) / 10 ** n

тестирование:

>>> f=1.923328437452
>>> [truncate(f, n) for n in range(5)]
[1.0, 1.9, 1.92, 1.923, 1.9233]

Я также новичок в python и после использования некоторых бит и частей здесь я предлагаю свои два цента

print str(int(time.time()))+str(datetime.now().microsecond)[:3]

str (int (time.time ())) займет временную эпоху как int и преобразовать его в строку и присоединиться к ... str (datetime.now (). microsecond) [: 3], которая возвращает только микросекунды, конвертировать в строку и усекать до первых трех символов

Если вы имеете в виду при печати, тогда должно работать следующее:

print '%.3f' % number

Общая и простая функция для использования:

def truncate_float(number, length):
    """Truncate float numbers, up to the number specified
    in length that must be an integer"""

    number = number * pow(10, length)
    number = int(number)
    number = float(number)
    number /= pow(10, length)
    return number