# Limiting Float Decimal Points in Python

## Introduction

In Python, we often deal with numbers that have a fractional part, known as floating-point numbers. But what if we want to limit the number of decimal points in these numbers? This Byte will talk about the concept of floating-point numbers, why we might want to limit their decimal points, and how to do so using Python's built-in functions.

## Floating-Point Numbers

Floating-point numbers, or simply "floats", are numbers that have a decimal point. In Python, you can define a float by simply including a decimal point in the number, like so:

```
my_float = 3.14159
print(my_float)
```

Output:

```
3.14159
```

## Why limit the decimal points?

You might be wondering, "Why would I want to limit the decimal points of a float?" Well, there are many reasons. Perhaps you're dealing with a currency value, and you only need two decimal places. Or maybe you're calculating a percentage, and you don't need a high level of precision and want to make it more readable.

Limiting the decimal points can make your data easier to read and understand.

## How to Limit a Float's Decimal Points

Python provides several ways to limit the decimal points of a float. We'll cover some of the most common methods here:

### Using the round() Function

The `round()`

function is a built-in Python function that rounds a number to a specified number of decimal places. By default, it rounds to the nearest whole number, but you can pass a second argument to specify the number of decimal places. Here's how you can use it:

```
my_float = 3.14159
rounded_float = round(my_float, 2)
print(rounded_float)
```

Output:

```
3.14
```

In this example, we've rounded `my_float`

to two decimal places.

**Note:** The `round()`

function uses "round half to even" rounding, also known as "bankers' rounding". This means that if the number to be rounded is exactly halfway between two possible values, it will be rounded to the nearest even number. This is something to keep in mind if you're dealing with numbers that often end in .5.

### Using the format() Function

The `format()`

function is another way to limit a float's decimal points in Python. This formatting method provides more control over how you want your numbers to be displayed.

```
num = 12.34567
formatted_num = "{:.2f}".format(num)
print(formatted_num)
```

Output:

```
12.35
```

In this example, the `:.2f`

inside the curly braces `{}`

is a format specification for the float number. The `.2`

part specifies the precision of the numbers after the decimal. The `f`

at the end stands for "fixed point" number, which is used to represent decimal numbers.

**Note:** The `format()`

function doesn't modify the original float number. Instead, it returns a formatted string. So if you want to use or manipulate this number, you'll need to convert it back into a float.

### Using the Decimal Module

Another method to limit a float's decimal points is by using the `Decimal`

module in Python. This module provides support for fast correctly rounded decimal floating point arithmetic.

```
from decimal import Decimal
num = Decimal(12.34567)
rounded_num = round(num, 2)
print(rounded_num)
```

Output:

```
12.35
```

In this example, we first import the `Decimal`

module. We then convert our float number to a Decimal and use the `round()`

function to limit the decimal points to two.

The `Decimal`

module provides more precision and control over floating point arithmetic than the built-in Python float data type.

## Rounding vs Truncating Decimal Points

When limiting decimal points, it's important to understand the difference between rounding and truncating. Rounding refers to approximating a number to the nearest value, while truncating means removing the excess digits *without* rounding.

For instance, if you have the number 12.789 and you want to limit it to two decimal points, rounding would give you 12.79 while truncating would give you 12.78.

Here's how you can truncate a float to two decimal points by using only `int`

and some multiplication/division:

```
num = 12.789
truncated_num = int(num * 100) / 100
print(truncated_num)
```

Output:

```
12.78
```

To achieve the truncation, we multiply the float by 100, convert it to an integer to remove the excess decimal points, and then divide it by 100 to get the truncated value.

## Conclusion

In this Byte, we explored different ways to limit a float's decimal points in Python using the `round()`

, `format()`

, and `Decimal`

module. We also discussed the difference between rounding and truncating decimal points. The choice of method you use is largely depends on the specific requirements of your program. The `Decimal`

module is a powerful tool for dealing with floating point numbers, especially when precision is most important. However, for simple rounding or formatting, the `round()`

and `format()`

functions are often enough.