Manipulation de tableaux Numpy

Numpy contient certaines fonctions pour traiter les tableaux, qui peuvent être grossièrement réparties dans les catégories suivantes :

Modifier la forme d’un tableau

Fonction	Description
`reshape`	Modifier la forme sans changer les données
`flat`	Itérateur d'éléments de tableau
`flatten`	Renvoie une copie du tableau. Les modifications apportées à la copie n'affecteront pas le tableau d'origine.
`ravel`	Renvoie un tableau aplati

numpy.reshape

La fonction numpy.reshape peut modifier la forme sans changer les données. Le format est le suivant :

numpy.reshape(arr, newshape, order='C')

arr: le tableau dont la forme doit être modifiée
newshape: un entier ou un tableau d'entiers. La nouvelle forme doit être compatible avec la forme d'origine.
order: 'C' -- par ligne, 'F' -- par colonne, 'A' -- ordre d'origine, 'k' -- l'ordre dans lequel les éléments apparaissent en mémoire.

Exemple

import numpy as np a = np.arange(8) print ('Tableau d'origine :') print (a) print ('\n') b = a.reshape(4,2) print ('Tableau modifié :') print (b)

La sortie est la suivante :

原始数组：
[0 1 2 3 4 5 6 7]

修改后的数组：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat

numpy.ndarray.flat est un itérateur d'éléments de tableau. Exemple :

Exemple

import numpy as np a = np.arange(9).reshape(3,3) print ('Tableau d'origine :') for row in a: print (row) # Pour traiter chaque élément du tableau, vous pouvez utiliser l'attribut flat, qui est un itérateur d'éléments de tableau : print ('Tableau après itération :') for element in a.flat: print (élément)

La sortie est la suivante :

原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8

numpy.ndarray.flatten

numpy.ndarray.flatten renvoie une copie du tableau. Les modifications apportées à la copie n'affecteront pas le tableau d'origine. Le format est le suivant :

ndarray.flatten(order='C')

Description du paramètre :

ordre : 'C' -- par ligne, 'F' -- par colonne, 'A' -- ordre d'origine, 'K' -- l'ordre dans lequel les éléments apparaissent en mémoire.

Exemple

import numpy as np a = np.arange(8).reshape(2,4) print ('Tableau d'origine :') print (a) print ('\n') # La valeur par défaut est par ligne print ('Tableau aplati :') print (a.flatten()) print ('\n') print ('Tableau aplati dans l'ordre F-style :') print (a.flatten(order = 'F'))

La sortie est la suivante :

原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组：
[0 1 2 3 4 5 6 7]


以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

numpy.ravel

numpy.ravel() aplatit les éléments d'un tableau, généralement dans l'ordre 'C style'. Elle renvoie une vue de tableau (view, un peu comme une référence C/C++). Les modifications affecteront le tableau d'origine.

Cette fonction accepte deux paramètres :

numpy.ravel(a, order='C')

Description du paramètre :

ordre : 'C' -- par ligne, 'F' -- par colonne, 'A' -- ordre d'origine, 'K' -- l'ordre dans lequel les éléments apparaissent en mémoire.

Exemple

import numpy as np a = np.arange(8).reshape(2,4) print ('Tableau d'origine :') print (a) print ('\n') print ('Après l'appel de la fonction ravel :') print (a.ravel()) print ('\n') print ('Après l'appel de la fonction ravel dans l'ordre F-style :') print (a.ravel(order = 'F'))

La sortie est la suivante :

原数组：
[[0 1 2 3]
 [4 5 6 7]]


调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]


以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]

Inverser un tableau

Fonction	Description
`transpose`	Échangez les dimensions du tableau
`ndarray.T`	et`self.transpose()`Identique
`rollaxis`	Faites rouler l'axe spécifié vers l'arrière
`swapaxes`	Échangez deux axes du tableau

numpy.transpose

La fonction numpy.transpose est utilisée pour échanger les dimensions d'un tableau. Le format est le suivant :

numpy.transpose(arr, axes)

Description du paramètre :

arr: Le tableau sur lequel effectuer l'opération
axes: Une liste d'entiers, correspondant aux dimensions. Généralement, toutes les dimensions sont échangées.

Exemple

import numpy as np a = np.arange(12).reshape(3,4) print ('Tableau d'origine :') print (a ) print ('\n') print ('Tableau transposé :') print (np.transpose(a))

La sortie est la suivante :

原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


对换数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

numpy.ndarray.T est similaire à numpy.transpose :

Exemple

import numpy as np a = np.arange(12).reshape(3,4) print ('Tableau d'origine :') print (a) print ('\n') print ('Tableau transposé :') print (a.T)

La sortie est la suivante :

原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

numpy.rollaxis

La fonction numpy.rollaxis fait reculer l'axe spécifié vers une position spécifique. Le format est le suivant :

numpy.rollaxis(arr, axis, start)

Description du paramètre :

arr: Tableau
axis: L'axe à faire reculer. Les positions relatives des autres axes ne changeront pas.
start: Par défaut zéro, indiquant un déplacement complet. Il reculera vers une position spécifique.

Exemple

import numpy as np # Création d'un ndarray tridimensionnel a = np.arange(8).reshape(2,2,2) print ('Tableau d'origine :') print (a) print ('Obtenir une valeur dans le tableau :') print(np.where(a==6)) print(a[1,1,0]) # vaut 6 print ('\n') # Faire rouler l'axe 2 vers l'axe 0 (largeur vers profondeur) print ('Appeler la fonction rollaxis :') b = np.rollaxis(a,2,0) print (b) # L'élément a[1,1,0], soit la coordonnée de 6, devient [0, 1, 1] # Le dernier 0 passe au début print(np.where(b==6)) print ('\n') # Faire rouler l'axe 2 vers l'axe 1 : (largeur vers hauteur) print ('Appeler la fonction rollaxis :') c = np.rollaxis(a,2,1) print (c) # Voir l'élément a[1,1,0], c'est-à-dire que la coordonnée de 6 devient [1, 0, 1] # Le dernier 0 échange sa position avec le 1 devant lui print(np.where(c==6)) print ('\n')

La sortie est la suivante :

原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
获取数组中一个值：
(array([1]), array([1]), array([0]))
6


调用 rollaxis 函数：
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]
(array([0]), array([1]), array([1]))


调用 rollaxis 函数：
[[[0 2]
  [1 3]]

 [[4 6]
  [5 7]]]
(array([1]), array([0]), array([1]))

numpy.swapaxes

La fonction numpy.swapaxes est utilisée pour échanger deux axes d'un tableau. Le format est le suivant :

numpy.swapaxes(arr, axis1, axis2)

arr: Tableau d'entrée
axis1: Un entier correspondant au premier axe
axis2: Un entier correspondant au deuxième axe

Exemple

import numpy as np # Création d'un ndarray tridimensionnel a = np.arange(8).reshape(2,2,2) print ('Tableau d'origine :') print (a) print ('\n') # Maintenant, échangez l'axe 0 (direction de la profondeur) avec l'axe 2 (direction de la largeur) print ('Tableau après l'appel de la fonction swapaxes :') print (np.swapaxes(a, 2, 0))

La sortie est la suivante :

原数组：
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]


调用 swapaxes 函数后的数组：
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

Modifier les dimensions d’un tableau

Dimension	Description
`broadcast`	Créer un objet qui imite la diffusion
`broadcast_to`	Diffuser le tableau vers une nouvelle forme
`expand_dims`	Étendre la forme du tableau
`squeeze`	Supprime les entrées unidimensionnelles de la forme du tableau

numpy.broadcast

numpy.broadcast est un objet utilisé pour imiter la diffusion. Il renvoie un objet qui encapsule le résultat de la diffusion d’un tableau vers un autre.

Cette fonction utilise deux tableaux comme paramètres d’entrée, comme dans l’exemple suivant :

Exemple

import numpy as np x = np.array([[1], [2], [3]]) y = np.array([4, 5, 6]) # Diffuser x par rapport à y b = np.broadcast(x,y) # Il possède un attribut d’itérateur, basé sur un tuple d’itérateurs de ses propres composants print ('Diffuser x par rapport à y :') r,c = b.iters # Pour Python3.x, il s’agit de next(context), pour Python2.x, il s’agit de context.next() print (next(r), next(c)) print (next(r), next(c)) print ('\n') # L’attribut shape renvoie la forme de l’objet broadcast print ('Forme de l’objet broadcast :') print (b.shape) print ('\n') # Utiliser broadcast manuellement pour ajouter x et y b = np.broadcast(x,y) c = np.empty(b.shape) print ('Ajouter manuellement x et y en utilisant la diffusion :') print (c.shape) print ('\n') c.flat = [u + v for (u,v) in b] print ('Appeler la fonction flat :') print (c) print ('\n') # Cela donne le même résultat que la prise en charge de la diffusion intégrée de NumPy print ('La somme de x et y :') print (x + y)

La sortie est :

对 y 广播 x：
1 4
1 5


广播对象的形状：
(3, 3)


手动使用 broadcast 将 x 与 y 相加：
(3, 3)


调用 flat 函数：
[[5. 6. 7.]
 [6. 7. 8.]
 [7. 8. 9.]]


x 与 y 的和：
[[5 6 7]
 [6 7 8]
 [7 8 9]]

numpy.broadcast_to

La fonction numpy.broadcast_to diffuse un tableau vers une nouvelle forme. Elle renvoie une vue en lecture seule sur le tableau d'origine. Elle est généralement non contiguë. Si la nouvelle forme ne respecte pas les règles de diffusion de NumPy, la fonction peut lever une ValueError.

numpy.broadcast_to(array, shape, subok)

Exemple

import numpy as np a = np.arange(4).reshape(1,4) print ('Tableau d'origine :') print (a) print ('\n') print ('Après avoir appelé la fonction broadcast_to :') print (np.broadcast_to(a,(4,4)))

La sortie est :

原数组：
[[0 1 2 3]]


调用 broadcast_to 函数之后：
[[0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]]

numpy.expand_dims

La fonction numpy.expand_dims développe la forme d’un tableau en insérant un nouvel axe à une position spécifiée. Le format de la fonction est le suivant :

 numpy.expand_dims(arr, axis)

Description du paramètre :

arr: Tableau d'entrée
axis: La position où le nouvel axe est inséré

Exemple

import numpy as np x = np.array(([1,2],[3,4])) print ('Tableau x :') print (x) print ('\n') y = np.expand_dims(x, axis = 0) print ('Tableau y :') print (y) print ('\n') print ('Formes des tableaux x et y :') print (x.shape, y.shape) print ('\n') # Insérer un axe à la position 1 y = np.expand_dims(x, axis = 1) print ('Tableau y après l’insertion d’un axe à la position 1 :') print (y) print ('\n') print ('x.ndim et y.ndim :') print (x.ndim,y.ndim) print ('\n') print ('x.shape et y.shape :') print (x.shape, y.shape)

Le résultat de sortie est:

数组 x：
[[1 2]
 [3 4]]


数组 y：
[[[1 2]
  [3 4]]]


数组 x 和 y 的形状：
(2, 2) (1, 2, 2)


在位置 1 插入轴之后的数组 y：
[[[1 2]]

 [[3 4]]]


x.ndim 和 y.ndim：
2 3


x.shape 和 y.shape：
(2, 2) (2, 1, 2)

numpy.squeeze

La fonction numpy.squeeze supprime les entrées de dimension 1 de la forme d'un tableau donné. Le format de la fonction est le suivant :

numpy.squeeze(arr, axis)

Description du paramètre :

arr: tableau d'entrée
axis: un entier ou un tuple d'entiers, utilisé pour sélectionner un sous-ensemble d'entrées de dimension 1 dans la forme

Exemple

import numpy as np x = np.arange(9).reshape(1,3,3) print ('Tableau x :') print (x) print ('\n') y = np.squeeze(x) print ('Tableau y :') print (y) print ('\n') print ('Les formes des tableaux x et y :') print (x.shape, y.shape)

Le résultat de sortie est:

数组 x：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]


数组 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]


数组 x 和 y 的形状：
(1, 3, 3) (3, 3)

Concaténation de tableaux

Fonction	Description
`concatenate`	Joindre une séquence de tableaux le long d'un axe existant.
`stack`	Joindre une séquence de tableaux le long d'un nouvel axe.
`hstack`	Empiler des tableaux en séquence horizontalement (direction des colonnes).
`vstack`	Empiler des tableaux en séquence verticalement (direction des lignes).

numpy.concatenate

La fonction numpy.concatenate est utilisée pour joindre deux tableaux ou plus de même forme le long d'un axe spécifié. Le format est le suivant :

numpy.concatenate((a1, a2, ...), axis)

Description du paramètre :

a1, a2, ...: tableaux de même type
axis: l'axe le long duquel les tableaux sont joints, la valeur par défaut est 0

Exemple

import numpy as np a = np.array([[1,2],[3,4]]) print ('Premier tableau :') print (a) print ('\n') b = np.array([[5,6],[7,8]]) print ('Deuxième tableau :') print (b) print ('\n') # Les deux tableaux ont les mêmes dimensions print ('Joindre les deux tableaux selon l'axe 0 :') print (np.concatenate((a,b))) print ('\n') print ('Joindre les deux tableaux selon l'axe 1 :') print (np.concatenate((a,b),axis = 1))

Le résultat de sortie est:

第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]


沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]

numpy.stack

La fonction numpy.stack est utilisée pour joindre une séquence de tableaux le long d'un nouvel axe. Le format est le suivant :

numpy.stack(arrays, axis)

Description du paramètre :

arraysUne séquence de tableaux de même forme
axis: l'axe dans le tableau renvoyé le long duquel les tableaux d'entrée sont empilés

Exemple

import numpy as np a = np.array([[1,2],[3,4]]) print ('Premier tableau :') print (a) print ('\n') b = np.array([[5,6],[7,8]]) print ('Deuxième tableau :') print (b) print ('\n') print ('Empiler les deux tableaux le long de l'axe 0 :') print (np.stack((a,b),0)) print ('\n') print ('Empiler les deux tableaux le long de l'axe 1 :') print (np.stack((a,b),1))

Le résultat de sortie est le suivant :

第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


沿轴 0 堆叠两个数组：
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]


沿轴 1 堆叠两个数组：
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]

numpy.hstack

numpy.hstack est un wrapper pratique de numpy.concatenate, utilisé pour empiler horizontalement des tableaux le long du deuxième axe (axis=1).

numpy.hstack traite les tableaux unidimensionnels comme des vecteurs colonnes pour la concaténation, équivalent à numpy.concatenate([numpy.atleast_1d(arr) for arr in arrays], axis=1) (lorsque tous les tableaux ont des dimensions ≥2, ils sont directement concaténés selon axis=1).

Exemple

Le résultat de sortie est le suivant :

第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]

numpy.vstack

numpy.vstack est un wrapper pratique de numpy.concatenate, utilisé pour empiler verticalement des tableaux le long du premier axe (axis=0).

numpy.vstack promeut automatiquement les tableaux unidimensionnels en vecteurs lignes bidimensionnels, puis les concatène verticalement, ce qui équivaut à numpy.concatenate([numpy.atleast_2d(arr) for arr in arrays], axis=0).

Exemple

Le résultat de sortie est:

第一个数组：
[[1 2]
 [3 4]]


第二个数组：
[[5 6]
 [7 8]]


竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

Fractionnement de tableaux

Fonction	Tableau et opération
`split`	Diviser un tableau en plusieurs sous-tableaux.
`hsplit`	Diviser un tableau horizontalement en plusieurs sous-tableaux (par colonne).
`vsplit`	Diviser un tableau verticalement en plusieurs sous-tableaux (par ligne).

numpy.split

La fonction numpy.split divise un tableau en sous-tableaux le long d'un axe spécifique. Le format est le suivant :

numpy.split(ary, indices_or_sections, axis)

Description du paramètre :

ary: le tableau à diviser
indices_or_sections: s'il s'agit d'un entier, le tableau est divisé en parties égales selon ce nombre ; s'il s'agit d'un tableau, il spécifie les positions le long de l'axe auxquelles effectuer la division (ouvert à gauche et fermé à droite).
axis: définit la direction selon laquelle diviser. La valeur par défaut est 0, une division horizontale, c'est-à-dire la direction horizontale. Lorsqu'elle vaut 1, il s'agit d'une division verticale, c'est-à-dire la direction verticale.

Exemple

import numpy as np a = np.arange(9) print ('Premier tableau :') print (a) print ('\n') print ('Divisez le tableau en trois sous-tableaux de taille égale :') b = np.split(a,3) print (b) print ('\n') print ('Divisez le tableau aux positions indiquées dans le tableau unidimensionnel :') b = np.split(a,[4,7]) print (b)

Le résultat de sortie est:

第一个数组：
[0 1 2 3 4 5 6 7 8]


将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

Lorsque axis vaut 0, divisez dans le sens horizontal ; lorsque axis vaut 1, divisez dans le sens vertical :

Exemple

import numpy as np

a = np.arange(16).reshape(4, 4)
print('Premier tableau :')
print(a)
print('\n')
print('Découpage par défaut (axis 0) :')
b = np.split(a,2)
print(b)
print('\n')

print('Découpage dans le sens horizontal :')
c = np.split(a,2,1)
print(c)
print('\n')

print('Découpage dans le sens horizontal :')
d= np.hsplit(a,2)
print(d)

Le résultat de sortie est:

第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


默认分割（0轴）：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]


沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]


沿水平方向分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

numpy.hsplit

La fonction numpy.hsplit est utilisée pour diviser un tableau horizontalement en spécifiant le nombre de tableaux de forme identique à renvoyer.

Exemple

import numpy as np harr = np.floor(10 * np.random.random((2, 6))) print ('Tableau d'origine :') print(harr) print ('Après la division :') print(np.hsplit(harr, 3))

Le résultat de sortie est:

原array：
[[4. 7. 6. 3. 2. 6.]
 [6. 3. 6. 7. 9. 7.]]
拆分后：
[array([[4., 7.],
       [6., 3.]]), array([[6., 3.],
       [6., 7.]]), array([[2., 6.],
       [9., 7.]])]

numpy.vsplit

numpy.vsplit divise le long de l'axe vertical, et sa méthode de division est identique à l'utilisation de hsplit.

Exemple

import numpy as np a = np.arange(16).reshape(4,4) print ('Premier tableau :') print (a) print ('\n') print ('Division verticale :') b = np.vsplit(a,2) print (b)

Le résultat de sortie est:

第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


竖直分割：
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

Ajout et suppression d'éléments de tableau

Fonction	Élément et description
`resize`	Renvoie un nouveau tableau de la forme spécifiée.
`append`	Ajouter des valeurs à la fin du tableau.
`insert`	Insérer des valeurs avant les indices spécifiés le long de l'axe spécifié.
`delete`	Supprimer un sous-tableau le long d'un certain axe et renvoyer le nouveau tableau après suppression.
`unique`	Trouver les éléments uniques dans un tableau.

numpy.resize

La fonction numpy.resize renvoie un nouveau tableau de la taille spécifiée.

Si le nouveau tableau est plus grand que la taille d'origine, il contient des copies des éléments du tableau d'origine.

numpy.resize(arr, shape)

Description du paramètre :

arr: le tableau dont la taille doit être modifiée
shape: la nouvelle forme du tableau renvoyé

Exemple

import numpy as np a = np.array([[1,2,3],[4,5,6]]) print ('Premier tableau :') print (a) print ('\n') print ('Forme du premier tableau :') print (a.shape) print ('\n') b = np.resize(a, (3,2)) print ('Deuxième tableau :') print (b) print ('\n') print ('Forme du deuxième tableau :') print (b.shape) print ('\n') # Notez que la première ligne de a apparaît plusieurs fois dans b car la taille a augmenté. print ('Modifier la taille du deuxième tableau :') b = np.resize(a,(3,3)) print (b)

Le résultat de sortie est:

第一个数组：
[[1 2 3]
 [4 5 6]]


第一个数组的形状：
(2, 3)


第二个数组：
[[1 2]
 [3 4]
 [5 6]]


第二个数组的形状：
(3, 2)


修改第二个数组的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]

numpy.append

La fonction numpy.append ajoute des valeurs à la fin d'un tableau. L'opération append alloue la totalité du tableau et copie le tableau d'origine dans le nouveau tableau. De plus, les dimensions des tableaux d'entrée doivent correspondre ; sinon, une ValueError sera générée.

La fonction append renvoie toujours un tableau à une dimension.

numpy.append(arr, values, axis=None)

Description du paramètre :

arr: tableau d'entrée
values: auquel ajouterarrLa valeur à ajouter doit êtrearrla même forme (sauf pour l'axe à ajouter)
axis: la valeur par défaut est None. Lorsque axis n'est pas défini, il s'agit d'un ajout horizontal, et le retour est toujours un tableau à une dimension ! Lorsque axis est défini, il vaut respectivement 0 et 1. Lorsque axis est défini, il vaut respectivement 0 et 1 (le nombre de colonnes doit être identique). Lorsque axis vaut 1, le tableau est ajouté à droite (le nombre de lignes doit être identique).

Exemple

import numpy as np a = np.array([[1,2,3],[4,5,6]]) print ('Premier tableau :') print (a) print ('\n') print ('Ajouter des éléments au tableau :') print (np.append(a, [7,8,9])) print ('\n') print ('Ajouter des éléments le long de l'axe 0 :') print (np.append(a, [[7,8,9]],axis = 0)) print ('\n') print ('Ajouter des éléments le long de l'axe 1 :') print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))

Le résultat de sortie est:

第一个数组：
[[1 2 3]
 [4 5 6]]


向数组添加元素：
[1 2 3 4 5 6 7 8 9]


沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]


沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

numpy.insert

La fonction numpy.insert insère des valeurs dans le tableau d'entrée le long de l'axe donné avant les indices donnés.

La fonction insère les valeurs ou les tableaux donnés aux positions spécifiées (ou au tableau de positions), puis renvoie un nouveau tableau. Les éléments insérés peuvent être des valeurs scalaires ou des tableaux. Notez que l'opération d'insertion renvoie un nouveau tableau et ne modifie pas le tableau d'origine.

numpy.insert(arr, obj, values, axis)

Description du paramètre :

arr: tableau d'entrée
obj: l'indice avant lequel les valeurs sont insérées
values: les valeurs à insérer
axis: l'axe le long duquel insérer ; s'il n'est pas fourni, le tableau d'entrée est aplati.

Exemple

import numpy as np a = np.array([[1,2],[3,4],[5,6]]) print ('Premier tableau :') print (a) print ('\n') print ('Le paramètre Axis n'est pas passé. Le tableau d'entrée est aplati avant la suppression.') print (np.insert(a,3,[11,12])) print ('\n') print ('Le paramètre Axis est passé. Le tableau de valeurs est diffusé pour correspondre au tableau d'entrée.') print ('Diffusion selon l'axe 0 :') print (np.insert(a,1,[11],axis = 0)) print ('\n') print ('Diffusion selon l'axe 1 :') print (np.insert(a,1,11,axis = 1))

Le résultat de sortie est le suivant :

第一个数组：
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

numpy.delete

La fonction numpy.delete renvoie un nouveau tableau avec le sous-tableau spécifié supprimé du tableau d'entrée. Comme pour la fonction insert(), si le paramètre axis n'est pas fourni, le tableau d'entrée est aplati.

Numpy.delete(arr, obj, axis)

Description du paramètre :

arr: tableau d'entrée
obj: peut être une tranche, un entier ou un tableau d'entiers, indiquant le sous-tableau à supprimer du tableau d'entrée.
axis: l'axe le long duquel le sous-tableau donné est supprimé ; s'il n'est pas fourni, le tableau d'entrée est aplati.

Exemple

import numpy as np a = np.arange(12).reshape(3,4) print ('Premier tableau :') print (a) print ('\n') print ('Le paramètre Axis n'est pas passé. Le tableau d'entrée est aplati avant l'insertion.') print (np.delete(a,5)) print ('\n') print ('Supprimer la deuxième colonne :') print (np.delete(a,1,axis = 1)) print ('\n') print ('Tranche contenant les valeurs alternatives à supprimer du tableau :') a = np.array([1,2,3,4,5,6,7,8,9,10]) print (np.delete(a, np.s_[::2]))

Le résultat de sortie est:

第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]


包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]

numpy.unique

La fonction numpy.unique est utilisée pour supprimer les éléments en double d'un tableau.

numpy.unique(arr, return_index, return_inverse, return_counts)

arr: tableau d'entrée ; s'il ne s'agit pas d'un tableau à une dimension, il sera aplati.
return_index: s'il esttrue, renvoie les positions (indices) des éléments de la nouvelle liste dans l'ancienne liste, et les stocke sous forme de liste.
return_inverse: s'il esttrueRenvoie les positions (indices) des éléments de l'ancienne liste dans la nouvelle liste, et les stocke sous forme de liste.
return_countsS'il esttrueRenvoie le nombre d'occurrences des éléments du tableau dédupliqué dans le tableau d'origine

Exemple

import numpy as np a = np.array([5,2,6,2,7,5,6,8,2,9]) print ('Premier tableau :') print (a) print ('\n') print ('Valeurs dédupliquées du premier tableau :') u = np.unique(a) print (u) print ('\n') print ('Tableau d'indices du tableau dédupliqué :') u,indices = np.unique(a, return_index = True) print (indices) print ('\n') print ('Nous pouvons voir que chaque valeur correspond à l'indice du tableau d'origine :') print (a) print ('\n') print ('Indices du tableau dédupliqué :') u,indices = np.unique(a,return_inverse = True) print (u) print ('\n') print ('Les indices sont :') print (indices) print ('\n') print ('Reconstruire le tableau d'origine à l'aide des indices :') print (u[indices]) print ('\n') print ('Renvoie le nombre d'occurrences des éléments dédupliqués :') u,indices = np.unique(a,return_counts = True) print (u) print (indices)

Le résultat de sortie est:

第一个数组：
[5 2 6 2 7 5 6 8 2 9]


第一个数组的去重值：
[2 5 6 7 8 9]


去重数组的索引数组：
[1 0 2 4 7 9]


我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]


去重数组的下标：
[2 5 6 7 8 9]


下标为：
[1 0 2 0 3 1 2 4 0 5]


使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]


返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]

Autres extensions