NumPy Array Reshape and Resize

  1. numpy.reshape()
  2. ndarray.reshape()
  3. reshape() Functie / methode Gedeeld geheugen
  4. numpy.resize()

NumPy heeft twee functies (en ook methoden) om matrixvormen te wijzigen - reshape en resize . Ze hebben een significant verschil waarop we ons in dit hoofdstuk zullen concentreren.

tegels verven, de alternatieven.
tegels verven, de alternatieven.

numpy.reshape()

Laten we beginnen met de functie om de vorm van de array te wijzigen - reshape().

import numpy as np

arrayA = np.arange(8)
# arrayA = array([0, 1, 2, 3, 4, 5, 6, 7])

np.reshape(arrayA, (2, 4))
#array([[0, 1, 2, 3],
#       [4, 5, 6, 7]])

Het converteert een vector van 8 elementen naar de reeks van de vorm van (4, 2) . Het kan met succes worden uitgevoerd omdat het aantal elementen voor en na het opnieuw vormen identiek is. Het verhoogt ValueError als de bedragen verschillen.

In [1]: np.reshape(arrayA, (3, 4))
    ---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
ValueError: cannot reshape array of size 8 into shape (3,4)

Laten we de hervormde array eens nader bekijken. De eerste rij is de eerste 4 gegevens van arrayA en de tweede rij neemt de laatste 4. Het vult de gegevens in de volgorde van de rij in deze hervormde conversie.

U moet de parameter wijzigen order als u wilt dat de volgorde van het vullen van gegevens kolom is.

In [1]: np.reshape(arrayA, (2, 4), order='F')
Out[1]: array([[0, 2, 4, 6],
              [1, 3, 5, 7]])

De standaardwaarde van order is C dat gegevens worden gelezen of geschreven in C-achtige indexvolgorde, of in eenvoudige woorden, in de volgorde van de rij. F betekent gegevens lezen of schrijven in Fortan-achtige indexvolgorde, of laten we zeggen in de volgorde van column . Je kan de officiële NumPy-documentatie raadplegen voor meer informatie over verschillende indexeringsmethoden.

ndarray.reshape()

Naast de reshape functie heeft NumPy ook een reshape methode in het ndarray object. De methode heeft dezelfde parameters als de functie, maar zonder gegeven array als parameter.

In [1]: arrayB = arrayA.reshape((2, 4))
    
In [2]: arrayB
Out[2]: array([[0, 1, 2, 3],
            [4, 5, 6, 7]])
In [1]: arrayA
Out[2]: array([0, 1, 2, 3, 4, 5, 6, 7])    

Je zou kunnen zien, reshape methode is vergelijkbaar met reshape functie. En u moet er ook rekening mee houden dat de ndarray.reshape() methode de gegevens en de vorm van de oorspronkelijke array niet verandert, maar een nieuw ndarray exemplaar retourneert.

reshape() Functie / methode Gedeeld geheugen

De geconverteerde array in reshape functie of methode deelt hetzelfde geheugen als de oorspronkelijke array. Je zou het kunnen denken als shallow copy in Python, waar als je de gegevens in de ene array wijzigt, de overeenkomstige gegevens in de andere array ook worden gewijzigd.

In [1]: arrayA = np.arange(8)
        arrayB = arrayA.reshape((2, 4))
        arrayB
Out[2]: array([[0, 1, 2, 3],
            [4, 5, 6, 7]])
In [2]: arrayA[0] = 10
        arrayA
Out[2]: array([10, 1, 2, 3, 4, 5, 6, 7]) 
In [3]: arrayB    
Out[3]: array([[10, 1, 2, 3],
            [4, 5, 6, 7]])    

numpy.resize()

numpy.resize() is een beetje vergelijkbaar met reshape in de zin van vormconversie. Maar het heeft enkele significante verschillen.

  1. Het heeft geen order parameter. De volgorde van resize is dezelfde als order='C' in reshape.
  2. Als het aantal elementen van de doelarray niet hetzelfde is als de originele array, wordt het formaat gewijzigd maar worden er geen fouten gegenereerd.

Laten we ons concentreren op het tweede verschil.

In [1]: arrayA = np.arange(8)
        arrayB = np.resize(arrayA, (2, 4))
Out[1]: array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

Het resultaat is hetzelfde als reshpae wanneer de elementnummers hetzelfde zijn.

In [1]: arrayC = np.resize(arrayA, (3, 4))
        arrayC
Out[1]: array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3]])
In [2]: arrayD = np.resize(arrayA, (4, 4))
        arrayD
Out[2]: array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3],
       [4, 5, 6, 7]])

Als de nieuwe array meer rijen heeft, worden de gegevens in de oorspronkelijke array herhaald, maar wordt de fout niet gegenereerd.

In [1]: arrayE = np.resize(arrayA, (2, 2))
        arrayE
Out[1]: array([[0, 1],
       [2, 3]])    
In [2]: np.resize(arrayA, (1,4))
Out[2]: array([[0, 1, 2, 3]])

Als het aantal elementen in de nieuwe array kleiner is, wordt het aantal elementen opgehaald dat nodig is om de nieuwe array in de volgorde van de rij in te vullen.

resize Functie / methode geheugen

De nieuwe array deelt niet hetzelfde geheugen met de originele array in resize functie / methode. De gegevensverandering in de ene array wordt niet toegewezen aan de andere.

In [1]: arrayA = np.arange(8)
        arrayB = arrayA.reshape((2, 4))
        arrayB
Out[2]: array([[0, 1, 2, 3],
            [4, 5, 6, 7]])
In [2]: arrayA[0] = 10
        arrayA
Out[2]: array([10, 1, 2, 3, 4, 5, 6, 7]) 
In [3]: arrayB    
Out[3]: array([[0, 1, 2, 3],
            [4, 5, 6, 7]])