Share
Zelfs de meest elementaire wiskundige bewerkingen kunnen soms een foutief resultaat opleveren. Dit gebeurt vanwege beperkingen bij het opslaan van de exacte waarde van sommige nummers. Je kunt deze beperkingen overwinnen door de decimale module in Python te gebruiken. Evenzo is geen van beide wiskunde noch de CMATH module die we hebben geleerd in onze laatste tutorial kan ons helpen bij het uitvoeren van fraction-based arithmetic. De fractie-module in Python doet precies hetzelfde.
In deze zelfstudie leert u meer over deze modules en de verschillende functies die ze beschikbaar maken.
Je vraagt je waarschijnlijk af waarom we een module nodig hebben om elementaire rekenkundige bewerkingen met decimale getallen uit te voeren wanneer we hetzelfde al kunnen doen met drijvers.
Voordat ik deze vraag beantwoord, wil ik dat u een schatting maakt van de uitvoerwaarde als u typt 0,1 + 0,2 in de Python-console. Als je raadt dat de uitvoer 0.3 zou moeten zijn, zul je verbaasd zijn als je het werkelijke resultaat bekijkt, dat is 0.30000000000000004. Je kunt een andere berekening proberen zoals 0,05 + 0,1 en je krijgt 0.15000000000000002.
Probeer te representeren om te begrijpen wat hier gebeurt 1/3 in decimale vorm, en je zult opmerken dat het aantal in feite niet-beëindigend is in basis 10. Op dezelfde manier zijn sommige getallen zoals 0.1 of 1/10 niet-beëindigend in basis 2. Aangezien deze getallen nog steeds op de een of andere manier moeten worden weergegeven, een paar Bij het opslaan worden benaderingen gemaakt, wat resulteert in die fouten.
Het nummer 0.30000000000000004 is eigenlijk bijna 0,3, dus we kunnen het meeste wegkomen met deze benadering. Helaas zal deze benadering het niet drukken als je een satellietlancering simuleert of met geld omgaat. Een ander probleem met deze benaderingen is dat de fouten blijven opstapelen.
Om precieze resultaten te krijgen, zoals die waarmee we werken wanneer we handmatig met berekeningen werken, hebben we iets nodig dat een snelle, correct afgeronde decimale drijvende komma-rekenkunde ondersteunt, en de decimale module doet precies dat.
Voordat u de module gebruikt, moet u deze eerst importeren. Hierna kunt u decimalen maken van gehele getallen, strings, drijvers of tuples. Wanneer het decimaalteken is opgebouwd uit een geheel getal of een float, is er een exacte conversie van de waarde van dat getal. Bekijk de onderstaande voorbeelden om te zien wat ik bedoel:
Accentsconagua
van decimale import Decimal Decimal (121) # retourneert Decimaal ('121') Decimaal (0.05) # retourneert Decimaal ('0.05000000000000000277555756') Decimaal ('0.05') # retourneert Decimaal ('0.05') Decimaal ((0, (8, 3, 2, 4), -3)) # retourneert Decimaal ('8.324') Decimaal ((1, (8, 3, 2, 4), -1)) # retourneert Decimaal ('- 832.4')Zoals je kunt zien, is de waarde van Decimaal (0,05) is iets anders dan Decimaal (0,05). Dit betekent dat als u 0,05 en 0,1 toevoegt, u zou moeten gebruiken decimal.Decimal (0,05) en decimal.Decimal (0,1 ') om de decimalen te construeren.
van decimale import Decimal Decimal ('0.05') + Decimal ('0.1') # retourneert Decimaal ('0.15') Decimaal (0.05) + Decimaal (0.1) # retourneert Decimaal ('0.1500000000000000083266726847')Nu u verschillende bewerkingen op decimalen kunt uitvoeren, wilt u misschien de precisie of afronding van die bewerkingen bepalen. Dit kan gedaan worden door de getcontext () functie. Met deze functie kunt u zowel de waarde van de precisie- en afrondingsopties instellen als onder andere.
Houd er rekening mee dat zowel afronding als precisie alleen tijdens rekenkundige bewerkingen in het spel komen en niet terwijl u de decimalen zelf maakt.
import decimal from decimal import Decimal, getcontext Decimal (1) / Decimal (13) # retourneert Decimaal ('0.07692307692307692307692307692') getcontext (). prec = 10 Decimal (0.03) # retourneert Decimal ('0.02999999999999999888977697537') Decimal (1) / Decimal (7) # retourneert Decimaal ('0.1428571429') getcontext (). Rounding = decimal.ROUND_DOWN Decimal (1) / Decimal (7) # retourneert Decimal ('0.1428571428') U kunt ook enkele van de wiskundige functies gebruiken, zoals sqrt (), exp (), en log () met decimalen. Hier zijn een paar voorbeelden:
decimaal importeren uit decimale import Decimaal, getcontext Decimaal (2) .sqrt () # retourneert Decimaal ('1.414213562373095048801688724') getcontext (). prec = 4 Decimaal ('2'). sqrt () # retourneert Decimaal ('1.414') Decimaal ('2000'). Log10 () # retourneert Decimal ('3.301')Soms kunt u situaties tegenkomen waarbij u verschillende bewerkingen op breuken moet uitvoeren of als het eindresultaat een breuk moet zijn. De breukenmodule kan in deze gevallen van grote hulp zijn. Hiermee kunt u een maken Fractie bijvoorbeeld uit getallen, drijvers, decimalen en zelfs reeksen. Net als de decimale module, zijn er ook enkele problemen met deze module als het gaat om het maken van breuken van drijvers. Hier zijn een paar voorbeelden:
from fractions import Fraction from decimal import Decimal Fraction (11, 35) # returns Fraction (11, 35) Fraction (10, 18) # returns Fraction (5, 9) Fraction ('8/25') # geeft Fractie (8, 25) Fraction (1.13) # returns Fraction (1272266894732165, 1125899906842624) Fraction ('1.13') # returns Fraction (113, 100) Fraction (Decimal ('1.13')) # returns Fraction (113, 100)U kunt ook eenvoudige wiskundige bewerkingen uitvoeren, zoals optellen en aftrekken van breuken, net als gewone getallen.
from fractions import Fraction Fraction (113, 100) + Fraction (25, 18) # returns Fraction (2267, 900) Fraction (18, 5) / Fraction (18, 10) # geeft Fraction (2, 1) Fractie (18, 5) * Breuk (16, 19) # retourneert Breuk (288, 95) Breuk (18, 5) * Breuk (15, 36) # retourneert Breuk (3, 2) Breuk (12, 5) ** Breuk (12, 10) # retourneert 2.8592589556010197
De module heeft ook enkele belangrijke methoden zoals limit_denominator (max_denominator) die een fractie vinden die het dichtst in waarde is voor de gegeven fractie waarvan de noemer hooguit is max_denominator. U kunt ook de teller van een gegeven breuk op de laagste termijn retourneren met behulp van de teller eigendom en de noemer met behulp van de noemer eigendom.
van breuken import Fraction Fraction ('3.14159265358979323846') # returns Fraction (157079632679489661923, 50000000000000000000) Fraction ('3.14159265358979323846') limit_denominator (10000) # returns Fractie (355, 113) Fractie ('3.14159265358979323846') limit_denominator (100) # retourneert Fraction (311, 99) Fraction ('3.14159265358979323846') limit_denominator (10) # returns Fraction (22, 7) Fraction (125, 50) .umerator # returns 5 Fraction (125, 50) .denominator # retourneert 2U kunt deze module ook gebruiken met verschillende functies in de wiskunde module om op breuken gebaseerde berekeningen uit te voeren.
import wiskunde uit breuken import Fractie math.sqrt (breuk (25, 4)) # retourneert 2,5 math.sqrt (breuk (28,3)) # retourneert 3.0550504633038935 math.floor (breuk (3558, 1213)) # retourneert 2 breuken ( math.sin (math.pi / 3)) # geeft als resultaat Fractie (3900231685776981, 4503599627370496) Fractie (math.sin (math.pi / 3)). limit_denominator (10) # retourneert breuk (6, 7)
Deze twee modules moeten voldoende zijn om u te helpen algemene bewerkingen uit te voeren op zowel decimalen als breuken. Zoals in de laatste sectie is te zien, kunt u deze modules samen met de wiskundemodule gebruiken om de waarde van alle soorten wiskundige functies te berekenen in het formaat dat u wenst.
In de volgende zelfstudie van de serie leert u meer over het willekeurig module in Python.
