python0.1+0.2_为什么0.1+0.2=0.30000000000000004

语言

代码

结果

C

#includeint main(int argc, char* argv) {printf(“%.17fn”, .1&＃43;.2);return 0;}

0.30000000000000004

C&＃43;&＃43;

#include std::cout <

0.30000000000000004

PHP

echo .1 &＃43; .2;

0.3

注1&＃xff1a;PHP 将 0.30000000000000004 格式化成字符串时&＃xff0c;会把它缩短成 “0.3″。为了得到需要的浮点数结果&＃xff0c;在 ini文件中调整精度设置&＃xff1a;iniset(“precision”, 17)。

MySQL

SELECT .1 &＃43; .2;

0.3

Postgres

SELECT select 0.1::float &＃43; 0.2::float;

0.3

Delphi XE5

writeln(0.1 &＃43; 0.2);

3.00000000000000E-0001

Erlang

io:format(“~w~n”, [0.1 &＃43; 0.2]).

0.30000000000000004

Elixir

IO.puts(0.1 &＃43; 0.2)

0.30000000000000004

Ruby

puts 0.1 &＃43; 0.2 And puts 1/10r &＃43; 2/10r

0.30000000000000004 And 3/10

注2&＃xff1a;Ruby 2.1及以后版本在语法上支持有理数。对于老版本&＃xff0c;请使用 Rational。Ruby还有一个专门处理小数的库&＃xff1a; BigDecimal。

Python 2

print(.1 &＃43; .2)

float(decimal.Decimal(“.1″) &＃43; decimal.Decimal(“.2″))  .1 &＃43; .2

0.3

0.3

0.30000000000000004

注3&＃xff1a;Python 2 中的 “print” 语句将 0.30000000000000004 转成一个字符串&＃xff0c;并缩短成 “0.3″。为了达到需要的浮点数结果&＃xff0c;使用 print(repr(.1 &＃43; .2))。在 Python 3中这是内置设定(见下面例子)。

Python 3

print(.1 &＃43; .2)

.1 &＃43; .2

0.30000000000000004

0.30000000000000004

Lua

print(.1 &＃43; .2) print(string.format(“%0.17f”, 0.1 &＃43; 0.2))

0.3 0.30000000000000004

Javascript

document.writeln(.1 &＃43; .2);

0.30000000000000004

Java

System.out.println(.1 &＃43; .2);System.out.println(.1F &＃43; .2F);

0.30000000000000004

0.3

Julia

.1 &＃43; .2

0.30000000000000004

注4&＃xff1a;Julia 内置 支持有理数 &＃xff0c;并且还有一个内置的数据类型BigFloat&＃xff0c;它支持任意精度 。要得到正确的运算结果&＃xff0c;使用 1//10 &＃43; 2//10 会返回3//10。

Clojure

(&＃43; 0.1 0.2)

0.30000000000000004

注5&＃xff1a;Clojure 支持任意精度的数据。 (&＃43; 0.1M 0.2M) 返回 0.3M&＃xff0c;而 (&＃43; 1/10 2/10) 返回 3/10。

C#

Console.WriteLine(“{0:R}”, .1 &＃43; .2);

0.30000000000000004

GHC (Haskell)

0.1 &＃43; 0.2

0.30000000000000004

注6&＃xff1a;Haskell 支持有理数。要得到正确的运算结果&＃xff0c;使用 (1 % 10) &＃43; (2 % 10) 返回 3 % 10。

Hugs (Haskell)

0.1 &＃43; 0.2

0.3

bc

0.1 &＃43; 0.2

0.3

Nim

echo(0.1 &＃43; 0.2)

0.3

Gforth

0.1e 0.2e f&＃43; f.

0.3

dc

0.1 0.2 &＃43; p

.3

Racket (PLT Scheme)

(&＃43; .1 .2) And (&＃43; 1/10 2/10)

0.30000000000000004 And 3/10

Rust

extern crate num; use num::rational::Ratio; fn main() {

println!(.1&＃43;.2); println!(“1/10 &＃43; 2/10 &＃61; {}”, Ratio::new(1, 10) &＃43;

Ratio::new(2, 10)); }

0.30000000000000004 3/10

注7&＃xff1a;Rust 中&＃xff0c;使用 num crate 支持获得 有理数支持 。

Emacs Lisp

(&＃43; .1 .2)

0.30000000000000004

Turbo Pascal 7.0

writeln(0.1 &＃43; 0.2);

3.0000000000E-01

Common Lisp

(&＃43; .1 .2) And * (&＃43; 1/10 2/10)

0.3 And 3/10

Go

package main import “fmt” func main() { fmt.Println(.1 &＃43;

.2) var a float64 &＃61; .1 var b float64 &＃61; .2 fmt.Println(a &＃43; b)

fmt.Printf(“%.54fn”, .1 &＃43; .2) }

0.3 0.30000000000000004 0.299999999999999988897769753748434595763683319091796875

Objective-C

0.1 &＃43; 0.2;

0.300000012

OCaml

0.1 &＃43;. 0.2;;

float &＃61; 0.300000000000000044

Powershell

PS C:>0.1 &＃43; 0.2

0.3

Prolog (SWI-Prolog)

?- X is 0.1 &＃43; 0.2.

X &＃61; 0.30000000000000004.

Perl 5

perl -E ‘say 0.1&＃43;0.2′ perl -e ‘printf q{%.17f}, 0.1&＃43;0.2′

0.3 0.30000000000000004

Perl 6

perl6 -e ‘say 0.1&＃43;0.2′ perl6 -e ‘say sprintf(q{%.17f}, 0.1&＃43;0.2)’ perl6 -e ‘say 1/10&＃43;2/10′

0.3 0.30000000000000000 0.3

注9&＃xff1a;Perl 6 与 Perl 5 不同&＃xff0c;默认使用有理数。因此 .1 被存储成类似这样 { 分子 &＃61;> 1, 分母 &＃61;> 10 }.

R

print(.1&＃43;.2) print(.1&＃43;.2, digits&＃61;18)

0.3 0.300000000000000044

scala

scala -e ‘println(0.1 &＃43; 0.2)’ And scala -e ‘println(0.1F &＃43; 0.2F)’ And scala -e ‘println(BigDecimal(“0.1″) &＃43; BigDecimal(“0.2″))’

0.30000000000000004 And 0.3 And 0.3

Smalltalk

0.1 &＃43; 0.2.

0.30000000000000004

Swift

0.1 &＃43; 0.2

0.3

D

import std.stdio; void main(string[] args) { writefln(“%.17f”, .1&＃43;.2); writefln(“%.17f”, .1f&＃43;.2f); writefln(“%.17f”, .1L&＃43;.2L); }

0.29999999999999999 0.30000001192092896 0.30000000000000000