Phenquestions
- Vad är Python NumPy-paketet?
- NumPy-matriser
- Olika operationer som kan göras via NumPy-matriser
- Några fler specialfunktioner
Vad är Python NumPy-paketet?
Enkelt uttryckt står NumPy för 'Numerical Python' och det är vad den syftar till att uppfylla, för att tillåta komplexa numeriska operationer som utförs på N-dimensionella arrayobjekt mycket enkelt och på ett intuitivt sätt. Det är kärnbiblioteket som används i vetenskaplig databehandling, med funktioner närvarande för att utföra linjära algebraiska operationer och statistiska operationer.
Ett av de mest grundläggande (och attraktiva) begreppen för NumPy är dess användning av N-dimensionella arrayobjekt. Vi kan ta denna matris som bara a samling av rader och kolumn, precis som en MS-Excel-fil. Det är möjligt att konvertera en Python-lista till en NumPy-array och hantera funktioner över den.
NumPy Array-representation
Bara en anteckning innan vi startar använder vi en virtuell miljö för den här lektionen som vi gjorde med följande kommando:
python -m virtualenv bedövadkälla numpy / bin / aktivera
När den virtuella miljön är aktiv kan vi installera numpy-biblioteket i det virtuella env så att exempel vi skapar nästa kan köras:
pip install numpyVi ser något liknande när vi utför ovanstående kommando:
Låt oss snabbt testa om NumPy-paketet har installerats korrekt med följande kortkodavsnitt:
importera numpy som npa = np.array ([1,2,3])
skriva ut (a)
När du har kört ovanstående program bör du se följande utdata:
Vi kan också ha flerdimensionella matriser med NumPy:
multi_dimension = np.array ([(1, 2, 3), (4, 5, 6)])skriva ut (flerdimension)
Detta ger en produktion som:
[[1 2 3][4 5 6]]
Du kan också använda Anaconda för att köra dessa exempel, vilket är lättare och det är vad vi har använt ovan. Om du vill installera den på din maskin, titta på lektionen som beskriver ”Hur man installerar Anaconda Python på Ubuntu 18.04 LTS ”och dela din feedback. Låt oss nu gå vidare till olika typer av operationer som kan utföras med Python NumPy-matriser.
Använda NumPy-matriser över Python-listor
Det är viktigt att fråga att när Python redan har en sofistikerad datastruktur för att innehålla flera objekt än varför behöver vi alls NumPy-matriser? NumPy-matriserna är föredras framför Python-listor på grund av följande skäl:
- Bekväm att använda för matematiska och beräkningsintensiva operationer på grund av närvaron av kompatibla NumPy-funktioner
- De går mycket snabbare på grund av hur de lagrar data internt
- Mindre minne
Låt oss bevisa att NumPy-matriser upptar mindre minne. Detta kan göras genom att skriva ett mycket enkelt Python-program:
importera numpy som npimporttid
importera sys
python_list = intervall (500)
skriva ut (sys.getsizeof (1) * len (python_list))
numpy_arr = np.arange (500)
skriva ut (numpy_arr.storlek * numpy_arr.artikelstorlek)
När vi kör programmet ovan får vi följande resultat:
140004000
Detta visar att samma storlekslista är mer än 3 gånger i storlek jämfört med samma storlek NumPy-array.
Utföra NumPy-operationer
I det här avsnittet kan vi snabbt se över de operationer som kan utföras på NumPy-matriser.
Hitta dimensioner i matrisen
Eftersom NumPy-matrisen kan användas i vilket som helst dimensionellt utrymme för att hålla data kan vi hitta dimensionen för en matris med följande kodavsnitt:
importera numpy som npnumpy_arr = np.array ([(1,2,3), (4,5,6)])
skriva ut (numpy_arr.ndim)
Vi kommer att se utdata som "2" eftersom detta är en tvådimensionell matris.
Hitta datatyp för objekt i matrisen
Vi kan använda NumPy-array för att hålla vilken datatyp som helst. Låt oss nu ta reda på datatypen för de data som en matris innehåller:
other_arr = np.array ([('awe', 'b', 'cat')])skriva ut (annat_arr.dtype)
numpy_arr = np.array ([(1,2,3), (4,5,6)])
skriva ut (numpy_arr.dtype)
Vi använde olika typer av element i kodavsnittet ovan. Här är utgången som detta skript visar:
Detta händer när tecken tolkas som unicode-tecken och andra är uppenbart.
Omforma objekt i en matris
Om en NumPy-array består av 2 rader och 4 kolumner kan den omformas så att den innehåller 4 rader och 2 kolumner. Låt oss skriva ett enkelt kodavsnitt för samma:
original = np.array ([('1', 'b', 'c', '4'), ('5', 'f', 'g', '8')])tryck (original)
omformad = original.omforma (4, 2)
tryck (omformad)
När vi har kört ovanstående kodavsnitt får vi följande utdata med båda matriserna skrivna ut på skärmen:
[['1' 'b' 'c' '4']['5' 'f' 'g' '8']]
[['1' 'b']
['c' '4']
['5' 'f']
['g' '8']]
Observera hur NumPy tog hand om att flytta och associera elementen till nya rader.
Matematiska operationer på objekt i en matris
Att utföra matematiska operationer på objekt i en matris är mycket enkelt. Vi börjar med att skriva ett enkelt kodavsnitt för att ta reda på max, minimum och tillägg för alla objekt i matrisen. Här är kodavsnittet:
numpy_arr = np.array ([(1, 2, 3, 4, 5)])skriva ut (numpy_arr.max ())
skriva ut (numpy_arr.min ())
skriva ut (numpy_arr.belopp())
skriva ut (numpy_arr.betyda())
skriva ut (np.sqrt (numpy_arr))
skriva ut (np.std (numpy_arr))
Under de senaste 2 operationerna ovan beräknade vi också kvadratroten och standardavvikelsen för varje matrisobjekt. Ovanstående kod ger följande resultat:
51
15
3.0
[[1. 1.41421356 1.73205081 2. 2.23606798]]
1.4142135623730951
Konvertera Python-listor till NumPy-matriser
Även om du har använt Python-listor i dina befintliga program och inte vill ändra all den koden men ändå vill använda NumPy-matriser i din nya kod, är det bra att veta att vi enkelt kan konvertera en Python lista till en NumPy-array. Här är ett exempel:
# Skapa två nya listor längd och vikthöjd = [2.37, 2.87, 1.52, 1.51, 1.70, 2.05]
vikt = [91.65, 97.52, 68.25, 88.98, 86.18, 88.45]
# Skapa 2 domna matriser från höjd och vikt
np_height = np.array (höjd)
np_vikt = np.array (vikt)
Bara för att kontrollera, kan vi nu skriva ut typen av en av variablerna:
skriv ut (typ (np_höjd))Och detta kommer att visa:
Vi kan nu utföra en matematisk operation över alla objekt på en gång. Låt oss se hur vi kan beräkna BMI för folket:
# Beräkna bmibmi = np_vikt / np_höjd ** 2
# Skriv ut resultatet
skriva ut (bmi)
Detta kommer att visa BMI för alla människor beräknat elementmässigt:
[16.31682957 11.8394056 29.54033934 39.02460418 29.8200692 21.04699584]Är det inte så enkelt och praktiskt? Vi kan till och med enkelt filtrera data med ett villkor istället för ett index inom hakparenteser:
bmi [bmi> 25]Detta ger:
array ([29.54033934, 39.02460418, 29.8200692])Skapa slumpmässiga sekvenser och repetitioner med NumPy
Med många funktioner i NumPy för att skapa slumpmässiga data och ordna dem i önskad form används NumPy-matriser många gånger för att generera testdataset på många ställen, inklusive felsökning och teständamål. Om du till exempel vill skapa en matris från 0 till n, kan vi använda arange (notera singeln 'r') som det angivna utdraget:
skriva ut (np.arange (5))Detta returnerar utdata som:
[0 1 2 3 4]Samma funktion kan användas för att ge ett lägre värde så att matrisen börjar från andra siffror än 0:
skriva ut (np.arange (4, 12))Detta returnerar utdata som:
[4 5 6 7 8 9 10 11]Siffrorna behöver inte vara kontinuerliga, de kan hoppa över ett fixsteg som:
skriva ut (np.arange (4, 14, 2))Detta returnerar utdata som:
[4 6 8 10 12]Vi kan också få siffrorna i en minskande ordning med ett negativt hoppvärde:
skriva ut (np.arange (14, 4, -1))Detta returnerar utdata som:
[14 13 12 11 10 9 8 7 6 5]Det är möjligt att finansiera n-tal mellan x och y med lika utrymme med linspace-metoden, här är kodavsnittet för samma:
np.linspace (start = 10, stop = 70, num = 10, dtype = int)Detta returnerar utdata som:
array ([10, 16, 23, 30, 36, 43, 50, 56, 63, 70])Observera att utmatningsobjekten inte är lika fördelade. NumPy gör sitt bästa för att göra det men du behöver inte lita på det eftersom det gör avrundningen.
Slutligen, låt oss titta på hur vi kan generera en uppsättning slumpmässig sekvens med NumPy som är en av de mest använda funktionerna för teständamål. Vi skickar ett antal siffror till NumPy som kommer att användas som en initial och sista punkt för slumpmässiga siffror:
skriva ut (np.slumpmässig.randint (0, 10, storlek = [2,2]))Ovanstående utdrag skapar en 2 x 2 dimensionell NumPy-array som innehåller slumpmässiga nummer mellan 0 och 10. Här är exempelutgången:
[[0 4][8 3]]
Observera eftersom siffrorna är slumpmässiga kan utdata variera även mellan de två körningarna på samma maskin.
Slutsats
I den här lektionen tittade vi på olika aspekter av detta databibliotek som vi kan använda med Python för att beräkna enkla såväl som komplexa matematiska problem som kan uppstå i olika användningsfall. NumPy är ett av de viktigaste beräkningsbiblioteken när det gäller datateknik och beräkning av numerisk dat, definitivt en färdighet vi måste ha under vårt bälte.
Dela din feedback om lektionen på Twitter med @sbmaggarwal och @LinuxHint.
