Tutorial :Truncating floats in Python

Question:

I want to remove digits from a float to have a fixed number of digits after the dot, like:

``1.923328437452 -> 1.923  ``

I need to output as a string to another function, not print.

Also I want to ignore the lost digits, not round them.

Solution:1

First, the function, for those who just want some copy-and-paste code:

``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]])  ``

This is valid in Python 2.7 and 3.1+. For older versions, it's not possible to get the same "intelligent rounding" effect (at least, not without a lot of complicated code), but rounding to 12 decimal places before truncation will work much of the time:

``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]])  ``

Explanation

The core of the underlying method is to convert the value to a string at full precision and then just chop off everything beyond the desired number of characters. The latter step is easy; it can be done either with string manipulation

``i, p, d = s.partition('.')  '.'.join([i, (d+'0'*n)[:n]])  ``

or the `decimal` module

``str(Decimal(s).quantize(Decimal((0, (1,), -n)), rounding=ROUND_DOWN))  ``

The first step, converting to a string, is quite difficult because there are some pairs of floating point literals (i.e. what you write in the source code) which both produce the same binary representation and yet should be truncated differently. For example, consider 0.3 and 0.29999999999999998. If you write `0.3` in a Python program, the compiler encodes it using the IEEE floating-point format into the sequence of bits (assuming a 64-bit float)

``0011111111010011001100110011001100110011001100110011001100110011  ``

This is the closest value to 0.3 that can accurately be represented as an IEEE float. But if you write `0.29999999999999998` in a Python program, the compiler translates it into exactly the same value. In one case, you meant it to be truncated (to one digit) as `0.3`, whereas in the other case you meant it to be truncated as `0.2`, but Python can only give one answer. This is a fundamental limitation of Python, or indeed any programming language without lazy evaluation. The truncation function only has access to the binary value stored in the computer's memory, not the string you actually typed into the source code.1

If you decode the sequence of bits back into a decimal number, again using the IEEE 64-bit floating-point format, you get

``0.2999999999999999888977697537484345957637...  ``

so a naive implementation would come up with `0.2` even though that's probably not what you want. For more on floating-point representation error, see the Python tutorial.

It's very rare to be working with a floating-point value that is so close to a round number and yet is intentionally not equal to that round number. So when truncating, it probably makes sense to choose the "nicest" decimal representation out of all that could correspond to the value in memory. Python 2.7 and up (but not 3.0) includes a sophisticated algorithm to do just that, which we can access through the default string formatting operation.

``'{}'.format(f)  ``

The only caveat is that this acts like a `g` format specification, in the sense that it uses exponential notation (`1.23e+4`) if the number is large or small enough. So the method has to catch this case and handle it differently. There are a few cases where using an `f` format specification instead causes a problem, such as trying to truncate `3e-10` to 28 digits of precision (it produces `0.0000000002999999999999999980`), and I'm not yet sure how best to handle those.

If you actually are working with `float`s that are very close to round numbers but intentionally not equal to them (like 0.29999999999999998 or 99.959999999999994), this will produce some false positives, i.e. it'll round numbers that you didn't want rounded. In that case the solution is to specify a fixed precision.

``'{0:.{1}f}'.format(f, sys.float_info.dig + n + 2)  ``

The number of digits of precision to use here doesn't really matter, it only needs to be large enough to ensure that any rounding performed in the string conversion doesn't "bump up" the value to its nice decimal representation. I think `sys.float_info.dig + n + 2` may be enough in all cases, but if not that `2` might have to be increased, and it doesn't hurt to do so.

In earlier versions of Python (up to 2.6, or 3.0), the floating point number formatting was a lot more crude, and would regularly produce things like

``>>> 1.1  1.1000000000000001  ``

If this is your situation, if you do want to use "nice" decimal representations for truncation, all you can do (as far as I know) is pick some number of digits, less than the full precision representable by a `float`, and round the number to that many digits before truncating it. A typical choice is 12,

``'%.12f' % f  ``

but you can adjust this to suit the numbers you're using.

1Well... I lied. Technically, you can instruct Python to re-parse its own source code and extract the part corresponding to the first argument you pass to the truncation function. If that argument is a floating-point literal, you can just cut it off a certain number of places after the decimal point and return that. However this strategy doesn't work if the argument is a variable, which makes it fairly useless. The following is presented for entertainment value only:

``def trunc_introspect(f, n):      '''Truncates/pads the float f to n decimal places by looking at the caller's 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  ``

Generalizing this to handle the case where you pass in a variable seems like a lost cause, since you'd have to trace backwards through the program's execution until you find the floating-point literal which gave the variable its value. If there even is one. Most variables will be initialized from user input or mathematical expressions, in which case the binary representation is all there is.

Solution:2

``round(1.923328437452, 3)  ``

See Python's documentation on the standard types. You'll need to scroll down a bit to get to the round function. Essentially the second number says how many decimal places to round it to.

Solution:3

The result of `round` is a float, so watch out:

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

You will be better off when using a formatted string:

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

Solution:4

``n = 1.923328437452  str(n)[:4]  ``

Solution:5

The truely pythonic way of doing it is

``from decimal import *    with localcontext() as ctx:      ctx.rounding = ROUND_DOWN      print Decimal('1.923328437452').quantize(Decimal('0.001'))  ``

Solution:6

At my Python 2.7 prompt:

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

Solution:7

So many of the answers given for this question are just completely wrong. They either round up floats (rather than truncate) or do not work for all cases.

This is the top Google result when I search for 'Python truncate float', a concept which is really straightforward, and which deserves better answers. I agree with Hatchkins that using the `decimal` module is the pythonic way of doing this, so I give here a function which I think answers the question correctly, and which works as expected for all cases.

As a side-note, fractional values, in general, cannot be represented exactly by binary floating point variables (see here for a discussion of this), which is why my function returns a string.

``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()  ``

Solution:8

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

This should work. It should give you the truncation you are looking for.

Solution:9

Simple python script -

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

Solution:10

I did something like this:

``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  ``

Solution:11

You can do:

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

testing:

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

Solution:12

Just wanted to mention that the old "make round() with floor()" trick of

``round(f) = floor(f+0.5)  ``

can be turned around to make floor() from round()

``floor(f) = round(f-0.5)  ``

Although both these rules break around negative numbers, so using it is less than ideal:

``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))  ``

Solution:13

int(16.5); this will give an integer value of 16, i.e. trunc, won't be able to specify decimals, but guess you can do that by

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

Solution:14

use numpy.round

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

Solution:15

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

Solution:16

A general and simple function to use:

``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  ``

Solution:17

If you fancy some mathemagic, this works for +ve numbers:

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

Solution:18

Here is an easy way:

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

for num = 1.923328437452, this outputs 1.923

Solution:19

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

# divide and multiply by 10**number of desired digits

Solution:20

Am also a python newbie and after making use of some bits and pieces here, I offer my two cents

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

str(int(time.time())) will take the time epoch as int and convert it to string and join with... str(datetime.now().microsecond)[:3] which returns the microseconds only, convert to string and truncate to first 3 chars

Solution:21

``# value  value to be truncated  # n  number of values after decimal    value = 0.999782  n = 3  float(int(value*1en))*1e-n  ``

Solution:22

If you mean when printing, then the following should work:

``print '%.3f' % number  ``

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »