For more detail, take a look at the `Include/pyport.h`

file in the Python source distribution. Here's an excerpt:

```
/* If we can't guarantee 53-bit precision, don't use the code
in Python/dtoa.c, but fall back to standard code. This
means that repr of a float will be long (17 sig digits).
Realistically, there are two things that could go wrong:
(1) doubles aren't IEEE 754 doubles, or
(2) we're on x86 with the rounding precision set to 64-bits
(extended precision), and we don't know how to change
the rounding precision.
*/
#if!defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \
!defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \
!defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754)
#define PY_NO_SHORT_FLOAT_REPR
#endif
/* double rounding is symptomatic of use of extended precision on x86. If
we're seeing double rounding, and we don't have any mechanism available for
changing the FPU rounding precision, then don't use Python/dtoa.c. */
#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION)
#define PY_NO_SHORT_FLOAT_REPR
#endif
```

Essentially, there are two things that can go wrong. One is that the Python configuration fails to identify the floating-point format of a C double. That format is almost always IEEE 754 binary64, but sometimes the config script fails to figure that out. That's the first `#if`

preprocessor check in the snippet above. Look at the `pyconfig.h`

file generated at compile time, and see if at least one of the `DOUBLE_IS_...`

macros is `#define`

d. Alternatively, try this at a Python prompt:

```
>>> float.__getformat__('double')
'IEEE, little-endian'
```

Representation error refers to the fact that some (most, actually) decimal fractions cannot be represented exactly as binary (base 2) fractions. This is the chief reason why Python (or Perl, C, C++, Java, Fortran, and many others) often won’t display the exact decimal number you expect.,Floating-point numbers are represented in computer hardware as base 2 (binary) fractions. For example, the decimal fraction,Unfortunately, most decimal fractions cannot be represented exactly as binary fractions. A consequence is that, in general, the decimal floating-point numbers you enter are only approximated by the binary floating-point numbers actually stored in the machine.,In the same way, no matter how many base 2 digits you’re willing to use, the decimal value 0.1 cannot be represented exactly as a base 2 fraction. In base 2, 1/10 is the infinitely repeating fraction

0.125

0.001

0.3

0.33

0.333

0.0001100110011001100110011001100110011001100110011...

This issue tracker has been migrated to GitHub, and is currently read-only. For more information, see the GitHub FAQs in the Python's Developer Guide.

```
The current float repr() always calculates the 17 first digits of the
decimal representation of a float, and displays all of them(discarding trailing zeros).This is a simple method
for making sure that
eval(repr(f)) == f.However, many times it results in a long string,
where a shorter string would have sufficed.For example, currently
repr(1.1) is '1.1000000000000001', where obviously '1.1'
would have been
good enough, and much easier to read.
This patch implements an algorithm
for finding the shortest string that
will evaluate to the right number.It is based on the code from
http: //www.cs.indiana.edu/~burger/fp/index.html, and also on the
floating - point formatting
function of TCL, Tcl_PrintDouble.
The patch also adds a test
case, which takes a long list of floating
point numbers, created especially
for testing binary to decimal
conversion, and makes sure that eval(repr(f)) == f.See
floating_points.txt
for the source of the list.
```

I like this; but I don 't have time for a complete thourough review. Maybe Tim can lend a hand ? If Tim has no time, I propose that if it works correctly without leaks on at least Windows, OSX and Linux, we check it in , and worry about more review later. Crys, can you test this on Windows and see if it needs any project file updates ? I 'll check OSX. Linux works and I see no leaks.

```
Applied in r59457
I had to add checks
for _M_X64 and _M_IA64 to doubledigits.c.The rest
was fine on Windows.
```

```
Noam, perhaps you can help with this ? We checked this in but found a
problem: repr(1e5) suddenly returns '1.0'.Can you think of a cause
for
this ?
```

I don 't know, for me it works fine, even after downloading a fresh SVN copy.On what platform does it happen ?

I 've disabled the new repr() in trunk and py3k until somebody has sorted out the build problems.I 've removed doubledigits.c from Makefile.in and disabled the code with #ifdef Py_BROKEN_REPR in floatobject.c.

The float() method returns a floating point number from a number or a string.,x (Optional) - number or string that needs to be converted to floating point number If it's a string, the string should contain decimal points,Equivalent floating point number if an argument is passed,In this tutorial, we will learn about the Python float() method with the help of examples.

### Example

int_number = 25 # convert int to float float_number = float(int_number) print(float_number) # Output: 25.0

### Example

int_number = 25 # convert int to float float_number = float(int_number) print(float_number) # Output: 25.0

The syntax for `float()`

is:

`float([x])`

## Example 1: How float() works in Python?

```
#
for integers
print(float(10))
#
for floats
print(float(11.22))
#
for string floats
print(float("-13.33"))
#
for string floats with whitespaces
print(float(" -24.45\n"))
# string float error
print(float("abc"))
```

## Example 2: float() for infinity and Nan(Not a number)?

```
#
for NaN
print(float("nan"))
print(float("NaN"))
#
for inf / infinity
print(float("inf"))
print(float("InF"))
print(float("InFiNiTy"))
print(float("infinity"))
```

Last Updated : 11 Nov, 2019

>>> 1.2 - 1.0

**Output:**

0.199999999999999996

We know similar cases in decimal math, there are many results that can’t be represented with a fixed number of decimal digits,**Example**

10 / 3 = 3.33333333.......

Which is exactly equal to :

1.1999999999999999555910790149937383830547332763671875

Because Python can represent some floats approximately, it will cause many problems when you compare two floating-point numbers.,Python uses a fixed number of bytes (8 bytes) to represent floats. Therefore, it can represent some numbers in binary approximately.,Because of this, Python can only use approximate float representations for those numbers.,Summary: in this tutorial, you’ll learn about the Python float type, how Python represents the floating-point numbers, and how to test the floating-point number for equality.

The `float()`

returns a floating-point number based on a number or a string. For example:

```
.wp - block - code {
border: 0;
padding: 0;
}
.wp - block - code > div {
overflow: auto;
}
.shcb - language {
border: 0;
clip: rect(1 px, 1 px, 1 px, 1 px); -
webkit - clip - path: inset(50 % );
clip - path: inset(50 % );
height: 1 px;
margin: -1 px;
overflow: hidden;
padding: 0;
position: absolute;
width: 1 px;
word - wrap: normal;
word - break: normal;
}
.hljs {
box - sizing: border - box;
}
.hljs.shcb - code - table {
display: table;
width: 100 % ;
}
.hljs.shcb - code - table > .shcb - loc {
color: inherit;
display: table - row;
width: 100 % ;
}
.hljs.shcb - code - table.shcb - loc > span {
display: table - cell;
}
.wp - block - code code.hljs: not(.shcb - wrap - lines) {
white - space: pre;
}
.wp - block - code code.hljs.shcb - wrap - lines {
white - space: pre - wrap;
}
.hljs.shcb - line - numbers {
border - spacing: 0;
counter - reset: line;
}
.hljs.shcb - line - numbers > .shcb - loc {
counter - increment: line;
}
.hljs.shcb - line - numbers.shcb - loc > span {
padding - left: 0.75 em;
}
.hljs.shcb - line - numbers.shcb - loc::before {
border - right: 1 px solid #ddd;
content: counter(line);
display: table - cell;
padding: 0 0.75 em;
text - align: right; -
webkit - user - select: none; -
moz - user - select: none; -
ms - user - select: none;
user - select: none;
white - space: nowrap;
width: 1 % ;
} >>> float(0.1)
0.1
>>>
float('1.25')
1.25 Code language: JavaScript(javascript)
```

The following shows how Python represents the number 0.1 using 20 digits:

```
>>> format(0.1, '.20f')
'0.10000000000000000555'
Code language: JavaScript(javascript)
```

Let’s take a look at the following example:

x = 0.1 + 0.1 + 0.1 y = 0.3 print(x == y) Code language: PHP(php)

Internally, Python cannot use a finite number of digits to represent the numbers `x`

and `y`

:

```
print(format(x, '.20f'))
print(format(y, '.20f')) Code language: PHP(php)
```

One way to work around this problem is to round both sides of the equality expression to a number of sigificant digits. For example:

x = 0.1 + 0.1 + 0.1 y = 0.3 print(round(x, 3) == round(y, 3)) Code language: PHP(php)