Denna handledning visar hur man använder NumPy max-funktionen, som i Python-kod kallas np.max.

På en övergripande nivå vill jag förklara funktionen och visa hur den fungerar. Eftersom detta är fallet finns det två primära avsnitt i den här handledningen: syntaxen för NumPy max och exempel på hur man använder NumPy max.

Om du fortfarande håller på att komma igång med NumPy rekommenderar jag att du läser hela handledningen, från början till slut. Med det sagt, om du bara vill få ett snabbt svar på en fråga kan du hoppa fram till lämpligt avsnitt med en av följande länkar:

• Syntaxen för NumPy max
• Exempel på hur man använder NumPy max

Okej. Med allt detta i åtanke kan vi börja.

Först ska vi prata om NumPy och NumPy max-funktionen.

En snabb introduktion till NumPy max-funktionen

Det är antagligen klart för dig att NumPy max-funktionen är en funktion i NumPy-modulen.

Men om du är en riktig nybörjare kanske du inte riktigt vet vad NumPy är. Så innan vi pratar om np.max-funktionen specifikt ska vi snabbt prata om NumPy.

Vad exakt är NumPy?

Numpy är en datamanipuleringsmodul för Python

För att uttrycka det mycket enkelt är NumPy ett datamanipuleringspaket för programmeringsspråket Python.

Om du är intresserad av datavetenskap i Python är NumPy mycket viktigt. Detta beror på att en stor del av datavetenskapens arbete helt enkelt består av datamanipulering. Oavsett om du gör djupinlärning eller dataanalys är en stor del av arbetet inom datavetenskap bara att rensa data, förbereda data och utforska dem för att se till att de är okej att använda.

Också på grund av betydelsen av datamanipulering är NumPy mycket viktigt för datavetenskap i Python.

Numpy är ett verktygslösning för att arbeta med numeriska data

Specifikt sett tillhandahåller dock NumPy en uppsättning verktyg för att arbeta med numeriska data.

Python har andra verktygslådor för att arbeta med icke-numeriska data och data av blandad typ (som Pandas-modulen). Men om du har någon form av numeriska data som du behöver rensa, ändra, omforma eller analysera är NumPy förmodligen den verktygslåda du behöver.

Och även om NumPy-funktioner kan arbeta med en mängd olika datastrukturer är de byggda för att arbeta med en struktur som kallas en NumPy-array. NumPy-matriser är bara en speciell typ av Pythonobjekt som innehåller numeriska data. Det finns en mängd olika sätt att skapa NumPy-matriser, bland annat med funktionen np.array, funktionen np.ones, funktionen np.zeros och funktionen np.arange, tillsammans med många andra funktioner som behandlats i tidigare handledningar här på Sharp Sight.

Väsentligt är att NumPy-matriser är optimerade för numeriska beräkningar. Så det finns en uppsättning verktyg i NumPy för att utföra numeriska beräkningar på NumPy-matriser, som att beräkna medelvärdet för en NumPy-matris, beräkna medianen för en NumPy-matris och så vidare.

I huvudsak ger NumPy dig en verktygslåda för att skapa matriser med numeriska data och utföra beräkningar på dessa numeriska data.

En av de beräkningar som du kan utföra är att beräkna det maximala värdet för en NumPy-matris. Det är där funktionen np.max kommer in.

NumPy max beräknar maxvärdet av värdena i en NumPy-array

Funktionen numpy.max() beräknar maxvärdet av de numeriska värden som ingår i en NumPy-array. Den kan också beräkna det maximala värdet för rader, kolumner eller andra axlar. Vi kommer att prata om detta i avsnittet om exempel.

Syntaktiskt sett ser du ofta NumPy max-funktionen i kod som np.max. Du ser den skriven så här när programmeraren har importerat NumPy-modulen med aliaset np.

För att förtydliga bör du dessutom veta att funktionen np.max är samma sak som funktionen NumPy amax, AKA np.amax. I huvudsak är np.max ett alias för np.amax. Bortsett från namnet är de samma.

Ett exempel på hög nivå på hur np.max fungerar

Senare i den här handledningen kommer jag att visa dig konkreta exempel på hur du kan använda np.max-funktionen, men här vill jag ge dig en ungefärlig uppfattning om vad den gör.

Antag till exempel att du har en 1-dimensionell NumPy-array med fem värden:

Vi kan använda NumPy max-funktionen för att beräkna det högsta värdet:

Och även om det här exemplet visar hur np.max()-funktionen fungerar på en 1-dimensionell NumPy-array, fungerar den på liknande sätt på 2-dimensionella arrayer och flerdimensionella arrayer. Återigen kommer jag att visa dig fullständiga exempel på dessa i avsnittet om exempel i den här handledningen.

För att titta på kodexemplen ska vi dock ta en snabb titt på syntaxen och parametrarna för np.max.

Syntaxen för numpy max

Syntaxen för np.max-funktionen är ganska enkel, även om några av parametrarna för funktionen kan vara lite förvirrande.

Här kommer vi att prata om funktionens syntaktiska struktur och jag kommer också att förklara de viktiga parametrarna.

En snabb anmärkning

En snabb anmärkning innan vi börjar gå igenom syntaxen.

Syntaktiskt sett är det korrekta namnet på funktionen numpy.max().

Med detta sagt kommer du ofta att se funktionen i koden som np.max().

Varför?

I början av ett program som använder NumPy-modulen importerar programmerare ofta NumPy-funktionen som np. Du kommer bokstavligen att se en kodrad i programmet som lyder import numpy as np. Detta innebär att NumPy-modulen importeras med aliaset np. Detta gör det möjligt för programmeraren att hänvisa till NumPy som np i koden, vilket gör det möjligt att hänvisa till funktionen numpy.max som np.max.

Med detta sagt, låt oss ta en närmare titt på syntaxen.

En förklaring av syntaxen

På en hög nivå är syntaxen för np.max är ganska enkel.

Det finns namnet på funktionen – np.max() – och inuti funktionen finns det flera parametrar som gör det möjligt för oss att styra funktionens exakta beteende.

Låt oss titta närmare på parametrarna i np.max, eftersom det är parametrarna som verkligen ger dig finkornig kontroll över funktionen.

Parametrarna i np.max

The numpy.max-funktionen har fyra primära parametrar:

• a
• axis
• out
• keepdims
• keepdims

Låta oss prata om var och en av dessa parametrar individuellt.

a (obligatoriskt)

Parametern gör det möjligt för dig att specificera de data som np.max-funktionen kommer att arbeta med. I huvudsak anger den inmatningsmatrisen till funktionen.

I många fall kommer denna inmatningsmatris att vara en riktig NumPy-matris. Med detta sagt kommer numpy.max (och de flesta av de andra NumPy-funktionerna) att fungera på vilken som helst ”arrayliknande sekvens” av data. Det betyder att argumentet till parametern a kan vara en Python-lista, en Python-tupel eller en av flera andra Python-sekvenser.

Håll i minnet att du måste ge något till detta argument. Det är obligatoriskt.

axis (valfritt)

Med parametern axis kan du ange på vilken axel du ska beräkna maximivärdena.

Säkert uttryckt gör axelparametern det möjligt för dig att beräkna radmaxima och kolumnmaxima.

Jag kommer att förklara hur du gör det mer i detalj i avsnittet med exempel nedan, men låt mig snabbt förklara hur parametern axis fungerar.

En snabb genomgång av array-axlar

På en hög nivå måste du förstå att NumPy-arrayer har axlar.

Axlar är som riktningar längs NumPy-arrayen. I en tvådimensionell array är axel 0 den axel som pekar nedåt i raderna och axel 1 är den axel som pekar horisontellt över kolumnerna.

Array-parametern anger den axel som ska beräkna maxima

Hur förhåller sig det här till parametern axis?

När vi använder parametern axis i funktionen numpy.max anger vi den axel längs vilken vi ska hitta maxima.

Detta låter oss i praktiken beräkna kolumnmaxima och radmaxima.

Låt mig visa dig vad jag menar.

Håll dig i minnet att axel 0 är den axel som pekar nedåt, nerför raderna.

När vi använder koden np.max(axis = 0) på en matris säger vi i själva verket till NumPy att beräkna de maximala värdena i den riktningen … axelns 0-riktning.

Effektivt sett, när vi ställer in axis = 0, anger vi att vi vill beräkna kolumnmaxima.

Samma sak, kom ihåg att i en tvådimensionell array pekar axel 1 horisontellt. När vi använder NumPy max med axis = 1 säger vi därför till NumPy att beräkna maxima horisontellt, i axel 1:s riktning.

Detta beräknar effektivt radmaxima.

Jag kommer att visa dig konkreta kodexempel på hur du gör detta, senare i avsnittet med exempel.

Håll i minnet att parametern axis är valfri. Om du inte anger någon axel kommer NumPy max att hitta det högsta värdet i hela NumPy-matrisen.

out (valfritt)

Med out-parametern kan du ange en speciell utmatningsmatris där du kan lagra resultatet av np.max.

Det är inte vanligt att använda den här parametern (särskilt inte om du är nybörjare), så vi kommer inte att diskutera det här i handledningen.

out är en valfri parameter.

keepdims (valfritt)

Parametern keepdims är lite förvirrande, så det kommer att krävas lite ansträngning för att förstå den.

I slutändan håller parametern keepdims dimensionerna i utmatningen desamma som dimensionerna i inmatningen.

För att förstå varför detta kan vara nödvändigt tar vi en titt på hur funktionen numpy.max vanligtvis fungerar.

När du använder np.max på en typisk NumPy-array minskar funktionen antalet dimensioner. Den sammanfattar data.

Till exempel kan vi säga att du har en 1-dimensionell NumPy-array. Du använder NumPy max på matrisen.

När du använder np.max på en 1-dimensionell matris blir resultatet ett enda tal. Ett skalärt värde … inte en 1-d array.

I princip kan funktioner som NumPy max (liksom numpy.Median, numpy.mean, etc.) sammanfattar data, och genom att sammanfatta data producerar dessa funktioner utdata som har ett reducerat antal dimensioner.

I vissa fall vill man dock att utdata ska ha samma antal dimensioner. Det finns tillfällen då du, om indata är en 1-d array, vill att utdata ska vara en 1-d array (även om utdata arrayen har ett enda värde i sig).

Du kan göra detta parametern keepdims.

Som standard är keepdims inställd på False. Så som standard (som diskuterats ovan) kommer dimensionerna för utdata inte att vara desamma som dimensionerna för indata. Som standard kommer dimensionerna i utmatningen att vara mindre (eftersom np.max sammanfattar data).

Men om du ställer in keepdims = True kommer utmatningen att ha samma dimensioner som inmatningen.

Det här är lite abstrakt utan ett konkret exempel, så jag kommer att visa dig ett exempel på det här beteendet senare i avsnittet med exempel.

Och faktiskt, nu när vi har gått igenom parametrarna är detta ett bra ställe att börja titta på exemplen på NumPy max.

Exempel: hur man använder numpy max-funktionen

I det här avsnittet kommer jag att visa dig konkreta exempel på hur man använder NumPy max-funktionen.

Jag kommer att visa dig flera varianter av hur du kan hitta det maximala värdet i en array. Jag kommer att visa hur man hittar maxvärdet för en 1-d array, hur man hittar maxvärdet för en 2-d array och hur man arbetar med flera av de viktiga parametrarna i numpy.max.

Kör den här koden först

Innan vi sätter igång finns det några inledande saker som du måste göra för att ställa in dig ordentligt.

För det första måste du ha NumPy installerat ordentligt på din dator.

Import numpy

För det andra måste du ha NumPy importerat till din arbetsmiljö.

Du kan importera NumPy med följande kod:

import numpy as np

Bemärk att vi har importerat NumPy som np. Det betyder att vi kommer att hänvisa till NumPy i vår kod med aliaset np.

Okej, nu när det är klart, låt oss titta på några exempel.

Beräkna maxvärdet av en 1-dimensionell matris

Vi börjar enkelt.

Här ska vi beräkna maxvärdet av en 1-d NumPy-array.

För att göra detta ska vi först bara skapa en 1-dimensionell array som innehåller några slumpmässiga heltal. För att skapa den här matrisen använder vi funktionen numpy.random.randint(). Tänk på att du måste använda funktionen np.random.seed() så att din NumPy-array innehåller samma heltal som heltalen i det här exemplet.

np.random.seed(22)np_array_1d = np.random.randint(size = 5, low = 0, high = 99)

Denna syntax kommer att skapa en 1-dimensionell array som heter np_array_1d.

Vi kan skriva ut np_array_1d med hjälp av funktionen print().

print(np_array_1d)

Och här är utmatningen:

Visuellt kan vi identifiera det högsta värdet, som är 84.

Men låt oss göra det med lite kod.

Här beräknar vi det maximala värdet för vår NumPy-array med hjälp av funktionen np.max().

np.max(np_array_1d)

Det ger följande utdata:

84

Det här är ett extremt enkelt exempel, men det illustrerar tekniken. När arrayen bara är 5 objekt lång kan du naturligtvis visuellt inspektera arrayen och hitta maxvärdet. Men den här tekniken fungerar om du har en array med tusentals värden (eller mer!).

Beräkna maxvärdet för en 2-d array

Nästan, låt oss beräkna maxvärdet för en 2-d array.

För att göra detta behöver vi naturligtvis en 2-dimensionell matris att arbeta med, så vi skapar först en 2-dimensionell NumPy-matris.

För att skapa vår 2-dimensionella matris kommer vi att använda funktionen np.random.choice(). I huvudsak kommer den här funktionen att dra ett slumpmässigt urval från helheterna mellan 0 och 8, utan ersättning. Efter att np.random.choice() har utförts använder vi metoden reshape() för att omforma heltalen till en tvådimensionell matris med 3 rader och 3 kolumner.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Vi tar en titt genom att skriva ut matrisen, np_array_2d.

print(np_array_2d)

 ]

Som du ser är detta en 2-dimensionell matris med 3 rader och 3 kolumner. Den innehåller heltalen från 0 till 8, arrangerade slumpmässigt i matrisen.

Nu beräknar vi det högsta värdet i matrisen:

np.max(np_array_2d)

Vilket ger följande resultat:

8

Det här är ett mycket enkelt exempel, men du kan använda det här med en mycket större tvådimensionell matris och det kommer att fungera på samma sätt. När du har lärt dig att använda den här tekniken kan du prova den med större matriser!

Nästan, låt oss göra något mer komplicerat.

… i nästa exempel ska vi beräkna kolumnmaxima och radmaxima.

Beräkna det maximala värdet av kolumnerna i en 2-d array

Först: vi ska beräkna de maximala värdena av kolumnerna i en array.

För att göra det här måste vi använda parametern axis. Närmare bestämt måste vi ställa in axis = 0 inne i funktionen numpy.max.

Låt oss snabbt gå igenom varför.

Parametern axis anger vilken axel du vill summera

Håll dig till att NumPy-matriser har axlar, och att axlarna är som riktningar längs matrisen. I en tvådimensionell matris är axel 0 den axel som pekar nedåt och axel 1 är den axel som pekar horisontellt.

Vi kan använda dessa axlar för att definiera riktningen längs vilken vi ska använda np.max.

Så låt oss säga att vi vill beräkna de maximala värdena för kolumnerna. Detta motsvarar att beräkna medelvärdena nedåt.

För att beräkna kolumnmaxima måste vi i princip beräkna maxima i axelns 0-riktning.

Beräkna max med axel = 0

Låt mig visa hur man gör.

Här ska vi återskapa vår 2-d NumPy-array. Detta är samma som den 2-d NumPy-array som vi skapade i ett tidigare exempel, så om du redan har kört den koden behöver du inte köra den igen.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

Och vi kan skriva ut den:

print(np_array_2d)

 ]

En gång till är detta en 2-d array med 3 rader och 3 kolumner. Den innehåller heltalen från 0 till 8, arrangerade slumpmässigt i matrisen.

Nu kan vi beräkna kolumnmaximum genom att använda numpy.max med axis = 0.

# CALCULATE COLUMN MAXIMAnp.max(np_array_2d, axis = 0)

Vilket ger följande utmatningsmatris:

array()

Låt oss utvärdera vad som hände här.

Då vi ställde in axis = 0 angav vi att vi vill att funktionen NumPy max ska beräkna maxvärdena nedåt längs axeln 0.

Det är ganska okomplicerat så länge du förstår NumPy-axlar och hur de fungerar i NumPy-funktionerna.

Beräkna radmax med axis = 1

På samma sätt kan vi beräkna radmax genom att ställa in parametern axis till axis = 1.

Här är koden för att skapa det 2-dimensionella datasetet igen:

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

print(np_array_2d)

 ]

Och låt oss nu beräkna radmaxima:

np.max(np_array_2d, axis = 1)

Med följande utdata:

array()

Det här borde vara begripligt om du redan har läst och förstått de tidigare exemplen.

När vi ställer in axis = 1 säger vi till numpy.max att beräkna maximivärdena i axel-1-riktningen. Eftersom axel 1 är den axel som löper horisontellt längs med matrisen beräknar detta i praktiken maxvärdena längs med raderna i en tvådimensionell matris:

Även det här är ganska okomplicerat, så länge du verkligen förstår NumPys matrisaxlar. Om du fortfarande har problem med att förstå axlar rekommenderar jag att du läser vår handledning om NumPy arrayaxlar.

Hur man använder keepdims-parametern med np.max

Slutligt ska vi ta en titt på parametern keepdims.

Innan vi gör det här ska jag förklara varför vi behöver den.

Som jag noterade tidigare sammanfattar NumPy max-funktionen data när du använder den. Faktum är att många av NumPy-funktionerna som beräknar sammanfattande statistik (som np.mean, np.median, np.min osv.) sammanfattar data till sin natur. När du beräknar en sammanfattande statistik sammanfattar du per definition data.

Detta har viktiga konsekvenser i samband med datans dimensioner.

När du sammanfattar dina data med en funktion som numpy.max kommer resultatet av funktionen att ha ett reducerat antal dimensioner.

Till exempel kan vi säga att du beräknar det maximala värdet i en tvådimensionell matris. Om du använder numpy.max på den här 2-dimensionella matrisen (utan parametern axis) kommer resultatet att vara ett enda tal, en skalär. Skalarer har noll dimensioner. Två dimensioner in, noll dimension ut.

NumPy max-funktionen reducerar effektivt dimensionerna mellan inmatningen och utmatningen.

I vissa fall vill man dock inte ha ett reducerat antal dimensioner. Det kan finnas situationer där du behöver att utmatningen tekniskt sett har samma dimensioner som inmatningen (även om utmatningen är ett enda tal).

Du kan tvinga fram det beteendet genom att använda parametern keepdims.

Sätt keepdims lika med true (och behåll samma dimensioner)

Som standard är parametern keepdims inställd på False. Som jag just förklarade innebär detta att utdata inte behöver ha samma dimensioner som indata, som standard.

Men om du ställer in keepdims = True kommer detta att tvinga utmatningen att ha samma antal dimensioner som inmatningen.

Detta kanske förvirrar dig, så låt oss ta en titt på ett gediget exempel.

Först ska vi bara skapa en 2-d array.

Detta är samma array som vi skapade tidigare, så om du redan har kört den här koden behöver du inte köra den igen. I huvudsak skapar den här koden en 2-d array med siffrorna från 0 till 8, arrangerade slumpmässigt i en 3 gånger 3 array.

np.random.seed(1)np_array_2d = np.random.choice(9, 9, replace = False).reshape((3,3))

För tydlighetens skull tar vi en titt genom att skriva ut den:

print(np_array_2d)

Och här är matrisen:

 ]

Också den här matrisen innehåller bara heltalen från 0 till 8, arrangerade slumpmässigt i en 3-by-3 NumPy-matris.

Och hur många dimensioner har den?

Det är förmodligen uppenbart för dig, men vi kan direkt hämta antalet dimensioner genom att extrahera attributet ndim från matrisen.

np_array_2d.ndim

Och detta talar om antalet dimensioner:

2

Så, np_array_2d är en 2-dimensionell matris.

Nu använder vi np.max för att beräkna det maximala värdet i matrisen.

np.max(np_array_2d)

Det maximala värdet är 8.

Och hur många dimensioner har resultatet? Vi kan kontrollera det genom att hänvisa till attributet ndim i slutet av funktionen np.max():

np.max(np_array_2d).ndim

Hur många dimensioner har utmatningen?

0.

Utmatningen av np.max är maximivärdet (8), vilket är en skalär. Denna skalär har noll dimensioner.

Kör np.max på nytt med keepdims = True

Nu kör vi koden på nytt med keepdims = True.

np.max(np_array_2d, keepdims = True)

Det ger följande utdata:

array(])

Och låt oss kontrollera dimensionerna:

np.max(np_array_2d, keepdims = True).ndim

2

Här, när vi kör np.max på np_array_2d med keepdims = True, har utdata 2 dimensioner.

Håll i åtanke att maxvärdet är detsamma: 8. Det är bara det att dimensionerna på utmatningen är olika. Genom att ställa in keepdims = True ändrar vi utmatningens struktur … i stället för att vara en skalär är utmatningen faktiskt en 2-dimensionell NumPy-array med ett enda värde (8).

Om du vill lära dig datavetenskap i Python, lär dig NumPy

Om du har läst andra handledningar här på bloggen Sharp Sight data science vet du hur viktig datamanipulation är.

Om du menar allvar med att lära dig datavetenskap måste du verkligen behärska grunderna i datamanipulation. En stor del av arbetsflödet inom datavetenskap är just att rensa och manipulera indata.

Om du arbetar i Python är NumPy en av de viktigaste färdigheterna du behöver kunna då. Numpy är avgörande för att rensa, manipulera och utforska dina data.

Om du vill lära dig datavetenskap i Python ska du lära dig NumPy och lära dig det väl.

För fler handledningar i datavetenskap i Python, anmäl dig till vår e-postlista

Med det sagt, om du vill lära dig NumPy och datavetenskap i Python, anmäl dig då till vår e-postlista.

Här på Sharp Sight-bloggen publicerar vi regelbundet handledningar i datavetenskap.

När du registrerar dig får du gratis handledning om:

• NumPy
• Pandas
• Base Python
• Scikit learn
• Machine learning
• Deep learning
• … och mer.

När vi publicerar tutorials skickar vi dem direkt till din inkorg.

Vill du lära dig datavetenskap i Python? Registrera dig nu.

.