Wie können die vektorisierten Funktionen von NumPy Arrays effizient rechtfertigen?

NumPy-Arrays mit vektorisierten Funktionen rechtfertigen

NumPy bietet effiziente Möglichkeiten zur Rechtfertigung von Arrays mit vektorisierten Funktionen und bietet im Vergleich zu herkömmlichen Python-Schleifen eine verbesserte Leistung und Einfachheit des Codes.

Problemstellung

Bei einem gegebenen NumPy-Array besteht die Aufgabe darin, seine Nicht-Null-Elemente zu verschieben nach links, rechts, oben oder unten, während die Form beibehalten wird.

Numpy-Lösung

Die folgende NumPy-Implementierung führt eine effiziente Ausrichtung durch:

import numpy as np

def justify(a, invalid_val=0, axis=1, side='left'):    
    if invalid_val is np.nan:
        mask = ~np.isnan(a)
    else:
        mask = a!=invalid_val
    justified_mask = np.sort(mask,axis=axis)
    if (side=='up') | (side=='left'):
        justified_mask = np.flip(justified_mask,axis=axis)
    out = np.full(a.shape, invalid_val) 
    if axis==1:
        out[justified_mask] = a[mask]
    else:
        out.T[justified_mask.T] = a.T[mask.T]
    return out

Diese Funktion richtet a aus 2D-Array entlang der angegebenen Achse und Seite (links, rechts, oben, unten). Es funktioniert, indem es Nicht-Null-Elemente mithilfe der Maske identifiziert, sie mithilfe der Sortierung sortiert, die Maske umdreht, wenn es nach oben oder links ausgerichtet wird, und schließlich das ursprüngliche Array mit den ausgerichteten Werten überschreibt.

Beispielverwendung

Hier ist ein Anwendungsbeispiel, das Nicht-Null-Elemente abdeckt links:

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

# Cover left
covered_left = justify(a, axis=1, side='left')

print("Original Array:")
print(a)
print("\nCovered Left:")
print(covered_left)

Ausgabe:

Original Array:
[[1 0 2 0]
 [3 0 4 0]
 [5 0 6 0]
 [0 7 0 8]]

Covered Left:
[[1 2 0 0]
 [3 4 0 0]
 [5 6 0 0]
 [7 8 0 0]]

Ausrichtung für ein generisches N-dimensionales Array

Um ein N-dimensionales Array auszurichten, kann die folgende Funktion verwendet werden :

def justify_nd(a, invalid_val, axis, side):    
    pushax = lambda a: np.moveaxis(a, axis, -1)
    if invalid_val is np.nan:
        mask = ~np.isnan(a)
    else:
        mask = a!=invalid_val
    justified_mask = np.sort(mask,axis=axis)
    
    if side=='front':
        justified_mask = np.flip(justified_mask,axis=axis)
            
    out = np.full(a.shape, invalid_val)
    if (axis==-1) or (axis==a.ndim-1):
        out[justified_mask] = a[mask]
    else:
        pushax(out)[pushax(justified_mask)] = pushax(a)[pushax(mask)]
    return out

Diese Funktion unterstützt komplexere Szenarien, indem sie ein N-dimensionales Array entlang einer beliebigen Achse und entweder an der Achse ausrichtet 'Vorderseite' oder 'Ende' des Arrays.

Das obige ist der detaillierte Inhalt vonWie können die vektorisierten Funktionen von NumPy Arrays effizient rechtfertigen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!