I’ve been working on a script that takes data from an Excel spreadsheet, rounds the numbers, and removes the decimal point, for example, 2606.89579999999 becomes 26069. However, I need the number to round to two decimal places even if there would be a trailing zero, so 2606.89579999999 should become 260690.

I currently have it so `i`

takes the data from the cell in Excel, and rounds it to two decimal places (`i = round(i, 2)`

) which gives me the single decimal point in the above example.

I’ve tried figuring out how to get this to work with `Decimal`

, but I can’t seem to get it working.

All other numbers that get rounded, if the rounded value doesn’t end in ‘0’, work fine with `round(i, 2)`

, but if the numbers just so happen to end in *.x0, that 0 gets dropped off and messes with the data.

## Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

### Solution 1

As you are talking about trailing zeros, this is a question about representation as string,

you can use

```
>>> "%.2f" % round(2606.89579999999, 2)
'2606.90'
```

Or use modern style with `format`

function:

```
>>> '{:.2f}'.format(round(2606.89579999999, 2))
'2606.90'
```

and remove point with `replace`

or `translate`

(`_`

refers to result of previous command in python console):

```
>>> _.translate(None, '.')
'260690'
```

Note that rounding is not needed here, as `.2f`

format applyies the same rounding:

```
>>> "%.2f" % 2606.89579999999
'2606.90'
```

But as you mentioned excel, you probably would opt to roll your own rounding function, or use decimal, as `float.round`

can lead to strange results due to float representation:

```
>>> round(2.675, 2)
2.67
>>> round(2606.89579999999, 2)
2606.89
```

With decimal use quantize:

```
>>> from decimal import *
>>> x = Decimal('2606.8950000000001')
# Decimal('2606.8950000000001')
>>> '{}'.format(x.quantize(Decimal('.01'), rounding=ROUND_HALF_EVEN))
'2606.90'
```

That, for your original task, becomes:

```
>>> x = Decimal('2606.8950000000001')
>>> int((x*100).quantize(1, rounding=ROUND_HALF_EVEN))
260690
```

And the reason of strange rounding comes to the front with `Decimal`

:

```
>>> x = Decimal(2606.8950000000001)
# Decimal('2606.89499999999998181010596454143524169921875') # internal float repr
```

### Solution 2

As of Python 3.6, you can also use an f-string to inline format the number. In this case, the desired format is floating point with 2 decimal places so you would use `.2f`

as the format specifier:

```
x = 2606.89579999999
x = round(x, 2) # not strictly necessary as format will round for you
print(f'{x:.2f}')
```

Output:

```
2606.90
```

### Solution 3

```
>>> '{:.2f}'.format(2606.89579999999).replace('.', '')
'260690'
```

### Solution 4

I the answers that I saw here did not satisfy me.

So here my solution:

```
def round_with_padding(value, round_digits):
return format(round(value,round_digits), "."+str(round_digits)+"f")
```

Hope you like it

### Solution 5

In case you want to dynamically change the number of decimal places, you can use the modification below:

```
def formatNumber(n, digits):
formatter = '{:.' + '{}'.format(digits) + 'f}'
x = round(n, digits)
return formatter.format(x)
x = 2606.89579999999
digits = 2
formatted_number = formatNumber(x, digits)
```

That way, all you have to do, it to change the `digits`

variable. This will return:

```
2606.90
```

### Solution 6

```
>>> int (round (2606.89579999999,2)*100)
260690
```

**Note: Use and implement solution 1 because this method fully tested our system.Thank you 🙂**

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0