Numpy Größenänderung und Füllung mit spezifischem Wert

Question

Wie kann ich ein numpy Array verändern und es mit einem bestimmten Wert füllen (wenn eine Dimension erweitert wird)?

ich einen Weg finden, meine Array mit np.pad zu verlängern, aber ich kann es nicht verkürzen:

>>> import numpy as np 
>>> a = np.ndarray((5, 5), dtype=np.uint16) 
>>> a 
array([[0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0]], dtype=uint16) 
>>> np.pad(a, ((0, 1), (0,3)), mode='constant', constant_values=9) 
array([[0, 0, 0, 0, 0, 9, 9, 9], 
     [0, 0, 0, 0, 0, 9, 9, 9], 
     [0, 0, 0, 0, 0, 9, 9, 9], 
     [0, 0, 0, 0, 0, 9, 9, 9], 
     [0, 0, 0, 0, 0, 9, 9, 9], 
     [9, 9, 9, 9, 9, 9, 9, 9]], dtype=uint16) 

Und wenn ich die Größe verwenden kann ich nicht den Wert angeben, die ich will benutzen.

>>> a.fill(5) 
>>> a.resize((2, 7)) 
>>> a 
array([[5, 5, 5, 5, 5, 5, 5], 
     [5, 5, 5, 5, 5, 5, 5]], dtype=uint16) 

aber ich würde

>>> a 
array([[5, 5, 5, 5, 5, 9, 9], 
     [5, 5, 5, 5, 5, 9, 9]], dtype=uint16) 

Nach einigen Test mag ich diese Funktion zu erstellen, aber es ist nur, wenn Sie x_value oder mit einem niedrigeren y_value ändern, wenn Sie y Dimension erhöhen müssen es nicht der Fall ist Arbeit, warum?

VALUE_TO_FILL = 9 
def resize(self, x_value, y_value): 
    x_diff = self.np_array.shape[0] - x_value 
    y_diff = self.np_array.shape[1] - y_value 
    self.np_array.resize((x_value, y_value), refcheck=False) 
    if x_diff < 0: 
     self.np_array[x_diff:, :] = VALUE_TO_FILL 
    if y_diff < 0: 
     self.np_array[:, y_diff:] = VALUE_TO_FILL 

Answer 1

Ihr Array hat eine feste Größe Datenpuffer. Sie können das Array ändern, ohne diesen Puffer zu ändern. Sie können eine Scheibe (view) nehmen, ohne den Puffer zu ändern. Sie können dem Array jedoch keine Werte hinzufügen, ohne den Puffer zu ändern.

Im Allgemeinen gibt resize ein neues Array mit einem neuen Datenpuffer zurück.

pad ist eine komplexe Funktion für allgemeine Fälle. Der einfachste Ansatz besteht jedoch darin, das Zielarray empty zu erstellen, zu füllen und dann die Eingabe an die richtige Stelle zu kopieren.

Alternativ pad könnte die Fill-Arrays erstellen und verketten sie mit dem Original. Aber concatenate macht auch die leere Rückkehr und kopiert.

A do it yourself-Pad mit Clipping so strukturiert sein könnte:

n,m = X.shape 
R = np.empty((k,l)) 
R.fill(value) 
<calc slices from n,m,k,l> 
R[slice1] = X[slice2] 

die Scheiben Berechnung kann if-else Tests oder gleichwertige min/max erfordern. Sie können wahrscheinlich diese Details ausarbeiten.

---

Dies kann alles sein, was

R[:X.shape[0],:X.shape[1]]=X[:R.shape[0],:R.shape[1]] 

Das ist erforderlich, weil es kein Problem ist, wenn ein Stück größer als die Abmessung ist.

In [37]: np.arange(5)[:10] 
Out[37]: array([0, 1, 2, 3, 4]) 

So ist zum Beispiel:

In [38]: X=np.ones((3,4),int)  
In [39]: R=np.empty((2,5),int) 
In [40]: R.fill(9) 

In [41]: R[:X.shape[0],:X.shape[1]]=X[:R.shape[0],:R.shape[1]] 

In [42]: R 
Out[42]: 
array([[1, 1, 1, 1, 9], 
     [1, 1, 1, 1, 9]]) 

Answer 2

es zu verkürzen, können Sie negative Werte in der Scheibe verwenden:

>>> import numpy as np 
>>> a = np.ndarray((5, 5), dtype=np.uint16) 
>>> a 
array([[0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0], 
     [0, 0, 0, 0, 0]], dtype=uint16) 
>>> b = a[0:-1,0:-3] 
>>> b 
array([[0, 0], 
     [0, 0], 
     [0, 0], 
     [0, 0]], dtype=uint16)