python wie man numpy array mit Nullen auffüllt

Möchte ich wissen, wie kann ich das pad eine 2D-numpy-array mit Nullen mit python 2.6.6 mit numpy version 1.5.0. Sorry! Aber diese sind meine Grenzen. Daher kann ich nicht verwenden np.pad. Zum Beispiel, ich möchte pad a mit Nullen, so dass seine Form entspricht b. Der Grund, warum ich dies tun wollen ist, so kann ich tun:

b-a

so, dass

>>> a
array([[ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.]])
>>> b
array([[ 3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.]])
>>> c
array([[1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 0],
       [0, 0, 0, 0, 0, 0]])

Nur so kann ich mir vorstellen, dies zu tun, ist das Anhängen, aber es scheint ziemlich hässlich. gibt es eine sauberere Lösung evtl. mit b.shape?

Bearbeiten,
Vielen Dank an MSeiferts Antwort. Ich hatte zu reinigen es ein wenig, und das ist, was ich habe:

def pad(array, reference_shape, offsets):
    """
    array: Array to be padded
    reference_shape: tuple of size of ndarray to create
    offsets: list of offsets (number of elements must be equal to the dimension of the array)
    will throw a ValueError if offsets is too big and the reference_shape cannot handle the offsets
    """

    # Create an array of zeros with the reference shape
    result = np.zeros(reference_shape)
    # Create a list of slices from offset to offset + shape in each dimension
    insertHere = [slice(offsets[dim], offsets[dim] + array.shape[dim]) for dim in range(array.ndim)]
    # Insert the array in the result at the specified offsets
    result[insertHere] = array
    return result

InformationsquelleAutor der Frage user2015487 | 2016-03-02

Sehr einfach, Sie erstellen ein array mit Nullen mithilfe des Verweis-Form:

result = np.zeros(b.shape)
# actually you can also use result = np.zeros_like(b) 
# but that also copies the dtype not only the shape

und legen Sie dann das array, wo Sie es brauchen:

result[:a.shape[0],:a.shape[1]] = a

und voila du hast gepolstert er:

print(result)
array([[ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.]])

Können Sie auch machen es ein bisschen mehr Allgemeinen, wenn Sie definieren, wo Ihr im oberen linken element eingefügt werden soll

result = np.zeros_like(b)
x_offset = 1  # 0 would be what you wanted
y_offset = 1  # 0 in your case
result[x_offset:a.shape[0]+x_offset,y_offset:a.shape[1]+y_offset] = a
result

array([[ 0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.],
       [ 0.,  1.,  1.,  1.,  1.,  1.],
       [ 0.,  1.,  1.,  1.,  1.,  1.]])

aber dann seien Sie vorsichtig, dass Sie nicht offsets größer als erlaubt. Für x_offset = 2 zum Beispiel wird dies scheitern.

Wenn Sie einer beliebigen Anzahl von Dimensionen können Sie eine Liste der Scheiben zum einlegen der original-array. Ich fand es interessant zu spielen ein bisschen herum und erstellt eine padding-Funktion können pad (mit offset) einem beliebigen geformten array solange das array und Referenz die gleiche Anzahl von Dimensionen und die Abstände sind nicht zu groß.

def pad(array, reference, offsets):
    """
    array: Array to be padded
    reference: Reference array with the desired shape
    offsets: list of offsets (number of elements must be equal to the dimension of the array)
    """
    # Create an array of zeros with the reference shape
    result = np.zeros(reference.shape)
    # Create a list of slices from offset to offset + shape in each dimension
    insertHere = [slice(offset[dim], offset[dim] + array.shape[dim]) for dim in range(a.ndim)]
    # Insert the array in the result at the specified offsets
    result[insertHere] = a
    return result

Und einige Testfälle:

import numpy as np

# 1 Dimension
a = np.ones(2)
b = np.ones(5)
offset = [3]
pad(a, b, offset)

# 3 Dimensions

a = np.ones((3,3,3))
b = np.ones((5,4,3))
offset = [1,0,0]
pad(a, b, offset)

InformationsquelleAutor der Antwort MSeifert

NumPy 1.7 (wenn np.pad Hinzugefügt wurde) ist ziemlich alt (es wurde veröffentlicht in 2013), so auch wenn die Frage nach einer Möglichkeit gefragt, ohne, dass die Funktion, die ich dachte, es könnte nützlich sein, zu wissen, wie das erreicht werden könnte, mit np.pad.

Es ist eigentlich ziemlich einfach:

>>> import numpy as np
>>> a = np.array([[ 1.,  1.,  1.,  1.,  1.],
...               [ 1.,  1.,  1.,  1.,  1.],
...               [ 1.,  1.,  1.,  1.,  1.]])
>>> np.pad(a, [(0, 1), (0, 1)], mode='constant')
array([[ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.]])

In diesem Fall verwendet, dass ich 0 ist der Standardwert für mode='constant'. Aber es könnte auch angegeben werden, indem Sie es explizit:

>>> np.pad(a, [(0, 1), (0, 1)], mode='constant', constant_values=0)
array([[ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.]])

Nur für den Fall, das zweite argument ([(0, 1), (0, 1)]) scheint verwirrend: Jedes Listenelement (in diesem Fall Tupel) entspricht einer dimension und Element darin stellt die Polsterung vor (erstes element) und nach (zweites element). Also:

[(0, 1), (0, 1)]
         ^^^^^^------ padding for second dimension
 ^^^^^^-------------- padding for first dimension

  ^------------------ no padding at the beginning of the first axis
     ^--------------- pad with one "value" at the end of the first axis.

In diesem Fall die Polsterung für die erste und zweite Achse sind identisch, man könnte also auch einfach nur pass bei der 2-Tupel:

>>> np.pad(a, (0, 1), mode='constant')
array([[ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.]])

Fall, dass die Polsterung vor und nach identisch ist, könnte man auch weglassen, das Tupel (in diesem Fall nicht anwendbar, wenn):

>>> np.pad(a, 1, mode='constant')
array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.]])

Oder wenn die Polsterung vor und nach identisch ist, sondern unterschiedlich für die Achse könnte man auch weglassen, das zweite argument in der inneren Tupel:

>>> np.pad(a, [(1, ), (2, )], mode='constant')
array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])

Allerdings Neige ich dazu, lieber immer explizit, weil es einfach zu einfach, Fehler zu machen (wenn NumPys Erwartungen unterscheiden sich von Ihren Absichten):

>>> np.pad(a, [1, 2], mode='constant')
array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  1.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])

Hier NumPy denkt, dass Sie wollte, pad-alle-Achse mit 1-element vor und 2 Elemente nach jeder Achse! Selbst wenn Sie es beabsichtigt pad mit 1 element in Achse 1 und 2 Elemente für Achse 2.

Ich verwendet Listen von Tupeln für die Polsterung, beachten Sie, dass dies nur "meine Konvention", Sie können auch Listen von Listen oder Tupel von Tupeln, oder auch Tupel von arrays. NumPy prüft nur die Länge des Arguments (oder, wenn es nicht eine Länge) und die Länge der einzelnen Artikel (oder, wenn es hat eine Länge)!

InformationsquelleAutor der Antwort MSeifert

Ich verstehe, dass Ihr Hauptproblem ist, dass Sie brauchen, um zu berechnen d=b-a aber deine arrays haben verschiedene Größen. Es gibt keine Notwendigkeit für eine zwischengeschaltete gepolsterte c

Können Sie dies lösen, ohne Polsterung:

import numpy as np

a = np.array([[ 1.,  1.,  1.,  1.,  1.],
              [ 1.,  1.,  1.,  1.,  1.],
              [ 1.,  1.,  1.,  1.,  1.]])

b = np.array([[ 3.,  3.,  3.,  3.,  3.,  3.],
              [ 3.,  3.,  3.,  3.,  3.,  3.],
              [ 3.,  3.,  3.,  3.,  3.,  3.],
              [ 3.,  3.,  3.,  3.,  3.,  3.]])

d = b.copy()
d[:a.shape[0],:a.shape[1]] -=  a

print d

Ausgabe:

[[ 2.  2.  2.  2.  2.  3.]
 [ 2.  2.  2.  2.  2.  3.]
 [ 2.  2.  2.  2.  2.  3.]
 [ 3.  3.  3.  3.  3.  3.]]

InformationsquelleAutor der Antwort purpletentacle

In Fall müssen Sie einen Zaun von 1s zu einem array:

>>> mat = np.zeros((4,4), np.int32)
>>> mat
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]])
>>> mat[0,:] = mat[:,0] = mat[:,-1] =  mat[-1,:] = 1
>>> mat
array([[1, 1, 1, 1],
       [1, 0, 0, 1],
       [1, 0, 0, 1],
       [1, 1, 1, 1]])

InformationsquelleAutor der Antwort user3409057

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.