denne opplæringen vil forklare hvordan du bruker numpy standardavvik funksjon (AKA, np.std).

på et høyt nivå er Numpy standardavviksfunksjonen enkel. Den beregner standardavviket av verdiene i En Numpy array.

men detaljene om nøyaktig hvordan funksjonen fungerer, er litt komplekse og krever litt forklaring.

når det er sagt, vil denne opplæringen forklare hvordan Du bruker Numpy standardavvik-funksjonen.

det vil forklare syntaksen til np.std (), og viser deg klare, trinnvise eksempler på hvordan funksjonen fungerer.

opplæringen er organisert i seksjoner. Du kan klikke på noen av de følgende koblingene, som tar deg til den aktuelle delen.

Innholdsfortegnelse:

• En veldig rask gjennomgang av Numpy
• Introduksjon Til Numpy standardavvik
• syntaksen til np.std
• Numpy standardavvik eksempler
• Numpy standardavvik FAQ

når det er sagt, Hvis Du er relativt ny Til Numpy, kan det være lurt å lese hele opplæringen.

en rask gjennomgang av Numpy

La oss bare starte med en veeeery rask gjennomgang Av Numpy.

Hva er Numpy?

Numpy er et verktøy for å jobbe med numeriske data

For å si det enkelt, Er Numpy et verktøy for å jobbe med numeriske data.

Først Har Numpy et sett med verktøy for å lage en datastruktur kalt En Numpy array.

Du kan tenke på En Numpy array som en rad-og-kolonne rutenett av tall. Numpy arrays kan være 1-dimensjonal, 2-dimensjonal, eller til og med n-dimensjonal.

EN 2d-array ser noe ut som dette:

for enkelhets skyld, i denne opplæringen holder vi oss til 1 eller 2-dimensjonale arrays.

Det finnes en rekke måter å lage forskjellige typer arrays med forskjellige typer tall. Noen andre verktøy for å lage Numpy arrays inkluderer numpy ordne, numpy nuller, numpy seg, numpy fliser, og andre metoder.

Uansett hvordan du lager Din Numpy array, på et høyt nivå, er de bare arrays av tall.

Numpy gir verktøy for å manipulere Numpy arrays

Numpy ikke bare gir verktøy for å lage Numpy arrays, numpy gir også verktøy for å arbeide med Numpy arrays.Noen av de viktigste av disse Numpy verktøyene er Numpy funksjoner for å utføre beregninger.

Det er et helt sett Numpy-funksjoner for å gjøre ting som:

• beregne summen av En Numpy array
• beregne maksimum
• beregne eksponentiell av tallene i en matrise
• beregne verdien x til noe strøm, for hver verdi i En Numpy array

… og en rekke andre beregninger.

Numpy standardavviket er i hovedsak mye som disse andre Numpy-verktøyene. Det er bare brukt til å utføre en beregning (standardavviket) av en gruppe tall i Et Numpy array.

en rask introduksjon Til Numpy standardavvik

på et svært høyt nivå er standardavvik et mål for spredningen av et datasett. Spesielt er det et mål på hvor langt datapunktene er fra gjennomsnittet av dataene.

la oss kort gjennomgå grunnleggende beregning.

Standardavvik beregnes som kvadratroten av variansen.

Så hvis vi har et datasett med tall, vil variansen være:

og standardavviket vil bare være kvadratroten av variansen:

Hvor:

= de individuelle verdiene i datasettet
= antall verdier i datasettet
= gjennomsnittet av verdiene

mesteparten av tiden er beregning av standardavvik for hånd litt utfordrende, fordi du må beregne gjennomsnittet, avvikene fra hvert datapunkt fra gjennomsnittet, deretter kvadratet av avvikene, etc. Helt ærlig er det litt kjedelig.

men hvis du jobber I Python, kan du bruke Numpy standardavvik-funksjonen til å utføre beregningen for deg.

et raskt notat hvis du er ny på statistikk

Fordi dette blogginnlegget handler om å bruke numpy.std () – funksjonen, jeg vil ikke komme for dypt inn i ugresset om hvordan beregningen utføres for hånd. Denne opplæringen handler egentlig om hvordan vi bruker funksjonen. Så, hvis du trenger en rask gjennomgang av hva standardavvik er, kan du se denne videoen.

Ok. Etter å ha raskt vurdert hva standardavvik er, la oss se på syntaksen for np.kjønnssykdom.

syntaksen til np.std

syntaksen Til numpy standardavviksfunksjonen er ganske enkel.jeg skal forklare det på bare et sekund, men først vil jeg fortelle deg et raskt notat om Numpy syntaks.

et raskt notat: den nøyaktige syntaksen avhenger av hvordan Du importerer Numpy

Vanligvis når vi skriver Numpy syntaks, bruker vi aliaset «np». Det er den vanlige konvensjonen blant de fleste datavitenskapere.

for å angi aliaset må Du importere Numpy slik:

import numpy as np

hvis vi importerer Numpy med dette aliaset, kan Vi kalle Numpy standardavviksfunksjonen som np.std().

Ok, når det er sagt, la oss ta en nærmere titt på syntaksen.

np.std syntaks

på et høyt nivå, syntaksen for np.std ser omtrent slik ut:

som jeg nevnte tidligere, forutsatt at vi har importert Numpy med aliaset «np » vi kaller funksjonen med syntaksen np.std().

så inne i parentesen er det flere parametere som lar deg kontrollere nøyaktig hvordan funksjonen fungerer.

La oss ta en titt på disse parametrene.

parametrene til numpy.std

Det er noen viktige parametere du bør vite:

• a

axisdtypeddof

• keepdims
• out

la oss ta en titt på hver av dem.

a(obligatorisk)

parameterena angir matrisen med verdier du vil beregne standardavviket for.

sa annerledes, dette gjor at du kan angi inngangsarrayen til funksjonen.

Passende innganger inkluderer Numpy arrays, men også» array like » objekter som Python lister.

Viktig, du må gi en inngang til denne parameteren. En inngang er nødvendig.

når det er sagt, kan parameteren selv være implisitt eller eksplisitt. Det jeg mener med det, er at du direkte kan skrive inn parameteren a=, ELLER du kan legge parameteren ut av syntaksen din, og bare skriv inn navnet på inngangsarrayet ditt.

jeg skal vise deg eksempler på dette i eksempel 1.

axis

akseparameteren lar deg angi en akse langs hvilken standardavviket skal beregnes.

For å forstå dette, trenger du virkelig å forstå akser.

Numpy arrays har akser.

Du kan tenke på en «akse» som en retning langs arrayet.

I en 2-dimensjonal matrise vil det være 2 akser: akse-0 og akse-1.

i EN 2d-array, akse-0 poeng nedover langs radene, og akse – 1 poeng horisontalt langs kolonnene.

Visuelt kan du visualisere aksene til ET 2d-array som dette:

ved hjelp av parameteren axis kan du beregne standardavviket i en bestemt retning langs arrayet.

dette illustreres best med eksempler, så jeg viser deg et eksempel i eksempel 2.(for en fullstendig forklaring Av Numpy array akser, se vår tutorial kalt Numpy akser forklart.)

dtype

(valgfritt)
parameteren dtypelar deg angi datatypen du vil bruke når np.std beregner standardavviket.

hvis dataene i inngangsarrayen er heltall, vil dette som standard være float64.

Ellers, hvis dataene i input array er flyter, så dette vil standard til samme float type som input array.

ddof

(valgfritt)
dette gjør at du kan angi «frihetsgrader» for beregningen.

for å forstå dette må du se på ligning 2 igjen.

i denne ligningen er den første termen .

Husk: er antall verdier i matrisen eller datasettet.

Men hvis vi tenker statistisk, er det faktisk en forskjell mellom å beregne en populasjonsstandardavvik vs en prøvestandardavvik.

hvis vi beregner et populasjonsstandardavvik, bruker vi begrepet i vår ligning.

Men når vi beregner standardavviket på et utvalg av data (et utvalg av datapoints), må vi endre ligningen slik at ledende termen er. I så fall blir ligningen for et standardavvik for prøven:

hvordan implementerer vi dette med np.kjønnssykdom?

Vi kan gjøre dette med parameterenddof ved å sette ddof = 1.

og faktisk kan vi setteddof termen mer generelt. Når vi bruker ddof, vil den endre standardavviksberegningen til å bli:

for å være ærlig, er dette litt teknisk. Hvis Du trenger å lære mer om Dette, bør du se denne videoen På Khan academy om grader av frihet, og befolkning vs prøve standardavvik.

out

(valgfritt)
parameterenout lar deg angi en alternativ matrise for å sette utdataene.

Den skal ha samme form som forventet utgang.

keepdims

(valgfritt)
keepdims parameteren kan brukes til å «beholde» det opprinnelige antall dimensjoner. Når du angir keepdims = True, vil utgangen ha samme antall dimensjoner som inngangen.

Husk: når vi beregner standardavviket, vil beregningen «kollapse» antall dimensjoner.

for eksempel, hvis vi legger inn et 2-dimensjonalt array som en inngang, så som standard, np.std vil sende ut et tall. En skalar verdi.

Men Hvis vi vil at utgangen skal være et tall i EN 2d-array (dvs.en utgangsarray med samme dimensjoner som inngangen), kan vi sette keepdims = True.For å være ærlig er noen av disse parametrene litt abstrakte, og jeg tror de vil gi mye mer mening med eksempler.

La oss ta en titt på noen eksempler.

Eksempler på Hvordan Du bruker Numpy standardavvik

Her jobber vi gjennom noen få eksempler. Vi starter enkelt og deretter øke kompleksiteten.

Eksempler:

• Beregn standardavviket for en 1-dimensjonal matrise
• Beregn standardavviket for en 2-dimensjonal matrise
• Bruk np.std for å beregne standardavvikene til kolonnene
• Bruk np.std for å beregne standardavvikene i radene
• Endre frihetsgrader
• Bruk keepdims-parameteren i np.std

Kjør denne koden først

Før du kjører noen av eksempelkoden, må du importere Numpy.

for å gjøre dette kan du kjøre følgende kode:

import numpy as np

dette vil importere Numpy med aliaset » np«.

EKSEMPEL 1: Beregn standardavvik for et 1-dimensjonalt array

Her starter vi enkelt.

Vi skal beregne standardavviket for 1-dimensjonal Numpy array.

Opprett 1d array

Først lager vi bare VÅR 1d array:

array_1d = np.array()

Beregn standard dev

nå beregner vi standardavviket til disse tallene.

np.std(array_1d)

UT:

30.84369195367723

Så hva skjedde her?

np.std-funksjonen beregnet bare standardavviket til tallene ved hjelp av ligning 2 som vi så tidligere. Hvert tall er et av i den ligningen.

En rask notat

i eksemplet ovenfor brukte vi ikke eksplisitt parameterena=. Det er fordi np.std forstår at når vi gir et argument til funksjonen som i koden np.std(array_1d), bør inngangen sendes tila parameter.

Alternativt kan du også eksplisitt brukea= parameter:

np.std(a = array_1d)

UT:

30.84369195367723

EKSEMPEL 2: Beregn standardavviket for en 2-dimensjonal matrise

Ok. La oss nå se på et eksempel med et 2-dimensjonalt array.

Lag 2-dimensjonal array

Her skal vi lage ET 2d-array ved hjelp av np.tilfeldig.randint funksjon.

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

denne gruppen har 3 rader og 4 kolonner.

la oss skrive det ut, så vi kan se det.

print(array_2d)

UT:

 ]

dette er bare EN 2d-matrise som inneholder 12 tilfeldige heltall mellom 0 og 20.

Beregn standardavvik med np.std

Ok, la oss beregne standardavviket.

np.std(array_2d)

UT:

5.007633062524539

Her, numpy.std () beregner bare standardavviket for alle 12 heltall.

standardavviket er 5.007633062524539.

EKSEMPEL 3: Beregn standardavviket til kolonnene

Nå skal Vi beregne standardavviket til kolonnene.

for å gjøre dette må vi bruke parameteren axis. (Du lærte om parameterenaxis i delen om parametrene til numpy.std)

Spesifikt må vi sette axis = 0.

Hvorfor?

som jeg nevnte i forklaringen avaxis parameter tidligere har Numpy arrays akser.

i en todimensjonal matrise er akse-0 aksen som peker nedover.

Når vi bruker numpy.std med axis = 0, som vil beregne standardavvikene nedover i akse – 0-retningen.

La oss ta en titt på et eksempel slik at du kan se hva jeg mener.

Lag 2-dimensjonal array

Først lager vi ET 2d-array ved hjelp av np.tilfeldig.randint funksjon.

(Dette er den samme matrisen som vi opprettet i eksempel 2, så hvis du allerede har opprettet den, trenger du ikke å opprette den igjen.)

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

la oss skrive det ut, så vi kan se det.

print(array_2d)

UT:

 ]

dette er bare EN 2d-matrise som inneholder heltall mellom 0 og 20.

Bruk np.std for å beregne standardavvik for kolonnene

nå setter vi axis = 0 innsiden av np.std for å beregne standardavvikene til kolonnene.

np.std(array_2d, axis = 0)

UT:

array()

Forklaring

Hva skjer her?

Når vi bruker np.std med axis = 0, vil Numpy beregne standardavviket nedover i aksen – 0 retning. Husk, som jeg nevnte ovenfor, akse-0 poeng nedover.

dette har effekten av å beregne standardavviket for hver kolonne I Numpy-arrayet.

La Oss nå gjøre et lignende eksempel med radstandardavvikene.

EKSEMPEL 4: Bruk np.std for å beregne standardavvikene i radene

Nå skal vi bruke np.std å beregne standardavvik horisontalt langs EN 2D numpy array.

Husk hva jeg sa tidligere: numpy arrays har akser. Aksene er som retninger langs Numpy array. I EN 2d-array, akse – 1 poeng horisontalt, slik som dette:

Så, hvis vi vil beregne standardavvikene horisontalt, kan vi sette axis = 1. Dette har effekten av å beregne radstandardavvikene.

La oss ta en titt.

Lag 2-dimensjonal array

for å kjøre dette eksemplet trenger vi igjen EN 2d Numpy array, så vi lager EN 2d array ved hjelp av np.tilfeldig.randint funksjon.

(Dette er den samme matrisen som vi opprettet i eksempel 2, så hvis du allerede har opprettet den, trenger du ikke å opprette den igjen.)

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

la oss skrive det ut, så vi kan se det.

print(array_2d)

UT:

 ]

dette er bare EN 2d-matrise som inneholder heltall mellom 0 og 20.

Bruk np.std for å beregne standardavvik av radene

Nå bruker vi np.std med axis = 1 for å beregne standardavvikene i radene.

np.std(array_2d, axis = 1)

UT:

array()

Forklaring

hvis du forstod eksempel 3, bør dette nye eksemplet være fornuftig.

Når vi bruker np.std og sett axis = 1, vil Numpy beregne standardavvikene horisontalt langs akse-1.

effektivt, når Vi bruker Numpy standardavvik med axis = 1, beregner funksjonen standardavviket til radene.

EKSEMPEL 5: Endre grader av frihet

Nå, la oss endre grader av frihet.

Her i dette eksemplet skal vi lage et stort utvalg av tall, ta et utvalg fra den gruppen og beregne standardavviket på den prøven.

Først, la oss lage våre arrays.

Opprett Numpy array

Først lager vi bare et normalt distribuert Numpy array med et gjennomsnitt på 0 og et standardavvik på 10.

For å gjøre dette bruker Vi numpy random normal-funksjonen. Merk at vi bruker numpy random seed-funksjonen til å sette frøet for random number generator. For mer informasjon om dette, les vår veiledning om np.tilfeldig.frø.

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

Ok. Nå har vi en Numpy array, population_array, som har 100 elementer som har et gjennomsnitt på 0 og et standardavvik på 10.

Lag prøve

Nå bruker Vi Numpy tilfeldig valg for å ta et tilfeldig utvalg fra Numpy-arrayet, population_array.

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

denne nye matrisen, sample_array, er et tilfeldig utvalg av 10 elementer fra population_array.

vi brukersample_array når vi beregner standardavviket vårt ved hjelp av parameterenddof.

Beregn standardavviket for prøven

nå beregner vi standardavviket for prøven.Spesielt skal Vi bruke Numpy standardavviksfunksjonen med ddof parameter satt til ddof = 1.

np.std(sample_array, ddof = 1)

UT:

10.703405562234051

Forklaring

her har vi beregnet:

Og når vi setterddof = 1, evalueres ligningen til:

for å være klar, når du beregner standardavviket til et utvalg, vil du sette ddof = 1.

for å være ærlig, detaljene om hvorfor er litt tekniske (og utenfor omfanget av dette innlegget), så for mer informasjon om beregning av et standardavvik, anbefaler jeg at du ser denne videoen.

Husk at for noen andre tilfeller kan du sette ddof til andre verdier i tillegg til 1 eller 0. Hvis du ikke bruker parameteren ddof, vil den som standard være 0.

Uansett hvilken verdi du velger, vil numpy standardavvik-funksjonen beregne standardavviket med ligningen:

EKSEMPEL 6: Bruk keepdims-parameteren i np.std

Ok. Til slutt vil vi gjøre et siste eksempel.

Her skal vi sette parameteren keepdimstil keepdims = True.

Lag 2-dimensjonal array

Først lager vi ET 2d-array ved hjelp av np.tilfeldig.randint funksjon.

(Dette er den samme matrisen som vi opprettet i eksempel 2, så hvis du allerede har opprettet den, trenger du ikke å opprette den igjen.)

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

la oss skrive det ut:

print(array_2d)

UT:

 ]

Sjekk dimensjonene

Nå, la Oss ta en titt på dimensjonene av denne matrisen.

array_2d.ndim

UT:

2

Dette ER ET 2d-array, akkurat som vi hadde tenkt.

Beregn standardavviket, og kontroller dimensjonene

Ok. Nå skal vi beregne standardavviket, og sjekke dimensjonene på utgangen.

output = np.std(array_2d)

La oss raskt skrive ut utdataene:

print(output)

UT:

5.007633062524539

så standardavviket er 5.007633062524539.

Nå, hva er dimensjonene til utgangen?

output.ndim

UT:

0

utgangen har 0 dimensjoner(det er en skalarverdi).

Hvorfor?

når np.std beregner standardavviket, det beregner en sammendragsstatistikk. I dette tilfellet tar funksjonen et stort antall verdier og kollapser dem ned til en enkelt metrisk.

så inngangen var 2-dimensjonal, men utgangen er 0-dimensjonal.

Hva om vi ønsker å endre det?

Hva om vi vil at utgangen skal ha teknisk 2-dimensjoner?

Vi kan gjøre det med parameterenkeepdims.

Behold de opprinnelige dimensjonene når vi bruker np.std

her setter vi keepdims = True for å gjøre utgangen samme dimensjoner som inngangen.

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

la Oss nå se på utgangen:

print(output_2d)

UT:

]

Legg merke til at utgangen, standardavviket, fortsatt er 5.00763306. Men resultatet er innelukket i doble parenteser.

la oss inspisere output_2d og ta en nærmere titt.

type(output_2d)

UT:

numpy.ndarray

Såoutput_2d er Et Numpy array, ikke en skalarverdi.

la oss sjekke dimensjonene:

output_2d.ndim

UT:

2

denne Numpy arrayet,output_2d, har 2 dimensjoner.

dette er det samme antall dimensjoner som inngangen.

hva skjedde ?

når vi setter keepdims = True, forårsaket det np.std funksjon for å produsere en utgang med samme antall dimensjoner som inngangen. Selv om det ikke er noen rader og kolonner i utgangen, har utgangen output_2d 2 dimensjoner.

Så, hvis du trenger at utdataene dine har samme antall dimensjoner som inngangen din, kan du angikeepdims = True.

(dette fungerer også når du bruker parameterenaxis … prøv det!)

Ofte stilte spørsmål om Numpy standardavvik

Nå som du har lært Om Numpy standardavvik og sett noen eksempler, la oss se gjennom noen vanlige spørsmål om np.kjønnssykdom.

Ofte stilte spørsmål:

• Hvorfor gir numpy std () et annet resultat enn matlab std() eller et annet programmeringsspråk?

Spørsmål 1: Hvorfor gir numpy std() et annet resultat enn matlab std () eller et annet programmeringsspråk?

den enkle grunnen er at matlab beregner standard dev i henhold til følgende:

(Mange andre verktøy bruker samme ligning.)

Numpy beregner Imidlertid med følgende:

Legg merke til den subtile forskjellen mellom vs .

for å fikse dette kan du bruke parameteren ddof i Numpy.

hvis du bruker np.std med ddof parameter satt til ddof = 1, bør du få det samme svaret som matlab.

Legg igjen dine andre spørsmål i kommentarene nedenfor

har du andre spørsmål om numpy standardavviksfunksjonen?

Legg igjen spørsmålet ditt i kommentarfeltet nedenfor.

Bli med på kurset vårt for å lære mer om Numpy

eksemplene du har sett i denne opplæringen, bør være nok til å komme i gang, men hvis du er seriøs om å lære Numpy, bør du melde deg på vårt premium kurs kalt Numpy Mastery.

det er mye mer å lære Om Numpy, Og Numpy Mastery vil lære deg alt, inkludert:

• hvordan lage Numpy arrays
• hvordan bruke numpy tilfeldige funksjoner
• Hva «Numpy random seed» – funksjonen gjør
• hvordan omforme, splitte og kombinere Dine Numpy arrays
• og mer …

Videre vil det hjelpe deg å mestre syntaksen helt i løpet av få uker. Du vil oppdage hvordan du blir «flytende» skriftlig Numpy kode.

finn ut mer her:

Lær Mer om Numpy Mastery