fraktioner — Rationella tal

Källkod: Lib/fractions.py

Modulen fractions ger stöd för aritmetik med rationella tal.

En Fraction-instans kan konstrueras från ett par heltal, från ett annat rationellt tal eller från en sträng.

class fractions.Fraction(numerator=0, denominator=1)
class fractions.Fraction(number)
class fractions.Fraction(string)

Den första versionen kräver att numerator och denominator är instanser av numbers.Rational och returnerar en ny Fraction-instans med värdet numerator/denominator. Om denominator är 0, ger den upphov till ett ZeroDivisionError.

Den andra versionen kräver att number är en instans av numbers.Rational eller har metoden as_integer_ratio() (detta inkluderar float och decimal.Decimal). Den returnerar en Fraction-instans med exakt samma värde. Antag att metoden as_integer_ratio() returnerar ett par coprime heltal och att det sista är positivt. Observera att på grund av de vanliga problemen med binär punkt (se Aritmetik med flyttal: problem och begränsningar) är argumentet till Fraction(1.1) inte exakt lika med 11/10, och därför returnerar Fraction(1.1) inte Fraction(11, 10) som man skulle kunna förvänta sig. (Men se dokumentationen för metoden limit_denominator() nedan)

Den sista versionen av konstruktören förväntar sig en sträng. Den vanliga formen för denna instans är:

[tecken] täljare ['/' nämnare]

där det valfria tecknet kan vara antingen ’+’ eller ’-’ och numerator och denominator (om de finns) är strängar av decimala siffror (understrykningar kan användas för att avgränsa siffror som med integrerade literaler i kod). Dessutom kan alla strängar som representerar ett ändligt värde och som accepteras av float-konstruktören också accepteras av Fraction-konstruktören. I båda formerna kan indatasträngen också ha inledande och/eller avslutande blanksteg. Här är några exempel:

>>> from fractions import Fraction
>>> Fraction(16, -10)
Fraction(-8, 5)
>>> Fraction(123)
Fraction(123, 1)
>>> Fraction()
Fraction(0, 1)
>>> Fraction('3/7')
Fraction(3, 7)
>>> Fraction(' -3/7 ')
Fraction(-3, 7)
>>> Fraction('1.414213 \t\n')
Fraction(1414213, 1000000)
>>> Fraction('-.125')
Fraction(-1, 8)
>>> Fraction('7e-6')
Fraction(7, 1000000)
>>> Fraction(2.25)
Fraction(9, 4)
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248)
>>> from decimal import Decimal
>>> Fraction(Decimal('1.1'))
Fraction(11, 10)

Klassen Fraction ärver från den abstrakta basklassen numbers.Rational, och implementerar alla metoder och operationer från den klassen. Fraction-instanser är hashable, och bör behandlas som oföränderliga. Dessutom har Fraction följande egenskaper och metoder:

Ändrad i version 3.2: Konstruktorn Fraction accepterar nu instanser av float och decimal.Decimal.

Ändrad i version 3.9: Funktionen math.gcd() används nu för att normalisera numerator och denominator. math.gcd() returnerar alltid en int-typ. Tidigare berodde GCD-typen på numerator och denominator.

Ändrad i version 3.11: Underscores är nu tillåtna när man skapar en Fraction-instans från en sträng, enligt PEP 515-reglerna.

Ändrad i version 3.11: Fraction implementerar __int__ nu för att uppfylla typing.SupportsInt instans kontroller.

Ändrad i version 3.12: Mellanslag tillåts runt snedstrecket för stränginmatningar: Fraktion('2 / 3').

Ändrad i version 3.12: Fraction-instanser stöder nu formatering i float-stil, med presentationstyperna "e", "E", "f", "F", "g", "G" och "%"".

Ändrad i version 3.13: Formatering av Fraction-instanser utan presentationstyp har nu stöd för fyllning, justering, teckenhantering, minsta bredd och gruppering.

Ändrad i version 3.14: Konstruktorn för Fraction accepterar nu alla objekt med metoden as_integer_ratio().

numerator

Täljaren i fraktionen i den lägsta termen.

denominator

Nämnaren i bråket i lägsta termen.

as_integer_ratio()

Returnerar en tupel av två heltal, vars förhållande är lika med den ursprungliga Fraction. Förhållandet är i lägsta termer och har en positiv nämnare.

Tillagd i version 3.8.

is_integer()

Returnerar True om Fraction är ett heltal.

Tillagd i version 3.12.

classmethod from_float(f)

Alternativ konstruktör som endast accepterar instanser av float eller numbers.Integral. Tänk på att Fraction.from_float(0.3) inte är samma värde som Fraction(3, 10).

Anteckning

Från Python 3.2 och framåt kan du också konstruera en Fraction-instans direkt från en float.

classmethod from_decimal(dec)

Alternativ konstruktor som endast accepterar instanser av decimal.Decimal eller numbers.Integral.

Anteckning

Från Python 3.2 och framåt kan du också konstruera en Fraction-instans direkt från en decimal.Decimal-instans.

classmethod from_number(number)

Alternativ konstruktör som endast accepterar instanser av numbers.Integral, numbers.Rational, float eller decimal.Decimal, och objekt med metoden as_integer_ratio(), men inte strängar.

Tillagd i version 3.14.

limit_denominator(max_denominator=1000000)

Hittar och returnerar den närmaste Fraction till self som har högst max_denominator som nämnare. Denna metod är användbar för att hitta rationella approximationer till ett givet flyttal:

>>> from fractions import Fraction
>>> Fraction('3.1415926535897932').limit_denominator(1000)
Fraction(355, 113)

eller för att återskapa ett rationellt tal som representeras som en float:

>>> from math import pi, cos
>>> Fraction(cos(pi/3))
Fraction(4503599627370497, 9007199254740992)
>>> Fraction(cos(pi/3)).limit_denominator()
Fraction(1, 2)
>>> Fraction(1.1).limit_denominator()
Fraction(11, 10)
__floor__()

Returnerar det största int <= self. Denna metod kan också nås via funktionen math.floor():

>>> from math import floor
>>> floor(Fraction(355, 113))
3
__ceil__()

Returnerar det minsta int >= self. Denna metod kan också nås via funktionen math.ceil().

__round__()
__round__(ndigits)

Den första versionen returnerar närmaste int till self och avrundar hälften till jämnt. Den andra versionen avrundar self till närmaste multipel av Fraction(1, 10**ndigits) (logiskt, om ndigits är negativt), och avrundar återigen hälften mot jämnt. Denna metod kan också nås genom funktionen round().

__format__(format_spec, /)

Ger stöd för formatering av Fraction-instanser via metoden str.format(), den inbyggda funktionen format() eller Formaterade stränglitteraler.

Om formatsträngen format_spec inte slutar med någon av presentationstyperna 'e', 'E', 'f', 'F', 'g', 'G' eller '%' följer formateringen de allmänna reglerna för fyllning, justering, teckenhantering, minsta bredd och gruppering som beskrivs i formatspecificering för minispråk. Flaggan för ”alternativ form” '#' stöds: om den finns, tvingar den utmatningssträngen att alltid inkludera en explicit nämnare, även när värdet som formateras är ett exakt heltal. Flaggan för nollfyllning '0' stöds inte.

Om formatspecifikationssträngen format_spec slutar med en av presentationstyperna 'e', 'E', 'f', 'F', 'g', 'G' eller '%' så följer formateringen de regler som beskrivs för typen float i avsnittet Formatspecifikation Mini-språk.

Här är några exempel:

>>> from fractions import Fraction
>>> format(Fraction(103993, 33102), '_')
'103_993/33_102'
>>> format(Fraction(1, 7), '.^+10')
'...+1/7...'
>>> format(Fraction(3, 1), '')
'3'
>>> format(Fraction(3, 1), '#')
'3/1'
>>> format(Fraction(1, 7), '.40g')
'0.1428571428571428571428571428571428571429'
>>> format(Fraction('1234567.855'), '_.2f')
'1_234_567.86'
>>> f"{Fraction(355, 113):*>20.6e}"
'********3.141593e+00'
>>> old_price, new_price = 499, 672
>>> "{:.2%} price increase".format(Fraction(new_price, old_price) - 1)
'34.67% price increase'

Se även

Modul numbers

De abstrakta basklasserna som utgör det numeriska tornet.