Introduction à la bibliothèque de calcul numérique Python NumPy
Cet article est une version formatée de mon article de blog pour Qiita. S'il y a des articles supplémentaires, je les écrirai sur le blog. __ "Introduction à la bibliothèque de calcul numérique Python NumPy" __ http://rest-term.com/archives/2999/
Introduction à la bibliothèque de calcul numérique Python NumPy
ScientificComputingToolsForPython—Numpy
NumPy est une extension du langage de programmation Python qui prend en charge les grands tableaux et matrices multidimensionnels, ainsi qu'une grande bibliothèque de fonctions mathématiques de haut niveau pour les manipuler. (via Wikipedia)
Je voudrais revoir à nouveau NumPy, dont les connaissances étaient jusqu'ici ambiguës. NumPy est souvent utilisé dans les calculs scientifiques et technologiques avec SciPy. De plus, étant donné que les opérations matricielles peuvent être effectuées à grande vitesse, OpenCV (Computer Vision Library) fournit également une interface Python utilisant NumPy.
Pour votre information, j'ai couvert la liaison OpenCV Python dans mon blog en 2011.
environnement
CentOS 6.4 (x86_64) Python 2.7.5 (ELF 64-bit LSB executable) NumPy 1.7.1
- Qu'est-ce qu'un tableau NumPy (numpy.ndarray)?
- attributs de numpy.ndarray
- À propos du type de données
- Génération de séquence
- Changement de forme de disposition
- Indexing
- Fancy Indexing
- Recherche d'index
- Opérations / opérations sur les tableaux
- Join / split array, manipulation des axes
- Trier le tableau
- Opérations sur les éléments du tableau
- Broadcasting
- Analyse de la matrice
- Fonction statistique
- Entrée / sortie de fichier
Qu'est-ce qu'un tableau NumPy (numpy.ndarray)?
An ndarray is a (usually fixed-size) multidimensional container of items of the same type and size.
numpy.ndarray est une classe qui gère les tableaux multidimensionnels. Fondamentalement, il existe les restrictions suivantes.
- Tous les éléments du tableau ont le même type
- Tableau de longueur fixe (tableau de longueur fixe)
- Le nombre d'éléments dans chaque dimension du tableau est le même
(* Cependant, la forme de l'arrangement peut être modifiée avec des restrictions. L'explication sera décrite plus tard) C'est très similaire à un tableau de langage C. En raison de la limitation, il est plus efficace lorsqu'il s'agit de grands tableaux par rapport au type de liste de Python. De plus, lorsque le terme «tableau» est utilisé par la suite, il fait essentiellement référence à numpy.ndarray.
import
##Il semble habituel de donner un alias de np lors de l'importation.
import numpy as np
Attributs de numpy.ndarray
Les principaux attributs de numpy.ndarray sont les suivants. Les données du ndarray sont stockées dans une zone contiguë de la mémoire pour un traitement efficace (), mais vous pouvez vous référer à ces attributs pour voir comment les données sont disposées en mémoire.
An instance of class ndarray consists of a contiguous one-dimensional segment of computer memory
| ndarray.flags | Informations sur la disposition de la mémoire pour les données de la baie(numpy.flagsobj) |
| ndarray.ndim | Nombre de dimensions du tableau |
| ndarray.size | Nombre d'éléments dans le tableau |
| ndarray.shape | Nombre d'éléments dans chaque dimension |
| ndarray.itemsize | Nombre d'octets par élément |
| ndarray.strides | Nombre d'octets requis pour passer à l'élément suivant dans chaque dimension |
| ndarray.nbytes | Nombre d'octets dans le tableau entier |
| ndarray.dtype | Type de données d'élément de tableau(numpy.dtype) |
numpy.ndarray
##Tableau bidimensionnel(queue)
>>> a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
>>> a
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
>>> a.flags
C_CONTIGUOUS : True ##Les données sont-elles continues en mémoire?(Type de tableau C)
F_CONTIGUOUS : False ##Comme ci-dessus(Type de baie Fortran)
OWNDATA : True ##Voir s'il s'agit de vos propres données(Voir ci-dessous)Dans le cas de faux
WRITEABLE : True ##Est-il possible de modifier les données?
ALIGNED : True ##Le type de données est-il aligné?
UPDATEIFCOPY : False ##Vous ne pouvez pas le changer en True, vous n'avez donc pas à vous en soucier.
>>> a.ndim ##Nombre de dimensions
2
>>> a.size ##Nombre d'éléments
12
>>> a.shape ##Nombre d'éléments dans chaque dimension(Nombre de lignes,Le nombre de colonnes)
(4, 3)
>>> a.itemsize ##Nombre d'octets par élément
8
>>> a.strides ##24 octets pour la ligne suivante, 8 octets pour la colonne suivante
(24, 8)
>>> a.nbytes ##Nombre d'octets dans le tableau entier(size*itemsize)
96
>>> a.dtype ##Type de données d'élément(Voir ci-dessous)
dtype('int64')
foulées indique que [0,0] et a [0,1] sont séparés de 8 octets et que [0,0] et a [1,0] sont séparés de 24 octets en mémoire. Si la séquence de données est de type Fortran, les frappes seront (8, 32). Dans le cas d'une dimension, ni le type C ni le type Fortran ne sont pertinents.
À propos du type de données
Le type de données de l'élément de tableau est géré par un objet appelé numpy.dtype. Les types qui peuvent être spécifiés sont à peu près divisés en cinq types: type logique, type entier signé, type entier non signé, type virgule flottante et type nombre complexe. Après cela, vous pouvez spécifier chacun par le nombre de bits du type de données. Veuillez consulter le site officiel pour plus de détails.
datatypes
## numpy.array()Si vous ne spécifiez pas l'option dtype dans, elle sera définie automatiquement.
##Puisqu'il s'agit d'un environnement 64 bits ici, il est généré avec un type 64 bits.
>>> a = np.array([1,2,3,4,5])
>>> a.dtype
dtype('int64') ##Entier signé 64 bits
>>> a.itemsize
8
>>> a = np.array([1.0,2.0,3.0,4.0,5.0])
>>> a.dtype
dtype('float64') ##Nombre à virgule flottante 64 bits
>>> a.itemsize
8
## numpy.array()Spécifiez l'option dtype avec
##Entier signé 32 bits
>>> a = np.array([1,2,3], dtype=np.int32)
>>> a.dtype
dtype('int32')
>>> a.itemsize
4
##Entier non signé 8 bits(Souvent utilisé dans le traitement d'image)
>>> a = np.array([1,2,3], dtype=np.uint8)
>>> a.dtype
dtype('uint8')
>>> a.itemsize
1
Vous pouvez également diffuser des types de données. Utilisez ndarray.astype ().
ndarray.astype()
>>> a = np.array([1, 2, 3, 4, 5]))
>>> a.dtype
dtype('int64')
##Transtyper du type int64 au type int32
>>> a.astype(np.int32)
array([1, 2, 3, 4, 5], dtype=int32)
>>> a = np.array([1.2, 2.4, 3.6, 4.8, 5.0])
>>> a.dtype
dtype('float64')
##Transtyper du type float64 au type int64, tronquer après la virgule décimale
>>> a.astype(np.int64)
array([1, 2, 3, 4, 5])
Le downcasting ne soulève pas d'exception. Notez également que ndarray.astype () crée et renvoie un nouveau tableau.
Génération de séquence
Tout d'abord, comment générer un tableau. Il existe de nombreuses méthodes de génération, mais ici nous nous concentrerons sur les méthodes de base et couramment utilisées.
python
>>> import numpy as np
## numpy.array()Généré par, lister comme argument(Ou taple)donner
>>> np.array([1,4,3,2,5])
array([1, 4, 3, 2, 5])
##Le tableau bidimensionnel est également OK
>>> np.array([[3,1,2], [6,4,5]])
array([[3, 1, 2],
[6, 4, 5]])
## numpy.zeros()Généré par, la valeur de tous les éléments est 0
>>> np.zeros(5)
array([ 0., 0., 0., 0., 0.])
>>> np.zeros([2,3])
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
## numpy.ones()Généré par, la valeur de tous les éléments est 1
>>> np.ones(5)
array([ 1., 1., 1., 1., 1.])
>>> np.ones([2,3])
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
## numpy.identity()Généré par, matrice unitaire(Puisqu'il s'agit d'une matrice carrée, elle a un argument.)
>>> np.identity(3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
## numpy.eye()Généré par, identité()Similaire à, mais vous pouvez spécifier le nombre de colonnes
>>> np.eye(3, 2)
array([[ 1., 0.],
[ 0., 1.],
[ 0., 0.]])
## numpy.arange()Généré par, gamme intégrée()Même procédure que
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
## (point de départ,point final,incrémentale)Spécifier
>>> np.arange(1.0, 2.0, 0.2)
array([ 1. , 1.2, 1.4, 1.6, 1.8])
## numpy.linspace()Généré par, organiser()Similaire à, mais vous pouvez spécifier le nombre d'éléments
>>> np.linspace(1, 4, 6)
array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ])
## numpy.logspace()Générée par, la valeur est une échelle logarithmique(Logarithmique commune)Aligné avec
>>> np.logspace(2, 3, 4)
array([ 100. , 215.443469 , 464.15888336, 1000. ])
##bas(base)Est spécifié comme 2
>>> np.logspace(2, 4 ,4, base=2)
array([ 4. , 6.34960421, 10.0793684 , 16. ])
## numpy.tile()Renvoie un tableau d'éléments répétés générés par
>>> np.tile([0,1,2,3,4], 2)
array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
## numpy.meshgrid()Généré par une disposition en forme de grille qui est uniformément espacée verticalement et horizontalement
>>> a, b = np.meshgrid([1,2,3], [4,5,6,7])
>>> a
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> b
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])
## numpy.tri()Généré par, matrice triangulaire
>>> np.tri(3)
array([[ 1., 0., 0.],
[ 1., 1., 0.],
[ 1., 1., 1.]])
## numpy.diag()Renvoie un tableau avec des éléments diagonaux extraits du tableau d'entrée généré par
>>> a = np.array([[0,1,2], [3,4,5], [6,7,8]])
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> np.diag(a)
array([0, 4, 8])
## numpy.empty()Généré par, uniquement zone sécurisée, non initialisé
>>> np.empty(5)
array([ 1.06452759e-312, 1.06452759e-312, 1.00000000e+000,
1.00000000e+000, 2.37151510e-322])
## ndarray.copy()Copie complète de la baie avec
>>> a = np.array([1,2,3])
>>> b = a.copy()
## numpy.Utilisation du module aléatoire
## numpy.random.randint()Générer un tableau avec des valeurs aléatoires entières comme éléments
##Plage de nombres aléatoires à générer(Valeur minimale, valeur maximale), Précisez le nombre d'éléments
>>> np.random.randint(0,100,10)
array([54, 68, 19, 57, 23, 27, 36, 99, 53, 70])
Changement de forme du tableau
L'objet ndarray peut changer la forme du tableau avec des restrictions.
- Voir (voir) L'objet renvoyé par certaines opérations NumPy est appelé une vue et fait référence aux données d'origine. Sachez donc que la modification de la valeur dans la vue modifiera également les données d'origine.
python
##Tableau unidimensionnel
>>> a = np.arange(10)
>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
## ndarray.reshape()Changer la forme de l'arrangement avec
##Passer à un tableau à deux dimensions, retourner une vue
>>> b = a.reshape((2,5))
>>> b
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
##Changer la valeur de la vue
>>> b[0] = 100
>>> b
array([[100, 100, 100, 100, 100],
[ 5, 6, 7, 8, 9]])
##Les données d'origine sont également modifiées
>>> a
array([100, 100, 100, 100, 100, 5, 6, 7, 8, 9])
##Une erreur se produira si le nombre d'éléments est différent.
>>> a.reshape((2,3))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
## ndarray.resize()Changer la forme de l'arrangement avec(in-place)
>>> a = np.arange(10)
##Passer à un tableau à deux dimensions avec le même nombre d'éléments, aucune vue renvoyée
>>> a.resize((2,5))
##La forme des données d'origine est modifiée
>>> a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
##Nombre d'éléments si la variable est référencée même une fois après la génération(Longueur de séquence)Ne peut pas être changé
>>> a.resize(11)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: cannot resize an array references or is referenced
by another array in this way. Use the resize function
##Cependant, si l'option refcheck est définie sur False, la vérification des références ne sera pas effectuée.
>>> a.resize(11, refcheck=False)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
## ndarray.flatten()Passer à un tableau unidimensionnel, renvoyer une copie au lieu d'une vue
>>> a = np.arange(10).reshape((2,5))
>>> a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> b = a.flatten()
>>> b
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
C'est une bonne idée de savoir si le tableau retourné sera une vue ou une copie. De plus, ndarray.reshape () est beaucoup utilisé, c'est donc une bonne idée de s'en souvenir également.
Indexing Introduit la référence / l'affectation des éléments de tableau, la tranche de tableau, etc. C'est fondamentalement similaire à la liste de Python, mais elle a une syntaxe étendue, alors vérifiez-la.
python
##Tableau bidimensionnel(queue)
>>> a = np.array([[0,1,2], [3,4,5], [6,7,8]])
>>> a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
##Référence d'élément/Substitution(Identique à la liste)
>>> a[2]
array([7, 8, 9])
>>> a[1][2]
6
>>> a[1][2] = 1
>>> a[1][2]
1
##IndexError si hors de portée est spécifié
>>> a[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: index out of bounds
##Référence séparée par des virgules/Substitution(Syntaxe étendue)
## a[ligne,Colonne]
>>> a[1,2]
6
##Si vous spécifiez un nombre négatif pour l'index, il comptera à partir de la fin
>>> a[-1,-2]
8
>>> a[1,2] = 10
>>> a[1,2]
10
##tranche(La notation est la même que la liste, la valeur de retour est view)
## a[start:end:step]
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[1:8:2]
array([1, 3, 5, 7])
>>> a[3:] ## a[3:10:1]
array([3, 4, 5, 6, 7, 8, 9])
>>> a[:8] ## a[0:8:1]
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> a[::-2] ## a[-1:-10:-2]
array([9, 7, 5, 3, 1])
##Peut être combiné
>>> a = np.arange(25).reshape((5,5))
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
>>> a[:,3] = 10 ## a[0:5:1,3] = 10 (Mettre à jour plusieurs éléments à la fois)
>>> a
array([[ 0, 1, 2, 10, 4],
[ 5, 6, 7, 10, 9],
[10, 11, 12, 10, 14],
[15, 16, 17, 10, 19],
[20, 21, 22, 10, 24]])
>>> a[:2,:3] = 100 ## a[0:2:1,0:3:1] = 100
>>> a
array([[100, 100, 100, 10, 4],
[100, 100, 100, 10, 9],
[ 10, 11, 12, 10, 14],
[ 15, 16, 17, 10, 19],
[ 20, 21, 22, 10, 24]])
>>> a[2::2,::2] ## a[2:5:2,0:5:2](Cas difficiles à lire s'ils sont omis)
array([[10, 12, 14],
[20, 22, 24]])
Fancy Indexing Il est également possible de spécifier un index spécial masqué par la position et les conditions de l'élément.
python
>>> a = np.arange(15,0,-1)
>>> a
array([15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
##Index spécifié sous forme de tableau d'entiers, renvoie une copie
>>> a[[0,2,4,8]]
array([15, 13, 11, 7])
##Index spécifié dans un tableau de type booléen, retourne une copie
>>> n = a>10
>>> n
array([ True, True, True, True, True, False, False, False, False,
False, False, False, False, False, False], dtype=bool)
>>> a[n]
array([15, 14, 13, 12, 11])
##Il est possible de spécifier la condition directement dans l'index
>>> a[a>10]
array([15, 14, 13, 12, 11])
##Utilisez l'opérateur de bits lorsqu'il y a plusieurs conditions
>>> a[(4<a) & (a<10)]
array([9, 8, 7, 6, 5])
##Vous pouvez également attribuer des valeurs
>>> a[a<8] = 0
>>> a
array([15, 14, 13, 12, 11, 10, 9, 8, 0, 0, 0, 0, 0, 0, 0])
Recherche d'index
python
## numpy.argmax()Renvoie le plus petit index des éléments de valeur maximale
>>> a = np.tile(np.arange(3),3)
>>> a
array([0, 1, 2, 0, 1, 2, 0, 1, 2])
>>> np.argmax(a)
2
## numpy.argmin()Renvoie le plus petit index des éléments de valeur minimale
>>> np.argmin(a)
0
## numpy.nonzero()Renvoie un tableau d'index d'éléments non nuls dans
>>> a = np.eye(3)
>>> a
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> np.nonzero(a) ##Puisqu'il s'agit d'un tableau à deux dimensions, deux tableaux sont renvoyés.
(array([0, 1, 2]), array([0, 1, 2]))
## numpy.where()Renvoie un tableau d'index d'éléments qui remplissent les conditions de
>>> a = np.arange(15).reshape((3,5))
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> np.where(a%2==0)
(array([0, 0, 0, 1, 1, 2, 2, 2]), array([0, 2, 4, 1, 3, 0, 2, 4]))
## numpy.select()Rechercher plusieurs conditions avec, définir la valeur de l'index
##Premier argument:Tableau de conditions(tableau booléen)
##Deuxième argument:Un tableau de valeurs à définir dans l'index de l'élément qui correspond à la condition
>>> a = np.arange(10)
>>> np.select([a<3, a>5], [a, a**2])
array([ 0, 1, 2, 0, 0, 0, 36, 49, 64, 81])
Même si la structure interne de ndarray est similaire à celle du tableau C, l'interface est vraiment un langage de grande classe. Cependant, si vous utilisez trop de notation spécifique à NumPy dans le découpage de tableaux, cela peut être difficile à lire, il semble donc préférable de l'utiliser modestement lorsque vous développez avec plusieurs personnes.
Opérations / opérations sur les baies
Diverses opérations sont possibles en plus du changement mentionné ci-dessus de la forme de l'agencement. Je ne peux pas tous les couvrir ici, je n'en énumérerai donc qu'une partie.
Rejoindre / scinder un tableau, manipulation d'axe
python
>>> a = np.arange(9).reshape((3,3))
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> b = np.arange(8,-1,-1).reshape((3,3))
>>> b
array([[8, 7, 6],
[5, 4, 3],
[2, 1, 0]])
## numpy.dstack()Combinez des tableaux bidimensionnels en un tableau tridimensionnel avec
>>> np.dstack((a,b))
array([[[0, 8],
[1, 7],
[2, 6]],
[[3, 5],
[4, 4],
[5, 3]],
[[6, 2],
[7, 1],
[8, 0]]])
## numpy.hstack()Joindre dans le sens de la colonne avec
>>> np.hstack((a,b))
array([[0, 1, 2, 8, 7, 6],
[3, 4, 5, 5, 4, 3],
[6, 7, 8, 2, 1, 0]])
## numpy.vstack()Rejoignez le sens de la ligne avec
>>> np.vstack((a,b))
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[8, 7, 6],
[5, 4, 3],
[2, 1, 0]])
## numpy.dsplit()Diviser un tableau en trois dimensions avec
>>> a = np.arange(16).reshape(2,2,4)
>>> a
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
>>> np.dsplit(a,2)
[array([[[ 0, 1],
[ 4, 5]],
[[ 8, 9],
[12, 13]]]), array([[[ 2, 3],
[ 6, 7]],
[[10, 11],
[14, 15]]])]
## numpy.hsplit()Fractionner dans le sens de la colonne avec
>>> a = np.arange(16).reshape(4,4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> np.hsplit(a,2)
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
## numpy.vsplit()Fractionner dans le sens de la ligne avec
>>> np.vsplit(a,2)
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
## numpy.transpose()Transposez le tableau avec
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
[3, 4]])
>>> np.transpose(a)
array([[1, 3],
[2, 4]])
## ndarray.T va bien
>>> a.T
array([[1, 3],
[2, 4]])
## numpy.swapaxes()Remplacement de l'arbre par
>>> a = np.array([[1,2,3]])
>>> np.swapaxes(a, 0, 1)
array([[1],
[2],
[3]])
Trier le tableau
python
## numpy.sort()Trier le tableau avec et renvoyer une copie
>>> a = np.random.randint(0,100,10)
>>> a
array([75, 24, 74, 49, 93, 18, 19, 85, 73, 90])
>>> np.sort(a)
array([18, 19, 24, 49, 73, 74, 75, 85, 90, 93])
## ndarray.sort()Arrangement destructeur avec(in-place)Trier par
>>> a.sort()
>>> a
array([18, 19, 24, 49, 73, 74, 75, 85, 90, 93])
##Pour les tableaux multidimensionnels
>> a = np.array([[1,4,2],[9,6,8],[5,3,7]])
>>> a
array([[1, 4, 2],
[9, 6, 8],
[5, 3, 7]])
>>> np.sort(a)
array([[1, 2, 4],
[6, 8, 9],
[3, 5, 7]])
##Spécifiez l'axe(Trier par colonne ici)
>>> np.sort(a, axis=0)
array([[1, 3, 2],
[5, 4, 7],
[9, 6, 8]])
##Trier dans un tableau à une dimension
>>> np.sort(a, axis=None)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Opérations sur les éléments du tableau
Il fournit des capacités arithmétiques élémentaires pour divers éléments de tableau. Beaucoup de ces fonctionnalités peuvent également être utilisées avec chaque opérateur.
python
>>> a = np.array([1,2,3])
>>> b = np.array([4,5,6])
##Ajouter
>>> a + b ## np.add(a,b)
array([5, 7, 9])
##Soustraire
>>> b - a ## np.subtract(b,a)
array([3, 3, 3])
##Multiplier
>>> a * b ## np.multiply(a,b)
array([ 4, 10, 18])
##division
>>> b / a ## np.divide(b,a)
array([4, 2, 2])
##Surplus
>>> a % b ## np.mod(a,b)
array([1, 2, 3])
##Équitation
>>> a ** b ## np.power(a,b)
array([ 1, 32, 729])
##Inversion de signe
>>> -a ## np.negative(a)
array([-1, -2, -3])
Broadcasting Chaque opération pour les éléments de tableau ci-dessus a été effectuée entre des tableaux de même taille / forme, mais avec NumPy, il est également possible d'effectuer des opérations entre des tableaux de différentes tailles / formes, ce qui est appelé diffusion.
python
>>> a = np.array([1,2,3,4,5])
>>> b = np.array([10])
>>> a * b ## (1,5) * (1,1) = (1,5)
array([10, 20, 30, 40, 50]
>>> a = np.array([0,10,20,30]).reshape((4,1))
>>> a
array([[ 0],
[10],
[20],
[30]])
>>> b = np.array([0,1,2])
>>> a + b ## (4,1) + (1,3) = (4,3)
array([[ 0, 1, 2],
[10, 11, 12],
[20, 21, 22],
[30, 31, 32]])
##Exemples qui ne peuvent pas être diffusés
>>> b = np.array([[1,2],[3,4]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (4,1) (2,2)
Le deuxième exemple est intéressant. Si vous utilisez bien la fonction de diffusion, il semble que vous puissiez réduire considérablement la quantité de code.
Analyse des baies
L'analyse d'un tableau peut être effectuée à l'aide de la syntaxe for in, similaire à une liste.
python
>>> a = np.arange(9).reshape((3,3))
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
##liste(list)Peut être numérisé avec pour in ainsi que
##Ici on scanne ligne par ligne
>>> for row in a:
... print row
...
[0 1 2]
[3 4 5]
[6 7 8]
## numpy.ndenumerate()Analyse d'un tableau multidimensionnel avec
## enumerate()Vous pouvez obtenir l'index ainsi que
>>> for i, value in np.ndenumerate(a):
... print i, value
...
(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 3
(1, 1) 4
(1, 2) 5
(2, 0) 6
(2, 1) 7
(2, 2) 8
## ndarray.Numériser comme un tableau unidimensionnel avec plat
>>> for value in a.flat:
... print value
...
0
1
2
3
4
5
6
7
8
Fonction statistique
NumPy fournit un ensemble de fonctions pour le traitement statistique de base.
python
>>> a = np.random.randint(0,500,20)
>>> a
array([260, 253, 185, 240, 252, 375, 63, 413, 293, 431, 207, 230, 288,
462, 270, 477, 451, 58, 408, 492])
>>> np.amax(a) ##Valeur maximum
492
>>> np.amin(a) ##valeur minimum
58
>>> np.ptp(a) ##Gamme de valeurs(Valeur maximum-valeur minimum)
434
>>> np.mean(a) ##Moyenne arithmétique
305.39999999999998
>>> np.median(a) ##Médian
279.0
>>> np.std(a) ##écart-type
125.73519793597973
>>> np.var(a) ##Distribué
15809.34
>>> b = np.random.randint(0,500,20)
>>> b
array([313, 117, 167, 353, 468, 289, 177, 196, 20, 70, 235, 280, 480,
125, 195, 271, 253, 55, 49, 354])
>>> np.corrcoef(a,b) ##Coefficient de corrélation
array([[ 1. , 0.05950681],
[ 0.05950681, 1. ]])
>>> c = np.random.randint(0,10,20)
>>> c
array([3, 8, 7, 9, 1, 8, 4, 0, 8, 3, 9, 4, 2, 1, 4, 3, 0, 4, 8, 4])
>>> np.histogram(c) ##histogramme
(array([2, 2, 1, 3, 5, 0, 0, 1, 4, 2]), array([ 0. , 0.9, 1.8, 2.7, 3.6, 4.5, 5.4, 6.3, 7.2, 8.1, 9. ]))
Si vous souhaitez effectuer un traitement statistique plus avancé, vous utiliserez probablement SciPy.
Entrée / sortie de fichier
Vous pouvez également entrer et sortir des fichiers de données de tableau. Cette fonction est souvent prise en charge dans les travaux expérimentaux.
python
>>> a = np.array([[1,3,2], [4,6,5]])
>>> a
array([[1, 3, 2],
[4, 6, 5]])
## numpy.savetxt()Écrire les données du tableau dans un fichier au format ASCII avec
>>> np.savetxt('data.txt', a)
##Delimita peut être spécifié librement en option(Format TSV)
>>> np.savetxt('data.txt', a, delimiter='\t')
##Puisqu'il est au format ASCII, le contenu du fichier peut être lu par des humains.
$ cat data.txt
1.000000000000000000e+00 3.000000000000000000e+00 2.000000000000000000e+00
4.000000000000000000e+00 6.000000000000000000e+00 5.000000000000000000e+00
## numpy.loadtxt()Lire les données du tableau à partir d'un fichier texte avec
>>> np.loadtxt('data.txt', delimiter='\t')
array([[ 1., 3., 2.],
[ 4., 6., 5.]])
## numpy.save()Écrire des données de tableau dans un fichier au format binaire avec
##L'extension du fichier de sortie est.Devenez npy
>>> np.save('data', a)
## numpy.load()Lire les données du tableau à partir d'un fichier binaire avec
>>> np.load('data.npy')
array([[1, 3, 2],
[4, 6, 5]])
## numpy.savez()Écrire plusieurs données de tableau dans un fichier au format binaire avec
>>> a, y = np.meshgrid([1,2,3], [4,5,6,7])
>>> a
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> y
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])
##L'extension du fichier de sortie est.devient npz
>>> np.savez('data', x=x, y=y)
## .npy, .Les deux fichiers npz sont numpy.load()Peut être lu par
>>> npz = np.load('data.npz')
>>> npz.files
['y', 'x']
>>> npz['x']
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> npz['y']
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])
Lorsque vous enregistrez une énorme quantité de données, il est préférable de les enregistrer au format binaire car la taille du fichier sera plus petite.
Cette fois, j'ai essayé d'organiser les bases de NumPy. J'utilise rarement NumPy seul, mais je suis souvent pris en charge lors de l'utilisation des liaisons Python d'OpenCV. Puisque NumPy a beaucoup de fonctions, il semble qu'il soit nécessaire de se référer à chaque fois à la référence officielle et de l'utiliser.
Recommended Posts