Hozza ki a legtöbbet a számokból tizedesjegyekkel

A Python egyik leggyakrabban használt adattípusa a float, amely lebegőpontos számokat jelent. A lebegőpontos számok olyan pozitív vagy negatív számok, amelyeknek tizedesjegye van. A lebegőpontos számok közé tartoznak a tudományos jelöléssel ábrázolt számok is, ahol az e vagy E karakter 10 hatványát jelzi.

A float egy nagyon fontos adattípus, mivel a valós számok széles skáláját képes reprezentálni, a nagyon kis számoktól a nagyon nagy számokig.

Példák lebegőpontos számokra Pythonban az alábbiakban láthatók:

# float numbers
a = 20.0
b = -51.51345
c = 65e7
d = -1.08E12
e = 2E10

print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))

Kimenet:

<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>
<class 'float'>

Ezenkívül pontosabb számításokat tesznek lehetővé az olyan adattípusokhoz képest, mint például az egész számok, amelyek eltávolítják a számok tört részét. Például egész számokkal egy olyan szám, mint a 3,142, egyszerűen 3-ként jelenik meg.

A lebegő adattípus azonban a tényleges számot jeleníti meg, ami 3,142. Ezért a lebegőértékek alkalmasabbak matematikai számításokhoz, mivel pontosabb eredményeket adnak.

E tekintetben a lebegőpontos értékeket széles körben használják a valós modellezésben, a gépi tanulásban, az adattudományban, a pénzügyi és gazdasági elemzésben, a matematikai számításokban, a grafikákban és a vizualizációkban, valamint a tudományos és mérnöki számításokban.

Integers vs. Float Pythonban

Az egész számok egy másik nagyon népszerű adattípus a Pythonban. A lebegőpontos számokkal ellentétben az egész számoknak nincs tizedesvesszője. Az egész számok pozitív egész számokból, negatív számokból és nullákból állnak, amelyek mindegyikének nincs tört része.

Az egész számok akkor hasznosak, ha egész számokat tartalmazó műveleteket hajtunk végre, például számláláskor vagy indexeléskor. A Pythonban az egész értékeket int-ként jelöljük.

Néhány egész szám az alábbiakban látható:

a = 0
b = 968
c = -14

print(type(a))
print(type(b))
print(type(c))

Kimenet:

<class 'int'>
<class 'int'>
<class 'int'>

Néhány különbség az egész számok és a lebegőpontos számok között a Pythonban:

KarakterisztikusIntegers(int)Lebegőpontos számok(float)Egész számokat, negatív megfelelőit és nullát jelentenek, mindegyik tizedesjegy nélkül. Valós számok tizedesvesszővel Precision Korlátlan pontosság, így nincs korlátozva az int érték hosszúsága vagy nagysága. Az egyetlen megkötés a rendszerben rendelkezésre álló memória lesz. Korlátozott a pontosság. A tárolható legnagyobb lebegő érték körülbelül 1,8 x 10308 Memóriahasználat Kevesebb memóriát használ, mint egész értékek Bitenkénti műveletek Kiterjedten használják bitenkénti műveletekben Szinte soha nem használják bitenkénti műveletekben Használat Általában számlálásban, indexelésben és bitenkénti műveletekben használják Széles körben használják mérésekben, tudományos számításokban a legtöbb matematikai művelet

Float készítésének és használatának különböző módjai a Pythonban

A lebegő értékekkel való munka megkezdésének egyszerű módja a Pythonban, ha egy változóhoz lebegő értéket rendelünk, például:

# assign a variable a float value
a = 3.142

A lebegőértékek megszerzésének másik módja az egész számok és a numerikus karakterláncok lebegőértékekké alakítása a float() konstruktor segítségével. Ha egész számot vagy numerikus karakterláncot adunk át a float()-ba, akkor az alább látható módon lebegő értékké lesz konvertálva:

number1 = 2524
numString1 = "513.523"
numString2 = "1341"
# Convert to a float and store the float value in a variable
a = float(number1)
print(a)
b = float(numString1);
print(b)
c = float(numString2)
print(c)

Kimenet:

2524.0
513.523
1341.0

A fenti példában az egész számot és a karakterláncokat a float() segítségével lebegő értékké alakítjuk, majd egy változóban tároljuk, amelyet aztán kinyomtatunk, és a konverzió után kapott lebegő értéket mutatjuk be.

A lebegőértékek megszerzésének másik módja a matematikai számítások, például az osztás végrehajtása, az alábbiak szerint:

num1 = 20
num2 = 3
result = num1/num2
print("Result of the division as an integer:")
print(int(20/3))
print("Result of the division as a float value:")
print(result)
print(type(result))

Kimenet:

Result of the division as an integer:
6
Result of the division as a float value:
6.666666666666667
<class 'float'>

A fenti példában figyelje meg, hogy a lebegőérték pontosabb választ ad, mint az elosztás és az eredmény egész számként való visszaszerzése.

Amikor lebegő számokkal dolgozik Pythonban, nagyon érdekes eredményekkel találkozhat, mivel a lebegőpontos értékek a számítógépen belül jelennek meg. A lebegőpontos számokat a számítógépes hardver 2-es (bináris) törtként ábrázolja.

A legtöbb tizedes tört azonban, különösen az ismétlődő tizedestörtekkel, nem ábrázolható pontos bináris törtként. Ennek eredményeként a lebegőpontos számokat általában a tényleges érték közelítéseként tárolják.

Ennek gyakorlati megjelenítéséhez vegyük figyelembe a 0,3-as lebegő értéket. Ha egy változóhoz 0,3-at rendelünk, akkor az nem lesz pontosan 0,3-ként tárolva. Ennek megtekintéséhez használhatjuk a format() függvényt, hogy megnézzük, hogyan jelenik meg a 0.3 belül. format() lehetővé teszi, hogy megjelenítsük egy adott érték kívánt számú jelentős számjegyét, amellyel dolgozunk. Az alábbi példában 0,3-20 szignifikáns számjegyet nyomtatunk ki, hogy megtudjuk, hogyan tárolódnak a belső adatok.

num = 0.3
print("num to 20 significant figures")
print(format(num, '.20f'))
print("Value we stored for num")
print(num)

Kimenet:

num to 20 significant figures
0.29999999999999998890
Value we stored for num
0.3

Amint láthatja, a 0,3-as értéket, amelyet a num nevű változóhoz rendeltünk, a rendszer nem tárolja belül pontosan 0,3-ként. Amikor kinyomtatja a num változót, kerekített értéket kap.

Emiatt váratlan eredményeket kaphat, amikor lebegő értékekkel dolgozik. Például, ha manuálisan kell kiszámítani a 0,3 + 0,3 + 0,3 értéket, a válasz 0,9 lesz. A Python szerint azonban ez nem így van, mivel belsőleg a tényleges érték bináris tört közelítését tárolja. Ez alább látható:

sum = 0.3 + 0.3 + 0.3
answer = 0.9
print("Is sum equal to answer: ")
print(sum == answer)
print("The internal representation of of sum is: ")
print(sum)
print("The answer from manual calculation is: ")
print(answer)

Kimenet:

Is sum equal to answer: 
False
The internal representation of of sum is: 
0.8999999999999999
The answer from manual calculation is: 
0.9

Ezért, amikor lebegő értékekkel dolgozik, fontos szem előtt tartani, hogy a Python nem tárolja a pontos értékeket belsőleg. Ehelyett a tényleges érték közelítését tárolja.

Ezért a lebegőértékek összehasonlításakor érdemes először kerekíteni a leszámítást ugyanannyi jelentős számra. A Pythonban lebegőpontos számokkal végzett munka nagyobb pontossága érdekében fontolja meg a beépített decimális modul használatát.

Decimális modul Pythonban

Olyan helyzetekben, ahol a nagy pontosság fontos és kötelező, mint például a pénzügyi és tudományos számításoknál, az úszó használata nem ideális. A lebegőpontos számokkal végzett munka során a nagy pontosság garantálása érdekében a beépített Python-modul decimális értéket használjuk.

Ellentétben a lebegőpontos bináris lebegőpontos ábrázolással, amely gépfüggő, a decimális modul a lebegőpontos számokat gépfüggetlen decimális alapú ábrázolással tárolja, amely nagyobb pontosságot biztosít.

Ezenkívül a decimális modul képes a decimális számokat pontosan úgy ábrázolni, ahogy vannak, és pontosan úgy tudja használni őket a számításokhoz. Helyesen kerekített tizedes lebegőpontos aritmetikát is kínál.

A decimális modul használatának megkezdéséhez importálja azt a Python-fájlba az alábbiak szerint:

import decimal

Ahhoz, hogy a decimális modul előnyeit lássuk, ismételjük meg a 0,3 + 0,3 + 0,3 összeg és a 0,9 érték korábbi összehasonlítását. Az ehhez szükséges kód az alábbiakban látható:

import decimal

sum = decimal.Decimal('0.3') + decimal.Decimal('0.3') + decimal.Decimal('0.3')
answer = decimal.Decimal('0.9')
print("Is sum equal to answer: ")
print(sum == answer)
print("The internal representation of sum is: ")
print(sum)
print("The answer from manual calculation is: ")
print(answer)

Kimenet:

Is sum equal to answer: 
True
The internal representation of sum is: 
0.9
The answer from manual calculation is: 
0.9

Ezért amikor lebegőpontos számokkal dolgozik, és nagy pontosságra van szüksége, ne felejtse el mindig a decimális modult használni.

Gyakori hibák az úszókkal való munka során

A Pythonban a Float használata során felmerülő hibák nagy része abból fakad, hogy nem értjük, hogyan reprezentálja a lebegőpontos számokat a Python belül. Például egy olyan érték, mint a 0,3, nem pontosan 0,3-ként kerül tárolásra. Ezért valószínűleg hibákba ütközik, ha lebegőértékeket dolgoz fel, feltételezve, hogy azok pontosan úgy vannak tárolva, ahogy vannak.

Az egyik gyakori hiba a kerekítési hiba, amellyel a lebegőértékeken végzett matematikai számítások során találkozhat. Mivel a Python nem tudja megjeleníteni a tényleges lebegőértékeket, valószínűleg olyan kerekítési hibákkal találkozhat, amelyeknél az eredmények nem feltétlenül az elvárásoknak felelnek meg.

Az olyan hibák miatt, mint például a kerekítési hibák, valószínűleg hibákba ütközhet, amikor a lebegőpontos értékek közötti egyenlőség-összehasonlítást próbálja elvégezni. Legyen nagyon óvatos, amikor Pythonban lebegőkkel dolgozik, és ügyeljen a váratlan eredményekre.

A lebegőértékekkel végzett munka során felmerülő hibák elkerülésének jobb módja a beépített decimális modul használata. Így a lebegőpontos számítások eredményei kiszámíthatóbbak és pontosabbak lesznek.

Következtetés

Pythonnal dolgozó programozóként köteles a lebegő adattípust használni. Az ezzel az adattípussal kapcsolatos hibák elkerülése érdekében fontos megérteni, hogy a Python hogyan reprezentálja a lebegő számokat belsőleg. Mivel a Python nem tudja tárolni a tényleges lebegőpontos számokat, kerülje a lebegőértékekkel való pontos egyenlőség-összehasonlítást. Ellenkező esetben hibákba ütközhet.

Ha pontos eredményekre van szüksége az alkalmazásban, kerülje a lebegőértékek használatát. Ehelyett használja a beépített decimális modult, amely pontos lebegőpontos eredményeket ad, és pontosan olyan formában jeleníti meg őket, ahogy vannak, gépfüggetlen módon.

Elolvashatja a Python Itertools Functions és a Python Try Except című részt is.