Я хочу удалить цифры из float, чтобы иметь фиксированное количество цифр после точки, например:
1.923328437452 -> 1.923
Мне нужно выводить как строку в другую функцию, а не печатать.
Также я хочу игнорировать потерянные цифры, а не круги вокруг них.
Во-первых, функция для тех, кто просто хочет получить код копирования и вставки:
def truncate(f, n):
'''Truncates/pads a float f to n decimal places without rounding'''
s = '{}'.format(f)
if 'e' in s or 'E' in s:
return '{0:.{1}f}'.format(f, n)
i, p, d = s.partition('.')
return '.'.join([i, (d+'0'*n)[:n]])
Это справедливо в Python 2.7 и 3.1+. Для более старых версий невозможно получить тот же эффект "интеллектуального округления" (по крайней мере, не без большого количества сложного кода), но округляя до 12 знаков после запятой, прежде чем усечение будет работать большую часть времени:
def truncate(f, n):
'''Truncates/pads a float f to n decimal places without rounding'''
s = '%.12f' % f
i, p, d = s.partition('.')
return '.'.join([i, (d+'0'*n)[:n]])
Ядро базового метода состоит в том, чтобы преобразовать значение в строку с полной точностью, а затем просто отрубить все, кроме желаемого количества символов. Последний шаг прост; это можно сделать либо с помощью строковой манипуляции
i, p, d = s.partition('.')
'.'.join([i, (d+'0'*n)[:n]])
или decimal модуль
str(Decimal(s).quantize(Decimal((0, (1,), -n)), rounding=ROUND_DOWN))
Первый шаг, преобразование в строку, довольно сложно, потому что есть несколько пар литералов с плавающей запятой (т.е. то, что вы пишете в исходном коде), которые оба производят одно и то же двоичное представление и все же должны быть усечены по-разному. Например, рассмотрите 0,3 и 0,29999999999999998. Если вы пишете 0.3 в программе Python, компилятор кодирует его с использованием формата с плавающей запятой IEEE в последовательность бит (при условии 64-битного поплавка)
0011111111010011001100110011001100110011001100110011001100110011
Это самое близкое значение до 0.3, которое может быть точно представлено как поплавок IEEE. Но если вы пишете 0.29999999999999998 в программе Python, компилятор переводит его в точно такое же значение. В одном случае вы имели в виду, что он был усечен (на одну цифру) как 0.3, тогда как в другом случае вы имели в виду, что он был усечен как 0.2, но Python может дать только один ответ. Это фундаментальное ограничение Python или даже любой язык программирования без ленивой оценки. Функция усечения имеет доступ только к двоичному значению, хранящемуся в памяти компьютера, а не к строке, которую вы действительно ввели в исходный код. 1
Если вы декодируете последовательность бит обратно в десятичное число, снова используя 64-битный формат с плавающей запятой IEEE, вы получите
0.2999999999999999888977697537484345957637...
поэтому наивная реализация возникла бы с 0.2, хотя это, вероятно, не то, что вы хотите. Подробнее о ошибке с плавающей запятой, см. Учебник Python.
Очень редко приходится работать с значением с плавающей запятой, которое так близко к круглому числу и все же намеренно не равно этому круглому числу. Поэтому при усечении, вероятно, имеет смысл выбрать "самое приятное" десятичное представление из всего, что может соответствовать значению в памяти. Python 2.7 и выше (но не 3.0) включают в себя сложный алгоритм, который делает именно это, к которому мы можем получить доступ через операцию форматирования строки по умолчанию.
'{}'.format(f)
Единственное предостережение состоит в том, что это действует как спецификация формата g в том смысле, что использует экспоненциальную нотацию (1.23e+4), если число является большим или достаточно маленьким. Поэтому метод должен поймать этот случай и обрабатывать его по-разному. Есть несколько случаев, когда использование спецификации формата f вместо этого вызывает проблему, например, попытку обрезать 3e-10 до 28 цифр точности (она производит 0.0000000002999999999999999980), и я еще не уверен, как лучше всего обрабатывать те.
Если вы действительно работаете с float, которые очень близки к круглым числам, но намеренно не равны им (например, 0.29999999999999998 или 99.959999999999994), это приведет к некоторым ложным срабатываниям, то есть будет округлено число, которое вы не сделали хотите округлить. В этом случае решение должно указывать фиксированную точность.
'{0:.{1}f}'.format(f, sys.float_info.dig + n + 2)
Число цифр точности, используемых здесь, не имеет большого значения, оно должно быть достаточно большим, чтобы гарантировать, что любое округление, выполняемое в преобразовании строки, не "подменяет" значение на его хорошее десятичное представление. Я думаю, что sys.float_info.dig + n + 2 может быть достаточно во всех случаях, но если не нужно, чтобы 2 мог быть увеличен, и это не помешает сделать это.
В более ранних версиях Python (до 2.6 или 3.0) форматирование чисел с плавающей запятой было намного более грубым и регулярно производило такие вещи, как
>>> 1.1
1.1000000000000001
Если это ваша ситуация, если вы хотите использовать "красивые" десятичные представления для усечения, все, что вы можете сделать (насколько мне известно), - это выбрать некоторое количество цифр, меньше полной точности, представляемой float, и округлите число до этого числа, прежде чем обрезать его. Типичный выбор - 12,
'%.12f' % f
но вы можете настроить его в соответствии с числами, которые вы используете.
1Ну... я соврал. Технически вы можете поручить Python повторно проанализировать свой собственный исходный код и извлечь часть, соответствующую первому аргументу, который вы передаете функции усечения. Если этот аргумент является литералом с плавающей запятой, вы можете просто отрезать его от определенного количества мест после десятичной точки и вернуть это. Однако эта стратегия не работает, если аргумент является переменной, что делает ее бесполезной. Для развлекательной ценности представлено только следующее:
def trunc_introspect(f, n):
'''Truncates/pads the float f to n decimal places by looking at the caller source code'''
current_frame = None
caller_frame = None
s = inspect.stack()
try:
current_frame = s[0]
caller_frame = s[1]
gen = tokenize.tokenize(io.BytesIO(caller_frame[4][caller_frame[5]].encode('utf-8')).readline)
for token_type, token_string, _, _, _ in gen:
if token_type == tokenize.NAME and token_string == current_frame[3]:
next(gen) # left parenthesis
token_type, token_string, _, _, _ = next(gen) # float literal
if token_type == tokenize.NUMBER:
try:
cut_point = token_string.index('.') + n + 1
except ValueError: # no decimal in string
return token_string + '.' + '0' * n
else:
if len(token_string) < cut_point:
token_string += '0' * (cut_point - len(token_string))
return token_string[:cut_point]
else:
raise ValueError('Unable to find floating-point literal (this probably means you called {} with a variable)'.format(current_frame[3]))
break
finally:
del s, current_frame, caller_frame
Обобщение этого для обработки случая, когда вы передаете переменную, похоже на потерянную причину, так как вам придется трассировать назад через выполнение программы, пока не найдете литерал с плавающей запятой, который дал переменной значение. Если есть даже один. Большинство переменных будут инициализированы из пользовательского ввода или математических выражений, и в этом случае двоичное представление есть все, что есть.
round(1.923328437452, 3)
См. Документация Python для стандартных типов. Вам нужно немного прокрутить список, чтобы перейти к круглой функции. По сути, второе число указывает, сколько десятичных знаков округлить до.
Результатом round является число с плавающей точкой, так что будьте внимательны (пример из 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'
n = 1.923328437452
str(n)[:4]
В моем приглашении Python 2.7:
>>> int(1.923328437452 * 1000)/1000.0
1.923
Простой скрипт на Python -
n = 1.923328437452
n = float(int(n * 1000))
n /=1000
def trunc(num, digits):
sp = str(num).split('.')
return '.'.join([sp[0], sp[1][:digits]])
Это должно работать. Это должно дать вам усечение, которое вы ищете.
Истинно питонический способ сделать это
from decimal import *
with localcontext() as ctx:
ctx.rounding = ROUND_DOWN
print Decimal('1.923328437452').quantize(Decimal('0.001'))
или короче:
from decimal import D, ROUND_DOWN
D('1.923328437452').quantize(D('0.001'), rounding=ROUND_DOWN)
Обновить
Обычно проблема заключается не в урезании самих чисел с плавающей запятой, а в неправильном использовании чисел с плавающей запятой перед округлением.
Например: int(0.7*3*100)/100 == 2.09.
Если вы вынуждены использовать float (например, вы ускоряете свой код с помощью numba), лучше использовать центы как "внутреннее представление" цен: (70*3 == 210) и умножать/делить входы/выходы.
Таким образом, многие ответы на этот вопрос совершенно неверны. Они либо округляют всплывающие окна (а не обрезают) или не работают для всех случаев.
Это лучший результат Google, когда я ищу "Python truncate float", концепцию, которая действительно проста, и которая заслуживает лучших ответов. Я согласен с Hatchkins в том, что использование модуля decimal - это питонический способ сделать это, поэтому я даю здесь функцию, которая, как я думаю, правильно отвечает на вопрос и которая работает как ожидалось для всех случаев.
Как побочная заметка, дробные значения, вообще говоря, не могут быть представлены точно бинарными переменными с плавающей запятой (см. здесь для обсуждения этого), что почему моя функция возвращает строку.
from decimal import Decimal, localcontext, ROUND_DOWN
def truncate(number, places):
if not isinstance(places, int):
raise ValueError("Decimal places must be an integer.")
if places < 1:
raise ValueError("Decimal places must be at least 1.")
# If you want to truncate to 0 decimal places, just do int(number).
with localcontext() as context:
context.rounding = ROUND_DOWN
exponent = Decimal(str(10 ** - places))
return Decimal(str(number)).quantize(exponent).to_eng_string()
Я сделал что-то вроде этого:
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 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]
Если вам интересна математика, это работает для чисел +ve:
>>> v = 1.923328437452
>>> v - v % 1e-3
1.923
def trunc(f,n):
return ('%.16f' % f)[:(n-16)]
Просто хотел упомянуть, что старый "make round() с тэгом floor()"
round(f) = floor(f+0.5)
можно поворачивать, чтобы сделать 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))
Int (16.5); это даст целое значение 16, т.е. trunc, не сможет указать десятичные числа, но предположите, что вы можете сделать это с помощью
import math;
def trunc(invalue, digits):
return int(invalue*math.pow(10,digits))/math.pow(10,digits);
Вот простой способ:
def truncate(num, res=3):
return (floor(num*pow(10, res)+0.5))/pow(10, res)
для num = 1.923328437452, это выводит 1.923
использовать numpy.round
import numpy as np
precision = 3
floats = [1.123123123, 2.321321321321]
new_float = np.round(floats, precision)
Общая и простая функция:
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
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
Большинство ответов слишком сложны, на мой взгляд, как насчет этого?
digits = 2 # Specify how many digits you want
fnum = '122.485221'
truncated_float = float(fnum[:fnum.find('.') + digits + 1])
>>> 122.48
Простое сканирование на предмет индекса '.' и обрезать по желанию (без округления). Конвертировать строку в плавающий как последний шаг.
Или в вашем случае, если вы получаете float в качестве входных данных и хотите строку в качестве выходных данных:
fnum = str(122.485221) # convert float to string first
truncated_float = fnum[:fnum.find('.') + digits + 1] # string output
>>> floor((1.23658945) * 10**4) / 10**4
1.2365
# разделить и умножить на 10 ** количество желаемых цифр
В python 3 есть простой обходной путь. Где вырезать, я определил с помощью переменной decPlace, чтобы облегчить адаптацию.
f = 1.12345
decPlace= 4
f_cut = int(f * 10**decPlace) /10**decPlace
Выход:
f = 1.1234
Надеюсь, поможет.
Что-то достаточно простое, чтобы вписаться в понимание списка, без библиотек или других внешних зависимостей. Для 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']
Основная идея, представленная здесь, кажется мне лучшим подходом к этой проблеме. К сожалению, он получил меньше голосов, в то время как более поздний ответ, который имеет больше голосов, не является полным (как отмечено в комментариях). Надеемся, что реализация ниже обеспечивает краткое и полное решение для усечения.
def trunc(num, digits):
l = str(float(num)).split('.')
digits = min(len(l[1]), digits)
return (l[0]+'.'+l[1][:digits])Короткий и простой вариант
def truncate_float(value, digits_after_point=2):
pow_10 = 10 ** digits_after_point
return (float(int(value * pow_10))) / pow_10
>>> truncate_float(1.14333, 2)
>>> 1.14
>>> truncate_float(1.14777, 2)
>>> 1.14
>>> truncate_float(1.14777, 4)
>>> 1.1477
f = 1.923328437452
f = f - f % 0.001
При использовании панд DF это работало для меня
import math
def truncate(number, digits) -> float:
stepper = 10.0 ** digits
return math.trunc(stepper * number) / stepper
df['trunc'] = df['float_val'].apply(lambda x: truncate(x,1))
df['trunc']=df['trunc'].map('{:.1f}'.format)
Я также новичок в python, и после использования некоторых бит и кусков здесь я предлагаю свои два цента
print str(int(time.time()))+str(datetime.now().microsecond)[:3]
str (int (time.time())) возьмет временную эпоху как int и преобразует ее в строку и присоединяется с помощью... str (datetime.now(). microsecond) [: 3], который возвращает только микросекунды, преобразуется в строку и усекает до первых трех символов
# value value to be truncated
# n number of values after decimal
value = 0.999782
n = 3
float(int(value*1en))*1e-n
Если вы имеете в виду при печати, тогда должно работать следующее:
print '%.3f' % number