`numpy` — numpy-kompatibla arrayoperationer¶

Undermodulen numpy i ulab tillhandahåller ett numpy-kompatibelt API uppbyggt kring den n-dimensionella arraytypen ndarray. Den implementerar en utvald delmängd av CPython numpy: arraykonstruktion, elementvis matematik, reduktioner och statistik, linjär algebra, FFT:er, slumptalsgenerering, polynomanpassning och grundläggande I/O.

Undermodulen importeras enligt konvention som np

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

Varje dtype-argument är en av heltalskonstanterna som exponeras på modulnivå: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (standardvärdet) och (när stöd för komplexa tal är inkompilerat) numpy.complex. Resultattypen ndarray syftar på numpy.ndarray.

Undermoduler¶

klass `ndarray` — den n-dimensionella arrayen¶

En ndarray är den n-dimensionella, dtype-medvetna behållaren i kärnan av numpy / ulab. Datan lagras i ett sammanhängande block vars tolkning beskrivs av ett litet huvud (dtype, shape, strides, ndim, itemsize). Många operationer – reshape, transpose, slicing – justerar bara detta huvud och är därför mycket billiga; metoder som allokerar nytt lagringsutrymme (copy, flatten, de flesta aritmetiska operationer) returnerar en ny tät array.

Samma typ är åtkomlig som ulab.ndarray, numpy.ndarray och (på den här sidan) helt enkelt ndarray.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)¶

Skapa en ny ndarray.

Parametrar:

values – Källdata. Antingen en annan ndarray (som djupkopieras, med typkonvertering om dtype skiljer sig) eller någon MicroPython-itererbar. Nästlade itererbara objekt ger flerdimensionella arrayer; de inre itererbara objekten måste alla ha samma längd, annars uppstår ett ValueError.
dtype – Elementtyp för den nya arrayen. En av typkodsheltalen som exponeras av numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float och – när det stöds – numpy.complex), eller en dtype-instans. Standardvärdet är numpy.float.

Fabriksfunktionen numpy.array är det konventionella sättet att skapa en ndarray; den vidarebefordrar till denna konstruktor.

byteswap(*, inplace: bool = False) → ndarray¶

Byt byteordning för varje element. För arrayer av typen uint16, int16, float och complex vänder detta byteordningen per element, vilket är användbart vid konsumtion av data från kringutrustning vars endianness inte matchar mikrokontrollerns. För dtypes på en byte (bool, uint8, int8) är detta en no-op som returnerar en vy eller kopia.

Om inplace är False (standardvärdet) returneras en ny ndarray och originalet lämnas orört. Om inplace är True byts byteordningen i self på plats och en vy av self returneras.

copy() → ndarray¶: Returnera en ny tät, djup kopia av arrayen. Kopian äger sin egen data; ändringar i den påverkar inte originalet.

flatten(*, order: str = 'C') → ndarray¶

Returnera en ny endimensionell kopia av arrayen.

Parametrar:: order – 'C' (standardvärdet) genomlöper datan i C-ordning (sista axeln varierar snabbast); 'F' genomlöper den i Fortran-ordning (första axeln varierar snabbast).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Returnera en vy av arrayen med en ny form. Det totala antalet element måste vara oförändrat, annars uppstår ett ValueError. Endast tillgänglig när ULAB_MAX_DIMS > 1. Motsvarar tilldelning till shape.

sort(*, axis: int | None = -1) → None¶

Sortera arrayen på plats.

Parametrar:: axis – Axel att sortera längs. -1 (standardvärdet) sorterar längs den sista axeln; None plattar först ut arrayen och sorterar sedan.

tobytes() → bytearray¶: Returnera en bytearray som aliasar arrayens underliggande databuffert. Skrivningar genom den returnerade bytearray ändrar arrayen på plats. Ger upphov till ValueError om arrayen inte är tät (t.ex. en utsnittad vy).

tolist() → list¶: Returnera arrayens innehåll som en (eventuellt nästlad) Python-list. Nästlingsdjupet är lika med ndim.

transpose() → ndarray¶: Returnera arrayens transponat (axlarna omvända). För endimensionella arrayer returnerar detta self. Endast tillgänglig när ULAB_MAX_DIMS > 1. Attributet T är en förkortning för denna metod.

dtype: dtype | int¶: Datatypen för arrayens element. Returnerar en dtype-instans när den fasta programvaran är byggd med ULAB_HAS_DTYPE_OBJECT aktiverat, annars den underliggande typkoden på ett tecken som ett heltal.

flat: flatiter¶: En platt iterator som ger varje element i arrayen i C-ordning. Till skillnad från flatten() allokerar iteration över flat ingen ny array.

itemsize: int¶: Storleken i byte för ett enskilt arrayelement, härledd från dtype.

ndim: int¶: Antalet arraydimensioner (längden på shape).

shape: tuple[int, ...]¶: Längderna för arrayen längs varje axel. Tilldelning av en tupel till shape omformar arrayen på plats (motsvarar reshape()).

size: int¶: Det totala antalet element i arrayen (produkten av shape).

strides: tuple[int, ...]¶: Antalet byte att stega i minnet längs varje axel för att nå nästa element längs den axeln.

T: ndarray¶: Arrayens transponat; motsvarar transpose().

real: ndarray¶: Realdelen av en komplex array, returnerad som en float-ndarray. För reella arrayer är detta en kopia av self med samma dtype. Endast tillgänglig när den fasta programvaran byggdes med stöd för komplexa tal.

imag: ndarray¶: Imaginärdelen av en komplex array, returnerad som en float-ndarray. För reella arrayer är detta en array av nollor med samma dtype som self. Endast tillgänglig när den fasta programvaran byggdes med stöd för komplexa tal.

Operatorer som stöds¶

ndarray-instanser stöder följande operatorer. Binära operatorer broadcastar sina operander enligt standardregler för numpy-broadcasting och följer numpys uppkonverteringsregler (t.ex. uint8 + int8 => int16, uint16 + int16 => float); operationer som involverar en komplex operand ger ett komplext resultat.

Aritmetik (binär): +, -, *, /, //, %, **. Reflekterade (högersidiga) operander och varianterna på plats +=, -=, *=, /=, %=, **= stöds också. Både formen ndarray-med-ndarray och ndarray-med-skalär accepteras. Heltalsdivision (//) och modulooperatorn (%) är inte implementerade för complex-arrayer.

Jämförelse: ==, !=, <, <=, >, >=. Var och en returnerar en boolesk ndarray av broadcast-formen.

Bitvis (endast heltalsarrayer): &, |, ^. Att tillämpa dessa på en float- eller complex-array ger upphov till TypeError.

Unär: + (returnerar en kopia), - (negation; på dtypes utan tecken slår värdena runt modulo \(2^N\)), abs() (elementvist absolutbelopp; på dtypes utan tecken returneras en kopia utan beräkning), ~ (bitvis inversion, endast heltals-dtypes), len() (returnerar längden för den första axeln).

Indexering och slicing: a[i], a[i, j, ...], a[start:stop:step], indexering med boolesk mask (a[mask]) och indexering med heltalsarray (fancy indexing) stöds alla vid både läsning och skrivning.

Iteration: Iteration över en ndarray ger underarrayer längs den första axeln (ett element i taget för 1-D-arrayer). Använd flat för att iterera över varje skalärt element oavsett dimensionalitet.

Matrismultiplikationsoperatorn @ är inte implementerad; använd numpy.dot (np.dot(a, b)) i stället.

Skiftoperatorerna (<<, >>) är inte implementerade på operatornivå. Använd numpy.left_shift och numpy.right_shift för elementvisa heltalsskift.

Arraykonstruktion¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Konstruera en ny ndarray från en nästlad itererbar av tal. Likvärdig alternativ konstruktor för numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Returnera jämnt fördelade värden över det halvöppna intervallet [start, stop). Om endast ett positionellt argument ges behandlas det som stop med start = 0. Om dtype utelämnas härleds det från indata (heltal om alla av start, stop, step är heltal och inom intervallet).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Om a redan är en ndarray vars dtype matchar dtype (eller dtype är None), returneras a oförändrad; annars skapas en ny array (med begärd dtype-konvertering när den anges). Itererbara objekt konverteras som i numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Sammanfoga en sekvens av ndarray längs en befintlig axis. Alla indataarrayer måste dela samma dtype, ndim och form på varje axel utom axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: För en 2-D a, returnera en 1-D-array som innehåller den k:te diagonalen. För en 1-D a, returnera en 2-D kvadratisk array med a placerad på den k:te diagonalen. k kan vara positiv (ovanför huvuddiagonalen) eller negativ (under).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias för zeros; returnerar en nollfylld array av shape och dtype. (ulab lämnar inte bufferten oinitierad.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Returnera en 2-D N x M-array (kvadratisk N x N om M är None) med ettor på den k:te diagonalen och nollor på övriga platser.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Tolka ett objekt med buffertprotokoll som en 1-D ndarray av dtype. count är antalet objekt att läsa (-1 läser alla tillgängliga objekt); offset hoppar över så många byte i början av bufferten.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Returnera en ny array av shape och dtype med varje element satt till fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Returnera num jämnt fördelade sampel över det slutna intervallet [start, stop] (eller halvöppet om endpoint är False). När retstep är True returneras en tupel (samples, step). Komplexa start/stop ger en komplex array (när stöd för komplexa tal är aktiverat).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Returnera num sampel jämnt fördelade på en logaritmisk skala: resultatet börjar vid base ** start och slutar vid base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Returnera en tupel av koordinatmatriser från en sekvens av endimensionella koordinatarrayer. Med indexing 'xy' (standardvärdet) behandlas de två första indata som kartesiska koordinater och deras utdataaxlar byter plats; med 'ij' används matrisbaserad indexering. Implementationen motsvarar NumPy-ekvivalenten med copy=True och sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Returnera en ny array av shape och dtype fylld med ettor.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Returnera en ny array av shape och dtype fylld med nollor.

Inspektion / utskrift¶

numpy.get_printoptions() → dict¶: Returnera de aktuella alternativen för arrayutskrift som en dict med nycklarna threshold och edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Ange alternativ för arrayutskrift. threshold är det maximala antalet arrayelement som skrivs ut i sin helhet; edgeitems är antalet objekt som visas i varje ände av en axel när arrayen sammanfattas.

numpy.ndinfo(array: ndarray) → None¶: Skriv ut diagnostisk information (form, strides, dtype, itemsize, …) om array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Returnera antalet element i a längs axis; om axis är None returneras det totala antalet element (produkten av ndarray.shape).

Jämförelse¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Begränsa värdena i a så att a_min <= result <= a_max. Motsvarar maximum(a_min, minimum(a, a_max)); broadcasting följer samma regler som minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Elementvis x1 == x2; returnerar en boolesk ndarray (eller en bool-skalär om båda indata är skalärer). Tillhandahålls för portabilitet – operatorn == på arrayer ger samma resultat.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Elementvis x1 != x2; den booleska motsvarigheten till equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Returnera en boolesk array (eller skalär) som är True där indata är ändlig. Heltalsindata är alltid ändliga.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Returnera en boolesk array (eller skalär) som är True där indata är oändlig. Heltalsindata är aldrig oändliga.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Elementvis maximum av två arrayer / skalärer. Argumenten broadcastas tillsammans; om dtypes skiljer sig uppkonverteras utdata.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Elementvis minimum av två arrayer / skalärer; motsvarighet till maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Returnera en tupel av ndarray, en per dimension av a, som innehåller indexen för de element i a som inte är noll.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Returnera en ndarray vars element kommer från x där condition är sann, och från y annars. De tre indata broadcastas tillsammans; utdatans dtype är uppkonverteringen av x och y.

Numeriska reduktioner¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Testa huruvida alla element längs axis utvärderas till True. Med axis=None (standardvärdet) testas den utplattade arrayen och en enda bool returneras.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Testa huruvida något element längs axis utvärderas till True. Med axis=None testas den utplattade arrayen.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Returnera indexet för det största elementet längs axis. Med axis=None plattas arrayen ut och ett enda heltal returneras.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Returnera indexet för det minsta elementet längs axis. Med axis=None plattas arrayen ut och ett enda heltal returneras.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Returnera en heltals-ndarray utan tecken vars poster sorterar a i stigande ordning längs axis. Utdatans dtype är uint16, så ingen axel får överstiga 65535 element. axis=None stöds inte.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Returnera kryssprodukten av två 1-D-arrayer med längd 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Returnera den n:te diskreta framåtdifferensen av a längs axis. n måste vara i 0..9 (differentieringsstencilen lagras i en int8); längden på axis krymper med n. Numpy-nyckelorden prepend och append är inte implementerade.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Returnera en ny array med ordningen på elementen omvänd längs axis; med axis=None vänds arrayen längs varje axel.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Returnera det största elementet längs axis. Med axis=None (standardvärdet) reduceras den utplattade arrayen till en skalär. Numpy-nyckelordet out är inte implementerat.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Returnera det minsta elementet längs axis; motsvarighet till max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Returnera det aritmetiska medelvärdet längs axis. Med axis=None (standardvärdet) returneras den utplattade arrayens medelvärde som en float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Returnera medianen längs axis. Med axis=None plattas arrayen ut först. Utdatans dtype är alltid float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Returnera a med dess element rullade (cykliskt förskjutna) med shift positioner. Med axis=None (standardvärdet) plattas arrayen ut först. Negativa förskjutningar rullar i motsatt riktning.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Returnera en sorterad kopia av a längs axis med heap sort. Med axis=None plattas arrayen ut först. Numpy-nyckelorden kind och order är inte implementerade.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Returnera standardavvikelsen längs axis. ddof är delta frihetsgrader – divisorn som används är N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Returnera summan längs axis. Med axis=None returneras den utplattade arrayens totalsumma som en skalär.

Statistik¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Räkna antalet förekomster av varje värde i den endimensionella, icke-negativa heltalsarrayen x. Dtypen för x måste vara uint8 eller uint16. Om weights anges bidrar varje post i x med sin matchande vikt i stället för 1 och utdata är av dtypen float; annars är utdata av dtypen uint16. Om minlength anges har utdataarrayen minst så många element (extra poster är noll).

numpy.trace(m: ndarray) → int | float¶: Returnera summan av diagonalelementen i den kvadratiska matrisen m. Returtypen följer dtypen för m (heltalsarrayer ger ett heltal, float-arrayer en float).

Transformera¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Returnera utsnitt av a valda längs axis av den booleska condition. Med axis=None används den utplattade arrayen.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Returnera en kopia av a med posterna vid indices borttagna längs axis. Med axis=None plattas arrayen ut först. Negativa index räknas från slutet av axis; indices sorteras internt före borttagning.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Returnera skalärprodukten av två arrayer. För två 1-D-arrayer är detta den inre produkten (en float-skalär). För 2-D-arrayer är detta matrismultiplikation; de inre dimensionerna måste matcha. Resultatet är alltid av dtypen float.

Approximation¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Endimensionell linjär interpolation. xp måste vara en monotont stigande 1-D-array av oberoende värden; fp innehåller motsvarande beroende värden; x är de punkter vid vilka interpolanten utvärderas. left och right åsidosätter värdet som returneras för x < xp[0] respektive x > xp[-1] (standardvärden: fp[0] och fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integrera y med den sammansatta trapetsregeln. Om x anges tillhandahåller den samplingspositionerna som motsvarar y; annars används avståndet dx. y (och x) måste vara 1-D.

Urval¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Hämta element från a vid de givna indices längs axis. Med axis=None används den utplattade arrayen. mode väljer beteendet utanför gränserna: "raise" (standard – ger upphov till ValueError), "wrap" (modulo axellängden) eller "clip" (begränsa till det giltiga intervallet; negativa index är inte tillåtna). Om out anges skrivs resultatet in i den.

Bitvis¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: Elementvis bitvis AND av två heltalsarrayer; broadcasting stöds. En dtype som inte är heltal ger upphov till ett undantag.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: Elementvis bitvis OR av två heltalsarrayer.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: Elementvis bitvis XOR av två heltalsarrayer.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Elementvis bitvis skift av x1 åt vänster med x2 bitar; båda arrayerna måste ha heltals-dtype.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Elementvis bitvis skift av x1 åt höger med x2 bitar; båda arrayerna måste ha heltals-dtype.

Filtrering¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Returnera den diskreta linjära faltningen av två 1-D-arrayer. Endast läget "full" stöds; numpy-nyckelordet mode accepteras inte (andra lägen kan erhållas genom att snitta det fullständiga resultatet). Utdatalängden är len(a) + len(v) - 1.

Polynom¶

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray¶

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Anpassa ett polynom av grad deg till datapunkterna (x, y) med minsta kvadratmetoden och returnera polynomets koefficienter (högsta graden först). Om x utelämnas används range(len(y)). Ger upphov till ValueError om längderna på x och y skiljer sig.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Utvärdera polynomet vars koefficienter är p (högsta graden först) vid x. Om x är en skalär returneras en float, annars en ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Läs en array som tidigare skrevs med save från file (numpys plattformsoberoende .npy-format). Endianness konverteras i farten om filens byteordning skiljer sig från värddatorns.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray¶: Läs numeriska data från en text-file och returnera dem som en ndarray. delimiter har som standard blanksteg; comments är radkommentarsmarkören; max_rows begränsar antalet datarader som läses (-1 för alla); usecols väljer kolumner efter index; skiprows hoppar över så många inledande rader. Om dtype inte är float konverteras värdena genom avrundning.

numpy.save(file: str, a: ndarray) → None¶: Spara a till file i numpys plattformsoberoende .npy-format.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Skriv a till file som text. delimiter separerar värden inom en rad; header och footer, om de anges, skrivs före/efter datan, var och en prefixad med comments. Värden skrivs som flyttal.

Komplexa hjälpfunktioner¶

Dessa funktioner är endast tillgängliga när ulab kompilerades med stöd för komplexa tal (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Returnera realdelen av val. För indata med reell dtype returneras en kopia som bevarar dtypen; för komplex indata returneras en float-ndarray.

numpy.imag(val: ndarray) → ndarray¶: Returnera imaginärdelen av val. För indata med reell dtype returneras en array av nollor med samma dtype; för komplex indata returneras en float-ndarray.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Returnera det komplexa konjugatet av val. Reellvärd indata returneras oförändrad.

numpy.sort_complex(a: ndarray) → ndarray¶: Sortera 1-D-arrayen a först efter realdel, sedan efter imaginärdel. Resultatet är alltid av komplex dtype, även om a var reellvärd.

Universella funktioner¶

Elementvisa matematiska funktioner. Var och en accepterar en skalär eller en ndarray och returnerar ett resultat av matchande form (en float-skalär för skalär indata, en ndarray för arrayindata). När de anropas med en ndarray är resultatet en ny ndarray med flyttal; ett valfritt out-nyckelord kan skickas för att skriva resultatet in i en förallokerad float-ndarray av samma storlek.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Beräkna inverskosinus (arcuscosinus) av varje element i x; resultatet är i radianer.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Beräkna invers hyperbolisk cosinus av varje element i x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Beräkna den tvåargumentsinversa tangenten atan2(y, x) elementvis; stöder broadcasting mellan de två indata.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Avrunda elementen i ndarray x till det givna antalet decimals; det första argumentet måste vara en ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Beräkna inverssinus (arcussinus) av varje element i x; resultatet är i radianer.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Beräkna invers hyperbolisk sinus av varje element i x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Beräkna inverstangent (arcustangens) av varje element i x; resultatet är i radianer.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Beräkna invers hyperbolisk tangent av varje element i x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Beräkna taket (det minsta heltalet som inte är mindre än värdet) för varje element i x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Beräkna cosinus av varje element i x (i radianer).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Beräkna hyperbolisk cosinus av varje element i x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Konvertera varje element i x från radianer till grader.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Beräkna exponentialen e**x av varje element i x; kan returnera en komplex ndarray vid komplex indata (om stöd för komplexa tal är aktiverat).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Beräkna exp(x) - 1 av varje element i x med förbättrad precision nära noll.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Beräkna golvet (det största heltalet som inte är större än värdet) för varje element i x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Beräkna den naturliga logaritmen av varje element i x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Beräkna 10-logaritmen av varje element i x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Beräkna 2-logaritmen av varje element i x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Konvertera varje element i x från grader till radianer.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Beräkna sinus av varje element i x (i radianer).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Beräkna den normaliserade sinc-funktionen sin(pi*x) / (pi*x) av varje element i x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Beräkna hyperbolisk sinus av varje element i x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Beräkna kvadratroten av varje element i x; skicka dtype=numpy.complex för att erhålla komplexa resultat för negativa reella indata (om stöd för komplexa tal är aktiverat).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Beräkna tangenten av varje element i x (i radianer).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Beräkna hyperbolisk tangent av varje element i x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Returnera ett anropbart objekt som tillämpar Python-funktionen f elementvis på en skalär, itererbar eller ndarray; otypes väljer utdatans dtype (standard float).

Konstanter¶

numpy.e: float¶: Eulers tal \(e \approx 2.71828\).

numpy.pi: float¶: \(\pi \approx 3.14159\).

numpy.inf: float¶: IEEE-754 positiv flyttalsoändlighet.

numpy.nan: float¶: IEEE-754 flyttals-”not a number”.

numpy.bool: int¶: Dtype-kod för booleska arrayer (lagrade som uint8).

numpy.uint8: int¶: Dtype-kod för 8-bitars heltalsarrayer utan tecken.

numpy.int8: int¶: Dtype-kod för 8-bitars heltalsarrayer med tecken.

numpy.uint16: int¶: Dtype-kod för 16-bitars heltalsarrayer utan tecken.

numpy.int16: int¶: Dtype-kod för 16-bitars heltalsarrayer med tecken.

numpy.float: int¶: Dtype-kod för 32-bitars flyttalsarrayer.

numpy — numpy-kompatibla arrayoperationer¶