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

numpy-sm.pngScientificComputingToolsForPython—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)?

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.

(* 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.

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

Introduction à la bibliothèque de calcul numérique Python NumPy
[Introduction à Python] <numpy ndarray> [modifier le 22/02/2020]
[Introduction à l'application Udemy Python3 +] 10. Valeur numérique
Introduction au langage Python
Introduction à OpenCV (python) - (2)
Introduction à Python Django (2) Win
Convertir numpy int64 en python int
Introduction à la communication série [Python]
[Introduction à Python] <liste> [modifier le 22/02/2020]
Introduction à Python (version Python APG4b)
Une introduction à la programmation Python
Introduction à Python pour, pendant
[Introduction à Python] Utilisation basique de la bibliothèque matplotlib
Introduction à Python numpy pandas matplotlib (pour ~ B3 ~ part2)
[Présentation de l'application Udemy Python3 +] 58. Lambda
[Présentation de l'application Udemy Python3 +] 31. Commentaire
Accès en indice au tableau numpy python
Entraine toi! !! Introduction au type Python (conseils de type)
[Introduction à Python3 Jour 1] Programmation et Python
[Présentation de l'application Udemy Python3 +] 57. Décorateur
Introduction à Python Hands On Partie 1
[Introduction à Python3 Jour 13] Chapitre 7 Chaînes de caractères (7.1-7.1.1.1)
Comment utiliser les requêtes (bibliothèque Python)
[Introduction à Python] Comment analyser JSON
[Présentation de l'application Udemy Python3 +] 56. Clôture
[Introduction à Python3 Jour 14] Chapitre 7 Chaînes de caractères (7.1.1.1 à 7.1.1.4)
Introduction à Protobuf-c (langage C ⇔ Python)
[Présentation de l'application Udemy Python3 +] 59. Générateur
[Introduction à Python3 Jour 15] Chapitre 7 Chaînes de caractères (7.1.2-7.1.2.2)
[Introduction à Python] Utilisons les pandas
Présentation de la bibliothèque d'apprentissage automatique SHOGUN
[Introduction à Python] Utilisons les pandas
[Introduction à l'application Udemy Python3 +] Résumé
Introduction à l'analyse d'image opencv python
[Introduction à Python] Utilisons les pandas
Premiers pas avec Python pour les non-ingénieurs
Introduction à Python Django (2) Édition Mac
[AWS SAM] Présentation de la version Python
[Introduction à Python3 Day 21] Chapitre 10 Système (10.1 à 10.5)
[Tutoriel Python] Une introduction facile à Python
[Introduction à Udemy Python3 + Application] 18. Méthode List
[Introduction à Udemy Python3 + Application] 63. Notation d'inclusion du générateur
[Introduction à l'application Udemy Python3 +] 28. Type collectif
[Introduction à Python] Comment utiliser la classe en Python?
[Introduction à Udemy Python3 + Application] 25. Méthode de type dictionnaire
[Introduction à l'application Udemy Python3 +] 33. instruction if
Introduction à la simulation d'événements discrets à l'aide de Python # 1
[Introduction à Udemy Python3 + Application] 13. Méthode de caractères
[Introduction à Python3, jour 17] Chapitre 8 Destinations de données (8.1-8.2.5)
[Introduction à l'application Udemy Python3 +] 55. Fonctions intégrées
[Introduction à l'application Udemy Python3 +] 48. Définition des fonctions
[Introduction à Python3, jour 17] Chapitre 8 Destinations de données (8.3-8.3.6.1)
Super Introduction Arithmétique Bit Python
Introduction au remplissage d'image Python Remplissage d'image à l'aide d'ImageDataGenerator
Web-WF Python Tornado Partie 3 (Introduction à Openpyexcel)
[Introduction à l'application Udemy Python3 +] 21. Type Taple
[Introduction à l'application Udemy Python3 +] 45. fonction enumerate
[Introduction à l'application Udemy Python3 +] 41. fonction d'entrée
[Introduction à Python] Utilisons foreach avec Python