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.