Numpy - le meilleur moyen de supprimer le dernier élément de 1 dimensions tableau?

NumPy tableaux ont une taille fixe, de sorte que vous ne pouvez pas supprimer un élément en place. Par exemple à l'aide de del ne fonctionne pas:

>>> import numpy as np
>>> arr = np.arange(5)
>>> del arr[-1]
ValueError: cannot delete array elements

Noter que l'indice -1 représente le dernier élément. C'est parce que les indices négatifs en Python (et NumPy) sont comptés à partir de la fin -1 est la dernière, -2 est l'avant-dernier et -len est en fait le premier élément. C'est juste pour votre information, dans le cas où vous ne saviez pas.

Python, les listes sont de taille variable, de sorte qu'il est facile d'ajouter ou de supprimer des éléments.

Donc, si vous voulez supprimer un élément, vous devez créer un nouveau tableau ou de la vue.

Création d'une nouvelle vue

Vous pouvez créer une nouvelle vue contenant tous les éléments sauf le dernier à l'aide de la tranche de notation:

>>> arr = np.arange(5)
>>> arr
array([0, 1, 2, 3, 4])

>>> arr[:-1]  # all but the last element
array([0, 1, 2, 3])
>>> arr[:-2]  # all but the last two elements
array([0, 1, 2])
>>> arr[1:]   # all but the first element
array([1, 2, 3, 4])
>>> arr[1:-1] # all but the first and last element
array([1, 2, 3])

Cependant un point de vue partage les données avec le tableau d'origine, de sorte que si l'une est modifiée de sorte est l'autre:

>>> sub = arr[:-1]
>>> sub
array([0, 1, 2, 3])
>>> sub[0] = 100
>>> sub
array([100,   1,   2,   3])
>>> arr
array([100,   1,   2,   3,   4])

La création d'un nouveau tableau de

1. Copier l'affichage

Si vous n'aimez pas cette mémoire de partage, vous devez créer un nouveau tableau, dans ce cas, il est probablement plus simple pour créer une vue, puis copier (par exemple à l'aide de la copier() méthode de tableaux):

>>> arr = np.arange(5)
>>> arr
array([0, 1, 2, 3, 4])
>>> sub_arr = arr[:-1].copy()
>>> sub_arr
array([0, 1, 2, 3])
>>> sub_arr[0] = 100
>>> sub_arr
array([100,   1,   2,   3])
>>> arr
array([0, 1, 2, 3, 4])

2. À l'aide de tableau d'entiers d'indexation [docs]

Cependant, vous pouvez également utiliser le tableau entier de l'indexation pour supprimer le dernier élément et obtenir un nouveau tableau. Ce tableau d'entiers, l'indexation toujours (pas sûr à 100% qu') créer une copie et non un point de vue:

>>> arr = np.arange(5)
>>> arr
array([0, 1, 2, 3, 4])
>>> indices_to_keep = [0, 1, 2, 3]
>>> sub_arr = arr[indices_to_keep]
>>> sub_arr
array([0, 1, 2, 3])
>>> sub_arr[0] = 100
>>> sub_arr
array([100,   1,   2,   3])
>>> arr
array([0, 1, 2, 3, 4])

Ce tableau d'entiers de l'indexation peut être utile de supprimer l'arbitraire des éléments d'un tableau (qui peut être difficile, voire impossible, lorsque vous voulez une vue):

>>> arr = np.arange(5, 10)
>>> arr
array([5, 6, 7, 8, 9])
>>> arr[[0, 1, 3, 4]]  # keep first, second, fourth and fifth element
array([5, 6, 8, 9])

Si vous voulez une fonction généralisée qui supprime le dernier élément à l'aide de tableau d'entiers indexation:

def remove_last_element(arr):
    return arr[np.arange(arr.size - 1)]

3. À l'aide de booléen tableau d'indexation [docs]

Il est également boolean d'indexation qui pourrait être utilisé, par exemple:

>>> arr = np.arange(5, 10)
>>> arr
array([5, 6, 7, 8, 9])
>>> keep = [True, True, True, True, False]
>>> arr[keep]
array([5, 6, 7, 8])

Cela crée aussi une copie! Et une approche généralisée pourrait ressembler à ceci:

def remove_last_element(arr):
    if not arr.size:
        raise IndexError('cannot remove last element of empty array')
    keep = np.ones(arr.shape, dtype=bool)
    keep[-1] = False
    return arr[keep]

Si vous souhaitez plus d'informations sur NumPys l'indexation de la documentation sur l ' "Indexation" est très bonne et couvre un grand nombre de cas.

4. À l'aide de np.delete()

Normalement, je ne recommanderais pas les fonctions de NumPy qui "semblent" comme ils sont en train de modifier le tableau en place (comme np.append et np.insert) mais faire remettre des copies, car ceux-ci sont généralement inutilement lent et trompeuse. Vous devriez les éviter autant que possible, c'est pourquoi il est le dernier point de ma réponse. Toutefois, dans ce cas, il est en fait un ajustement parfait donc je dois le mentionner:

>>> arr = np.arange(10, 20)
>>> arr
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
>>> np.delete(arr, -1)
array([10, 11, 12, 13, 14, 15, 16, 17, 18])

5.) À l'aide de np.resize()

NumPy a une autre méthode qui sonne comme il le fait d'une opération, mais c'est vraiment renvoie un nouveau tableau:

>>> arr = np.arange(5)
>>> arr
array([0, 1, 2, 3, 4])
>>> np.resize(arr, arr.size - 1)
array([0, 1, 2, 3])

Pour supprimer le dernier élément que j'ai simplement donné une nouvelle forme qui est 1 plus petit qu'avant, ce qui, de fait, supprime le dernier élément.

La modification de la matrice en place

Oui, je l'ai déjà écrit précédemment que vous ne pouvez pas modifier un tableau en place. Mais je disais ça parce que dans la plupart des cas, il n'est pas possible ou seulement en désactivant certains (tout à fait utiles) les contrôles de sécurité. Je ne suis pas sûr que sur le fonctionnement interne, mais en fonction de la taille ancienne et de la nouvelle taille, il pourrait être possible que cela comprend un (interne uniquement) opération de copie, de sorte qu'il pourrait être plus lente que la création d'une vue.

À l'aide de np.ndarray.resize()

Si le tableau ne partage pas sa mémoire avec un autre tableau, alors il est possible de redimensionner le tableau en place:

>>> arr = np.arange(5, 10)
>>> arr.resize(4)
>>> arr
array([5, 6, 7, 8])

Cependant, que va jeter ValueErrors dans le cas où c'est effectivement référencé par un autre tableau:

>>> arr = np.arange(5)
>>> view = arr[1:]
>>> arr.resize(4)
ValueError: cannot resize an array that references or is referenced by another array in this way.  Use the resize function

Vous pouvez désactiver cette sécurité-vérification par la mise en refcheck=False mais cela ne doit pas être fait à la légère, car vous rendre vulnérable pour la segmentation des défauts et de corruption de la mémoire dans le cas où l'autre tente d'accéder à un les éléments supprimés! Ce refcheck argument doit être considéré comme un expert seule option!

Résumé

Création d'une vue est vraiment très rapide et ne prend pas beaucoup de mémoire supplémentaire, donc chaque fois que possible, vous devriez essayer de travailler autant avec des points de vue que possible. Toutefois, selon les cas d'utilisation, il n'est pas si facile à enlever arbitraire des éléments de l'aide de la base de découpage. Alors qu'il est facile de supprimer les n premiers éléments et/ou n derniers éléments ou de supprimer tout élément x (l'étape argument pour le tranchage) c'est tout ce que vous pouvez faire avec elle.

Mais dans votre cas de suppression du dernier élément d'un tableau à une dimension, je recommanderais:

arr[:-1]          # if you want a view
arr[:-1].copy()   # if you want a new array

parce que ces la plupart d'exprimer clairement l'intention et tout le monde avec Python/NumPy expérience reconnaître que.

Timings

Basé sur le timing cadre de cette réponse:

# Setup
import numpy as np
def view(arr):
return arr[:-1]
def array_copy_view(arr):
return arr[:-1].copy()
def array_int_index(arr):
return arr[np.arange(arr.size - 1)]
def array_bool_index(arr):
if not arr.size:
raise IndexError('cannot remove last element of empty array')
keep = np.ones(arr.shape, dtype=bool)
keep[-1] = False
return arr[keep]
def array_delete(arr):
return np.delete(arr, -1)
def array_resize(arr):
return np.resize(arr, arr.size - 1)
# Timing setup
timings = {view: [], 
array_copy_view: [], array_int_index: [], array_bool_index: [], 
array_delete: [], array_resize: []}
sizes = [2**i for i in range(1, 20, 2)]
# Timing
for size in sizes:
print(size)
func_input = np.random.random(size=size)
for func in timings:
print(func.__name__.ljust(20), ' ', end='')
res = %timeit -o func(func_input)   # if you use IPython, otherwise use the "timeit" module
timings[func].append(res)
# Plotting
%matplotlib notebook
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure(1)
ax = plt.subplot(111)
for func in timings:
ax.plot(sizes, 
[time.best for time in timings[func]], 
label=func.__name__)
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel('size')
ax.set_ylabel('time [seconds]')
ax.grid(which='both')
ax.legend()
plt.tight_layout()

J'ai le minutage comme graphe log-log pour couvrir tous les détails, moins de temps encore le moyen le plus rapide, mais l'intervalle entre deux graduations représente un ordre de grandeur au lieu d'un montant fixe. Dans le cas où vous êtes intéressé par les valeurs spécifiques, j'ai copié dans cette gist:

Selon la ces horaires ces deux approches sont aussi le plus rapide. (Python 3.6 et NumPy 1.14.0)

OriginalL'auteur MSeifert