denna handledning kommer att förklara hur man använder Numpy standardavvikelse funktion (AKA, np.std).

på en hög nivå är Numpy standardavvikelsefunktionen enkel. Den beräknar standardavvikelsen för värdena i en Numpy array.

men detaljerna om exakt hur funktionen fungerar är lite komplexa och kräver viss förklaring.

med detta sagt kommer denna handledning att förklara hur man använder Numpy standardavvikelsefunktionen.

det kommer att förklara syntaxen för np.std (), och visar tydliga, steg-för-steg exempel på hur funktionen fungerar.

handledningen är organiserad i sektioner. Du kan klicka på någon av följande länkar, som tar dig till lämplig sektion.

Innehållsförteckning:

• en mycket snabb genomgång av Numpy
• introduktion till Numpy standardavvikelse
• syntaxen för np.std
• numpy standardavvikelse exempel
• Numpy standardavvikelse FAQ

med detta sagt, om du är relativt ny på Numpy, kanske du vill läsa hela handledningen.

en snabb genomgång av Numpy

Låt oss bara börja med en veeeery snabb genomgång av Numpy.

vad är Numpy?

Numpy är en verktygslåda för att arbeta med numeriska data

För att uttrycka det enkelt, Numpy är en verktygslåda för att arbeta med numeriska data.

För det första har Numpy en uppsättning verktyg för att skapa en datastruktur som kallas en Numpy-array.

Du kan tänka på en Numpy array som en rad-och-kolumn rutnät av siffror. Numpy arrays kan vara 1-dimensionell, 2-dimensionell eller till och med n-dimensionell.

en 2D-array ser ut så här:

För enkelhetens skull kommer vi i denna handledning att hålla fast vid 1 eller 2-dimentionella arrayer.

det finns en mängd olika sätt att skapa olika typer av matriser med olika typer av siffror. Några andra verktyg för att skapa Numpy arrays inkluderar numpy ordna, numpy nollor, numpy ettor, numpy kakel, och andra metoder.

oavsett hur du skapar din Numpy array, på en hög nivå, är de helt enkelt arrayer av siffror.

Numpy tillhandahåller verktyg för att manipulera Numpy arrays

Numpy tillhandahåller inte bara verktyg för att skapa Numpy arrays, Numpy ger också verktyg för att arbeta med Numpy arrays.

några av de viktigaste av dessa Numpy-verktyg är Numpy-funktioner för att utföra beräkningar.

det finns en hel uppsättning Numpy funktioner för att göra saker som:

• beräkna summan av en Numpy array
• beräkna det maximala
• beräkna exponentialen för siffrorna i en array
• beräkna värdet x till viss effekt, för varje värde i en Numpy array

… och en mängd andra beräkningar.

Numpy-standardavvikelsen är i huvudsak mycket som dessa andra Numpy-verktyg. Det används bara för att utföra en beräkning (standardavvikelsen) för en grupp siffror i en Numpy-array.

en snabb introduktion till Numpy standardavvikelse

på en mycket hög nivå är standardavvikelsen ett mått på spridningen av en dataset. I synnerhet är det ett mått på hur långt datapoints är från medelvärdet av data.

låt oss kortfattat granska den grundläggande beräkningen.

standardavvikelse beräknas som kvadratroten av variansen.

Så om vi har en dataset med siffror kommer variansen att vara:

och standardavvikelsen kommer bara att vara kvadratroten av variansen:

var:

= de enskilda värdena i datasetet
= antalet värden i datasetet
= medelvärdet av värdena

för det mesta är beräkningen av standardavvikelsen för hand lite utmanande, eftersom du måste beräkna medelvärdet, avvikelserna för varje datapunkt från medelvärdet, sedan kvadraten av avvikelserna etc. Uppriktigt sagt är det lite tråkigt.

men om du arbetar i Python kan du använda funktionen Numpy standardavvikelse för att utföra beräkningen åt dig.

en snabb anteckning om du är ny på statistik

eftersom det här blogginlägget handlar om att använda numpy.std () funktion, Jag vill inte komma för djupt in i ogräset om hur beräkningen utförs för hand. Denna handledning handlar verkligen om hur vi använder funktionen. Så, om du behöver en snabb granskning av vad standardavvikelse är, kan du titta på den här videon.

Ok. Efter att ha snabbt granskat vilken standardavvikelse som är, låt oss titta på syntaxen för np.std.

syntaxen för np.STD

syntaxen för Numpy standardavvikelsefunktionen är ganska enkel.

Jag förklarar det på bara en sekund, men först vill jag berätta en snabb anteckning om Numpy syntax.

en snabb anteckning: den exakta syntaxen beror på hur du importerar Numpy

När vi skriver Numpy-syntax använder vi vanligtvis aliaset ”np”. Det är den gemensamma konventionen bland de flesta Dataforskare.

för att ställa in det aliaset måste du importera Numpy så här:

import numpy as np

om vi importerar Numpy med detta alias kan vi ringa Numpy standardavvikelsefunktionen som np.std().

Ok, med det sagt, låt oss ta en närmare titt på syntaxen.

np.STD syntax

på en hög nivå, syntaxen för np.std ser ut så här:

som jag nämnde tidigare, förutsatt att vi har importerat Numpy med aliaset ”np” kallar vi funktionen med syntaxen np.std().

sedan inuti parentesen finns det flera parametrar som låter dig styra exakt hur funktionen fungerar.

Låt oss ta en titt på dessa parametrar.

parametrarna för numpy.std

det finns några viktiga parametrar du borde veta:

• a
• axis
• dtype
• ddof
• keepdims
• out

låt oss ta en titt på var och en av dem.

a(obligatoriskt)

parameterna anger den uppsättning värden som du vill beräkna standardavvikelsen över.

sa annorlunda, Detta gör att du kan ange ingångsmatrisen till funktionen.

lämpliga ingångar inkluderar Numpy arrays, men också ”array like” – objekt som Python-listor.

viktigt är att du måste ange en ingång till denna parameter. En ingång krävs.

med detta sagt kan parametern i sig vara implicit eller explicit. Vad jag menar med det är att du direkt kan skriva parametern a=, eller du kan lämna parametern ur din syntax och skriv bara namnet på din inmatningsarray.

Jag visar exempel på detta i Exempel 1.

axis

axelparametern gör att du kan ange en axel längs vilken standardavvikelsen ska beräknas.

för att förstå detta måste du verkligen förstå axlar.

Numpy arrays har axlar.

Du kan tänka på en ”axel” som en riktning längs matrisen.

i en 2-dimensionell array kommer det att finnas 2 axlar: axel-0 och axel-1.

i en 2D-array pekar axeln-0 nedåt längs raderna och axeln-1 pekar horisontellt längs kolumnerna.

visuellt kan du visualisera axlarna i en 2D-array så här:

med parameternaxis kan du beräkna standardavvikelsen i en viss riktning längs matrisen.

detta illustreras bäst med exempel, så jag visar dig ett exempel i Exempel 2.

(för en fullständig förklaring av numpy array axlar, se vår handledning som heter Numpy axlar förklarade.)

dtype

(valfritt)
parameterndtype gör att du kan ange den datatyp som du vill använda när np.std Beräknar standardavvikelsen.

om data i ingångsmatrisen är heltal, kommer detta att vara standard till float64.

annars, om data i ingångsmatrisen är floats, kommer detta att vara standard för samma float-typ som ingångsmatrisen.

ddof

(valfritt)
Detta gör att du kan ange ”frihetsgrader” för beräkningen.

för att förstå detta måste du titta på ekvation 2 igen.

i denna ekvation är den första termen .

Kom ihåg: är antalet värden i matrisen eller datauppsättningen.

men om vi tänker i statistiska termer är det faktiskt en skillnad mellan att beräkna en befolkningsstandardavvikelse jämfört med en provstandardavvikelse.

om vi beräknar en befolkningsstandardavvikelse använder vi termen i vår ekvation.

men när vi beräknar standardavvikelsen på ett urval av data (ett urval av datapunkter), måste vi ändra ekvationen så att den ledande termen är . I så fall blir ekvationen för en standardavvikelse för ett prov:

hur implementerar vi detta med NP.könssjukdomar?

Vi kan göra detta med parameternddof genom att ställa inddof = 1.

och i själva verket kan vi ställa in ddof termen mer generellt. När vi använder ddof, kommer det att ändra standardavvikelseberäkningen för att bli:

för att vara ärlig är detta lite tekniskt. Om du behöver lära dig mer om detta, Du bör titta på den här videon på Khan academy om frihetsgrader, och befolkning vs prov standardavvikelse.

out

(valfritt)
parameternout gör att du kan ange en alternativ array för att placera utmatningen.

den ska ha samma form som den förväntade utgången.

keepdims

(valfritt)
parameternkeepdims kan användas för att ”behålla” det ursprungliga antalet dimensioner. När du ställer in keepdims = True kommer utgången att ha samma antal dimensioner som ingången.

Kom ihåg: när vi beräknar standardavvikelsen kommer beräkningen att ”kollapsa” antalet dimensioner.

till exempel, om vi matar in en 2-dimensionell array som en ingång, då som standard, np.std kommer att mata ut ett nummer. Ett skalärt värde.

men om vi vill att utgången ska vara ett tal inom en 2D-array (dvs en utgångsmatris med samma dimensioner som ingången), kan vi ställa in keepdims = True.

för att vara ärlig är några av dessa parametrar lite abstrakta, och jag tror att de kommer att ge mycket mer mening med exempel.

Låt oss ta en titt på några exempel.

exempel på hur man använder Numpy standardavvikelse

Här kommer vi att arbeta igenom några exempel. Vi börjar enkelt och ökar sedan komplexiteten.

exempel:

• beräkna standardavvikelsen för en 1-dimensionell array
• beräkna standardavvikelsen för en 2-dimensionell array
• använd np.std för att beräkna standardavvikelserna för kolumnerna
• använd np.std för att beräkna standardavvikelserna för raderna
• ändra frihetsgraderna
• använd keepdims-parametern i np.std

kör den här koden först

innan du kör någon av exempelkoden måste du importera Numpy.

för att göra detta kan du köra följande kod:

import numpy as np

detta importerar Numpy med aliaset ”np”.

exempel 1: beräkna standardavvikelsen för en 1-dimensionell array

Här börjar vi enkelt.

Vi kommer att beräkna standardavvikelsen för 1-dimensionell Numpy array.

skapa 1D array

först skapar vi bara vår 1D-array:

array_1d = np.array()

beräkna standard dev

nu beräknar vi standardavvikelsen för dessa siffror.

np.std(array_1d)

ut:

30.84369195367723

Så vad hände här?

np.std-funktionen beräknade bara standardavvikelsen för siffrorna med ekvation 2 som vi såg tidigare. Varje nummer är ett av I den ekvationen.

en snabb anteckning

i exemplet ovan använde vi inte uttryckligen parametern a=. Det beror på np.std förstår att när vi ger ett argument till funktionen som i koden np.std(array_1d), ska ingången skickas till parametern a.

Alternativt kan du också uttryckligen använda parameterna=:

np.std(a = array_1d)

OUT:

30.84369195367723

exempel 2: beräkna standardavvikelsen för en 2-dimensionell array

Ok. Låt oss nu titta på ett exempel med en 2-dimensionell array.

Skapa 2-dimensionell array

Här ska vi skapa en 2D-array med np.slumpmässig.randint funktion.

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

denna array har 3 rader och 4 kolumner.

låt oss skriva ut det, så vi kan se det.

print(array_2d)

OUT:

 ]

detta är bara en 2D-array som innehåller 12 slumpmässiga heltal mellan 0 och 20.

beräkna standardavvikelse med np.std

Okej, låt oss beräkna standardavvikelsen.

np.std(array_2d)

Ut:

5.007633062524539

Här, numpy.std () beräknar bara standardavvikelsen för alla 12 heltal.

standardavvikelsen är 5.007633062524539.

exempel 3: beräkna standardavvikelsen för kolumnerna

Nu ska vi beräkna standardavvikelsen för kolumnerna.

för att göra detta måste vi använda parametern axis. (Du lärde dig om parametern axis I avsnittet om parametrarna för numpy.std)

specifikt måste vi ställa in axis = 0.

varför?

som jag nämnde i förklaringen av parameternaxis tidigare har Numpy-arrayer axlar.

i en tvådimensionell array är axel-0 den axel som pekar nedåt.

När vi använder numpy.std med axis = 0, som beräknar standardavvikelserna nedåt i axel-0-riktningen.

Låt oss ta en titt på ett exempel så att du kan se vad jag menar.

Skapa 2-dimensionell array

först skapar vi en 2D-array med np.slumpmässig.randint funktion.

(det här är samma array som vi skapade i Exempel 2, Så om du redan skapade den borde du inte behöva skapa den igen.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Låt oss skriva ut det så att vi kan se det.

print(array_2d)

OUT:

 ]

detta är bara en 2D-array som innehåller heltal mellan 0 och 20.

använd np.std för att beräkna standardavvikelsen för kolumnerna

Nu ställer vi in axis = 0 inuti np.std för att beräkna standardavvikelserna för kolumnerna.

np.std(array_2d, axis = 0)

ut:

array()

förklaring

vad händer här?

När vi använder np.std med axis = 0, numpy Beräknar standardavvikelsen nedåt i axel-0-riktningen. Kom ihåg, som jag nämnde ovan, Axis-0 pekar nedåt.

detta har effekten att beräkna standardavvikelsen för varje kolumn i Numpy-arrayen.

Låt oss nu göra ett liknande exempel med raden standardavvikelser.

exempel 4: Använd np.std för att beräkna standardavvikelserna för raderna

Nu ska vi använda np.std att beräkna standardavvikelser horisontellt längs en 2D numpy array.

Kom ihåg vad jag sa tidigare: numpy arrays har axlar. Axlarna är som riktningar längs Numpy-matrisen. I en 2D-array pekar axis-1 horisontellt, så här:

Så om vi vill beräkna standardavvikelserna horisontellt kan vi ställa in axis = 1. Detta har effekten av att beräkna raden standardavvikelser.

Låt oss ta en titt.

Skapa 2-dimensionell array

för att köra det här exemplet behöver vi igen en 2D Numpy-array, så vi skapar en 2D-array med np.slumpmässig.randint funktion.

(det här är samma array som vi skapade i Exempel 2, Så om du redan skapade den borde du inte behöva skapa den igen.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Låt oss skriva ut det så att vi kan se det.

print(array_2d)

OUT:

 ]

detta är bara en 2D-array som innehåller heltal mellan 0 och 20.

använd np.std för att beräkna standardavvikelsen för raderna

nu använder vi np.std med axis = 1 för att beräkna standardavvikelserna för raderna.

np.std(array_2d, axis = 1)

Ut:

array()

förklaring

om du förstod exempel 3 bör det här nya exemplet vara meningsfullt.

När vi använder np.std och set axis = 1, numpy beräknar standardavvikelserna horisontellt längs axeln-1.

effektivt, när vi använder Numpy standardavvikelse med axis = 1, beräknar funktionen standardavvikelsen för raderna.

exempel 5: Ändra frihetsgraderna

låt oss nu ändra frihetsgraderna.

här i det här exemplet kommer vi att skapa ett stort antal siffror, ta ett prov från den matrisen och beräkna standardavvikelsen på det provet.

Låt oss först skapa våra arrayer.

skapa Numpy array

först skapar vi bara en normalt distribuerad Numpy array med ett medelvärde på 0 och en standardavvikelse på 10.

för att göra detta använder vi Numpy random normal-funktionen. Observera att vi använder Numpy random seed-funktionen för att ställa in fröet för slumptalsgeneratorn. För mer information om detta, läs vår handledning om np.slumpmässig.frö.

np.random.seed(22)population_array = np.random.normal(size = 100, loc = 0, scale = 10)

Ok. Nu har vi en Numpy array, population_array, som har 100 element som har ett medelvärde på 0 och en standardavvikelse på 10.

skapa prov

Nu använder vi Numpy slumpmässigt val för att ta ett slumpmässigt urval från Numpy-arrayen, population_array.

np.random.seed(22)sample_array = np.random.choice(population_array, size = 10)

denna nya array, sample_array, är ett slumpmässigt urval av 10 element från population_array.

vi användersample_array när vi beräknar vår standardavvikelse med parameternddof.

beräkna standardavvikelsen för provet

nu beräknar vi standardavvikelsen för provet.

specifikt kommer vi att använda Numpy standardavvikelse funktion medddof parameter inställd påddof = 1.

np.std(sample_array, ddof = 1)

ut:

10.703405562234051

förklaring

Här har vi beräknat:

och när vi ställer in ddof = 1, utvärderas ekvationen till:

för att vara tydlig, när du beräknar standardavvikelsen för ett prov, kommer du att ställa in ddof = 1.

för att vara ärlig är detaljerna om varför lite tekniska (och utanför ramen för detta inlägg), så för mer information om att beräkna en standardavvikelse för prov rekommenderar jag att du tittar på den här videon.

Tänk på att för vissa andra fall kan du ställa in ddof till andra värden förutom 1 eller 0. Om du inte använder parametern ddof kommer den som standard att vara 0.

oavsett vilket värde du väljer, beräknar Numpy standardavvikelsefunktionen standardavvikelsen med ekvationen:

exempel 6: Använd keepdims-parametern i np.std

Ok. Slutligen gör vi ett sista exempel.

Här kommer vi att ställa in parameternkeepdims tillkeepdims = True.

Skapa 2-dimensionell array

först skapar vi en 2D-array med np.slumpmässig.randint funktion.

(det här är samma array som vi skapade i Exempel 2, Så om du redan skapade den borde du inte behöva skapa den igen.)

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

Låt oss skriva ut det:

print(array_2d)

ut:

 ]

kontrollera dimensionerna

Låt oss nu titta på dimensionerna för denna array.

array_2d.ndim

ut:

2

detta är en 2D-array, precis som vi tänkt.

beräkna standardavvikelsen och kontrollera måtten

Ok. Nu ska vi beräkna standardavvikelsen och kontrollera utgångens dimensioner.

output = np.std(array_2d)

Låt oss snabbt skriva ut utmatningen:

print(output)

ut:

5.007633062524539

så standardavvikelsen är 5.007633062524539.

Nu, Vad är måtten på utgången?

output.ndim

Ut:

0

utgången har 0 dimensioner (det är ett skalärt värde).

varför?

När np.std Beräknar standardavvikelsen, det beräknar en sammanfattande statistik. I det här fallet tar funktionen ett stort antal värden och kollapsar dem ner till en enda metrisk.

så ingången var 2-dimensionell, men utgången är 0-dimensionell.

vad händer om vi vill ändra det?

vad händer om vi vill att produktionen Tekniskt ska ha 2-dimensioner?

Vi kan göra det med parametern keepdims.

behåll de ursprungliga dimensionerna när vi använder np.std

här ställer vi in keepdims = True för att göra utgången samma dimensioner som ingången.

output_2d = np.std(array_2d, keepdims = True)

Låt oss nu titta på utgången:

print(output_2d)

ut:

]

Lägg märke till att utgången, standardavvikelsen, fortfarande är 5.00763306. Men resultatet är inneslutet inuti dubbla fästen.

låt oss inspektera output_2d och titta närmare.

type(output_2d)

OUT:

numpy.ndarray

så, output_2d är en Numpy array, inte ett skalärt värde.

låt oss kontrollera dimensionerna:

output_2d.ndim

ut:

2

denna Numpy array, output_2d, har 2 dimensioner.

detta är samma antal dimensioner som ingången.

vad hände?

När vi ställer in keepdims = True, orsakade det np.std-funktion för att producera en utgång med samma antal dimensioner som ingången. Även om det inte finns några rader och kolumner i utgången har utgången output_2d 2 dimensioner.

Så, om du någonsin behöver din utgång för att ha samma antal dimensioner som din ingång, kan du ställa in keepdims = True.

(detta fungerar också när du använder parameternaxis … prova!)

Vanliga frågor om Numpy standardavvikelse

Nu när du har lärt dig om Numpy standardavvikelse och sett några exempel, låt oss granska några vanliga frågor om np.std.

vanliga frågor:

• Varför ger numpy std() ett annat resultat än matlab std() eller ett annat programmeringsspråk?

Fråga 1: Varför ger numpy std() ett annat resultat än matlab std() eller ett annat programmeringsspråk?

den enkla anledningen är att matlab beräknar standard dev enligt följande:

(många andra verktyg använder samma ekvation.)

Numpy beräknar dock med följande:

Lägg märke till den subtila skillnaden mellan vs .

för att åtgärda detta kan du använda parameternddof I numpy.

Om du använder np.STD med parameternddof inställd påddof = 1 ska du få samma svar som matlab.

lämna dina andra frågor i kommentarerna nedan

har du andra frågor om Numpy standardavvikelsefunktionen?

lämna din fråga i kommentarfältet nedan.

gå med i vår kurs för att lära dig mer om Numpy

exemplen du har sett i den här handledningen bör räcka för att komma igång, men om du menar allvar med att lära dig Numpy, bör du anmäla dig till vår premiumkurs som heter Numpy Mastery.

det finns mycket mer att lära sig om Numpy, och Numpy Mastery kommer att lära dig allt, inklusive:

• hur man skapar Numpy arrays
• hur man använder Numpy random functions
• vad funktionen” numpy random seed ” gör
• hur man omformar, delar upp och kombinerar dina Numpy arrays
• och mer …

dessutom hjälper det dig att helt behärska syntaxen inom några veckor. Du kommer att upptäcka hur man blir ”flytande” skriftligen Numpy kod.

Läs mer här:

Läs mer om Numpy Mastery