numpy
Tableaux
Recherche…
Introduction
Les tableaux ou les ndarrays n-dimensions sont l'objet principal de numpy utilisé pour stocker les éléments du même type de données. Ils fournissent une structure de données efficace supérieure aux baies Python ordinaires.
Remarques
Autant que possible, exprimer les opérations sur les données en termes de tableaux et d'opérations vectorielles. Les opérations vectorielles s'exécutent beaucoup plus vite qu'équivalent pour les boucles
Créer un tableau
Tableau vide
np.empty((2,3))
Notez que dans ce cas, les valeurs de ce tableau ne sont pas définies. Cette façon de créer un tableau n'est donc utile que si le tableau est rempli plus tard dans le code.
À partir d'une liste
np.array([0,1,2,3])
# Out: array([0, 1, 2, 3])
Créer une gamme
np.arange(4)
# Out: array([0, 1, 2, 3])
Créer des zéros
np.zeros((3,2))
# Out:
# array([[ 0., 0.],
# [ 0., 0.],
# [ 0., 0.]])
Créer des objets
np.ones((3,2))
# Out:
# array([[ 1., 1.],
# [ 1., 1.],
# [ 1., 1.]])
Créer des éléments de tableau à espacement linéaire
np.linspace(0,1,21)
# Out:
# array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 ,
# 0.45, 0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85,
# 0.9 , 0.95, 1. ])
Créer des éléments de tableau à espacement de journal
np.logspace(-2,2,5)
# Out:
# array([ 1.00000000e-02, 1.00000000e-01, 1.00000000e+00,
# 1.00000000e+01, 1.00000000e+02])
Créer un tableau à partir d'une fonction donnée
np.fromfunction(lambda i: i**2, (5,))
# Out:
# array([ 0., 1., 4., 9., 16.])
np.fromfunction(lambda i,j: i**2, (3,3))
# Out:
# array([[ 0., 0., 0.],
# [ 1., 1., 1.],
# [ 4., 4., 4.]])
Opérateurs de tableau
x = np.arange(4)
x
#Out:array([0, 1, 2, 3])
l'addition scalaire est élémentaire
x+10
#Out: array([10, 11, 12, 13])
la multiplication scalaire est élémentaire
x*2
#Out: array([0, 2, 4, 6])
l'ajout de tableau est élémentaire
x+x
#Out: array([0, 2, 4, 6])
la multiplication de tableau est élémentaire
x*x
#Out: array([0, 1, 4, 9])
le produit scalaire (ou plus généralement la multiplication matricielle) se fait avec une fonction
x.dot(x)
#Out: 14
Dans Python 3.5, l'opérateur @ été ajouté en tant qu'opérateur infixe pour la multiplication matricielle
x = np.diag(np.arange(4))
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]])
'''
print(x@x)
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 9]])
'''
Ajouter Renvoie une copie avec les valeurs ajoutées. Pas en place.
#np.append(array, values_to_append, axis=None)
x = np.array([0,1,2,3,4])
np.append(x, [5,6,7,8,9])
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x
# Out: array([0, 1, 2, 3, 4])
y = np.append(x, [5,6,7,8,9])
y
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
hstack . Pile horizontale (colonne colonne)
vstack . Pile verticale (pile de lignes)
# np.hstack(tup), np.vstack(tup)
x = np.array([0,0,0])
y = np.array([1,1,1])
z = np.array([2,2,2])
np.hstack(x,y,z)
# Out: array([0, 0, 0, 1, 1, 1, 2, 2, 2])
np.vstack(x,y,z)
# Out: array([[0, 0, 0],
# [1, 1, 1],
# [2, 2, 2]])
Accès aux tableaux
La syntaxe de tranche est i:j:k où i est l'indice de départ (inclus), j est l'index d'arrêt (exclusif) et k la taille de pas. Comme d’autres structures de données python, le premier élément a un index de 0:
x = np.arange(10)
x[0]
# Out: 0
x[0:4]
# Out: array([0, 1, 2, 3])
x[0:4:2]
# Out:array([0, 2])
Les valeurs négatives sont prises en compte à partir de la fin du tableau. -1 accède donc au dernier élément d'un tableau:
x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])
Les tableaux multidimensionnels sont accessibles en spécifiant chaque dimension séparée par des virgules. Toutes les règles précédentes s'appliquent.
x = np.arange(16).reshape((4,4))
x
# Out:
# array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
x[1,1]
# Out: 5
x[0:3,0]
# Out: array([0, 4, 8])
x[0:3, 0:3]
# Out:
# array([[ 0, 1, 2],
# [ 4, 5, 6],
# [ 8, 9, 10]])
x[0:3:2, 0:3:2]
# Out:
# array([[ 0, 2],
# [ 8, 10]])
Transposer un tableau
arr = np.arange(10).reshape(2, 5)
En .transpose méthode .transpose :
arr.transpose()
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
.T méthode:
arr.T
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Ou np.transpose :
np.transpose(arr)
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Dans le cas d'un tableau à deux dimensions, cela équivaut à une transposition de matrice standard (comme décrit ci-dessus). Dans le cas de la dimension n, vous pouvez spécifier une permutation des axes du tableau. Par défaut, ceci inverse le array.shape .
a = np.arange(12).reshape((3,2,2))
a.transpose() # equivalent to a.transpose(2,1,0)
# Out:
# array([[[ 0, 4, 8],
# [ 2, 6, 10]],
#
# [[ 1, 5, 9],
# [ 3, 7, 11]]])
Mais toute permutation des index des axes est possible:
a.transpose(2,0,1)
# Out:
# array([[[ 0, 2],
# [ 4, 6],
# [ 8, 10]],
#
# [[ 1, 3],
# [ 5, 7],
# [ 9, 11]]])
a = np.arange(24).reshape((2,3,4)) # shape (2,3,4)
a.transpose(2,0,1).shape
# Out:
# (4, 2, 3)
Indexation booléenne
arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])
La comparaison avec un scalaire renvoie un tableau booléen:
arr > 4
# Out: array([False, False, False, False, False, True, True], dtype=bool)
Ce tableau peut être utilisé dans l’indexation pour sélectionner uniquement les nombres supérieurs à 4:
arr[arr>4]
# Out: array([5, 6])
L'indexation booléenne peut être utilisée entre différents tableaux (par exemple, des tableaux parallèles associés):
# Two related arrays of same length, i.e. parallel arrays
idxs = np.arange(10)
sqrs = idxs**2
# Retrieve elements from one array using a condition on the other
my_sqrs = sqrs[idxs % 2 == 0]
print(my_sqrs)
# Out: array([0, 4, 16, 36, 64])
Remodeler un tableau
La numpy.reshape (identique à numpy.ndarray.reshape ) renvoie un tableau de la même taille totale, mais sous une nouvelle forme:
print(np.arange(10).reshape((2, 5)))
# [[0 1 2 3 4]
# [5 6 7 8 9]]
Il retourne un nouveau tableau et ne fonctionne pas sur place:
a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
Cependant, il est possible de remplacer l'attribut de shape d'un ndarray :
a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Ce comportement peut être surprenant au premier abord, mais ndarray s est stocké dans des blocs de mémoire contigus, et leur shape spécifie uniquement comment ce flux de données doit être interprété comme un objet multidimensionnel.
Jusqu'à un axe du tuple de shape peut avoir une valeur de -1 . numpy alors la longueur de cet axe pour vous:
a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Ou:
a = np.arange(12)
print(a.reshape((3, 2, -1)))
# [[[ 0 1]
# [ 2 3]]
# [[ 4 5]
# [ 6 7]]
# [[ 8 9]
# [10 11]]]
Plusieurs dimensions non spécifiées, par exemple a.reshape((3, -1, -1)) ne sont pas autorisées et jettent un ValueError .
Opérations de tableau de diffusion
Les opérations arithmétiques sont effectuées élément par élément sur les tableaux Numpy. Pour les tableaux de forme identique, cela signifie que l'opération est exécutée entre des éléments aux indices correspondants.
# Create two arrays of the same size
a = np.arange(6).reshape(2, 3)
b = np.ones(6).reshape(2, 3)
a
# array([0, 1, 2],
# [3, 4, 5])
b
# array([1, 1, 1],
# [1, 1, 1])
# a + b: a and b are added elementwise
a + b
# array([1, 2, 3],
# [4, 5, 6])
Les opérations arithmétiques peuvent également être exécutées sur des tableaux de formes différentes au moyen de la diffusion Numpy. En général, un tableau est "diffusé" sur l'autre, de sorte que les opérations élémentaires sont effectuées sur des sous-tableaux de forme congruente.
# Create arrays of shapes (1, 5) and (13, 1) respectively
a = np.arange(5).reshape(1, 5)
a
# array([[0, 1, 2, 3, 4]])
b = np.arange(4).reshape(4, 1)
b
# array([0],
# [1],
# [2],
# [3])
# When multiplying a * b, slices with the same dimensions are multiplied
# elementwise. In the case of a * b, the one and only row of a is multiplied
# with each scalar down the one and only column of b.
a*b
# array([[ 0, 0, 0, 0, 0],
# [ 0, 1, 2, 3, 4],
# [ 0, 2, 4, 6, 8],
# [ 0, 3, 6, 9, 12]])
Pour illustrer cela, considérons la multiplication de tableaux 2D et 3D avec des sous-dimensions congruentes.
# Create arrays of shapes (2, 2, 3) and (2, 3) respectively
a = np.arange(12).reshape(2, 2, 3)
a
# array([[[ 0 1 2]
# [ 3 4 5]]
#
# [[ 6 7 8]
# [ 9 10 11]]])
b = np.arange(6).reshape(2, 3)
# array([[0, 1, 2],
# [3, 4, 5]])
# Executing a*b broadcasts b to each (2, 3) slice of a,
# multiplying elementwise.
a*b
# array([[[ 0, 1, 4],
# [ 9, 16, 25]],
#
# [[ 0, 7, 16],
# [27, 40, 55]]])
# Executing b*a gives the same result, i.e. the smaller
# array is broadcast over the other.
Quand la diffusion en réseau est-elle appliquée?
La diffusion a lieu lorsque deux tableaux ont des formes compatibles .
Les formes sont comparées au niveau des composants à partir des formes suivantes. Deux dimensions sont compatibles si elles sont identiques ou si l'une d'elles est 1 . Si l'une des formes a une dimension supérieure à l'autre, les composants excédentaires ne sont pas comparés.
Quelques exemples de formes compatibles:
(7, 5, 3) # compatible because dimensions are the same
(7, 5, 3)
(7, 5, 3) # compatible because second dimension is 1
(7, 1, 3)
(7, 5, 3, 5) # compatible because exceeding dimensions are not compared
(3, 5)
(3, 4, 5) # incompatible
(5, 5)
(3, 4, 5) # compatible
(1, 5)
Voici la documentation officielle sur la diffusion en réseau .
Remplir un tableau avec le contenu d'un fichier CSV
filePath = "file.csv"
data = np.genfromtxt(filePath)
De nombreuses options sont prises en charge, voir la documentation officielle pour la liste complète:
data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )
Tableau n-dimensionnel numpy: le ndarray
La structure de données de base de numpy est le ndarray (abréviation de tableau à n dimensions). ndarray s sont
- homogène (c'est-à-dire qu'ils contiennent des éléments du même type de données)
- contenir des objets de taille fixe (donnés par une forme , un tuple de n nombres entiers positifs qui spécifient les tailles de chaque dimension)
Tableau à une dimension:
x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)
Tableau à deux dimensions:
x = np.asarray([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
x
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
x.shape
# (3, 5)
Tridimensionnel:
np.arange(12).reshape([2,3,2])
Pour initialiser un tableau sans spécifier son contenu, utilisez:
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
Estimation du type de données et diffusion automatique
Le type de données est défini pour flotter par défaut
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
x.dtype
# dtype('float64')
Si certaines données sont fournies, numpy devinera le type de données:
x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')
Notez que lors des affectations, numpy tentera de convertir automatiquement les valeurs en fonction du ndarray de données de ndarray .
x[1, 1] = 1.5 # assign a float value
x[1, 1]
# 1
# value has been casted to int
x[1, 1] = 'z' # value cannot be casted, resulting in a ValueError
Diffusion de tableaux
Voir aussi Diffusion des opérations de tableau .
x = np.asarray([[1, 2], [3, 4]])
# array([[1, 2],
[3, 4]])
y = np.asarray([[5, 6]])
# array([[5, 6]])
En terminologie matricielle, nous aurions une matrice 2x2 et un vecteur 1x2. Nous sommes toujours en mesure de faire une somme
# x + y
array([[ 6, 8],
[ 8, 10]])
C'est parce que le tableau y est " étiré " pour:
array([[5, 6],
[5, 6]])
pour s'adapter à la forme de x .
Ressources:
- Introduction au ndarray à partir de la documentation officielle: Le tableau N-dimensionnel (ndarray)
- Référence de classe: ndarray .
