Zéro pavé numpy tableau

Ce qui est le plus pythonic façon à compléter un tableau avec des zéros à la fin?

def pad(A, length):
    ...

A = np.array([1,2,3,4,5])
pad(A, 8)    # expected : [1,2,3,4,5,0,0,0]

Dans mon cas d'utilisation, en fait je veux pad un tableau au plus proche multiple de 1024. Ex: 1342 => 2048, 3000 => 3072

source d'informationauteur Basj | 2016-07-04

  1. 18

    numpy.pad avec constant mode est ce que vous avez besoin, où l'on peut passer un tuple comme deuxième argument de dire combien de zéros de remplissage sur chaque taille, un (2, 3) par exemple sera pad 2 zéros sur le côté gauche et 3 zéros sur le côté droit:

    Donné A:

    A = np.array([1,2,3,4,5])

np.pad(A, (2, 3), 'constant')
# array([0, 0, 1, 2, 3, 4, 5, 0, 0, 0])

    Il est également possible d'ajouter un 2D tableaux numpy par le passage d'un tuple de tuples, comme le rembourrage en largeur, qui prend le format de ((top, bottom), (left, right)):

    A = np.array([[1,2],[3,4]])

np.pad(A, ((1,2),(2,1)), 'constant')

#array([[0, 0, 0, 0, 0],           # 1 zero padded to the top
#       [0, 0, 1, 2, 0],           # 2 zeros padded to the bottom
#       [0, 0, 3, 4, 0],           # 2 zeros padded to the left
#       [0, 0, 0, 0, 0],           # 1 zero padded to the right
#       [0, 0, 0, 0, 0]])

    Pour votre cas, vous indiquez le côté gauche à zéro et à droite pad calculée à partir d'une division modulaire:

    B = np.pad(A, (0, 1024 - len(A)%1024), 'constant')
B
# array([1, 2, 3, ..., 0, 0, 0])
len(B)
# 1024

    Pour une plus grande A:

    A = np.ones(3000)
B = np.pad(A, (0, 1024 - len(A)%1024), 'constant')
B
# array([ 1.,  1.,  1., ...,  0.,  0.,  0.])

len(B)
# 3072
  2. 3

    Cela devrait fonctionner:

    def pad(A, length):
    arr = np.zeros(length)
    arr[:len(A)] = A
    return arr

    Vous pourrait être en mesure d'obtenir des performances légèrement meilleures si vous initialiser un tableau vide (np.empty(length)) et puis de remplir A et la zeros séparément, mais je doute que les accélérations serait intéressant de code supplémentaire de complexité dans la plupart des cas.

    Pour obtenir la valeur de pad, je pense que vous auriez probablement juste utiliser quelque chose comme divmod:

    n, remainder = divmod(len(A), 1024)
n += bool(remainder)

    Fondamentalement, c'est juste des chiffres combien de fois 1024 divise la longueur de votre tableau (et ce que le reste de la division de l'est). Si il n'y a pas de reste, alors vous voulez juste n * 1024 éléments. Si il y a un reste, alors vous voulez (n + 1) * 1024.

    tout ensemble:

    def pad1024(A):
    n, remainder = divmod(len(A), 1024)
    n += bool(remainder)
    arr = np.zeros(n * 1024)
    arr[:len(A)] = A
    return arr
  3. 2

    Vous pouvez également utiliser numpy.pad:

    >>> A = np.array([1,2,3,4,5])
>>> npad = 8 - len(A)
>>> np.pad(A, pad_width=npad, mode='constant', constant_values=0)[npad:]
array([1, 2, 3, 4, 5, 0, 0, 0])

    Et dans une fonction:

    def pad(A, npads):
    _npads = npads - len(A)
    return np.pad(A, pad_width=_npads, mode='constant', constant_values=0)[_npads:]
  4. 2

    Il y a np.pad:

    A = np.array([1, 2, 3, 4, 5])
A = np.pad(A, (0, length), mode='constant')

    Au sujet de votre cas d'utilisation, le nombre de zéros de remplissage peut être calculé comme length = len(A) + 1024 - 1024 % len(A).

  5. 2

    Pour référence future:

    def padarray(A, size):
    t = size - len(A)
    return np.pad(A, pad_width=(0, t), mode='constant')

padarray([1,2,3], 8)     # [1 2 3 0 0 0 0 0]