Numerisk Python: Typer, moduler och praktisk användning

Hem » Python » Numerisk Python: Typer, moduler och praktisk användning

Att arbeta med siffror är kärnan i de flesta Python-program, oavsett om du bygger ett enkelt skript, bearbetar vetenskapliga data eller prototyper en algoritm. Att förstå hur Python representerar och manipulerar numeriska värden är det första steget till att skriva pålitlig och effektiv kod som beter sig som du förväntar dig.

När folk pratar om "numerisk Python" menar de ofta två saker.å ena sidan, de inbyggda taltyperna och standardbiblioteksverktyg som math, cmath, decimal, random och numbers; å andra sidan det bredare ekosystemet kring numerisk beräkning, med bibliotek som NumPy som utökar språket med extra numeriska typer och vektoriserade operationer. Den här guiden guidar dig genom den grunden i detalj, från grundläggande typer till avancerade abstraktioner.

Kärnnumeriska typer i Python

Python definierar flera inbyggda numeriska kategorier som täcker de flesta vardagliga behov.: heltal för heltal, flyttal för reella värden med decimaler, komplexa tal för värden med reella och imaginära delar, och den speciella booleska typen som beter sig som en mycket liten medlem i heltalsfamiljen. Alla integreras smidigt med Pythons aritmetiska operatorer.

Heltal (int) representerar heltal, positiva eller negativa, utan decimalpunktDet finns ingen fast övre gräns för deras storlek i standard Python; så länge du har minne kan ditt heltal växa. Värden som 1, -5 or 20234567890123456789 är alla giltiga int exempel, och du kan bekräfta det med type(1) or type(-5), som kommer att återvända <class 'int'>.

Flyttalsnummer (float) används för reella tal med en bråkdelskomponentDe skrivs med decimaltecken, till exempel 2.0, -7.823457 or 0.5, eller med vetenskaplig notation som 1e8 (vilket betyder 100 000 000). När man utför operationer som division, även mellan heltal, höjer Python ofta resultatet till en float; till exempel, 9 / 2 utbyten 4.5och type(4.5) is <class 'float'>.

Komplexa tal (complex) kombinera en realdel och en imaginärdel, skrivet med en efterföljande j för den imaginära enheten. Ett värde som 2 + 3j har en reell komponent 2 och en imaginär komponent 3. Du kan konstruera dem direkt (t.ex. 3.14j) och inspektera dem med attribut som .real och .imag, eller ring .conjugate() för att få det komplexa konjugatet. Dessa är särskilt populära inom teknik, signalbehandling och vetenskaplig databehandling.

Booleanska värden (bool) är tekniskt sett numeriska också, därför att True och False beter sig som heltal 1 och 0 i aritmetiska uttryck. Till exempel, True + 2 utvärderar till 3Internt, bool är en underklass av int, vilket är anledningen till att booleska värden integreras sömlöst i beräkningar och jämförelser.

Python låter dig fritt blanda dessa numeriska typer i uttryckoch uppgraderar till en mer generell typ vid behov. Lägger till en int till en float ger en float, och att kombinera flyttal med komplexa tal ger ett komplext resultat: uttryck som 1 + 1.0, 2.0 + (3 + 5j) or 6 / (5 + 8j) allt arbete utan extra ceremoni.

Aritmetiska operatorer och divisionsbeteende

När du väl har numeriska värden använder du de vanliga aritmetiska operatorerna för att arbeta med dem: addition (+), subtraktion (-), multiplikation (*), division (/), våningsindelning (//), exponentiering (**) och modulo (%Python tillämpar dessa på heltal, flyttal och komplexa tal, och utför typbefordran efter behov.

Division är ett område där Pythons design är mycket avsiktlig., Använda / ger alltid ett flyttal när båda argumenten är numeriska, även om de båda är heltal. Så 9 / 2 resulterar i 4.5, Inte 4Detta uppmuntrar dig att tänka i termer av reelltaldivision som standard, vilket vanligtvis är vad du vill ha i vetenskapliga eller finansiella beräkningar.

Om du behöver heltalsdivision som tar bort bråkdelen använder du golvdivisionsoperatorn //. Till exempel, 9 // 2 producerar 4och -9 // 2 utbyten -5, eftersom resultatet är avrundat nedåt mot negativ oändlighet. Dessutom, divmod(a, b) ger dig både kvoten och resten samtidigt, vilket returnerar ett par som reflekterar (a // b, a % b).

Bakom kulisserna koordinerar Python noggrant hur olika numeriska smaker interagerarEtt internt mönster som man kan se i standardbiblioteket är idén om "operator-fallbacks": funktioner som först provar en typspecifik implementering, till exempel för rationella tal, och sedan återgår till inbyggda operatorer när en operand är en reguljär operand. int, float or complexDet här är vad som gör att anpassade numeriska typer kan samverka med Pythons aritmetiska system med hjälp av speciella metoder som __add__ och __radd__.

Bibliotekskod för rationell aritmetik, såsom Fraction typ, illustrerar denna strategi tydligtNär man lägger till två Fraction i vissa fall beräknar den ett nytt bråk genom att korsmultiplicera täljare och nämnare. Om du lägger till en Fraction till ett vanligt heltal eller en instans av numbers.Rational, använder den den precisa rationella algoritmen. Om den andra operanden är en float or complex, kommer den att konvertera till den bredare typen och delegera till de vanliga operatorerna, vilket håller beteendet konsekvent och intuitivt.

Inbyggda numeriska funktioner

Utöver råoperatorer levereras Python med en uppsättning inbyggda funktioner som vet hur man hanterar talDessa funktioner är alltid tillgängliga utan att importera något och fungerar över de numeriska standardtyperna, plus alla anpassade objekt som implementerar rätt specialmetoder.

abs(x) returnerar det absoluta värdet av sitt argument, vilket gör negativa tal positiva och lämnar positiva värden oförändrade. Om du skickar in ett objekt som definierar __abs__(), Python delegerar till den metoden. För komplexa tal, abs() returnerar magnituden (avståndet från origo i det komplexa planet).

round(x, ndigits) ger dig ett värde avrundat till ett givet antal decimaler. Om ndigits utelämnas eller None, returnerar den närmaste heltal. Till skillnad från skolbokens regel om att "runda av till hälften uppåt" är Pythons inbyggda round använder en "runda av hälften till jämnt"-strategi för oavgjorda beräkningar för att minska statistisk bias i upprepade beräkningar.

Konverteringsfunktioner som int() och float() konstruera tal från andra objektRinger int(x) på en flyttal kasserar bråkdelen (till exempel int(1.9) is 1), Och float(x) producerar en flyttalsrepresentation från heltal, strängar eller kompatibla objekt. När du konverterar från flyttal till int sker ingen avrundning; decimaldelen avkortas helt enkelt.

Andra inbyggda funktioner fungerar som representations- och aggregeringsfunktionerFunktioner som hex() och oct() returnera strängrepresentationer av heltal i hexadecimalt eller oktalt format med lämpliga prefix (0x och 0o). Aggregeringshjälpmedel som max() och min() skanna en iterabel eller en serie argument för att hitta det största eller minsta värdet, medan pow() och ** operatorns beräkningskrafter och valfritt acceptera ett tredje argument för modulär exponentiering.

Avancerade numeriska verktyg: matematik, cmath och decimal

För mer sofistikerade beräkningar tillhandahåller Python dedikerade standardbiblioteksmoduler istället för att överdriva kärnspråket. De viktigaste för numeriskt arbete är math, cmath och decimal, var och en inriktad på en specifik delmängd av problem.

Ocuco-landskapet math Modulen fokuserar på flyttalsmatematik med reella värdenEfter att ha importerat den med import mathfår du tillgång till funktioner och konstanter som vanligtvis behövs inom teknik, fysik och vardaglig analys, allt implementerat i effektiv C-kod och som fungerar på float värden.

math inkluderar talteoretiska och representationsverktyg såsom math.ceil() för avrundning uppåt till närmaste heltal, math.floor() för avrundning nedåt, math.modf() att dela upp ett flyttal i bråkdelar och heltal, och math.frexp() / math.ldexp() att arbeta med den interna binära representationen. Den tillhandahåller även potens- och logaritmiska rutiner som math.exp(), math.log(), math.log10(), math.pow() och math.sqrt(), såväl som trigonometriska och hyperboliska funktioner som math.sin(), math.cos(), math.tan(), math.asin(), math.acos(), math.atan(), math.atan2(), math.sinh(), math.cosh() och math.tanh().

För bekvämlighet, math exporterar grundläggande konstanter som math.pi och math.eDessa är praktiska när du beräknar areor, vinklar eller exponentiell tillväxt och vill ha konsekventa värden med god precision över hela din kodbas.

När du behöver arbeta med komplexa tal, cmath modulen spelar samma roll för det komplexa planetDess API-speglar math men använder komplexa argument och returnerar komplexa resultat, så att du kan beräkna komplexa exponentialer, logaritmer och trigonometriska funktioner utan att manuellt dela upp tal i reella och imaginära delar.

Ocuco-landskapet decimal modulen riktar sig mot en annan smärtpunkt: exakt 10-basaritmetikStandard binär flyttal kan inte representera många decimalbråk exakt, så beräkningar som 0.1 + 0.2 ge ett något avvikande resultat. decimal.Decimal kringgår detta genom att använda godtycklig precisionsaritmetik med basen 10, vilket gör den idealisk för finansiella tillämpningar och överallt där du måste kontrollera avrundningsbeteendet mycket noggrant.

Som standard följer Pythons flyttalsmetoder IEEE-754-beteendet och använder bas-2-representationNär ett värde ligger exakt mitt emellan två representerbara tal tillämpas "avrunda hälften till jämnt", vilket innebär att hälften av de oavgjorda talen avrundas nedåt och hälften uppåt. Detta undviker systematisk avvikelse i stora beräkningar. Om du vill ha kommersiell semantik för "avrunda hälften uppåt" kan du konfigurera en decimal sammanhang att använda ROUND_HALF_UP, vilket alltid knuffar 5 värden bort från noll.

Att arbeta med numeriska typer i praktiken

Att utforska hur siffror beter sig interaktivt är ett bra sätt att bygga intuitionStarta Python-tolken och skapa en blandning av heltal, flyttal och komplexa värden, och prova sedan grundläggande operationer över dem. Addition och multiplikation är enkelt, men det är särskilt lärorikt att experimentera med division, golvdivision, avrundning och omvandlingar, och observera hur typen av resultat ändras.

Att konvertera mellan numeriska typer är ibland nödvändigt för att matcha ett API:s förväntningar eller för att förenkla logiken.Om du har ett flyttal och bara vill ha dess heltalsdel, tilldela det till en variabel som my_float = 1.9 och sedan ringa my_int = int(my_float)Utskrift my_int ger 1och type(my_int) bekräftar att det är en intTänk på att bråkdelen kasseras snarare än avrundas.

Den omvända riktningen – att befordra till en mer generell typ – sker ofta implicit.När du adderar ett heltal och ett flyttal returnerar Python ett flyttal utan att fråga, eftersom det reella talsystemet innehåller heltalen. Samma hänvisning sker när du kombinerar ett flyttal och ett komplext tal: flyttalsvärdet behandlas som att det har en imaginärdel av noll, och resultatet är komplext.

Komplexa tal har flera inbyggda funktioner som gör att de känns naturliga.Du kan inspektera direkt a.real och a.imag för att få komponenterna, ring a.conjugate() att vända tecknet på den imaginära delen och skicka dem till funktioner i cmath utan manuell konvertering. Även om du sällan använder dem, är det bra att veta att de existerar och hur de beter sig när du stöter på vetenskaplig kod.

Noggrannhet och precision är alltid viktigt när man hanterar flyttaldataDen effektiva precisionen hos en vanlig Python-kod float är ungefär 15 decimalsiffror; utöver det kan den 16:e siffran vara opålitlig. För många uppgifter är detta helt acceptabelt, men om du behöver exakt decimalberäkning eller mer förutsägbar avrundning, decimal modulen ger dig den kontroll du behöver på bekostnad av viss prestanda.

Slumptal och speciella numeriska värden

Generering av slumptal är en annan vanlig uppgift i numeriska Python-arbetsflöden., oavsett om du bygger enkla spel, kör Monte Carlo-simuleringar eller skriver testfall som utövar kantvillkor. Standardbibliotekets random Modulen ger grunderna för sådana scenarier.

random.randint(a, b) producerar ett pseudoslumpmässigt heltal mellan a och b, inklusiveDetta gör det enkelt att simulera tärningskast eller välja slumpmässiga index i en lista. För flyttalvärden används funktioner som random.random() och relaterade hjälpare genererar enhetliga slumptal i intervall som [0.0, 1.0], redo att skalas eller transformeras för din specifika distribution.

Python exponerar också några numeriska värden som representerar ovanliga eller "edgefalls"-mängder.En är NaN (”Inte ett nummer”), som till exempel erhålls genom att anropa float('nan')NaN indikerar odefinierade eller orepresenterbara resultat, såsom resultatet av att dividera noll med noll eller analysera ett korrupt numeriskt fält från indata.

Förutom NaN stöder Python positiv och negativ oändlighet, konstruerad med hjälp av float('inf') och float('-inf')Dessa är användbara som sentinelvärden vid initiering av variabler för algoritmer som söker efter minimi- eller maximivärden, eller vid modellering av obegränsade intervall i numeriska metoder.

Att arbeta med NaN kräver särskild försiktighet eftersom de inte beter sig som vanliga talJämförelser som involverar NaN är alltid falska (även nan == nan), och aritmetik med NaN tenderar att sprida NaN genom resultatet. Även om den här guiden inte går djupt in på NaN-semantik, hjälper medvetenhet om deras egenheter dig att felsöka datapipelines och numeriska algoritmer mer effektivt.

Abstrakta numeriska hierarkier med siffermodulen

Allt eftersom din kod blir mer sofistikerad kan du behöva ett flexibelt sätt att känna igen "numeriska" värden. utan att manuellt kontrollera mot varje enskild betongtyp (som int, float, complex och NumPy-skalärer). Det är här numbers modulen kommer in och tillhandahåller en abstrakt hierarki av numeriska typer.

Ocuco-landskapet numbers modulen definierar abstrakta basklasser (ABC) som beskriver numeriskt beteende, Såsom Number, Complex, Real, Rational och IntegralDessa klasser är inte avsedda att instansieras direkt. Istället ärver konkreta numeriska typer från dem för att signalera att de implementerar de nödvändiga operationerna och egenskaperna.

Det mest allmänna ABC:t är numbers.Number, som representerar "valfri numerisk typ"Om du vill testa om en variabel ska behandlas som numerisk – kanske under felsökning eller när du skriver små verktygsskript – kan du kombinera isinstance med detta ABC. Till exempel, isinstance(x, Number) återgår True för inbyggda numeriska typer och många externa numeriska typer, såsom olika NumPy-skalärer.

En praktisk illustration använder NumPy-typer tillsammans med Pythons inbyggda funktionerOm du importerar NumPy som np och sedan loopa över värden som 1, 1., -0.2, 1e8, np.int64(1), np.int0(10), np.int16(2), np.float64(10), np.complex64(10) och np.int32(89), ringer isinstance(value, Number) För varje typ ser du att de alla räknas som numeriska. Detta sparar dig från att skriva en lång kedja av typkontroller för varje specifik klass.

Det är värt att notera att isinstance i sig betraktas som en kod-"lukt" när den används i överdriven mängdÖverdriven beroende av explicit typkontroll kan signalera djupare designproblem i ett objektorienterat program. Med det sagt, för snabb felsökning, utforskande skript eller små verktyg, kontroll mot numbers.Number är ett kraftfullt, pragmatiskt verktyg för att verifiera att dina variabler verkligen beter sig som tal.

Utökade numeriska ekosystem: NumPy och anpassade typer

Även om Pythons kärnprogram bara exponerar en liten uppsättning generella numeriska typer, utökar det bredare ekosystemet dina alternativ avsevärt.NumPy introducerar i synnerhet många fler numeriska varianter utformade för effektiv beräkning över stora arrayer och matriser.

NumPy definierar heltalstyper med fast bredd, till exempel numpy.int64, numpy.int32, numpy.int16 och specialiserade alias som numpy.int0Dessa liknar de typer som finns i numeriskt orienterade lågnivåspråk som Fortran och C, där det är avgörande för prestanda och interoperabilitet att känna till den exakta lagringsstorleken och beteendet hos dina tal.

Förutom heltal erbjuder NumPy typer som numpy.float64 och numpy.complex64, tillsammans med många andra, som integreras snyggt med arrayer och ufuncs (universella funktioner). Dessa typer registreras vanligtvis som instanser av lämpliga ABC:er från numbers modul, vilket är anledningen till att kontrollera mot numbers.Number arbete som illustrerats tidigare.

Pythons design höll avsiktligt den numeriska kärnmodellen enkel och tillgängligIstället för att tvinga varje användare att hantera dussintals distinkta numeriska varianter fokuserar den på tre grundläggande numeriska typer (plus booleska värden), samtidigt som det gör det enkelt för specialiserade bibliotek att utöka denna repertoar efter behov. En ingenjörsfokuserad miljö, som en byggd av ett simuleringsprogramvaruföretag, kommer naturligtvis att luta sig starkt mot dessa utökade typer och bibliotek.

Om du bygger dina egna numeriska klasser, följ mönstren från numbers och fractions hjälper dig att passa in i ekosystemetGenom att underklassificera lämplig ABC och implementera de nödvändiga specialmetoderna (__add__, __radd__, __mul__, och så vidare), kan dina anpassade typer interagera naturligt med Pythons operatorer, inbyggda numeriska funktioner och andra numeriska bibliotek.

Sammantaget kombinerar numerisk Python ett rent kärntypsystem, kraftfulla standardbiblioteksmoduler och ett rikt ekosystem av bibliotek precis som NumPy, skapar en miljö där du bekvämt kan gå från enkel aritmetik till avancerade tekniska beräkningar. När du väl internaliserat hur heltal, flyttal, komplexa tal, specialvärden, avrundningsregler och abstrakta numeriska klasser passar ihop, kan du resonera mer säkert kring din kod, undvika subtila buggar och välja rätt verktyg för varje numerisk uppgift du stöter på.