Share
Numerisk är ett paket som ursprungligen utvecklades av Jim Hugunin. Det betraktas som förfader till NumPy, ett Python-bibliotek och ett open source-projekt skapat av Travis Oliphant som står för Numerical Python. Travis skapade NumPy genom att integrera funktionerna i Numarray Paketera till Numeric.
Den grundläggande idén med NumPy är stöd för multidimensionella arrays. Så NumPy kan betraktas som basen för numerisk databehandling i Python, och har skapats för att möjliggöra att Python används för att lösa matematiska och vetenskapliga problem. NumPy-modulen ger oss hundratals användbara matematiska funktioner utöver konstanter som basen av naturliga logaritmer (e) och pi (π).
Denna handledning visar hur vi kan använda NumPy för att arbeta med multidimensionella arrayer och beskriver ndarray-objektet, ett grundläggande objekt för biblioteket.
Eftersom Python inte kommer med NumPy, är det första steget att använda det här biblioteket att gå vidare och installera det. Detta kan enkelt göras genom att köra följande kommando i kommandotolken:
pip installera numpy
För att försäkra dig om att NumPy har installerats, kör följande kommandon i Pythons IDLE:
Om importera Uttalandet kör åtminstone framgångsrikt, då är du helt uppsatt!
De ndarray är ett grundläggande syfte med NumPy. Detta objekt är en N-dimensionell array, vilket innebär att den innehåller en samling av element av samma typ som indexeras med N (dimensioner av arrayen) heltal.
De viktigaste egenskaperna hos ndarray är datatyp (dtype), form, storlek, itemsize, data, och ndim. Låt oss lära oss vad varje attribut betyder genom ett exempel.
I det här exemplet kommer vi att använda NumPy för att skapa en array. Jag kommer inte att ge dimensionerna av arrayen och annan information, som vi kommer se att använda ovanstående attribut.
Observera att vi använde array funktion för att skapa en array. Resultatet av ovanstående skript är följande:
Låt oss nu återvända till våra attribut.
De dtype attributet kan köras som visas i följande uttalande:
data_type = my_array.dtype
Ovanstående uttalande kommer tillbaka int32 som datatyp. Detta betyder att elementen i arrayen är av typ int32. Jag får 32 som jag använder en 32-bitars Python. Om du använder en 64-bitars Python får du det int64, men vi har att göra med heltal i slutet.
Eftersom NumPy används i vetenskaplig databehandling har den många datatyper, vilket framgår av dokumentationen. Observera att majoriteten av NumPy-datatyperna slutar med ett tal, vilket anger antalet bitar som är associerade med den typen (detta nämndes kortfattat i ovanstående stycke).
Följande exempel visar hur vi kan konvertera från en typ till en annan:
bool (35) bool (0) bool (-1) float (True) int (67.7) float (87)
Ovanstående uttalanden returnerar följande:
True False True 1.0 67 87.0
Även om vi kan konvertera från en typ till en annan, är det viktigt att notera att vi inte kan konvertera ett komplext tal till ett heltal eller en flottör.
Formattributet returnerar en tupel av arraydimensionerna. Så följande uttalande:
array_shape = my_array.shape
kommer att återvända (4,4), vilket betyder att vår grupp består av 4 rader och 4 kolonner.
De storlek attribut returnerar antalet element i arrayen. Således, om vi skriver:
array_size = my_array.size
vi kommer få 16 som resultat, vilket betyder att vi har 16 element i vår grupp.
De itemsize attribut returnerar storleken på ett arrayelement i byte. Följande uttalande:
array_item_size = my_array.itemsize
kommer att återvända 4. Detta betyder att varje matriselement har storlek 4-byte.
De data Attribut är ett Python-buffertobjekt som pekar på början av arrayens data. Om vi skriver följande:
array_location = my_array.data
vi kommer att få följande:
Attributet ndim kommer att returnera numret på matrisdimensionerna. Så skriver du följande uttalande:
array_dimension = my_array.ndim
kommer att återvända 2, det är uppställningen består av två dimensioner.
Efter att ha förstått vad de olika ndarray attribut betyder, låt oss ta en titt på några fler exempel på att använda ndarray.
Säg att vi vill skapa en ny array med en rad och fem kolumner. Vi skulle göra det enligt följande:
my_array = np.array ((1, 2, 3, 4, 5))
Resultatet av ovanstående uttalande är: [1 2 3 4 5].
I det här exemplet kommer jag att skriva om det första exemplet i denna handledning, men med [] istället för (), som följer:
Detta exempel visar hur vi använder en strukturerad datatyp där vi deklarerar fältnamnet och motsvarande datatyp:
Accentsconagua
importera numpy som np height_type = np.dtype ([('height', np.float)])Om vi trycket (DATA_TYPE), vi kommer att få följande:
[("höjd", "Vi kan ansöka height_type till en ndarray objekt, enligt följande:
importera numpy som np height_type = np.dtype ([('height', np.float)]) my_array = np.array ([(1,78,), (1,69,), (1,88,)], dtype = height_type) tillgång till innehåll i höjdkolumnavtryck (my_array ['height'])Väljer objekt
I det här avsnittet ska jag visa dig hur du väljer specifika objekt i matrisen. För vår grupp som visas ovan under avsnittet "ndarry Object", låt oss säga att vi vill välja objektet som ligger i tredje raden och den fjärde kolumnen. Vi gör det enligt följande:
my_array [2,3]
Kom ihåg att indexering här börjar på 0, och det är därför vi skrev [2,3] istället för [3,4].
Mer om NumPy Arrays
I det här avsnittet kommer vi att dyka djupare in i NumPy-arrays.
Tom (Uninitialized) Arrays
Vi kan skapa en tom array med numpy.empty med följande syntax:
numpy.empty (form, dt, order)
Betydelsen av parametrarna i ovanstående konstruktor är som följer
- Form: formen (dimensioner) för den tomma matrisen.
- dtype: Den önskade utgångstypen, som är valfri.
- Ordning: Om du vill ha en C-style (row-major) array, skriver du
C; Om du vill ha en FORTRAN-stil (kolumn-major) -grupp, skulle du skriva F.
Så låt oss skapa en tom [2,2] array av typ int. Vi kan göra det enligt följande:
importera numpy som np empty_array = np.empty ([2,2], dtype = int) print (empty_array)
Ovanstående skript returnerar följande slumpmässiga värden då matrisen inte initialiserades:
[[1852795252 111218] [7500288 53018624]]
Array fylld med nollor
För att skapa en matris där elementen är alla nollor använder vi numpy.zeros. Konstruktören har samma syntax och parametrar som i numpy.empty. Så, om vi vill skapa en [2,2] nollor av typen int, det kan vi göra så här:
importera numpy som np zeros_array = np.zeros ([2,2], dtype = int) print (zeros_array)
Ovanstående skript kommer att returnera följande:
[[0 0] [0 0]]
En array med alla element som har värdet 1 kan enkelt skapas på samma sätt som ovan, men med numpy.ones.
Arrays med jämnt fördelade värden inom en given räckvidd
Vi kan använda numpy.arange för att skapa en array med jämnt fördelade värden inom ett visst intervall. Konstruktören har följande format:
numpy.arange (start, stopp, steg, dyp)
Nedan är meningen med varje parameter:
- Start: Det här är var intervallet börjar. Standardvärdet är
0. - Sluta: slutet på intervallet, förutsatt att detta nummer inte ingår.
- Steg: avståndet mellan värdena. Standardvärdet är
1. - dtype: datatypen för utgången. Om det inte anges, kommer datatypen att vara densamma som för ingången.
Låt oss ta ett exempel på numpy.arange.
importera numpy som np my_array = np.arange (1,10) print (my_array)
Resultatet av ovanstående skript är:
[1 2 3 4 5 6 7 8 9]
Omforma en array
För att omforma en array använder vi numpy.reshape fungera. Denna funktion ger en ny form till en array utan att ändra dess data. Som framgår av dokumentationen har funktionen följande attribut: numpy.reshape (a, newshape, order = "C"), var en är den grupp vi skulle vilja omforma, newshape är den nya önskade formen förutsatt att den nya formen skulle vara kompatibel med ursprungsformen, och ordning är ett valfritt argument som hänvisar till indexordningen vi vill använda för att både läsa arrayen en och hur vi skulle vilja placera elementen i den omformade gruppen.
C betyder läsning / skrivning av elementen med hjälp av C-liknande indexorder; F betyder läsning / skrivning av elementen med hjälp av Fortran-liknande indexorder, och en betyder att läsa / skriva elementen i Fortran-liknande indexordning om en är Fortran angränsande i minnet, C-liknande ordning annars.
Jag vet att jag har täckt mycket i ovanstående stycke, men konceptet är väldigt enkelt. Låt oss ta vår ursprungliga uppsättning my_array och försök att omforma det. Kom ihåg att den nya arrayen (omformad array) måste vara kompatibel med den ursprungliga matrisen. Till exempel, my_array har formen (4,4), det är vi har 16 element i arrayen och den nya arrayen måste ha det antal element.
Vi kan omforma my_array genom att ställa in åtta rader och två kolumner, enligt följande:
import numpy som np my_array = np.array ((6, 12, 93, 2), (5, 26, 78, 90), (3, 12, 16, 22), (5, 3, 1, 16) )) my_array_reshaped = np.reshape (my_array, (8,2))
I så fall skulle vi ha följande produktion, där vi också har 16 element.
[[6 12] [93 2] [5 26] [78 90] [3 12] [16 22] [5 3] [1 16]]
Vad händer om vi skriver omformuläret enligt följande?
my_array_reshaped = np.reshape (my_array, (8,3))
I det här fallet skulle du få följande fel:
ValueError: kan inte omforma array med storlek 16 i form (8,3)
Sammanlänkande arrays
Om vi vill ansluta två eller flera arrays av samma form längs en viss axel kan vi använda numpy.concatenate fungera. Syntaxen för denna funktion är: numnumpy.concatenate ((a1, a2, ...), axel = 0) y.concatenate. a1 och a2 är arrays med samma form och axel är den axel längs vilken arraysna kommer att förenas, förutsatt att standarden är 0.
Låt oss ta ett exempel för att förenkla konceptet. I det här exemplet kommer vi att ansluta (sammanfatta) tre arrays.
import numpy som np array_1 = np.array ((1, 2), (3, 4))) array_2 = np.array (((5, 6), (7, 8)) array_3 = np.array ( ((9, 10), (11, 12))) contacted_array = np.concatenate ((array_1, array_2, array_3)) Skriv ut ('Första Array:') Skriv ut (array_1) array_2) print ('Third Array:') print (array_3) skriv ut ('Concatenated Array:') print (contacted_array)Utsignalen från ovanstående kod är enligt följande:
Första Array: [[1 2] [3 4]] Andra Array: [[5 6] [7 8]] Tredje Array: [[9 10] [11 12]] Sammansatt Array: [[1 2] [3 4 ] [5 6] [7 8] [9 10] [11 12]]
Splitting Arrays
I motsats till anslutningsrader som visas i ovanstående avsnitt, låt oss se hur vi kan dela upp (uppdela) en array i flera delrader. Detta kan göras med hjälp av följande funktion:
numpy.split (ary, indices_or_sections, axel = 0)
ary är matrisen uppdelad i delrader. Angående indices_or_sections, om det är ett heltal N, arrayen delas in i N lika arrays längs axel. Om det är en 1-D-rad sorterade heltal anger ange var längs axel arrayen är uppdelad. axel är axeln som ska delas upp.
Följande exempel kommer att vända det som vi gjort i det föregående exemplet, det vill säga att returnera den sammanlänkade matrisen till sina tre uppsättningskomponenter:
importera numpy som np concatenated_array = np.array (((1,2), (3,4), (5,6), (7,8), (9,10), (11,12))) split_array = np.split (concatenated_array, 3) print ('Original Array:') print (concatenated_array) print ('Split Subarray:') print ('First Sub array') utskrift (split_array [0]) print Sub-array ") utskrift (split_array [1]) print (" Tredje undermatris ") utskrift (split_array [2])Utmatningen av ovanstående skript är:
Original-array: [1 2] [3 4] [5 6] [7 8] [9 10] [11 12]] Delade delrader: Första delrader [[1 2] [3 4]] Andra del -array [[5 6] [7 8]] Tredje underarrangemang [[9 10] [11 12]]
Slutsats
Som vi såg i den här handledningen gör NumPy det mycket flexibelt för att fungera med arrays. Handledningen var bara en skrapa på ytan av det här intressanta Python-biblioteket. NumPy har fortfarande många fler funktioner att titta på för att få ut det mesta av det här biblioteket. En omfattande bok om ämnet av NumPy skaparen själv är Guide to NumPy.
Se vidare vad vi har till salu och studera på marknaden, och tveka inte att ställa några frågor och ge din värdefulla feedback genom att använda foderet nedan.
