NumPy - Guide rapide
NumPy est un package Python. Il signifie «Python numérique». Il s'agit d'une bibliothèque composée d'objets de tableau multidimensionnel et d'une collection de routines pour le traitement de tableau.
Numeric, l'ancêtre de NumPy, a été développé par Jim Hugunin. Un autre package Numarray a également été développé, avec quelques fonctionnalités supplémentaires. En 2005, Travis Oliphant a créé le package NumPy en incorporant les fonctionnalités de Numarray dans le package Numeric. Il existe de nombreux contributeurs à ce projet open source.
Opérations utilisant NumPy
En utilisant NumPy, un développeur peut effectuer les opérations suivantes -
Opérations mathématiques et logiques sur les tableaux.
Transformations de Fourier et routines pour la manipulation de formes.
Opérations liées à l'algèbre linéaire. NumPy a des fonctions intégrées pour l'algèbre linéaire et la génération de nombres aléatoires.
NumPy - Un remplacement pour MatLab
NumPy est souvent utilisé avec des packages comme SciPy (Python scientifique) et Mat−plotlib(bibliothèque de traçage). Cette combinaison est largement utilisée en remplacement de MatLab, une plate-forme populaire pour l'informatique technique. Cependant, l'alternative Python à MatLab est désormais considérée comme un langage de programmation plus moderne et complet.
Il est open source, ce qui est un avantage supplémentaire de NumPy.
La distribution Python standard n'est pas fournie avec le module NumPy. Une alternative légère consiste à installer NumPy à l'aide du programme d'installation de package Python populaire,pip.
pip install numpy
La meilleure façon d'activer NumPy est d'utiliser un package binaire installable spécifique à votre système d'exploitation. Ces binaires contiennent une pile SciPy complète (y compris les packages NumPy, SciPy, matplotlib, IPython, SymPy et nose avec le noyau Python).
les fenêtres
Anaconda (à partir de https://www.continuum.io) est une distribution Python gratuite pour la pile SciPy. Il est également disponible pour Linux et Mac.
Canopée (https://www.enthought.com/products/canopy/) est disponible en tant que distribution gratuite et commerciale avec une pile SciPy complète pour Windows, Linux et Mac.
Python (x, y): Il s'agit d'une distribution Python gratuite avec la pile SciPy et Spyder IDE pour Windows OS. (Téléchargeable depuishttps://www.python-xy.github.io/)
Linux
Les gestionnaires de packages des distributions Linux respectives sont utilisés pour installer un ou plusieurs packages dans la pile SciPy.
Pour Ubuntu
sudo apt-get install python-numpy
python-scipy python-matplotlibipythonipythonnotebook python-pandas
python-sympy python-nose
Pour Fedora
sudo yum install numpyscipy python-matplotlibipython
python-pandas sympy python-nose atlas-devel
Construire à partir de la source
Core Python (à partir de 2.6.x, 2.7.x et 3.2.x) doit être installé avec distutils et le module zlib doit être activé.
Le compilateur C GNU gcc (4.2 et supérieur) doit être disponible.
Pour installer NumPy, exécutez la commande suivante.
Python setup.py install
Pour tester si le module NumPy est correctement installé, essayez de l'importer à partir de l'invite Python.
import numpy
S'il n'est pas installé, le message d'erreur suivant s'affiche.
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
import numpy
ImportError: No module named 'numpy'
Sinon, le package NumPy est importé en utilisant la syntaxe suivante -
import numpy as np
L'objet le plus important défini dans NumPy est un type de tableau à N dimensions appelé ndarray. Il décrit la collection d'objets du même type. Les éléments de la collection sont accessibles à l'aide d'un index de base zéro.
Chaque élément d'un ndarray prend la même taille de bloc dans la mémoire. Chaque élément de ndarray est un objet d'objet de type données (appelédtype).
Tout élément extrait de l'objet ndarray (par découpage) est représenté par un objet Python de l'un des types scalaires de tableau. Le diagramme suivant montre une relation entre ndarray, objet de type de données (dtype) et type scalaire de tableau -
Une instance de la classe ndarray peut être construite par différentes routines de création de tableau décrites plus loin dans le didacticiel. Le ndarray de base est créé à l'aide d'une fonction de tableau dans NumPy comme suit -
numpy.array
Il crée un ndarray à partir de n'importe quel objet exposant une interface de tableau, ou de toute méthode qui renvoie un tableau.
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
Le constructeur ci-dessus prend les paramètres suivants -
Sr.No. | Paramètre et description |
---|---|
1 | object Tout objet exposant la méthode d'interface de tableau renvoie un tableau ou toute séquence (imbriquée). |
2 | dtype Type de données de tableau souhaité, facultatif |
3 | copy Optionnel. Par défaut (vrai), l'objet est copié |
4 | order C (ligne principale) ou F (colonne principale) ou A (n'importe quel) (par défaut) |
5 | subok Par défaut, le tableau renvoyé est forcé d'être un tableau de classe de base. Si vrai, les sous-classes sont passées par |
6 | ndmin Spécifie les dimensions minimales du tableau résultant |
Jetez un œil aux exemples suivants pour mieux comprendre.
Exemple 1
import numpy as np
a = np.array([1,2,3])
print a
La sortie est la suivante -
[1, 2, 3]
Exemple 2
# more than one dimensions
import numpy as np
a = np.array([[1, 2], [3, 4]])
print a
La sortie est la suivante -
[[1, 2]
[3, 4]]
Exemple 3
# minimum dimensions
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
print a
La sortie est la suivante -
[[1, 2, 3, 4, 5]]
Exemple 4
# dtype parameter
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print a
La sortie est la suivante -
[ 1.+0.j, 2.+0.j, 3.+0.j]
le ndarrayobjet se compose d'un segment unidimensionnel contigu de la mémoire de l'ordinateur, combiné avec un schéma d'indexation qui mappe chaque élément à un emplacement dans le bloc de mémoire. Le bloc de mémoire contient les éléments dans un ordre principal de ligne (style C) ou dans un ordre de colonne principale (style FORTRAN ou MatLab).
NumPy prend en charge une plus grande variété de types numériques que Python. Le tableau suivant présente les différents types de données scalaires définis dans NumPy.
Sr.No. | Types de données et description |
---|---|
1 | bool_ Boolean (True ou False) stocké sous forme d'octet |
2 | int_ Type entier par défaut (identique à C long; normalement soit int64 ou int32) |
3 | intc Identique à C int (normalement int32 ou int64) |
4 | intp Entier utilisé pour l'indexation (identique à C ssize_t; normalement soit int32 ou int64) |
5 | int8 Octet (-128 à 127) |
6 | int16 Entier (-32768 à 32767) |
sept | int32 Entier (-2147483648 à 2147483647) |
8 | int64 Entier (-9223372036854775808 à 9223372036854775807) |
9 | uint8 Entier non signé (0 à 255) |
dix | uint16 Entier non signé (0 à 65535) |
11 | uint32 Entier non signé (0 à 4294967295) |
12 | uint64 Entier non signé (0 à 18446744073709551615) |
13 | float_ Raccourci pour float64 |
14 | float16 Flottant demi-précision: bit de signe, exposant 5 bits, mantisse 10 bits |
15 | float32 Flotteur simple précision: bit de signe, exposant 8 bits, mantisse 23 bits |
16 | float64 Flottant double précision: bit de signe, exposant 11 bits, mantisse 52 bits |
17 | complex_ Raccourci pour complex128 |
18 | complex64 Nombre complexe, représenté par deux flottants 32 bits (composants réels et imaginaires) |
19 | complex128 Nombre complexe, représenté par deux flottants 64 bits (composants réels et imaginaires) |
Les types numériques NumPy sont des instances d'objets dtype (type de données), chacun ayant des caractéristiques uniques. Les dtypes sont disponibles sous les noms np.bool_, np.float32, etc.
Objets de type de données (dtype)
Un objet de type de données décrit l'interprétation d'un bloc fixe de mémoire correspondant à un tableau, en fonction des aspects suivants -
Type de données (entier, flottant ou objet Python)
Taille des données
Ordre des octets (petit-boutiste ou grand-boutiste)
En cas de type structuré, les noms des champs, le type de données de chaque champ et une partie du bloc mémoire prise par chaque champ.
Si le type de données est un sous-tableau, sa forme et son type de données
L'ordre des octets est décidé en préfixant «<» ou «>» au type de données. '<' signifie que le codage est petit-boutiste (le moins significatif est stocké dans la plus petite adresse). '>' signifie que l'encodage est big-endian (l'octet le plus significatif est stocké dans la plus petite adresse).
Un objet dtype est construit en utilisant la syntaxe suivante -
numpy.dtype(object, align, copy)
Les paramètres sont -
Object - À convertir en objet de type de données
Align - Si vrai, ajoute un remplissage au champ pour le rendre similaire à C-struct
Copy- Crée une nouvelle copie de l'objet dtype. Si false, le résultat est une référence à un objet de type de données intégré
Exemple 1
# using array-scalar type
import numpy as np
dt = np.dtype(np.int32)
print dt
La sortie est la suivante -
int32
Exemple 2
#int8, int16, int32, int64 can be replaced by equivalent string 'i1', 'i2','i4', etc.
import numpy as np
dt = np.dtype('i4')
print dt
La sortie est la suivante -
int32
Exemple 3
# using endian notation
import numpy as np
dt = np.dtype('>i4')
print dt
La sortie est la suivante -
>i4
Les exemples suivants illustrent l'utilisation du type de données structurées. Ici, le nom du champ et le type de données scalaire correspondant doivent être déclarés.
Exemple 4
# first create structured data type
import numpy as np
dt = np.dtype([('age',np.int8)])
print dt
La sortie est la suivante -
[('age', 'i1')]
Exemple 5
# now apply it to ndarray object
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a
La sortie est la suivante -
[(10,) (20,) (30,)]
Exemple 6
# file name can be used to access content of age column
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a['age']
La sortie est la suivante -
[10 20 30]
Exemple 7
Les exemples suivants définissent un type de données structurées appelé student avec un champ de chaîne 'nom', un integer field 'age' et un float field'Des marques'. Ce dtype est appliqué à l'objet ndarray.
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print student
La sortie est la suivante -
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
Exemple 8
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print a
La sortie est la suivante -
[('abc', 21, 50.0), ('xyz', 18, 75.0)]
Chaque type de données intégré a un code de caractère qui l'identifie de manière unique.
'b' - booléen
'i' - entier (signé)
'u' - entier non signé
'f' - virgule flottante
'c' - virgule flottante complexe
'm' - timedelta
'M' - date / heure
'O' - (Python) objets
'S', 'a' - Chaîne (octet-)
'U' - Unicode
'V' - données brutes (nulles)
Dans ce chapitre, nous aborderons les différents attributs de tableau de NumPy.
ndarray.shape
Cet attribut de tableau renvoie un tuple composé de dimensions de tableau. Il peut également être utilisé pour redimensionner le tableau.
Exemple 1
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print a.shape
La sortie est la suivante -
(2, 3)
Exemple 2
# this resizes the ndarray
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print a
La sortie est la suivante -
[[1, 2]
[3, 4]
[5, 6]]
Exemple 3
NumPy fournit également une fonction de remodelage pour redimensionner un tableau.
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print b
La sortie est la suivante -
[[1, 2]
[3, 4]
[5, 6]]
ndarray.ndim
Cet attribut de tableau renvoie le nombre de dimensions de tableau.
Exemple 1
# an array of evenly spaced numbers
import numpy as np
a = np.arange(24)
print a
La sortie est la suivante -
[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
Exemple 2
# this is one dimensional array
import numpy as np
a = np.arange(24)
a.ndim
# now reshape it
b = a.reshape(2,4,3)
print b
# b is having three dimensions
La sortie est la suivante -
[[[ 0, 1, 2]
[ 3, 4, 5]
[ 6, 7, 8]
[ 9, 10, 11]]
[[12, 13, 14]
[15, 16, 17]
[18, 19, 20]
[21, 22, 23]]]
numpy.itemsize
Cet attribut de tableau renvoie la longueur de chaque élément du tableau en octets.
Exemple 1
# dtype of array is int8 (1 byte)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.int8)
print x.itemsize
La sortie est la suivante -
1
Exemple 2
# dtype of array is now float32 (4 bytes)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.float32)
print x.itemsize
La sortie est la suivante -
4
numpy.flags
L'objet ndarray a les attributs suivants. Ses valeurs actuelles sont renvoyées par cette fonction.
Sr.No. | Attribut et description |
---|---|
1 | C_CONTIGUOUS (C) Les données se trouvent dans un seul segment contigu de style C |
2 | F_CONTIGUOUS (F) Les données se trouvent dans un seul segment contigu de style Fortran |
3 | OWNDATA (O) Le tableau possède la mémoire qu'il utilise ou l'emprunte à un autre objet |
4 | WRITEABLE (W) La zone de données peut être écrite. La définition de ce paramètre sur False verrouille les données, les rendant en lecture seule |
5 | ALIGNED (A) Les données et tous les éléments sont alignés de manière appropriée pour le matériel |
6 | UPDATEIFCOPY (U) Ce tableau est une copie d'un autre tableau. Lorsque ce tableau est désalloué, le tableau de base sera mis à jour avec le contenu de ce tableau |
Exemple
L'exemple suivant montre les valeurs actuelles des indicateurs.
import numpy as np
x = np.array([1,2,3,4,5])
print x.flags
La sortie est la suivante -
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
Un nouveau ndarray L'objet peut être construit par l'une des routines de création de tableau suivantes ou en utilisant un constructeur ndarray de bas niveau.
numpy.empty
Il crée un tableau non initialisé de forme et de type spécifié. Il utilise le constructeur suivant -
numpy.empty(shape, dtype = float, order = 'C')
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | Shape Forme d'un tableau vide en int ou tuple de int |
2 | Dtype Type de données de sortie souhaité. Optionnel |
3 | Order 'C' pour le tableau principal de ligne de style C, 'F' pour le tableau principal de colonne de style FORTRAN |
Exemple
Le code suivant montre un exemple de tableau vide.
import numpy as np
x = np.empty([3,2], dtype = int)
print x
La sortie est la suivante -
[[22649312 1701344351]
[1818321759 1885959276]
[16779776 156368896]]
Note - Les éléments d'un tableau affichent des valeurs aléatoires car ils ne sont pas initialisés.
numpy.zeros
Renvoie un nouveau tableau de la taille spécifiée, rempli de zéros.
numpy.zeros(shape, dtype = float, order = 'C')
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | Shape Forme d'un tableau vide en int ou séquence de int |
2 | Dtype Type de données de sortie souhaité. Optionnel |
3 | Order 'C' pour le tableau principal de ligne de style C, 'F' pour le tableau principal de colonne de style FORTRAN |
Exemple 1
# array of five zeros. Default dtype is float
import numpy as np
x = np.zeros(5)
print x
La sortie est la suivante -
[ 0. 0. 0. 0. 0.]
Exemple 2
import numpy as np
x = np.zeros((5,), dtype = np.int)
print x
Maintenant, la sortie serait la suivante -
[0 0 0 0 0]
Exemple 3
# custom type
import numpy as np
x = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print x
Il devrait produire la sortie suivante -
[[(0,0)(0,0)]
[(0,0)(0,0)]]
numpy.ones
Renvoie un nouveau tableau de taille et de type spécifiés, rempli de uns.
numpy.ones(shape, dtype = None, order = 'C')
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | Shape Forme d'un tableau vide en int ou tuple de int |
2 | Dtype Type de données de sortie souhaité. Optionnel |
3 | Order 'C' pour le tableau principal de ligne de style C, 'F' pour le tableau principal de colonne de style FORTRAN |
Exemple 1
# array of five ones. Default dtype is float
import numpy as np
x = np.ones(5)
print x
La sortie est la suivante -
[ 1. 1. 1. 1. 1.]
Exemple 2
import numpy as np
x = np.ones([2,2], dtype = int)
print x
Maintenant, la sortie serait la suivante -
[[1 1]
[1 1]]
Dans ce chapitre, nous verrons comment créer un tableau à partir de données existantes.
numpy.asarray
Cette fonction est similaire à numpy.array, sauf qu'elle a moins de paramètres. Cette routine est utile pour convertir une séquence Python en ndarray.
numpy.asarray(a, dtype = None, order = None)
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | a Données d'entrée sous n'importe quelle forme telle que liste, liste de tuples, tuples, tuple de tuples ou tuple de listes |
2 | dtype Par défaut, le type de données des données d'entrée est appliqué au ndarray résultant |
3 | order C (ligne principale) ou F (colonne principale). C est la valeur par défaut |
Les exemples suivants montrent comment utiliser le asarray fonction.
Exemple 1
# convert list to ndarray
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print a
Sa sortie serait la suivante -
[1 2 3]
Exemple 2
# dtype is set
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print a
Maintenant, la sortie serait la suivante -
[ 1. 2. 3.]
Exemple 3
# ndarray from tuple
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print a
Sa sortie serait -
[1 2 3]
Exemple 4
# ndarray from list of tuples
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print a
Ici, la sortie serait la suivante -
[(1, 2, 3) (4, 5)]
numpy.frombuffer
Cette fonction interprète un tampon comme un tableau unidimensionnel. Tout objet qui expose l'interface tampon est utilisé comme paramètre pour renvoyer unndarray.
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | buffer Tout objet qui expose l'interface de la mémoire tampon |
2 | dtype Type de données du ndarray renvoyé. Par défaut, float |
3 | count Le nombre d'éléments à lire, par défaut -1 signifie toutes les données |
4 | offset La position de départ à partir de laquelle lire. La valeur par défaut est 0 |
Exemple
Les exemples suivants illustrent l'utilisation de frombuffer fonction.
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print a
Voici sa sortie -
['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
numpy.fromiter
Cette fonction construit un ndarrayobjet de tout objet itérable. Un nouveau tableau unidimensionnel est renvoyé par cette fonction.
numpy.fromiter(iterable, dtype, count = -1)
Ici, le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | iterable Tout objet itérable |
2 | dtype Type de données du tableau résultant |
3 | count Le nombre d'éléments à lire à partir de l'itérateur. La valeur par défaut est -1, ce qui signifie que toutes les données doivent être lues |
Les exemples suivants montrent comment utiliser la fonction intégrée range()fonction pour renvoyer un objet de liste. Un itérateur de cette liste est utilisé pour former unndarray objet.
Exemple 1
# create list object using range function
import numpy as np
list = range(5)
print list
Sa sortie est la suivante -
[0, 1, 2, 3, 4]
Exemple 2
# obtain iterator object from list
import numpy as np
list = range(5)
it = iter(list)
# use iterator to create ndarray
x = np.fromiter(it, dtype = float)
print x
Maintenant, la sortie serait la suivante -
[0. 1. 2. 3. 4.]
Dans ce chapitre, nous verrons comment créer un tableau à partir de plages numériques.
numpy.arange
Cette fonction renvoie un ndarrayobjet contenant des valeurs régulièrement espacées dans une plage donnée. Le format de la fonction est le suivant -
numpy.arange(start, stop, step, dtype)
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | start Le début d'un intervalle. Si omis, la valeur par défaut est 0 |
2 | stop La fin d'un intervalle (sans compter ce nombre) |
3 | step Espacement entre les valeurs, la valeur par défaut est 1 |
4 | dtype Type de données du ndarray résultant. S'il n'est pas indiqué, le type de données d'entrée est utilisé |
Les exemples suivants montrent comment utiliser cette fonction.
Exemple 1
import numpy as np
x = np.arange(5)
print x
Sa sortie serait la suivante -
[0 1 2 3 4]
Exemple 2
import numpy as np
# dtype set
x = np.arange(5, dtype = float)
print x
Ici, la sortie serait -
[0. 1. 2. 3. 4.]
Exemple 3
# start and stop parameters set
import numpy as np
x = np.arange(10,20,2)
print x
Sa sortie est la suivante -
[10 12 14 16 18]
numpy.linspace
Cette fonction est similaire à arange()fonction. Dans cette fonction, au lieu de la taille de pas, le nombre de valeurs régulièrement espacées entre l'intervalle est spécifié. L'utilisation de cette fonction est la suivante -
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
Le constructeur prend les paramètres suivants.
Sr.No. | Paramètre et description |
---|---|
1 | start La valeur de départ de la séquence |
2 | stop La valeur finale de la séquence, incluse dans la séquence si le point final est défini sur true |
3 | num Le nombre d'échantillons régulièrement espacés à générer. La valeur par défaut est 50 |
4 | endpoint Vrai par défaut, la valeur d'arrêt est donc incluse dans la séquence. Si faux, il n'est pas inclus |
5 | retstep Si vrai, renvoie des échantillons et passe entre les nombres consécutifs |
6 | dtype Type de données de sortie ndarray |
Les exemples suivants illustrent l'utilisation linspace fonction.
Exemple 1
import numpy as np
x = np.linspace(10,20,5)
print x
Sa sortie serait -
[10. 12.5 15. 17.5 20.]
Exemple 2
# endpoint set to false
import numpy as np
x = np.linspace(10,20, 5, endpoint = False)
print x
La sortie serait -
[10. 12. 14. 16. 18.]
Exemple 3
# find retstep value
import numpy as np
x = np.linspace(1,2,5, retstep = True)
print x
# retstep here is 0.25
Maintenant, la sortie serait -
(array([ 1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)
numpy.logspace
Cette fonction renvoie un ndarrayobjet contenant les nombres régulièrement espacés sur une échelle logarithmique. Les points de fin de début et d'arrêt de l'échelle sont des indices de la base, généralement 10.
numpy.logspace(start, stop, num, endpoint, base, dtype)
Les paramètres suivants déterminent la sortie de logspace fonction.
Sr.No. | Paramètre et description |
---|---|
1 | start Le point de départ de la séquence est le début de base |
2 | stop La valeur finale de la séquence est l' arrêt de base |
3 | num Le nombre de valeurs entre la plage. La valeur par défaut est 50 |
4 | endpoint Si vrai, stop est la dernière valeur de la plage |
5 | base Base de l'espace journal, la valeur par défaut est 10 |
6 | dtype Type de données du tableau de sortie. S'il n'est pas donné, cela dépend d'autres arguments d'entrée |
Les exemples suivants vous aideront à comprendre logspace fonction.
Exemple 1
import numpy as np
# default base is 10
a = np.logspace(1.0, 2.0, num = 10)
print a
Sa sortie serait la suivante -
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
Exemple 2
# set base of log space to 2
import numpy as np
a = np.logspace(1,10,num = 10, base = 2)
print a
Maintenant, la sortie serait -
[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]
Le contenu de l'objet ndarray peut être consulté et modifié par indexation ou découpage, tout comme les objets conteneurs intégrés de Python.
Comme mentionné précédemment, les éléments de l'objet ndarray suivent un index de base zéro. Trois types de méthodes d'indexation sont disponibles -field access, basic slicing et advanced indexing.
Le découpage de base est une extension du concept de base de Python de découpage en n dimensions. Un objet de tranche Python est construit en donnantstart, stop, et step paramètres au intégré slicefonction. Cet objet slice est passé au tableau pour extraire une partie du tableau.
Exemple 1
import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print a[s]
Sa sortie est la suivante -
[2 4 6]
Dans l'exemple ci-dessus, un ndarray l'objet est préparé par arange()fonction. Ensuite, un objet de tranche est défini avec les valeurs de démarrage, d'arrêt et de pas respectivement 2, 7 et 2. Lorsque cet objet slice est passé au ndarray, une partie de celui-ci commençant par les index 2 jusqu'à 7 avec un pas de 2 est découpée.
Le même résultat peut également être obtenu en donnant les paramètres de découpage séparés par deux points: (start: stop: step) directement au ndarray objet.
Exemple 2
import numpy as np
a = np.arange(10)
b = a[2:7:2]
print b
Ici, nous obtiendrons le même résultat -
[2 4 6]
Si un seul paramètre est mis, un seul élément correspondant à l'index sera renvoyé. Si un: est inséré devant lui, tous les éléments de cet index seront extraits. Si deux paramètres (avec: entre eux) sont utilisés, les éléments entre les deux index (sans compter l'index d'arrêt) avec la première étape par défaut sont découpés.
Exemple 3
# slice single item
import numpy as np
a = np.arange(10)
b = a[5]
print b
Sa sortie est la suivante -
5
Exemple 4
# slice items starting from index
import numpy as np
a = np.arange(10)
print a[2:]
Maintenant, la sortie serait -
[2 3 4 5 6 7 8 9]
Exemple 5
# slice items between indexes
import numpy as np
a = np.arange(10)
print a[2:5]
Ici, la sortie serait -
[2 3 4]
La description ci-dessus s'applique aux ndarray aussi.
Exemple 6
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print a
# slice items starting from index
print 'Now we will slice the array from the index a[1:]'
print a[1:]
La sortie est la suivante -
[[1 2 3]
[3 4 5]
[4 5 6]]
Now we will slice the array from the index a[1:]
[[3 4 5]
[4 5 6]]
Le découpage peut également inclure des points de suspension (…) pour créer un tuple de sélection de la même longueur que la dimension d'un tableau. Si des points de suspension sont utilisés à la position de la ligne, il renverra un ndarray comprenant des éléments en lignes.
Exemple 7
# array to begin with
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print 'Our array is:'
print a
print '\n'
# this returns array of items in the second column
print 'The items in the second column are:'
print a[...,1]
print '\n'
# Now we will slice all items from the second row
print 'The items in the second row are:'
print a[1,...]
print '\n'
# Now we will slice all items from column 1 onwards
print 'The items column 1 onwards are:'
print a[...,1:]
La sortie de ce programme est la suivante -
Our array is:
[[1 2 3]
[3 4 5]
[4 5 6]]
The items in the second column are:
[2 4 5]
The items in the second row are:
[3 4 5]
The items column 1 onwards are:
[[2 3]
[4 5]
[5 6]]
Il est possible de faire une sélection à partir de ndarray qui est une séquence non-tuple, un objet ndarray de type de données entier ou booléen, ou un tuple avec au moins un élément étant un objet séquence. L'indexation avancée renvoie toujours une copie des données. Par contre, le tranchage ne présente qu'une vue.
Il existe deux types d'indexation avancée - Integer et Boolean.
Indexation entière
Ce mécanisme aide à sélectionner n'importe quel élément arbitraire dans un tableau en fonction de son index à N dimensions. Chaque tableau d'entiers représente le nombre d'index dans cette dimension. Lorsque l'index se compose d'autant de tableaux d'entiers que les dimensions du ndarray cible, cela devient simple.
Dans l'exemple suivant, un élément de la colonne spécifiée de chaque ligne de l'objet ndarray est sélectionné. Par conséquent, l'index de ligne contient tous les numéros de ligne et l'index de colonne spécifie l'élément à sélectionner.
Exemple 1
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print y
Sa sortie serait la suivante -
[1 4 5]
La sélection comprend des éléments en (0,0), (1,1) et (2,0) du premier tableau.
Dans l'exemple suivant, les éléments placés aux coins d'un tableau 4X3 sont sélectionnés. Les indices de sélection de ligne sont [0, 0] et [3,3] tandis que les indices de colonne sont [0,2] et [0,2].
Exemple 2
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print 'Our array is:'
print x
print '\n'
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print 'The corner elements of this array are:'
print y
La sortie de ce programme est la suivante -
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
The corner elements of this array are:
[[ 0 2]
[ 9 11]]
La sélection résultante est un objet ndarray contenant des éléments d'angle.
L'indexation avancée et basique peut être combinée en utilisant une tranche (:) ou des points de suspension (…) avec un tableau d'index. L'exemple suivant utilise une tranche pour la ligne et un index avancé pour la colonne. Le résultat est le même lorsque slice est utilisé pour les deux. Mais l'index avancé entraîne une copie et peut avoir une disposition de mémoire différente.
Exemple 3
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print 'Our array is:'
print x
print '\n'
# slicing
z = x[1:4,1:3]
print 'After slicing, our array becomes:'
print z
print '\n'
# using advanced index for column
y = x[1:4,[1,2]]
print 'Slicing using advanced index for column:'
print y
Le résultat de ce programme serait le suivant -
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
After slicing, our array becomes:
[[ 4 5]
[ 7 8]
[10 11]]
Slicing using advanced index for column:
[[ 4 5]
[ 7 8]
[10 11]]
Indexation de tableaux booléens
Ce type d'indexation avancée est utilisé lorsque l'objet résultant est censé être le résultat d'opérations booléennes, telles que des opérateurs de comparaison.
Exemple 1
Dans cet exemple, les éléments supérieurs à 5 sont renvoyés suite à l'indexation booléenne.
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print 'Our array is:'
print x
print '\n'
# Now we will print the items greater than 5
print 'The items greater than 5 are:'
print x[x > 5]
Le résultat de ce programme serait -
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
The items greater than 5 are:
[ 6 7 8 9 10 11]
Exemple 2
Dans cet exemple, les éléments NaN (Not a Number) sont omis à l'aide de ~ (opérateur de complément).
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print a[~np.isnan(a)]
Sa sortie serait -
[ 1. 2. 3. 4. 5.]
Exemple 3
L'exemple suivant montre comment filtrer les éléments non complexes d'un tableau.
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print a[np.iscomplex(a)]
Ici, la sortie est la suivante -
[2.0+6.j 3.5+5.j]
Le terme broadcastingfait référence à la capacité de NumPy à traiter des tableaux de différentes formes lors d'opérations arithmétiques. Les opérations arithmétiques sur les tableaux sont généralement effectuées sur les éléments correspondants. Si deux tableaux ont exactement la même forme, ces opérations sont effectuées en douceur.
Exemple 1
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print c
Sa sortie est la suivante -
[10 40 90 160]
Si les dimensions de deux tableaux sont différentes, les opérations élément à élément ne sont pas possibles. Cependant, les opérations sur des tableaux de formes non similaires sont toujours possibles dans NumPy, en raison de la capacité de diffusion. Le plus petit tableau estbroadcast à la taille du plus grand tableau afin qu'ils aient des formes compatibles.
La diffusion est possible si les règles suivantes sont respectées -
Array avec plus petit ndim que l'autre est précédé de «1» dans sa forme.
La taille de chaque dimension de la forme de sortie correspond au maximum des tailles d'entrée de cette dimension.
Une entrée peut être utilisée dans le calcul, si sa taille dans une dimension particulière correspond à la taille de sortie ou si sa valeur est exactement 1.
Si une entrée a une taille de dimension de 1, la première entrée de données dans cette dimension est utilisée pour tous les calculs le long de cette dimension.
On dit qu'un ensemble de tableaux est broadcastable si les règles ci-dessus produisent un résultat valide et que l'une des conditions suivantes est vraie -
Les tableaux ont exactement la même forme.
Les tableaux ont le même nombre de dimensions et la longueur de chaque dimension est soit une longueur commune, soit 1.
Un tableau ayant trop peu de dimensions peut avoir sa forme précédée d'une dimension de longueur 1, de sorte que la propriété indiquée ci-dessus est vraie.
Le programme suivant montre un exemple de diffusion.
Exemple 2
import numpy as np
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])
b = np.array([1.0,2.0,3.0])
print 'First array:'
print a
print '\n'
print 'Second array:'
print b
print '\n'
print 'First Array + Second Array'
print a + b
Le résultat de ce programme serait le suivant -
First array:
[[ 0. 0. 0.]
[ 10. 10. 10.]
[ 20. 20. 20.]
[ 30. 30. 30.]]
Second array:
[ 1. 2. 3.]
First Array + Second Array
[[ 1. 2. 3.]
[ 11. 12. 13.]
[ 21. 22. 23.]
[ 31. 32. 33.]]
La figure suivante montre comment le tableau b est diffusé pour devenir compatible avec a.
Le package NumPy contient un objet itérateur numpy.nditer. C'est un objet itérateur multidimensionnel efficace à l'aide duquel il est possible d'itérer sur un tableau. Chaque élément d'un tableau est visité à l'aide de l'interface Iterator standard de Python.
Créons un tableau 3X4 en utilisant la fonction arange () et itérons dessus en utilisant nditer.
Exemple 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Modified array is:'
for x in np.nditer(a):
print x,
La sortie de ce programme est la suivante -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55
Exemple 2
L'ordre d'itération est choisi pour correspondre à la disposition de la mémoire d'un tableau, sans tenir compte d'un ordre particulier. Cela peut être vu en itérant sur la transposition du tableau ci-dessus.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Transpose of the original array is:'
b = a.T
print b
print '\n'
print 'Modified array is:'
for x in np.nditer(b):
print x,
La sortie du programme ci-dessus est la suivante -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Transpose of the original array is:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55
Ordre d'itération
Si les mêmes éléments sont stockés en utilisant l'ordre de style F, l'itérateur choisit la manière la plus efficace d'itérer sur un tableau.
Exemple 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Transpose of the original array is:'
b = a.T
print b
print '\n'
print 'Sorted in C-style order:'
c = b.copy(order='C')
print c
for x in np.nditer(c):
print x,
print '\n'
print 'Sorted in F-style order:'
c = b.copy(order='F')
print c
for x in np.nditer(c):
print x,
Sa sortie serait la suivante -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Transpose of the original array is:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
Sorted in C-style order:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
Sorted in F-style order:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55
Exemple 2
Il est possible de forcer nditer object pour utiliser un ordre spécifique en le mentionnant explicitement.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Sorted in C-style order:'
for x in np.nditer(a, order = 'C'):
print x,
print '\n'
print 'Sorted in F-style order:'
for x in np.nditer(a, order = 'F'):
print x,
Sa sortie serait -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Sorted in C-style order:
0 5 10 15 20 25 30 35 40 45 50 55
Sorted in F-style order:
0 20 40 5 25 45 10 30 50 15 35 55
Modification des valeurs de tableau
le nditer object a un autre paramètre facultatif appelé op_flags. Sa valeur par défaut est en lecture seule, mais peut être définie en mode lecture-écriture ou écriture seule. Cela permettra de modifier les éléments du tableau à l'aide de cet itérateur.
Exemple
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
for x in np.nditer(a, op_flags = ['readwrite']):
x[...] = 2*x
print 'Modified array is:'
print a
Sa sortie est la suivante -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
Boucle externe
Le constructeur de classe nditer a un ‘flags’ paramètre, qui peut prendre les valeurs suivantes -
Sr.No. | Paramètre et description |
---|---|
1 | c_index L'index C_order peut être suivi |
2 | f_index L'index Fortran_order est suivi |
3 | multi-index Les types d'index avec un par itération peuvent être suivis |
4 | external_loop Fait en sorte que les valeurs données soient des tableaux à une dimension avec plusieurs valeurs au lieu d'un tableau à zéro dimension |
Exemple
Dans l'exemple suivant, les tableaux unidimensionnels correspondant à chaque colonne sont parcourus par l'itérateur.
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'
print 'Modified array is:'
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
print x,
La sortie est la suivante -
Original array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Modified array is:
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]
Itération de diffusion
Si deux tableaux sont broadcastable, un combiné nditerobjet est capable de les itérer simultanément. En supposant qu'un tableaua a la dimension 3X4, et il y a un autre tableau b de dimension 1X4, l'itérateur de type suivant est utilisé (tableau b est diffusé à la taille de a).
Exemple
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'First array is:'
print a
print '\n'
print 'Second array is:'
b = np.array([1, 2, 3, 4], dtype = int)
print b
print '\n'
print 'Modified array is:'
for x,y in np.nditer([a,b]):
print "%d:%d" % (x,y),
Sa sortie serait la suivante -
First array is:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
Second array is:
[1 2 3 4]
Modified array is:
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4
Plusieurs routines sont disponibles dans le package NumPy pour la manipulation d'éléments dans l'objet ndarray. Ils peuvent être classés dans les types suivants -
Changer de forme
Sr.No. | Forme et description |
---|---|
1 | remodeler Donne une nouvelle forme à un tableau sans changer ses données |
2 | appartement Un itérateur 1-D sur le tableau |
3 | aplatir Renvoie une copie du tableau réduit en une dimension |
4 | effilochage Renvoie un tableau aplati contigu |
Transposer les opérations
Sr.No. | Description d'opération |
---|---|
1 | transposer Permute les dimensions d'un tableau |
2 | ndarray.T Identique à self.transpose () |
3 | rollaxis Fait rouler l'axe spécifié vers l'arrière |
4 | swapaxes Intervertit les deux axes d'un tableau |
Modification des dimensions
Sr.No. | Dimension et description |
---|---|
1 | diffuser Produit un objet qui imite la diffusion |
2 | broadcast_to Diffuse un tableau sous une nouvelle forme |
3 | expand_dims Développe la forme d'un tableau |
4 | écraser Supprime les entrées unidimensionnelles de la forme d'un tableau |
Joindre des tableaux
Sr.No. | Tableau et description |
---|---|
1 | enchaîner Joint une séquence de tableaux le long d'un axe existant |
2 | empiler Joint une séquence de tableaux le long d'un nouvel axe |
3 | hstack Empile les tableaux en séquence horizontalement (colonne par colonne) |
4 | vstack Empile les tableaux en séquence verticalement (ligne par ligne) |
Division des tableaux
Sr.No. | Tableau et description |
---|---|
1 | Divisé Divise un tableau en plusieurs sous-tableaux |
2 | hsplit Divise un tableau en plusieurs sous-tableaux horizontalement (par colonne) |
3 | vsplit Divise un tableau en plusieurs sous-tableaux verticalement (par ligne) |
Ajout / suppression d'éléments
Sr.No. | Élément et description |
---|---|
1 | redimensionner Renvoie un nouveau tableau avec la forme spécifiée |
2 | ajouter Ajoute les valeurs à la fin d'un tableau |
3 | insérer Insère les valeurs le long de l'axe donné avant les indices donnés |
4 | effacer Renvoie un nouveau tableau avec des sous-tableaux le long d'un axe supprimés |
5 | unique Recherche les éléments uniques d'un tableau |
Voici les fonctions pour les opérations au niveau du bit disponibles dans le package NumPy.
Sr.No. | Description d'opération |
---|---|
1 | bitwise_and Calcule l'opération ET au niveau du bit des éléments du tableau |
2 | bitwise_or Calcule l'opération OU au niveau du bit des éléments du tableau |
3 | inverser Calcule PAS au niveau du bit |
4 | décalage à gauche Décale les bits d'une représentation binaire vers la gauche |
5 | droite_shift Décale les bits de la représentation binaire vers la droite |
Les fonctions suivantes sont utilisées pour effectuer des opérations de chaîne vectorisées pour les tableaux de type dtype numpy.string_ ou numpy.unicode_. Ils sont basés sur les fonctions de chaîne standard de la bibliothèque intégrée de Python.
Sr.No. | Description de la fonction |
---|---|
1 | ajouter() Renvoie la concaténation de chaînes élément par élément pour deux tableaux de str ou Unicode |
2 | multiplier() Renvoie la chaîne avec plusieurs concaténations, élément par élément |
3 | centre() Renvoie une copie de la chaîne donnée avec les éléments centrés dans une chaîne de longueur spécifiée |
4 | capitaliser() Renvoie une copie de la chaîne avec uniquement le premier caractère en majuscule |
5 | Titre() Renvoie la version casse du titre élément par élément de la chaîne ou de l'unicode |
6 | inférieur() Renvoie un tableau avec les éléments convertis en minuscules |
sept | plus haut() Renvoie un tableau avec les éléments convertis en majuscules |
8 | Divisé() Renvoie une liste des mots de la chaîne, en utilisant separatordelimiter |
9 | lignes de division () Renvoie une liste des lignes de l'élément, se coupant aux limites de la ligne |
dix | bande() Renvoie une copie avec les caractères de début et de fin supprimés |
11 | joindre() Renvoie une chaîne qui est la concaténation des chaînes de la séquence |
12 | remplacer() Renvoie une copie de la chaîne avec toutes les occurrences de sous-chaîne remplacées par la nouvelle chaîne |
13 | décoder() Appelle str.decode par élément |
14 | encoder() Appelle str.encode élément par élément |
Ces fonctions sont définies dans la classe de tableau de caractères (numpy.char). L'ancien package Numarray contenait la classe chararray. Les fonctions ci-dessus dans la classe numpy.char sont utiles pour effectuer des opérations de chaîne vectorisées.
Tout naturellement, NumPy contient un grand nombre de diverses opérations mathématiques. NumPy fournit des fonctions trigonométriques standard, des fonctions pour les opérations arithmétiques, la gestion de nombres complexes, etc.
Fonctions trigonométriques
NumPy a des fonctions trigonométriques standard qui renvoient des rapports trigonométriques pour un angle donné en radians.
Example
import numpy as np
a = np.array([0,30,45,60,90])
print 'Sine of different angles:'
# Convert to radians by multiplying with pi/180
print np.sin(a*np.pi/180)
print '\n'
print 'Cosine values for angles in array:'
print np.cos(a*np.pi/180)
print '\n'
print 'Tangent values for given angles:'
print np.tan(a*np.pi/180)
Voici sa sortie -
Sine of different angles:
[ 0. 0.5 0.70710678 0.8660254 1. ]
Cosine values for angles in array:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
Tangent values for given angles:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
arcsin, arcos, et arctanLes fonctions renvoient l'inverse trigonométrique de sin, cos et tan de l'angle donné. Le résultat de ces fonctions peut être vérifié parnumpy.degrees() function en convertissant les radians en degrés.
Example
import numpy as np
a = np.array([0,30,45,60,90])
print 'Array containing sine values:'
sin = np.sin(a*np.pi/180)
print sin
print '\n'
print 'Compute sine inverse of angles. Returned values are in radians.'
inv = np.arcsin(sin)
print inv
print '\n'
print 'Check result by converting to degrees:'
print np.degrees(inv)
print '\n'
print 'arccos and arctan functions behave similarly:'
cos = np.cos(a*np.pi/180)
print cos
print '\n'
print 'Inverse of cos:'
inv = np.arccos(cos)
print inv
print '\n'
print 'In degrees:'
print np.degrees(inv)
print '\n'
print 'Tan function:'
tan = np.tan(a*np.pi/180)
print tan
print '\n'
print 'Inverse of tan:'
inv = np.arctan(tan)
print inv
print '\n'
print 'In degrees:'
print np.degrees(inv)
Sa sortie est la suivante -
Array containing sine values:
[ 0. 0.5 0.70710678 0.8660254 1. ]
Compute sine inverse of angles. Returned values are in radians.
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
Check result by converting to degrees:
[ 0. 30. 45. 60. 90.]
arccos and arctan functions behave similarly:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
Inverse of cos:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
In degrees:
[ 0. 30. 45. 60. 90.]
Tan function:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
Inverse of tan:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
In degrees:
[ 0. 30. 45. 60. 90.]
Fonctions d'arrondi
numpy.around ()
Il s'agit d'une fonction qui renvoie la valeur arrondie à la précision souhaitée. La fonction prend les paramètres suivants.
numpy.around(a,decimals)
Où,
Sr.No. | Paramètre et description |
---|---|
1 | a Des données d'entrée |
2 | decimals Le nombre de décimales à arrondir. La valeur par défaut est 0. S'il est négatif, l'entier est arrondi à la position à gauche de la virgule décimale |
Example
import numpy as np
a = np.array([1.0,5.55, 123, 0.567, 25.532])
print 'Original array:'
print a
print '\n'
print 'After rounding:'
print np.around(a)
print np.around(a, decimals = 1)
print np.around(a, decimals = -1)
Il produit la sortie suivante -
Original array:
[ 1. 5.55 123. 0.567 25.532]
After rounding:
[ 1. 6. 123. 1. 26. ]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30. ]
numpy.floor ()
Cette fonction renvoie le plus grand entier non supérieur au paramètre d'entrée. Le sol de lascalar x est le plus grand integer i, tel que i <= x. Notez qu'en Python, le sol est toujours arrondi à partir de 0.
Example
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print 'The given array:'
print a
print '\n'
print 'The modified array:'
print np.floor(a)
Il produit la sortie suivante -
The given array:
[ -1.7 1.5 -0.2 0.6 10. ]
The modified array:
[ -2. 1. -1. 0. 10.]
numpy.ceil ()
La fonction ceil () renvoie le plafond d'une valeur d'entrée, c'est-à-dire le ceil du scalar x est le plus petit integer i, tel que i >= x.
Example
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print 'The given array:'
print a
print '\n'
print 'The modified array:'
print np.ceil(a)
Il produira la sortie suivante -
The given array:
[ -1.7 1.5 -0.2 0.6 10. ]
The modified array:
[ -1. 2. -0. 1. 10.]
Les tableaux d'entrée pour effectuer des opérations arithmétiques telles que add (), soustract (), multiplier () et divide () doivent avoir la même forme ou être conformes aux règles de diffusion des tableaux.
Exemple
import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print 'First array:'
print a
print '\n'
print 'Second array:'
b = np.array([10,10,10])
print b
print '\n'
print 'Add the two arrays:'
print np.add(a,b)
print '\n'
print 'Subtract the two arrays:'
print np.subtract(a,b)
print '\n'
print 'Multiply the two arrays:'
print np.multiply(a,b)
print '\n'
print 'Divide the two arrays:'
print np.divide(a,b)
Il produira la sortie suivante -
First array:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Second array:
[10 10 10]
Add the two arrays:
[[ 10. 11. 12.]
[ 13. 14. 15.]
[ 16. 17. 18.]]
Subtract the two arrays:
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
Multiply the two arrays:
[[ 0. 10. 20.]
[ 30. 40. 50.]
[ 60. 70. 80.]]
Divide the two arrays:
[[ 0. 0.1 0.2]
[ 0.3 0.4 0.5]
[ 0.6 0.7 0.8]]
Voyons maintenant quelques-unes des autres fonctions arithmétiques importantes disponibles dans NumPy.
numpy.reciprocal ()
Cette fonction renvoie la réciproque de l'argument, élément par élément. Pour les éléments avec des valeurs absolues supérieures à 1, le résultat est toujours 0 en raison de la façon dont Python gère la division entière. Pour l'entier 0, un avertissement de dépassement est émis.
Exemple
import numpy as np
a = np.array([0.25, 1.33, 1, 0, 100])
print 'Our array is:'
print a
print '\n'
print 'After applying reciprocal function:'
print np.reciprocal(a)
print '\n'
b = np.array([100], dtype = int)
print 'The second array is:'
print b
print '\n'
print 'After applying reciprocal function:'
print np.reciprocal(b)
Il produira la sortie suivante -
Our array is:
[ 0.25 1.33 1. 0. 100. ]
After applying reciprocal function:
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal
print np.reciprocal(a)
[ 4. 0.7518797 1. inf 0.01 ]
The second array is:
[100]
After applying reciprocal function:
[0]
numpy.power ()
Cette fonction traite les éléments du premier tableau d'entrée comme une base et la renvoie à la puissance de l'élément correspondant dans le deuxième tableau d'entrée.
import numpy as np
a = np.array([10,100,1000])
print 'Our array is:'
print a
print '\n'
print 'Applying power function:'
print np.power(a,2)
print '\n'
print 'Second array:'
b = np.array([1,2,3])
print b
print '\n'
print 'Applying power function again:'
print np.power(a,b)
Il produira la sortie suivante -
Our array is:
[ 10 100 1000]
Applying power function:
[ 100 10000 1000000]
Second array:
[1 2 3]
Applying power function again:
[ 10 10000 1000000000]
numpy.mod ()
Cette fonction renvoie le reste de la division des éléments correspondants dans le tableau d'entrée. La fonctionnumpy.remainder() produit également le même résultat.
import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])
print 'First array:'
print a
print '\n'
print 'Second array:'
print b
print '\n'
print 'Applying mod() function:'
print np.mod(a,b)
print '\n'
print 'Applying remainder() function:'
print np.remainder(a,b)
Il produira la sortie suivante -
First array:
[10 20 30]
Second array:
[3 5 7]
Applying mod() function:
[1 0 2]
Applying remainder() function:
[1 0 2]
Les fonctions suivantes sont utilisées pour effectuer des opérations sur un tableau avec des nombres complexes.
numpy.real() - renvoie la partie réelle de l'argument de type de données complexe.
numpy.imag() - renvoie la partie imaginaire de l'argument de type de données complexe.
numpy.conj() - renvoie le conjugué complexe, obtenu en changeant le signe de la partie imaginaire.
numpy.angle()- renvoie l'angle de l'argument complexe. La fonction a un paramètre de degré. Si vrai, l'angle en degré est renvoyé, sinon l'angle est en radians.
import numpy as np
a = np.array([-5.6j, 0.2j, 11. , 1+1j])
print 'Our array is:'
print a
print '\n'
print 'Applying real() function:'
print np.real(a)
print '\n'
print 'Applying imag() function:'
print np.imag(a)
print '\n'
print 'Applying conj() function:'
print np.conj(a)
print '\n'
print 'Applying angle() function:'
print np.angle(a)
print '\n'
print 'Applying angle() function again (result in degrees)'
print np.angle(a, deg = True)
Il produira la sortie suivante -
Our array is:
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]
Applying real() function:
[ 0. 0. 11. 1.]
Applying imag() function:
[-5.6 0.2 0. 1. ]
Applying conj() function:
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]
Applying angle() function:
[-1.57079633 1.57079633 0. 0.78539816]
Applying angle() function again (result in degrees)
[-90. 90. 0. 45.]
NumPy a quelques fonctions statistiques utiles pour trouver l'écart-type et la variance minimum, maximum, percentile, etc. à partir des éléments donnés dans le tableau. Les fonctions sont expliquées comme suit -
numpy.amin () et numpy.amax ()
Ces fonctions renvoient le minimum et le maximum à partir des éléments du tableau donné le long de l'axe spécifié.
Exemple
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print 'Our array is:'
print a
print '\n'
print 'Applying amin() function:'
print np.amin(a,1)
print '\n'
print 'Applying amin() function again:'
print np.amin(a,0)
print '\n'
print 'Applying amax() function:'
print np.amax(a)
print '\n'
print 'Applying amax() function again:'
print np.amax(a, axis = 0)
Il produira la sortie suivante -
Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]
Applying amin() function:
[3 3 2]
Applying amin() function again:
[2 4 3]
Applying amax() function:
9
Applying amax() function again:
[8 7 9]
numpy.ptp ()
le numpy.ptp() La fonction renvoie la plage (maximum-minimum) de valeurs le long d'un axe.
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print 'Our array is:'
print a
print '\n'
print 'Applying ptp() function:'
print np.ptp(a)
print '\n'
print 'Applying ptp() function along axis 1:'
print np.ptp(a, axis = 1)
print '\n'
print 'Applying ptp() function along axis 0:'
print np.ptp(a, axis = 0)
Il produira la sortie suivante -
Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]
Applying ptp() function:
7
Applying ptp() function along axis 1:
[4 5 7]
Applying ptp() function along axis 0:
[6 3 6]
numpy.percentile ()
Le centile (ou centile) est une mesure utilisée dans les statistiques indiquant la valeur en dessous de laquelle tombe un pourcentage donné d'observations dans un groupe d'observations. La fonctionnumpy.percentile() prend les arguments suivants.
numpy.percentile(a, q, axis)
Où,
Sr.No. | Argument et description |
---|---|
1 | a Tableau d'entrée |
2 | q Le centile à calculer doit être compris entre 0 et 100 |
3 | axis L'axe le long duquel le centile doit être calculé |
Exemple
import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying percentile() function:'
print np.percentile(a,50)
print '\n'
print 'Applying percentile() function along axis 1:'
print np.percentile(a,50, axis = 1)
print '\n'
print 'Applying percentile() function along axis 0:'
print np.percentile(a,50, axis = 0)
Il produira la sortie suivante -
Our array is:
[[30 40 70]
[80 20 10]
[50 90 60]]
Applying percentile() function:
50.0
Applying percentile() function along axis 1:
[ 40. 20. 60.]
Applying percentile() function along axis 0:
[ 50. 40. 60.]
numpy.median ()
Medianest définie comme la valeur séparant la moitié supérieure d'un échantillon de données de la moitié inférieure. lenumpy.median() La fonction est utilisée comme indiqué dans le programme suivant.
Exemple
import numpy as np
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying median() function:'
print np.median(a)
print '\n'
print 'Applying median() function along axis 0:'
print np.median(a, axis = 0)
print '\n'
print 'Applying median() function along axis 1:'
print np.median(a, axis = 1)
Il produira la sortie suivante -
Our array is:
[[30 65 70]
[80 95 10]
[50 90 60]]
Applying median() function:
65.0
Applying median() function along axis 0:
[ 50. 90. 60.]
Applying median() function along axis 1:
[ 65. 80. 60.]
numpy.mean ()
La moyenne arithmétique est la somme des éléments le long d'un axe divisée par le nombre d'éléments. lenumpy.mean()La fonction renvoie la moyenne arithmétique des éléments du tableau. Si l'axe est mentionné, il est calculé le long de celui-ci.
Exemple
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print 'Our array is:'
print a
print '\n'
print 'Applying mean() function:'
print np.mean(a)
print '\n'
print 'Applying mean() function along axis 0:'
print np.mean(a, axis = 0)
print '\n'
print 'Applying mean() function along axis 1:'
print np.mean(a, axis = 1)
Il produira la sortie suivante -
Our array is:
[[1 2 3]
[3 4 5]
[4 5 6]]
Applying mean() function:
3.66666666667
Applying mean() function along axis 0:
[ 2.66666667 3.66666667 4.66666667]
Applying mean() function along axis 1:
[ 2. 4. 5.]
numpy.average ()
La moyenne pondérée est une moyenne résultant de la multiplication de chaque composante par un facteur reflétant son importance. lenumpy.average()La fonction calcule la moyenne pondérée des éléments d'un tableau en fonction de leur poids respectif donné dans un autre tableau. La fonction peut avoir un paramètre d'axe. Si l'axe n'est pas spécifié, le tableau est aplati.
En considérant un tableau [1,2,3,4] et des poids correspondants [4,3,2,1], la moyenne pondérée est calculée en additionnant le produit des éléments correspondants et en divisant la somme par la somme des poids.
Moyenne pondérée = (1 * 4 + 2 * 3 + 3 * 2 + 4 * 1) / (4 + 3 + 2 + 1)
Exemple
import numpy as np
a = np.array([1,2,3,4])
print 'Our array is:'
print a
print '\n'
print 'Applying average() function:'
print np.average(a)
print '\n'
# this is same as mean when weight is not specified
wts = np.array([4,3,2,1])
print 'Applying average() function again:'
print np.average(a,weights = wts)
print '\n'
# Returns the sum of weights, if the returned parameter is set to True.
print 'Sum of weights'
print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True)
Il produira la sortie suivante -
Our array is:
[1 2 3 4]
Applying average() function:
2.5
Applying average() function again:
2.0
Sum of weights
(2.0, 10.0)
Dans un tableau multidimensionnel, l'axe de calcul peut être spécifié.
Exemple
import numpy as np
a = np.arange(6).reshape(3,2)
print 'Our array is:'
print a
print '\n'
print 'Modified array:'
wt = np.array([3,5])
print np.average(a, axis = 1, weights = wt)
print '\n'
print 'Modified array:'
print np.average(a, axis = 1, weights = wt, returned = True)
Il produira la sortie suivante -
Our array is:
[[0 1]
[2 3]
[4 5]]
Modified array:
[ 0.625 2.625 4.625]
Modified array:
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))
Écart-type
L'écart type est la racine carrée de la moyenne des écarts au carré de la moyenne. La formule de l'écart type est la suivante -
std = sqrt(mean(abs(x - x.mean())**2))
Si le tableau est [1, 2, 3, 4], alors sa moyenne est de 2,5. Par conséquent, les écarts au carré sont [2,25, 0,25, 0,25, 2,25] et la racine carrée de sa moyenne divisée par 4, c'est-à-dire que sqrt (5/4) est 1,1180339887498949.
Exemple
import numpy as np
print np.std([1,2,3,4])
Il produira la sortie suivante -
1.1180339887498949
Variance
La variance est la moyenne des écarts au carré, c'est-à-dire mean(abs(x - x.mean())**2). En d'autres termes, l'écart type est la racine carrée de la variance.
Exemple
import numpy as np
print np.var([1,2,3,4])
Il produira la sortie suivante -
1.25
Une variété de fonctions liées au tri sont disponibles dans NumPy. Ces fonctions de tri implémentent différents algorithmes de tri, chacun d'eux étant caractérisé par la vitesse d'exécution, les pires performances, l'espace de travail requis et la stabilité des algorithmes. Le tableau suivant montre la comparaison de trois algorithmes de tri.
gentil | la vitesse | pire cas | espace de travail | stable |
---|---|---|---|---|
'tri rapide' | 1 | O (n ^ 2) | 0 | non |
'tri par fusion' | 2 | O (n * log (n)) | ~ n / 2 | Oui |
'tas' | 3 | O (n * log (n)) | 0 | non |
numpy.sort ()
La fonction sort () renvoie une copie triée du tableau d'entrée. Il a les paramètres suivants -
numpy.sort(a, axis, kind, order)
Où,
Sr.No. | Paramètre et description |
---|---|
1 | a Tableau à trier |
2 | axis L'axe le long duquel le tableau doit être trié. Si aucun, le tableau est aplati, tri sur le dernier axe |
3 | kind La valeur par défaut est le tri rapide |
4 | order Si le tableau contient des champs, l'ordre des champs à trier |
Exemple
import numpy as np
a = np.array([[3,7],[9,1]])
print 'Our array is:'
print a
print '\n'
print 'Applying sort() function:'
print np.sort(a)
print '\n'
print 'Sort along axis 0:'
print np.sort(a, axis = 0)
print '\n'
# Order parameter in sort function
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
print 'Our array is:'
print a
print '\n'
print 'Order by name:'
print np.sort(a, order = 'name')
Il produira la sortie suivante -
Our array is:
[[3 7]
[9 1]]
Applying sort() function:
[[3 7]
[1 9]]
Sort along axis 0:
[[3 1]
[9 7]]
Our array is:
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]
Order by name:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]
numpy.argsort ()
le numpy.argsort()La fonction effectue un tri indirect sur le tableau d'entrée, le long de l'axe donné et en utilisant un type de tri spécifié pour renvoyer le tableau d'indices de données. Ce tableau d'indices est utilisé pour construire le tableau trié.
Exemple
import numpy as np
x = np.array([3, 1, 2])
print 'Our array is:'
print x
print '\n'
print 'Applying argsort() to x:'
y = np.argsort(x)
print y
print '\n'
print 'Reconstruct original array in sorted order:'
print x[y]
print '\n'
print 'Reconstruct the original array using loop:'
for i in y:
print x[i],
Il produira la sortie suivante -
Our array is:
[3 1 2]
Applying argsort() to x:
[1 2 0]
Reconstruct original array in sorted order:
[1 2 3]
Reconstruct the original array using loop:
1 2 3
numpy.lexsort ()
La fonction effectue un tri indirect à l'aide d'une séquence de touches. Les clés peuvent être vues comme une colonne dans une feuille de calcul. La fonction renvoie un tableau d'indices, à l'aide duquel les données triées peuvent être obtenues. Notez que la dernière clé se trouve être la clé primaire de tri.
Exemple
import numpy as np
nm = ('raju','anil','ravi','amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv,nm))
print 'Applying lexsort() function:'
print ind
print '\n'
print 'Use this index to get sorted data:'
print [nm[i] + ", " + dv[i] for i in ind]
Il produira la sortie suivante -
Applying lexsort() function:
[3 1 0 2]
Use this index to get sorted data:
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']
Le module NumPy a un certain nombre de fonctions pour rechercher dans un tableau. Des fonctions pour trouver le maximum, le minimum ainsi que les éléments satisfaisant à une condition donnée sont disponibles.
numpy.argmax () et numpy.argmin ()
Ces deux fonctions renvoient les indices des éléments maximum et minimum respectivement le long de l'axe donné.
Exemple
import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying argmax() function:'
print np.argmax(a)
print '\n'
print 'Index of maximum number in flattened array'
print a.flatten()
print '\n'
print 'Array containing indices of maximum along axis 0:'
maxindex = np.argmax(a, axis = 0)
print maxindex
print '\n'
print 'Array containing indices of maximum along axis 1:'
maxindex = np.argmax(a, axis = 1)
print maxindex
print '\n'
print 'Applying argmin() function:'
minindex = np.argmin(a)
print minindex
print '\n'
print 'Flattened array:'
print a.flatten()[minindex]
print '\n'
print 'Flattened array along axis 0:'
minindex = np.argmin(a, axis = 0)
print minindex
print '\n'
print 'Flattened array along axis 1:'
minindex = np.argmin(a, axis = 1)
print minindex
Il produira la sortie suivante -
Our array is:
[[30 40 70]
[80 20 10]
[50 90 60]]
Applying argmax() function:
7
Index of maximum number in flattened array
[30 40 70 80 20 10 50 90 60]
Array containing indices of maximum along axis 0:
[1 2 0]
Array containing indices of maximum along axis 1:
[2 0 1]
Applying argmin() function:
5
Flattened array:
10
Flattened array along axis 0:
[0 1 1]
Flattened array along axis 1:
[0 2 0]
numpy.nonzero ()
le numpy.nonzero() La fonction renvoie les indices des éléments non nuls dans le tableau d'entrée.
Exemple
import numpy as np
a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print 'Our array is:'
print a
print '\n'
print 'Applying nonzero() function:'
print np.nonzero (a)
Il produira la sortie suivante -
Our array is:
[[30 40 0]
[ 0 20 10]
[50 0 60]]
Applying nonzero() function:
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
numpy.where ()
La fonction where () renvoie les indices des éléments dans un tableau d'entrée où la condition donnée est satisfaite.
Exemple
import numpy as np
x = np.arange(9.).reshape(3, 3)
print 'Our array is:'
print x
print 'Indices of elements > 3'
y = np.where(x > 3)
print y
print 'Use these indices to get elements satisfying the condition'
print x[y]
Il produira la sortie suivante -
Our array is:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Indices of elements > 3
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
Use these indices to get elements satisfying the condition
[ 4. 5. 6. 7. 8.]
numpy.extract ()
le extract() function renvoie les éléments satisfaisant à n'importe quelle condition.
import numpy as np
x = np.arange(9.).reshape(3, 3)
print 'Our array is:'
print x
# define a condition
condition = np.mod(x,2) == 0
print 'Element-wise value of condition'
print condition
print 'Extract elements using condition'
print np.extract(condition, x)
Il produira la sortie suivante -
Our array is:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Element-wise value of condition
[[ True False True]
[False True False]
[ True False True]]
Extract elements using condition
[ 0. 2. 4. 6. 8.]
Nous avons vu que les données stockées dans la mémoire d'un ordinateur dépendent de l'architecture utilisée par le CPU. Il peut être petit-boutiste (le moins significatif est stocké dans la plus petite adresse) ou gros-boutiste (octet le plus significatif dans la plus petite adresse).
numpy.ndarray.byteswap ()
le numpy.ndarray.byteswap() La fonction bascule entre les deux représentations: bigendian et little-endian.
import numpy as np
a = np.array([1, 256, 8755], dtype = np.int16)
print 'Our array is:'
print a
print 'Representation of data in memory in hexadecimal form:'
print map(hex,a)
# byteswap() function swaps in place by passing True parameter
print 'Applying byteswap() function:'
print a.byteswap(True)
print 'In hexadecimal form:'
print map(hex,a)
# We can see the bytes being swapped
Il produira la sortie suivante -
Our array is:
[1 256 8755]
Representation of data in memory in hexadecimal form:
['0x1', '0x100', '0x2233']
Applying byteswap() function:
[256 1 13090]
In hexadecimal form:
['0x100', '0x1', '0x3322']
Lors de l'exécution des fonctions, certaines renvoient une copie du tableau d'entrée, tandis que d'autres renvoient la vue. Lorsque le contenu est physiquement stocké dans un autre emplacement, il est appeléCopy. Si, en revanche, une vue différente du même contenu de mémoire est fournie, nous l'appelons commeView.
Pas de copie
Les affectations simples ne font pas la copie de l'objet tableau. Au lieu de cela, il utilise le même id () du tableau d'origine pour y accéder. leid() renvoie un identifiant universel de l'objet Python, similaire au pointeur en C.
De plus, tout changement dans l'un ou l'autre se reflète dans l'autre. Par exemple, le changement de forme de l'un changera également la forme de l'autre.
Exemple
import numpy as np
a = np.arange(6)
print 'Our array is:'
print a
print 'Applying id() function:'
print id(a)
print 'a is assigned to b:'
b = a
print b
print 'b has same id():'
print id(b)
print 'Change shape of b:'
b.shape = 3,2
print b
print 'Shape of a also gets changed:'
print a
Il produira la sortie suivante -
Our array is:
[0 1 2 3 4 5]
Applying id() function:
139747815479536
a is assigned to b:
[0 1 2 3 4 5]
b has same id():
139747815479536
Change shape of b:
[[0 1]
[2 3]
[4 5]]
Shape of a also gets changed:
[[0 1]
[2 3]
[4 5]]
Afficher ou copie superficielle
NumPy a ndarray.view()méthode qui est un nouvel objet de tableau qui regarde les mêmes données du tableau d'origine. Contrairement au cas précédent, la modification des dimensions du nouveau tableau ne modifie pas les dimensions de l'original.
Exemple
import numpy as np
# To begin with, a is 3X2 array
a = np.arange(6).reshape(3,2)
print 'Array a:'
print a
print 'Create view of a:'
b = a.view()
print b
print 'id() for both the arrays are different:'
print 'id() of a:'
print id(a)
print 'id() of b:'
print id(b)
# Change the shape of b. It does not change the shape of a
b.shape = 2,3
print 'Shape of b:'
print b
print 'Shape of a:'
print a
Il produira la sortie suivante -
Array a:
[[0 1]
[2 3]
[4 5]]
Create view of a:
[[0 1]
[2 3]
[4 5]]
id() for both the arrays are different:
id() of a:
140424307227264
id() of b:
140424151696288
Shape of b:
[[0 1 2]
[3 4 5]]
Shape of a:
[[0 1]
[2 3]
[4 5]]
Une tranche d'un tableau crée une vue.
Exemple
import numpy as np
a = np.array([[10,10], [2,3], [4,5]])
print 'Our array is:'
print a
print 'Create a slice:'
s = a[:, :2]
print s
Il produira la sortie suivante -
Our array is:
[[10 10]
[ 2 3]
[ 4 5]]
Create a slice:
[[10 10]
[ 2 3]
[ 4 5]]
Copie profonde
le ndarray.copy()La fonction crée une copie complète. Il s'agit d'une copie complète du tableau et de ses données, et ne partage pas avec le tableau d'origine.
Exemple
import numpy as np
a = np.array([[10,10], [2,3], [4,5]])
print 'Array a is:'
print a
print 'Create a deep copy of a:'
b = a.copy()
print 'Array b is:'
print b
#b does not share any memory of a
print 'Can we write b is a'
print b is a
print 'Change the contents of b:'
b[0,0] = 100
print 'Modified array b:'
print b
print 'a remains unchanged:'
print a
Il produira la sortie suivante -
Array a is:
[[10 10]
[ 2 3]
[ 4 5]]
Create a deep copy of a:
Array b is:
[[10 10]
[ 2 3]
[ 4 5]]
Can we write b is a
False
Change the contents of b:
Modified array b:
[[100 10]
[ 2 3]
[ 4 5]]
a remains unchanged:
[[10 10]
[ 2 3]
[ 4 5]]
Le package NumPy contient une bibliothèque Matrix numpy.matlib. Ce module a des fonctions qui renvoient des matrices au lieu d'objets ndarray.
matlib.empty ()
le matlib.empty()La fonction renvoie une nouvelle matrice sans initialiser les entrées. La fonction prend les paramètres suivants.
numpy.matlib.empty(shape, dtype, order)
Où,
Sr.No. | Paramètre et description |
---|---|
1 | shape int ou tuple de int définir la forme de la nouvelle matrice |
2 | Dtype Optionnel. Type de données de la sortie |
3 | order C ou F |
Exemple
import numpy.matlib
import numpy as np
print np.matlib.empty((2,2))
# filled with random data
Il produira la sortie suivante -
[[ 2.12199579e-314, 4.24399158e-314]
[ 4.24399158e-314, 2.12199579e-314]]
numpy.matlib.zeros ()
Cette fonction renvoie la matrice remplie de zéros.
import numpy.matlib
import numpy as np
print np.matlib.zeros((2,2))
Il produira la sortie suivante -
[[ 0. 0.]
[ 0. 0.]]
numpy.matlib.ones ()
Cette fonction renvoie la matrice remplie de 1.
import numpy.matlib
import numpy as np
print np.matlib.ones((2,2))
Il produira la sortie suivante -
[[ 1. 1.]
[ 1. 1.]]
numpy.matlib.eye ()
Cette fonction renvoie une matrice avec 1 le long des éléments diagonaux et les zéros ailleurs. La fonction prend les paramètres suivants.
numpy.matlib.eye(n, M,k, dtype)
Où,
Sr.No. | Paramètre et description |
---|---|
1 | n Le nombre de lignes dans la matrice résultante |
2 | M Le nombre de colonnes, par défaut n |
3 | k Index de la diagonale |
4 | dtype Type de données de la sortie |
Exemple
import numpy.matlib
import numpy as np
print np.matlib.eye(n = 3, M = 4, k = 0, dtype = float)
Il produira la sortie suivante -
[[ 1. 0. 0. 0.]
[ 0. 1. 0. 0.]
[ 0. 0. 1. 0.]]
numpy.matlib.identity ()
le numpy.matlib.identity()La fonction renvoie la matrice d'identité de la taille donnée. Une matrice d'identité est une matrice carrée avec tous les éléments diagonaux comme 1.
import numpy.matlib
import numpy as np
print np.matlib.identity(5, dtype = float)
Il produira la sortie suivante -
[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]
numpy.matlib.rand ()
le numpy.matlib.rand() La fonction renvoie une matrice de la taille donnée remplie de valeurs aléatoires.
Exemple
import numpy.matlib
import numpy as np
print np.matlib.rand(3,3)
Il produira la sortie suivante -
[[ 0.82674464 0.57206837 0.15497519]
[ 0.33857374 0.35742401 0.90895076]
[ 0.03968467 0.13962089 0.39665201]]
Notequ'une matrice est toujours bidimensionnelle, alors que ndarray est un tableau à n dimensions. Les deux objets sont inter-convertibles.
Exemple
import numpy.matlib
import numpy as np
i = np.matrix('1,2;3,4')
print i
Il produira la sortie suivante -
[[1 2]
[3 4]]
Exemple
import numpy.matlib
import numpy as np
j = np.asarray(i)
print j
Il produira la sortie suivante -
[[1 2]
[3 4]]
Exemple
import numpy.matlib
import numpy as np
k = np.asmatrix (j)
print k
Il produira la sortie suivante -
[[1 2]
[3 4]]
Le package NumPy contient numpy.linalgmodule qui fournit toutes les fonctionnalités requises pour l'algèbre linéaire. Certaines des fonctions importantes de ce module sont décrites dans le tableau suivant.
Sr.No. | Description de la fonction |
---|---|
1 | point Produit scalaire des deux tableaux |
2 | vdot Produit scalaire des deux vecteurs |
3 | interne Produit interne des deux tableaux |
4 | matmul Produit matriciel des deux tableaux |
5 | déterminant Calcule le déterminant du tableau |
6 | résoudre Résout l'équation de la matrice linéaire |
sept | inv Trouve l'inverse multiplicatif de la matrice |
Matplotlib est une bibliothèque de traçage pour Python. Il est utilisé avec NumPy pour fournir un environnement qui est une alternative open source efficace pour MatLab. Il peut également être utilisé avec des kits d'outils graphiques tels que PyQt et wxPython.
Le module Matplotlib a d'abord été écrit par John D. Hunter. Depuis 2012, Michael Droettboom est le développeur principal. Actuellement, Matplotlib ver. 1.5.1 est la version stable disponible. Le paquet est disponible en distribution binaire ainsi que sous forme de code source sur www.matplotlib.org .
Par convention, le package est importé dans le script Python en ajoutant l'instruction suivante -
from matplotlib import pyplot as plt
Ici pyplot()est la fonction la plus importante de la bibliothèque matplotlib, utilisée pour tracer des données 2D. Le script suivant trace l'équationy = 2x + 5
Exemple
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y)
plt.show()
Un objet ndarray x est créé à partir de np.arange() function comme les valeurs sur le x axis. Les valeurs correspondantes sur ley axis sont stockés dans un autre ndarray object y. Ces valeurs sont tracées à l'aide deplot() fonction du sous-module pyplot du package matplotlib.
La représentation graphique est affichée par show() fonction.
Le code ci-dessus doit produire la sortie suivante -
Au lieu du graphe linéaire, les valeurs peuvent être affichées discrètement en ajoutant une chaîne de format à la plot()fonction. Les caractères de formatage suivants peuvent être utilisés.
Sr.No. | Caractère et description |
---|---|
1 | '-' Style de ligne continue |
2 | '--' Style de ligne pointillée |
3 | '-.' Style de ligne pointillé |
4 | ':' Style de ligne pointillée |
5 | '.' Marqueur de point |
6 | ',' Marqueur de pixel |
sept | 'o' Marqueur de cercle |
8 | 'v' Marqueur Triangle_down |
9 | '^' Marqueur Triangle_up |
dix | '<' Marqueur Triangle_left |
11 | '>' Marqueur Triangle_right |
12 | '1' Marqueur Tri_down |
13 | '2' Marqueur Tri_up |
14 | '3' Marqueur Tri_left |
15 | '4' Marqueur Tri_right |
16 | 's' Marqueur carré |
17 | 'p' Marqueur Pentagone |
18 | '*' Marqueur étoile |
19 | 'h' Marqueur Hexagon1 |
20 | 'H' Marqueur hexagone2 |
21 | '+' Marqueur Plus |
22 | 'x' Marqueur X |
23 | 'D' Marqueur diamant |
24 | 'd' Marqueur Thin_diamond |
25 | '|' Marqueur Vline |
26 | '_' Marqueur Hline |
Les abréviations de couleur suivantes sont également définies.
Personnage | Couleur |
---|---|
«b» | Bleu |
'g' | vert |
«r» | rouge |
«c» | Cyan |
«m» | Magenta |
«y» | Jaune |
«k» | Noir |
«w» | blanc |
Pour afficher les cercles représentant des points, au lieu de la ligne dans l'exemple ci-dessus, utilisez “ob” comme chaîne de format dans la fonction plot ().
Exemple
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y,"ob")
plt.show()
Le code ci-dessus doit produire la sortie suivante -
Graphique d'onde sinusoïdale
Le script suivant produit le sine wave plot en utilisant matplotlib.
Exemple
import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on a sine curve
x = np.arange(0, 3 * np.pi, 0.1)
y = np.sin(x)
plt.title("sine wave form")
# Plot the points using matplotlib
plt.plot(x, y)
plt.show()
sous-tracé ()
La fonction subplot () vous permet de tracer différentes choses dans la même figure. Dans le script suivant,sine et cosine values sont tracés.
Exemple
import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
# Set up a subplot grid that has height 2 and width 1,
# and set the first such subplot as active.
plt.subplot(2, 1, 1)
# Make the first plot
plt.plot(x, y_sin)
plt.title('Sine')
# Set the second subplot as active, and make the second plot.
plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title('Cosine')
# Show the figure.
plt.show()
Le code ci-dessus doit produire la sortie suivante -
bar()
le pyplot submodule fournit bar()fonction pour générer des graphiques à barres. L'exemple suivant produit le graphique à barres de deux ensembles dex et y tableaux.
Exemple
from matplotlib import pyplot as plt
x = [5,8,10]
y = [12,16,6]
x2 = [6,9,11]
y2 = [6,15,7]
plt.bar(x, y, align = 'center')
plt.bar(x2, y2, color = 'g', align = 'center')
plt.title('Bar graph')
plt.ylabel('Y axis')
plt.xlabel('X axis')
plt.show()
Ce code devrait produire la sortie suivante -
NumPy a un numpy.histogram()fonction qui est une représentation graphique de la distribution de fréquence des données. Rectangles de taille horizontale égale correspondant à l'intervalle de classe appelébin et variable height correspondant à la fréquence.
numpy.histogram ()
La fonction numpy.histogram () prend le tableau d'entrée et les bins comme deux paramètres. Les éléments successifs du tableau bin agissent comme la limite de chaque bin.
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
np.histogram(a,bins = [0,20,40,60,80,100])
hist,bins = np.histogram(a,bins = [0,20,40,60,80,100])
print hist
print bins
Il produira la sortie suivante -
[3 4 5 2 1]
[0 20 40 60 80 100]
plt ()
Matplotlib peut convertir cette représentation numérique de l'histogramme en un graphique. leplt() function du sous-module pyplot prend le tableau contenant les données et le tableau bin comme paramètres et se convertit en histogramme.
from matplotlib import pyplot as plt
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
plt.hist(a, bins = [0,20,40,60,80,100])
plt.title("histogram")
plt.show()
Il devrait produire la sortie suivante -
Les objets ndarray peuvent être enregistrés et chargés à partir des fichiers disque. Les fonctions IO disponibles sont -
load() et save() fonctions gèrent les fichiers binaires / numPy (avec npy extension)
loadtxt() et savetxt() les fonctions gèrent les fichiers texte normaux
NumPy introduit un format de fichier simple pour les objets ndarray. Ce.npy file stocke les données, la forme, le type dtype et d'autres informations nécessaires pour reconstruire le ndarray dans un fichier disque de sorte que le tableau soit correctement récupéré même si le fichier est sur une autre machine avec une architecture différente.
numpy.save ()
le numpy.save() fichier stocke la matrice d'entrée dans un fichier disque avec npy extension.
import numpy as np
a = np.array([1,2,3,4,5])
np.save('outfile',a)
Pour reconstruire un tableau à partir de outfile.npy, utilisation load() fonction.
import numpy as np
b = np.load('outfile.npy')
print b
Il produira la sortie suivante -
array([1, 2, 3, 4, 5])
Les fonctions save () et load () acceptent un paramètre booléen supplémentaire allow_pickles. Un pickle en Python est utilisé pour sérialiser et désérialiser des objets avant d'enregistrer ou de lire à partir d'un fichier disque.
savetxt ()
Le stockage et la récupération des données du tableau dans un format de fichier texte simple se fait avec savetxt() et loadtxt() les fonctions.
Exemple
import numpy as np
a = np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b = np.loadtxt('out.txt')
print b
Il produira la sortie suivante -
[ 1. 2. 3. 4. 5.]
Les fonctions savetxt () et loadtxt () acceptent des paramètres optionnels supplémentaires tels que l'en-tête, le pied de page et le délimiteur.