Python NumPy-handledning för nybörjare

Vad är NumPy i Python?

numpy är en öppen källkod Python bibliotek för matematisk, vetenskaplig, ingenjörsmässig och datavetenskaplig programmering. Det är ett mycket användbart bibliotek för matematiska och statistiska operationer inom PythonDen fungerar perfekt med flerdimensionella arrayer och matrismultiplikation, och integreras enkelt med C/C++ och Fortran.

För alla vetenskapliga projekt är NumPy verktyget att känna till. Det är byggt för N-dimensionella matriser, linjär algebra, slumptalsgenerering, Fouriertransformer och mer.

NumPy ger Python förstklassigt stöd för flerdimensionella arrayer och matriser, plus en stor uppsättning matematiska operationer som påverkar dem. I den här guiden kommer vi att granska de viktigaste funktionerna du behöver känna till innan vi går vidare till handledningen om 'TensorFlow. '

Varför använda NumPy?

NumPy är minneseffektivt, så det kan hantera stora volymer numerisk data lättare än ren Python listor. Det är också mycket praktiskt för matrismultiplikation och omformuleringping, och det är snabbt eftersom det tunga arbetet delegeras till kompilerade C-rutiner. Faktum är att bibliotek som TensorFlow, PyTorch och Scikit-learn förlitar sig på NumPy-arrayer för matrismatematik i sin backend, vilket gör NumPy till den tysta arbetshästen under de flesta moderna datavetenskaps- och AI-arbetsflöden.

Hur man installerar NumPy

För att installera NumPy-biblioteket, se vår handledning Hur man installerar TensorFlow. NumPy är installerat som standard med Anaconda.

I det sällsynta fallet att NumPy inte är installerat, använd något av alternativen nedan.

Du kan installera NumPy med Anaconda:

conda install -c anaconda numpy

• In Jupyter Debatt:

import sys
!conda install --yes --prefix {sys.prefix} numpy

Pip-användare kan installera eller uppgradera med ett enda kommando:

pip install --upgrade numpy

Importera NumPy och kontrollera version

Kommandot för att importera numpy är:

import numpy as np

Raden ovan byter namn på NumPy-namnrymden till npMed den här genvägen kan du prefixa NumPy-funktioner, metoder och attribut med np. istället för tackping numpy., och det är standardkonventionen du hittar i hela NumPy-ekosystemet.

För att kontrollera din installerade version av NumPy, använd kommandot nedan:

print(np.__version__)

Produktion:

2.1.3

NumPy 2.0 levererades i juni 2024 och är den nuvarande stabila huvudserien. Om ditt projekt fortfarande är beroende av 1.x API, fäst till numpy<2 i din kravfil eftersom vissa äldre alias som np.float togs bort i 2.0.

Vad är en Python NumPy Array?

NumPy-arrayer ser lite ut som Python listor vid första anblicken, men de beter sig väldigt olika. För läsare som är nya inom ämnet, låt oss klargöra vad en ndarray är och varför den är viktig.

Som namnet antyder är en NumPy-array den centrala datastrukturen i NumPy-biblioteket. Själva namnet är en förkortning för "Numeric Python” eller ”Numerisk Python”, och ndarrayen är ett homogent minnesblock med fast storlek med en känd form och datatyp.

Skapa en NumPy-array

Det enklaste sättet att skapa en array i NumPy är att börja från en Python Lista.

myPythonList = [1,9,8,3]

konvertera den Python lista till en NumPy-array med hjälp av np.array.

numpy_array_from_list = np.array(myPythonList)

Visa innehållet i arrayen.

numpy_array_from_list

Produktion:

array([1, 9, 8, 3])

I praktiken finns det inget behov av att deklarera en Python lista först. De två stegen kan kombineras.

a = np.array([1,9,8,3])

OBS: NumPy-dokumentationen nämner också np.ndarray, Men np.array är den rekommenderade fabriksfunktionen för dagligt bruk.

Du kan också skapa en NumPy-array från en tupel på samma sätt.

Matematisk Operationer på en Array

Du kan utföra matematiska operationer som addition, subtraktiontraction, division och multiplikation på en array. Syntaxen är arraynamnet, följt av operatorn (+, -, *, /), följt av operanden. Dessa operationer är vektoriserade, vilket innebär att NumPy tillämpar dem på varje element utan en explicit Python slinga.

Exempel:

numpy_array_from_list + 10

Produktion:

array([11, 19, 18, 13])

Den här operationen adderar 10 till varje element i NumPy-arrayen.

Shape of Array

Du kan kontrollera formen på en array med shape attribut, som nås genom att lägga till det i arraynamnet. På samma sätt kan du kontrollera typen med dtype.

import numpy as np
a = np.array([1,2,3])
print(a.shape)
print(a.dtype)

(3,)
int64

Ett heltal är ett värde utan decimaltecken. Om du skapar en array med decimaler ändras dtypen till flyttal.

#### Different type
b = np.array([1.1,2.0,3.2])
print(b.dtype)

float64

2 Dimension Array

Du kan lägga till en dimension med ett kommatecken inom parenteserna.

Observera att de inre tuplerna måste sitta innanför de yttre parenteserna [].

### 2 dimension
c = np.array([(1,2,3),
              (4,5,6)])
print(c.shape)
(2, 3)

3 Dimension Array

Högre dimensioner kan konstrueras på samma sätt.

### 3 dimension
d = np.array([
    [[1, 2,3],
        [4, 5, 6]],
    [[7, 8,9],
        [10, 11, 12]]
])
print(d.shape)
(2, 2, 3)

Mål	Code
Skapa array	array([1,2,3])
skriv ut formen	array([.]).form

Vad är numpy.zeros()?

numpy.zeros() or np.zeros är en Python Funktion som används för att skapa en matris fylld med nollor. numpy.zeros() är användbart när du behöver initiera vikter under den första iterationen i TensorFlow eller konfigurera platshållarbuffertar för andra statistiska uppgifter.

numpy.zeros() funktion Syntax

numpy.zeros(shape, dtype=float, order='C')

Python numpy.zeros() Parametrar

Här,

• Forma: formen på NumPy-nollmatrisen.
• Dtyp: datatyp för elementen. Det är valfritt och standardvärdet är float64.
• Ordersammanställning: standard är C, vilket är den rad-huvudlayout som används av numpy.zeros() in Python.

Python numpy.zeros() Exempel

import numpy as np
np.zeros((2,2))

Produktion:

array([[0., 0.],
          [0., 0.]])

Exempel på numpy zero med Datatype

import numpy as np
np.zeros((2,2), dtype=np.int16)

Produktion:

array([[0, 0],
         [0, 0]], dtype=int16)

Vad är numpy.ones()?

np.ones() funktion skapar en matris fylld med ettor. numpy.ones() in Python är användbart när du initierar vikter under den första iterationen i TensorFlow och för andra statistiska uppgifter.

Python numpy.ones() Syntax

numpy.ones(shape, dtype=float, order='C')

Python numpy.ones() Parametrar

Här,

• Forma: formen på np-enorna Python array.
• Dtyp: datatyp för elementen. Det är valfritt och standardvärdet är float64.
• Ordersammanställning: standard är C, vilket är layouten för huvudrad.

Python numpy.ones() 2D-array med datatypexempel

import numpy as np
np.ones((1,2,3), dtype=np.int16)

Produktion:

array([[[1, 1, 1],
       [1, 1, 1]]], dtype=int16)

numpy.reshape()-funktionen i Python

Python NumPy omforma ändrar formen på en array utan att ändra dess data. Du kan behöva omforma data från brett till långt format, eller gå från en 1D-vektor till en 2D-matris innan du matar in den i en modell. np.reshape Funktionen hanterar detta i ett anrop.

Syntax för np.reshape()

numpy.reshape(a, newShape, order='C')

Här,

a: array som du vill omforma.

newShape: den nya önskade formen.

Ordersammanställning: standard är C, layouten för huvudrad.

Exempel på NumPy Reshape

import numpy as np
e = np.array([(1,2,3), (4,5,6)])
print(e)
e.reshape(3,2)

Produktion:

 // Before reshape
[[1 2 3]
 [4 5 6]]

//After Reshape
array([[1, 2],
	[3, 4],
	[5, 6]])

numpy.flatten() in Python

Python NumPy Flatten returnerar en kopia av arrayen hopfälld till en dimension. När du arbetar med neurala nätverk som convnets behöver du ofta platta till en bildtensor innan du skickar den till ett tätt lager. np.flatten() Funktionen hanterar detta i ett enda anrop.

Syntax för np.flatten()

numpy.flatten(order='C')

Här,
Ordersammanställning: standard är C, layouten för huvudrad.

Exempel på NumPy Flatten

e.flatten()

Produktion:

array([1, 2, 3, 4, 5, 6])

Vad är numpy.hstack() i Python?

numpy.hstack är en Python funktion som används för att horisontellt stapla sekvenser av inmatningsmatriser till en enda matris. Med hstack(), lägger du till data längs kolumnaxeln. Det är en mycket praktisk hjälp i NumPy när du behöver sammanfoga funktionsvektorer sida vid sida.

Låt oss studera hstack in Python med ett exempel.

Exempel:

## Horizontal Stack
import numpy as np
f = np.array([1,2,3])
g = np.array([4,5,6])
print('Horizontal Append:', np.hstack((f, g)))

Produktion:

Horizontal Append: [1 2 3 4 5 6]

Vad är numpy.vstack() i Python?

numpy.vstack är en Python funktion som används för att vertikalt stapla sekvenser av inmatningsmatriser till en enda matris. Med vstack(), lägger du till data längs radaxeln, vilket är praktiskt när du vill kombinera batchar av exempel.

Låt oss studera det med ett exempel.

Exempel:

## Vertical Stack
import numpy as np
f = np.array([1,2,3])
g = np.array([4,5,6])
print('Vertical Append:', np.vstack((f, g)))

Produktion:

Vertical Append: [[1 2 3]
 [4 5 6]]

Efter att ha studerat NumPy vstack och hstack, låt oss titta på ett exempel som genererar slumptal i NumPy.

Generera slumpmässigt Numbers använder NumPy

För att generera slumptal från en Gaussisk fördelning, använd:

numpy.random.normal(loc, scale, size)

Här,

• Plats: medelvärdet. Fördelningens centrum.
• Skala: standardavvikelsen.
• Storlek: antal returnerade prover.

Exempel:

## Generate random numbers from a normal distribution
normal_array = np.random.normal(5, 0.5, 10)
print(normal_array)
[5.56171852 4.84233558 4.65392767 4.946659   4.85165567 5.61211317 4.46704244 5.22675736 4.49888936 4.68731125]

Om den plottas liknar fördelningen följande diagram.

Observera att nyare kod i allt högre grad använder det moderna generator-API:et, np.random.default_rng(), vilket är den rekommenderade ersättningen för det äldre np.random.normal anrop i NumPy 2.x.

NumPy Asarray-funktion

Ocuco-landskapet asarray() Funktionen konverterar indata till en array. Indata kan vara en lista, tupel, ndarray eller liknande sekvens.

Syntax:

numpy.asarray(data, dtype=None, order=None)

Här,

datum: data som du vill konvertera till en array.

dtypeValfritt. Om inget anges härleds datatypen från indata.

Ordersammanställning: standard är C, rad-huvudlayouten. Det andra alternativet är F (Fortran-stil kolumn-stor).

Exempel:

Betrakta följande 2D-matris med fyra rader och fyra kolumner, fylld med 1.

import numpy as np
A = np.matrix(np.ones((4,4)))

Om du försöker ändra ett värde i matrisen genom np.array, originalet är inte modifierat. Anledningen är att np.array skapar en kopia av matrisen.

np.array(A)[2]=2
print(A)
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

Matrisen är oförändrad. Använd asarray när du vill ändra den ursprungliga arrayen. Låt oss se vad som händer när du ställer in den tredje raden till värdet 2.

np.asarray(A)[2]=2
print(A)

Code Förklaring:

np.asarray(A) omvandlar matrisen A till en arrayvy.

[2] väljer den tredje raden.

Produktion:

[[1. 1. 1. 1.]
      [1. 1. 1. 1.]
      [2. 2. 2. 2.] # new value
      [1. 1. 1. 1.]]

Vad är numpy.arange()?

numpy.arange() är en inbyggd NumPy-funktion som returnerar en ndarray som innehåller jämnt fördelade värden inom ett definierat intervall. För att till exempel skapa värden från 1 till 10 kan du anropa np.arange() in Python.

Syntax:

numpy.arange(start, stop, step, dtype)

Python NumPy arange parametrar:

• Start: början av intervallet för np.arange in Python.
• Sluta: slutet av intervallet.
• Steg: avstånd mellan värden. Standardsteg är 1.
• Dtyptyp av utmatningsmatris för NumPy arange.

Exempel:

import numpy as np
np.arange(1, 11)

Produktion:

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

Exempel:

För att ändra steget i detta NumPy arange till exempel, lägg till ett tredje tal i parentesen. Det ändrar stegstorleken.

import numpy as np
np.arange(1, 14, 4)

Produktion:

array([ 1,  5,  9, 13])

NumPy Linspace-funktion

linspace returnerar jämnt fördelade sampel mellan två slutpunkter.

Syntax:

numpy.linspace(start, stop, num, endpoint)

Här,

• Start: startvärdet för sekvensen.
• Sluta: slutvärdet för sekvensen.
• IAntal prover att generera. Standardvärdet är 50.
• Slutpunkt: om True (Standard), stop är det sista värdet. Om False, stop ingår inte.

Exempel:

Till exempel kan den användas för att skapa 10 jämnt fördelade värden från 1 till 5.

import numpy as np
np.linspace(1.0, 5.0, num=10)

Produktion:

array([1.        , 1.44444444, 1.88888889, 2.33333333, 2.77777778,       3.22222222, 3.66666667, 4.11111111, 4.55555556, 5.        ])

Om du inte vill inkludera den sista siffran i intervallet, ställ in endpoint till False.

np.linspace(1.0, 5.0, num=5, endpoint=False)

Produktion:

array([1. , 1.8, 2.6, 3.4, 4.2])

LogSpace NumPy-funktion in Python

logspace returnerar jämnt fördelade tal på en logaritmisk skala. logspace delar samma parametrar som np.linspace.

Syntax:

numpy.logspace(start, stop, num, endpoint)

Exempel:

np.logspace(3.0, 4.0, num=4)

Produktion:

array([ 1000. ,  2154.43469003,  4641.58883361, 10000.        ])

Slutligen, om du vill kontrollera minnesstorleken för ett enskilt element i en array, kan du använda itemsize.

x = np.array([1,2,3], dtype=np.complex128)
x.itemsize

Produktion:

16

Varje element tar 16 byte.

Indexering och skärning Python

Att segmentera data är enkelt med NumPy. Vi kommer att segmentera matrisen e. I Python, använder du hakparenteser för att returnera rader eller kolumner.
Exempel:

## Slice
import numpy as np
e = np.array([(1,2,3), (4,5,6)])
print(e)
[[1 2 3]
 [4 5 6]]

Kom ihåg att i NumPy börjar det första arrayindexet på 0.

## First row
print('First row:', e[0])

## Second row
print('Second row:', e[1])

Produktion:

First row: [1 2 3]
Second row: [4 5 6]

In Python, liksom i många andra språk,

• Värdet före kommatecknet står för raderna.
• Värdet efter kommatecknet står för kolumnerna.
• Om du vill välja en kolumn, lägg till : före kolumnindexet.
• : betyder att du vill ha alla rader från den valda kolumnen.

print('Second column:', e[:,1])

Second column: [2 5]

För att returnera de två första värdena på den andra raden, använd : för att markera alla kolumner upp till det andra indexet.

## Second Row, two values
print(e[1, :2])
[4 5]

Statistiska funktioner i Python

NumPy tillhandahåller en användbar uppsättning statistiska funktioner för att hitta minimum, maximum, percentil, standardavvikelse, varians med mera från en given array. De vanligaste listas nedan.

NumPy levereras med robusta statistiska hjälpmedel, sammanfattade i tabellen.

Funktion	numpy
Min	np.min()
Max	np.max()
Betyda	np.mean()
median	np.median()
Standardavvikelse	np.std()

Betrakta följande array:

Exempel:

import numpy as np
normal_array = np.random.normal(5, 0.5, 10)
print(normal_array)

Produktion:

[5.56171852 4.84233558 4.65392767 4.946659   4.85165567 5.61211317 4.46704244 5.22675736 4.49888936 4.68731125]

Exempel på statistiska NumPy-funktioner

### Min
print(np.min(normal_array))

### Max
print(np.max(normal_array))

### Mean
print(np.mean(normal_array))

### Median
print(np.median(normal_array))

### Sd
print(np.std(normal_array))

Produktion:

4.467042435266913
5.612113171990201
4.934841002270593
4.846995625786663
0.3875019367395316

Vad är numpy dot-produkt?

numpy.dot är en kraftfull funktion för matrisberäkning. Till exempel kan du beräkna punktprodukten med np.dot. numpy.dot returnerar punktprodukten av a och b, och hanterar både 1D- och 2D-matriser. För 2D-ingångar utför den matrismultiplikation.

Syntax:

numpy.dot(x, y, out=None)

Driftparametrar

Här,

x, y: inmatningsmatriser. x och y borde båda vara 1D eller 2D för np.dot() att fungera som en punktprodukt eller matrismultiplikation.

ut: valfritt utdataargument som används för att samla in resultatet. Annars returneras en ndarray.

Returer

Funktionen numpy.dot() returnerar punktprodukten av två arrayer x och yDen returnerar en skalär när båda är 1D, annars returnerar den en array. Om out är given, returneras den arrayen.

höjningar

Punktprodukten i Python höjer a ValueError om den sista dimensionen av x matchar inte den näst sista dimensionen av y.

Exempel:

## Linear algebra
### Dot product: product of two arrays
f = np.array([1,2])
g = np.array([4,5])
### 1*4+2*5
np.dot(f, g)

Produktion:

14

Matrix Multiplikation in Python

NumPy-filen matmul() Funktionen returnerar matrisprodukten av två matriser. Så här fungerar det.

1) För 2D-matriser returnerar den normalmatrisprodukten.

2) För dimensioner större än 2 behandlas produkten som en stapel av matriser.

3) En 1D-matris omvandlas först till en matris, sedan beräknas produkten.

Infixet @ operatör, tillgänglig sedan Python 3.5 är en förkortning för matmul och används flitigt i modern kod.

Syntax:

numpy.matmul(x, y, out=None)

Här,

x, y: inmatningsmatriser. Skalärer är inte tillåtna.

ut: valfri parameter. Vanligtvis lagras utdata i en ndarray.

Exempel:

På samma sätt kan du beräkna matrismultiplikation med np.matmul.

### Matmul: matrix product of two arrays
h = [[1,2],[3,4]]
i = [[5,6],[7,8]]
### 1*5+2*7 = 19
np.matmul(h, i)

Produktion:

array([[19, 22],
            [43, 50]])

determinanten

Om du behöver beräkna determinanten för en matris, använd np.linalg.det()NumPy tar hand om dimensionerna åt dig.

Exempel:

## Determinant 2*2 matrix
### 5*8-7*6
np.linalg.det(i)

Produktion:

-2.000000000000005

NumPy-sändningar förklarade

Broadcasting är regeln som låter NumPy utföra aritmetik på matriser med olika former utan att kopiera data. När du lägger till en skalär till en 1D-vektor, eller en 1D-vektor till en 2D-matris, sträcker NumPy den mindre operanden längs de saknade axlarna så att formerna radas upp. Detta undviker explicita Python loopar och är en av de främsta anledningarna till att NumPy-kod känns snabb och koncis.

Två former är kompatibla för sändning när, jämfört från höger till vänster, varje dimensionspar antingen är lika med eller en av dem är lika med 1. Till exempel, en matris av formen (3, 4) sänder mot en rad av former (4,) eller en kolumn med form (3, 1)Samma logik driver normalisering inom maskininlärning, där du subtracen per-funktion medelvärdesvektor från en sats av samplingar i en enda rad. Broadcasting är också den konceptuella modellen som används av tensorbibliotek som PyTorch, TensorFlow och JAX, så reglerna du lär dig här överförs direkt till GPU-kod.

Hur NumPy driver AI och maskininlärning

NumPy sitter under nästan alla moderna Python AI-stack. PyTorch-tensorer, TensorFlow Eager-tensorer och JAX-arrayer exponerar samma sändning, skivning och omformning.ping API som du lärde dig på NumPy ndarrays. Många handledningar matar fortfarande in förbearbetade NumPy-arrayer i modellträningsloopar, och ramverk accepterar dem utan konvertering.

Tre konkreta mönster visar hur NumPy kopplas till AI-arbete idag. För det första formar dataingenjörer råa funktioner till NumPy-arrayer innan de skickas till scikit-learn-pipelines eller till Hugging Face-dataset. För det andra använder forskare NumPy som en CPU-baslinje och byter sedan in CuPy, vilket tillhandahåller ett nästan identiskt API men körs på NVIDIA GPU:er via CUDA. För det tredje bygger JAX vidare på NumPy API för att lägga till automatisk differentiering och just-in-time-kompilering, så att samma kod som körs på den bärbara datorn kan köras på TPU:er i molnet. Slutsatsen är att de array-färdigheter du bygger med NumPy kan överföras till alla större verktyg för djupinlärning, vilket gör den här handledningen till ett användbart steg på vägen mot AI-utveckling.

Vanliga frågor