Tutoriel NumPy

NumPy, qui signifie Numerical Python, est une bibliothèque composée d'objets de tableau
multidimensionnel et d'une collection de routines pour traiter ces tableaux. En utilisant NumPy,
des opérations mathématiques et logiques sur des tableaux peuvent être effectuées. Ce tutoriel
explique les bases de NumPy telles que son architecture et son environnement. Il aborde
également les différentes fonctions de tableau, les types d'indexation, etc. Une introduction à
Matplotlib est également fournie. Tout cela est expliqué à l'aide d'exemples pour une meilleure
compréhension.
Ce tutoriel a été préparé pour ceux qui souhaitent en savoir plus sur les bases et les différentes
fonctions de NumPy. Il est particulièrement utile pour les développeurs d'algorithmes. Après avoir
terminé ce didacticiel, vous vous retrouverez à un niveau d'expertise modéré à partir duquel vous
pourrez accéder à des niveaux d'expertise plus élevés.
Vous devez avoir une compréhension de base des terminologies de programmation informatique.
Une compréhension de base de Python et de l'un des langages de programmation est un plus.

NumPy - Introduction
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.

NumPy - Environnement
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 [Link] est une distribution Python gratuite pour la pile
SciPy. Il est également disponible pour Linux et Mac.
Canopée ([Link] 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 depuis[Link]

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 [Link] 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

NumPy - Objet Ndarray

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 -

[Link]

Il crée un ndarray à partir de n'importe quel objet exposant l'interface de tableau, ou de toute
méthode qui renvoie un tableau.

[Link](object, dtype = None, copy = True, order = None, subok = False,

ndmin = 0)

Le constructeur ci-dessus prend les paramètres suivants -

N ° Sr. Paramètre et description

1 object
Tout objet exposant la méthode d'interface de tableau renvoie un tableau ou toute séquence (imbr
 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-classe

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 = [Link]([1,2,3])
print a

La sortie est la suivante -

[1, 2, 3]

Exemple 2
# more than one dimensions
import numpy as np
a = [Link]([[1, 2], [3, 4]])
print a

La sortie est la suivante -

[[1, 2]
[3, 4]]
Exemple 3
# minimum dimensions
import numpy as np
a = [Link]([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 = [Link]([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é à 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 - Types de données

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.

N ° Sr. 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
 Flotteur 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 -

[Link](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 = [Link](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 = [Link]('i4')
print dt

La sortie est la suivante -

int32

Exemple 3
# using endian notation
import numpy as np
dt = [Link]('>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 = [Link]([('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 = [Link]([('age',np.int8)])
a = [Link]([(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 = [Link]([('age',np.int8)])
a = [Link]([(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 = [Link]([('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 = [Link]([('name','S20'), ('age', 'i1'), ('marks', 'f4')])

a = [Link]([('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)

NumPy - Attributs de tableau

Dans ce chapitre, nous aborderons les différents attributs de tableau de NumPy.

[Link]
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 = [Link]([[1,2,3],[4,5,6]])
print [Link]

La sortie est la suivante -

(2, 3)
Exemple 2
# this resizes the ndarray
import numpy as np

a = [Link]([[1,2,3],[4,5,6]])
[Link] = (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 = [Link]([[1,2,3],[4,5,6]])
b = [Link](3,2)
print b

La sortie est la suivante -

[[1, 2]
[3, 4]
[5, 6]]

[Link]
Cet attribut de tableau renvoie le nombre de dimensions de tableau.

Exemple 1
# an array of evenly spaced numbers
import numpy as np
a = [Link](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 = [Link](24)
[Link]

# now reshape it
b = [Link](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]]]

[Link]
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 = [Link]([1,2,3,4,5], dtype = np.int8)
print [Link]

La sortie est la suivante -

1

Exemple 2
# dtype of array is now float32 (4 bytes)
import numpy as np
x = [Link]([1,2,3,4,5], dtype = np.float32)
print [Link]

La sortie est la suivante -

[Link]
L'objet ndarray possède les attributs suivants. Ses valeurs actuelles sont renvoyées par cette
fonction.

N ° Sr. 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,

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 ser
tableau
Exemple
L'exemple suivant montre les valeurs actuelles des indicateurs.

import numpy as np
x = [Link]([1,2,3,4,5])
print [Link]

La sortie est la suivante -

C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False

NumPy - Routines de création de tableaux

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.

[Link]
Il crée un tableau non initialisé de forme et de type spécifié. Il utilise le constructeur suivant -

[Link](shape, dtype = float, order = 'C')

Le constructeur prend les paramètres suivants.

[Link]. 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 F
Exemple
Le code suivant montre un exemple de tableau vide.

import numpy as np
x = [Link]([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.

[Link]
Renvoie un nouveau tableau de la taille spécifiée, rempli de zéros.

[Link](shape, dtype = float, order = 'C')

Le constructeur prend les paramètres suivants.

[Link]. 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 F

Exemple 1
# array of five zeros. Default dtype is float
import numpy as np
x = [Link](5)
print x
La sortie est la suivante -

[ 0. 0. 0. 0. 0.]

Exemple 2
import numpy as np
x = [Link]((5,), dtype = [Link])
print x

Maintenant, la sortie serait la suivante -

[0 0 0 0 0]

Exemple 3
# custom type
import numpy as np
x = [Link]((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print x

Il devrait produire la sortie suivante -

[[(0,0)(0,0)]
[(0,0)(0,0)]]

[Link]
Renvoie un nouveau tableau de taille et de type spécifiés, rempli de uns.

[Link](shape, dtype = None, order = 'C')

Le constructeur prend les paramètres suivants.

[Link]. 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 F

Exemple 1
# array of five ones. Default dtype is float
import numpy as np
x = [Link](5)
print x

La sortie est la suivante -

[ 1. 1. 1. 1. 1.]

Exemple 2
import numpy as np
x = [Link]([2,2], dtype = int)
print x

Maintenant, la sortie serait la suivante -

[[1 1]
[1 1]]

NumPy - Tableau à partir de données

existantes
Dans ce chapitre, nous verrons comment créer un tableau à partir de données existantes.

[Link]
Cette fonction est similaire à [Link], sauf qu'elle a moins de paramètres. Cette routine est
utile pour convertir une séquence Python en ndarray.

[Link](a, dtype = None, order = None)

Le constructeur prend les paramètres suivants.

N ° Sr. 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 tuple

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 = [Link](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 = [Link](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 = [Link](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 = [Link](x)
print a

Ici, la sortie serait la suivante -

[(1, 2, 3) (4, 5)]

[Link]
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.

[Link](buffer, dtype = float, count = -1, offset = 0)

Le constructeur prend les paramètres suivants.

N ° Sr. 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 = [Link](s, dtype = 'S1')
print a

Voici sa sortie -

['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']

[Link]
Cette fonction construit un ndarrayobjet de tout objet itérable. Un nouveau tableau
unidimensionnel est renvoyé par cette fonction.

[Link](iterable, dtype, count = -1)

Ici, le constructeur prend les paramètres suivants.

N ° Sr. 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 to
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 = [Link](it, dtype = float)
print x

Maintenant, la sortie serait la suivante -

[0. 1. 2. 3. 4.]

NumPy - Tableau à partir de plages

numériques
Dans ce chapitre, nous verrons comment créer un tableau à partir de plages numériques.

[Link]
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 -

[Link](start, stop, step, dtype)

Le constructeur prend les paramètres suivants.

 N ° Sr. 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 utili

Les exemples suivants montrent comment utiliser cette fonction.

Exemple 1
import numpy as np
x = [Link](5)
print x

Sa sortie serait la suivante -

[0 1 2 3 4]

Exemple 2
import numpy as np
# dtype set
x = [Link](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 = [Link](10,20,2)
print x

Sa sortie est la suivante -

[10 12 14 16 18]

[Link]
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 -

[Link](start, stop, num, endpoint, retstep, dtype)

Le constructeur prend les paramètres suivants.

N ° Sr. 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 = [Link](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 = [Link](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 = [Link](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)

[Link]
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.

[Link](start, stop, num, endpoint, base, dtype)

Les paramètres suivants déterminent la sortie de logspace fonction.

N ° Sr. 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'ent

Les exemples suivants vous aideront à comprendre logspace fonction.

Exemple 1
import numpy as np
# default base is 10
a = [Link](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 = [Link](1,10,num = 10, base = 2)
print a

Maintenant, la sortie serait -

[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]

NumPy - Indexation et découpage

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 = [Link](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 transmis au ndarray, une partie de celui-ci commençant par l'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 = [Link](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 = [Link](10)
b = a[5]
print b

Sa sortie est la suivante -

Exemple 4
# slice items starting from index
import numpy as np
a = [Link](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 = [Link](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 = [Link]([[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 ligne, il renverra un ndarray comprenant des éléments en lignes.

Exemple 7
# array to begin with
import numpy as np
a = [Link]([[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]]

NumPy - Indexation avancée

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 basé sur
son index Ndimensional. 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 = [Link]([[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 = [Link]([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])

print 'Our array is:'

print x
print '\n'

rows = [Link]([[0,0],[3,3]])
cols = [Link]([[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 = [Link]([[ 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 = [Link]([[ 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 = [Link]([[Link], 1,2,[Link],3,4,5])
print a[~[Link](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 = [Link]([1, 2+6j, 5, 3.5+5j])
print a[[Link](a)]

Ici, la sortie est la suivante -

[2.0+6.j 3.5+5.j]

NumPy - Diffusion
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 = [Link]([1,2,3,4])
b = [Link]([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 dans chaque dimension de la forme de sortie est au maximum des tailles
d'entrée dans 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 = [Link]([[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 = [Link]([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.

NumPy - Itération sur un tableau

Le package NumPy contient un objet itérateur [Link]. 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 = [Link](0,60,5)
a = [Link](3,4)

print 'Original array is:'

print a
print '\n'

print 'Modified array is:'

for x in [Link](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 = [Link](0,60,5)
a = [Link](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 [Link](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 = [Link](0,60,5)
a = [Link](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 = [Link](order = 'C')
print c
for x in [Link](c):
print x,

print '\n'

print 'Sorted in F-style order:'

c = [Link](order = 'F')
print c
for x in [Link](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 = [Link](0,60,5)
a = [Link](3,4)

print 'Original array is:'

print a
print '\n'

print 'Sorted in C-style order:'

for x in [Link](a, order = 'C'):
print x,
print '\n'

print 'Sorted in F-style order:'

for x in [Link](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 objet 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 = [Link](0,60,5)
a = [Link](3,4)
print 'Original array is:'
print a
print '\n'

for x in [Link](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 -
 N ° Sr. 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

Exemple
Dans l'exemple suivant, les tableaux unidimensionnels correspondant à chaque colonne sont
parcourus par l'itérateur.

import numpy as np
a = [Link](0,60,5)
a = [Link](3,4)

print 'Original array is:'

print a
print '\n'

print 'Modified array is:'

for x in [Link](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 = [Link](0,60,5)
a = [Link](3,4)

print 'First array is:'

print a
print '\n'

print 'Second array is:'

b = [Link]([1, 2, 3, 4], dtype = int)
print b
print '\n'

print 'Modified array is:'

for x,y in [Link]([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

NumPy - Manipulation de tableaux

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
N ° Sr. 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

N ° Sr. Description d'opération

1 transposer

Permute les dimensions d'un tableau

2 ndarray.T

Identique à [Link] ()

3 rollaxis

Fait rouler l'axe spécifié vers l'arrière

4 swapaxes
 Intervertit les deux axes d'un tableau

Modification des dimensions

N ° Sr. 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

N ° Sr. 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
N ° Sr. 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 (ligne par ligne)

Ajout / suppression d'éléments

N ° Sr. É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

NumPy - Opérateurs binaires

Voici les fonctions pour les opérations au niveau du bit disponibles dans le package NumPy.
 [Link]. 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

NumPy - Fonctions de chaîne

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.

N ° Sr. 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

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 nou

13 décoder()

Appelle [Link] par élément

14 encoder()

Appelle [Link] élément par élément

Ces fonctions sont définies dans la classe de tableau de caractères ([Link]). L'ancien
package Numarray contenait la classe chararray. Les fonctions ci-dessus dans la classe
[Link] sont utiles pour effectuer des opérations de chaîne vectorisées.

NumPy - Fonctions mathématiques

Tout naturellement, NumPy contient un grand nombre d'opérations mathématiques diverses.
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 = [Link]([0,30,45,60,90])

print 'Sine of different angles:'

# Convert to radians by multiplying with pi/180
print [Link](a*[Link]/180)
print '\n'

print 'Cosine values for angles in array:'

print [Link](a*[Link]/180)
print '\n'

print 'Tangent values for given angles:'

print [Link](a*[Link]/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é [Link]() function en
convertissant les radians en degrés.
Example

import numpy as np
a = [Link]([0,30,45,60,90])

print 'Array containing sine values:'

sin = [Link](a*[Link]/180)
print sin
print '\n'

print 'Compute sine inverse of angles. Returned values are in radians.'

inv = [Link](sin)
print inv
print '\n'

print 'Check result by converting to degrees:'

print [Link](inv)
print '\n'

print 'arccos and arctan functions behave similarly:'

cos = [Link](a*[Link]/180)
print cos
print '\n'

print 'Inverse of cos:'

inv = [Link](cos)
print inv
print '\n'

print 'In degrees:'

print [Link](inv)
print '\n'

print 'Tan function:'

tan = [Link](a*[Link]/180)
print tan
print '\n'

print 'Inverse of tan:'

inv = [Link](tan)
print inv
print '\n'

print 'In degrees:'

print [Link](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

[Link] ()
Il s'agit d'une fonction qui renvoie la valeur arrondie à la précision souhaitée. La fonction prend
les paramètres suivants.

[Link](a,decimals)

Où,

N ° Sr. 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 à
décimale

Example

import numpy as np
a = [Link]([1.0,5.55, 123, 0.567, 25.532])

print 'Original array:'

print a
print '\n'

print 'After rounding:'

print [Link](a)
print [Link](a, decimals = 1)
print [Link](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. ]

[Link] ()
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 = [Link]([-1.7, 1.5, -0.2, 0.6, 10])

print 'The given array:'

print a
print '\n'

print 'The modified array:'

print [Link](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.]

[Link] ()
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 = [Link]([-1.7, 1.5, -0.2, 0.6, 10])

print 'The given array:'

print a
print '\n'

print 'The modified array:'

print [Link](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.]

NumPy - Opérations arithmétiques

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 = [Link](9, dtype = np.float_).reshape(3,3)

print 'First array:'

print a
print '\n'

print 'Second array:'

b = [Link]([10,10,10])
print b
print '\n'

print 'Add the two arrays:'

print [Link](a,b)
print '\n'

print 'Subtract the two arrays:'

print [Link](a,b)
print '\n'

print 'Multiply the two arrays:'

print [Link](a,b)
print '\n'

print 'Divide the two arrays:'

print [Link](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.

[Link] ()
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 = [Link]([0.25, 1.33, 1, 0, 100])

print 'Our array is:'

print a
print '\n'

print 'After applying reciprocal function:'

print [Link](a)
print '\n'

b = [Link]([100], dtype = int)

print 'The second array is:'
print b
print '\n'

print 'After applying reciprocal function:'

print [Link](b)

Il produira la sortie suivante -

Our array is:

[ 0.25 1.33 1. 0. 100. ]

After applying reciprocal function:

[Link]: RuntimeWarning: divide by zero encountered in reciprocal
print [Link](a)
[ 4. 0.7518797 1. inf 0.01 ]

The second array is:

[100]

After applying reciprocal function:

[0]

[Link] ()
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 = [Link]([10,100,1000])

print 'Our array is:'

print a
print '\n'

print 'Applying power function:'

print [Link](a,2)
print '\n'

print 'Second array:'

b = [Link]([1,2,3])
print b
print '\n'

print 'Applying power function again:'

print [Link](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]

[Link] ()
Cette fonction renvoie le reste de la division des éléments correspondants dans le tableau
d'entrée. La [Link]() produit également le même résultat.

import numpy as np
a = [Link]([10,20,30])
b = [Link]([3,5,7])

print 'First array:'

print a
print '\n'

print 'Second array:'

print b
print '\n'

print 'Applying mod() function:'

print [Link](a,b)
print '\n'

print 'Applying remainder() function:'

print [Link](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.
 [Link]() - renvoie la partie réelle de l'argument de type de données complexe.
 [Link]() - renvoie la partie imaginaire de l'argument de type de données complexe.
 [Link]() - renvoie le conjugué complexe, qui est obtenu en changeant le signe de la
partie imaginaire.
 [Link]()- 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 = [Link]([-5.6j, 0.2j, 11. , 1+1j])

print 'Our array is:'

print a
print '\n'

print 'Applying real() function:'

print [Link](a)
print '\n'

print 'Applying imag() function:'

print [Link](a)
print '\n'

print 'Applying conj() function:'

print [Link](a)
print '\n'

print 'Applying angle() function:'

print [Link](a)
print '\n'
print 'Applying angle() function again (result in degrees)'
print [Link](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 - Fonctions statistiques

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 -

[Link] () et [Link] ()
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 = [Link]([[3,7,5],[8,4,3],[2,4,9]])
print 'Our array is:'
print a
print '\n'

print 'Applying amin() function:'

print [Link](a,1)
print '\n'

print 'Applying amin() function again:'

print [Link](a,0)
print '\n'

print 'Applying amax() function:'

print [Link](a)
print '\n'

print 'Applying amax() function again:'

print [Link](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]
[Link] ()
le [Link]() La fonction renvoie la plage (maximum-minimum) de valeurs le long d'un axe.

import numpy as np
a = [Link]([[3,7,5],[8,4,3],[2,4,9]])

print 'Our array is:'

print a
print '\n'

print 'Applying ptp() function:'

print [Link](a)
print '\n'

print 'Applying ptp() function along axis 1:'

print [Link](a, axis = 1)
print '\n'

print 'Applying ptp() function along axis 0:'

print [Link](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]
[Link] ()
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
[Link]() prend les arguments suivants.

[Link](a, q, axis)

Où,

N ° Sr. 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 = [Link]([[30,40,70],[80,20,10],[50,90,60]])

print 'Our array is:'

print a
print '\n'

print 'Applying percentile() function:'

print [Link](a,50)
print '\n'

print 'Applying percentile() function along axis 1:'

print [Link](a,50, axis = 1)
print '\n'
print 'Applying percentile() function along axis 0:'
print [Link](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.]

[Link] ()
Medianest définie comme la valeur séparant la moitié supérieure d'un échantillon de données de
la moitié inférieure. [Link]() La fonction est utilisée comme indiqué dans le
programme suivant.

Exemple
import numpy as np
a = [Link]([[30,65,70],[80,95,10],[50,90,60]])

print 'Our array is:'

print a
print '\n'

print 'Applying median() function:'

print [Link](a)
print '\n'

print 'Applying median() function along axis 0:'

print [Link](a, axis = 0)
print '\n'

print 'Applying median() function along axis 1:'

print [Link](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.]

[Link] ()
La moyenne arithmétique est la somme des éléments le long d'un axe divisée par le nombre
d'éléments. [Link]()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 = [Link]([[1,2,3],[3,4,5],[4,5,6]])

print 'Our array is:'

print a
print '\n'

print 'Applying mean() function:'

print [Link](a)
print '\n'

print 'Applying mean() function along axis 0:'

print [Link](a, axis = 0)
print '\n'

print 'Applying mean() function along axis 1:'

print [Link](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.]

[Link] ()
La moyenne pondérée est une moyenne résultant de la multiplication de chaque composante par
un facteur reflétant son importance. [Link]()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 = [Link]([1,2,3,4])
print 'Our array is:'
print a
print '\n'

print 'Applying average() function:'

print [Link](a)
print '\n'

# this is same as mean when weight is not specified

wts = [Link]([4,3,2,1])

print 'Applying average() function again:'

print [Link](a,weights = wts)
print '\n'

# Returns the sum of weights, if the returned parameter is set to True.

print 'Sum of weights'
print [Link]([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 = [Link](6).reshape(3,2)

print 'Our array is:'

print a
print '\n'

print 'Modified array:'

wt = [Link]([3,5])
print [Link](a, axis = 1, weights = wt)
print '\n'

print 'Modified array:'

print [Link](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 carrés par rapport à la moyenne. La
formule de l'écart type est la suivante -

std = sqrt(mean(abs(x - [Link]())**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.-à-d. Sqrt (5/4) est
1,1180339887498949.
Exemple
import numpy as np
print [Link]([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 - [Link]())**2). En
d'autres termes, l'écart type est la racine carrée de la variance.

Exemple
import numpy as np
print [Link]([1,2,3,4])

Il produira la sortie suivante -

1.25

NumPy - Fonctions de tri, de recherche et

de comptage
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

'tri rapide' 1 O (n ^ 2) 0

'tri par fusion' 2 O (n * log (n)) ~n/2

'tas' 3 O (n * log (n)) 0

[Link] ()
La fonction sort () renvoie une copie triée du tableau d'entrée. Il a les paramètres suivants -
[Link](a, axis, kind, order)

Où,

[Link]. 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 = [Link]([[3,7],[9,1]])

print 'Our array is:'

print a
print '\n'

print 'Applying sort() function:'

print [Link](a)
print '\n'

print 'Sort along axis 0:'

print [Link](a, axis = 0)
print '\n'

# Order parameter in sort function

dt = [Link]([('name', 'S10'),('age', int)])
a = [Link]([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype =
dt)

print 'Our array is:'

print a
print '\n'

print 'Order by name:'

print [Link](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)]

[Link] ()
le [Link]()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 = [Link]([3, 1, 2])

print 'Our array is:'

print x
print '\n'

print 'Applying argsort() to x:'

y = [Link](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
[Link] ()
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 = [Link]((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.

[Link] () et [Link] ()
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 = [Link]([[30,40,70],[80,20,10],[50,90,60]])

print 'Our array is:'

print a
print '\n'

print 'Applying argmax() function:'

print [Link](a)
print '\n'

print 'Index of maximum number in flattened array'

print [Link]()
print '\n'

print 'Array containing indices of maximum along axis 0:'

maxindex = [Link](a, axis = 0)
print maxindex
print '\n'

print 'Array containing indices of maximum along axis 1:'

maxindex = [Link](a, axis = 1)
print maxindex
print '\n'

print 'Applying argmin() function:'

minindex = [Link](a)
print minindex
print '\n'

print 'Flattened array:'

print [Link]()[minindex]
print '\n'

print 'Flattened array along axis 0:'

minindex = [Link](a, axis = 0)
print minindex
print '\n'

print 'Flattened array along axis 1:'

minindex = [Link](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]
[Link] ()
le [Link]() La fonction renvoie les indices des éléments non nuls dans le tableau
d'entrée.

Exemple
import numpy as np
a = [Link]([[30,40,0],[0,20,10],[50,0,60]])

print 'Our array is:'

print a
print '\n'

print 'Applying nonzero() function:'

print [Link] (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]))

[Link] ()
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 = [Link](9.).reshape(3, 3)

print 'Our array is:'

print x
print 'Indices of elements > 3'
y = [Link](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.]

[Link] ()
le extract() function renvoie les éléments satisfaisant à n'importe quelle condition.

import numpy as np
x = [Link](9.).reshape(3, 3)

print 'Our array is:'

print x

# define a condition
condition = [Link](x,2) == 0

print 'Element-wise value of condition'

print condition

print 'Extract elements using condition'

print [Link](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.]

NumPy - Permutation d'octets

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 little-endian (le moins significatif est stocké dans la
plus petite adresse) ou big-endian (octet le plus significatif dans la plus petite adresse).

[Link] ()
le [Link]() La fonction bascule entre les deux représentations: bigendian et
little-endian.

import numpy as np
a = [Link]([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 [Link](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']

NumPy - Copies et vues

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 = [Link](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:'

[Link] = 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 [Link]()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 = [Link](6).reshape(3,2)

print 'Array a:'

print a

print 'Create view of a:'

b = [Link]()
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

[Link] = 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 = [Link]([[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 [Link]()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 se partage pas avec le tableau d'origine.

Exemple
import numpy as np
a = [Link]([[10,10], [2,3], [4,5]])

print 'Array a is:'

print a

print 'Create a deep copy of a:'

b = [Link]()
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]]

NumPy - Bibliothèque de matrices

Le package NumPy contient une bibliothèque Matrix [Link]. Ce module a des fonctions
qui renvoient des matrices au lieu d'objets ndarray.
[Link] ()
le [Link]()La fonction renvoie une nouvelle matrice sans initialiser les entrées. La fonction
prend les paramètres suivants.

[Link](shape, dtype, order)

Où,

[Link]. 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 [Link]
import numpy as np

print [Link]((2,2))
# filled with random data

Il produira la sortie suivante -

[[ 2.12199579e-314, 4.24399158e-314]
[ 4.24399158e-314, 2.12199579e-314]]

[Link] ()
Cette fonction renvoie la matrice remplie de zéros.

import [Link]
import numpy as np
print [Link]((2,2))
Il produira la sortie suivante -

[[ 0. 0.]
[ 0. 0.]]

[Link] ()
Cette fonction renvoie la matrice remplie de 1.

import [Link]
import numpy as np
print [Link]((2,2))

Il produira la sortie suivante -

[[ 1. 1.]
[ 1. 1.]]

[Link] ()
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.

[Link](n, M,k, dtype)

Où,

[Link]. 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 [Link]
import numpy as np
print [Link](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.]]

[Link] ()
le [Link]()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 [Link]
import numpy as np
print [Link](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.]]

[Link] ()
le [Link]() La fonction renvoie une matrice de la taille donnée remplie de valeurs
aléatoires.

Exemple
import [Link]
import numpy as np
print [Link](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 [Link]
import numpy as np

i = [Link]('1,2;3,4')
print i

Il produira la sortie suivante -

[[1 2]
[3 4]]

Exemple
import [Link]
import numpy as np

j = [Link](i)
print j

Il produira la sortie suivante -

[[1 2]
[3 4]]

Exemple
import [Link]
import numpy as np

k = [Link] (j)
print k
Il produira la sortie suivante -

[[1 2]
[3 4]]

NumPy - Algèbre linéaire

Le package NumPy contient [Link] 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.

N ° Sr. 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

NumPy - Matplotlib
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 [Link] .
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 = [Link](1,11)
y = 2 * x + 5
[Link]("Matplotlib demo")
[Link]("x axis caption")
[Link]("y axis caption")
[Link](x,y)
[Link]()

Un objet ndarray x est créé à partir de [Link]() 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.

N ° Sr. 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 Hexagon2

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 = [Link](1,11)
y = 2 * x + 5
[Link]("Matplotlib demo")
[Link]("x axis caption")
[Link]("y axis caption")
[Link](x,y,"ob")
[Link]()

Le code ci-dessus doit produire la sortie suivante -

Tracé sinusoïdal
Le script suivant produit le sine wave plot en utilisant matplotlib.

Exemple
import numpy as np
import [Link] as plt

# Compute the x and y coordinates for points on a sine curve

x = [Link](0, 3 * [Link], 0.1)
y = [Link](x)
[Link]("sine wave form")

# Plot the points using matplotlib

[Link](x, y)
[Link]()
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 [Link] as plt

# Compute the x and y coordinates for points on sine and cosine curves
x = [Link](0, 3 * [Link], 0.1)
y_sin = [Link](x)
y_cos = [Link](x)

# Set up a subplot grid that has height 2 and width 1,

# and set the first such subplot as active.
[Link](2, 1, 1)
# Make the first plot
[Link](x, y_sin)
[Link]('Sine')

# Set the second subplot as active, and make the second plot.
[Link](2, 1, 2)
[Link](x, y_cos)
[Link]('Cosine')

# Show the figure.

[Link]()

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]
[Link](x, y, align = 'center')
[Link](x2, y2, color = 'g', align = 'center')
[Link]('Bar graph')
[Link]('Y axis')
[Link]('X axis')

[Link]()

Ce code devrait produire la sortie suivante -

NumPy - Histogramme utilisant Matplotlib
NumPy a un [Link]()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.

[Link] ()
La fonction [Link] () 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 = [Link]([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
[Link](a,bins = [0,20,40,60,80,100])
hist,bins = [Link](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 = [Link]([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
[Link](a, bins = [0,20,40,60,80,100])
[Link]("histogram")
[Link]()

Il devrait produire la sortie suivante -

E / S avec NumPy
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. [Link] 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 se
trouve sur une autre machine avec une architecture différente.

[Link] ()
le [Link]() fichier stocke la matrice d'entrée dans un fichier disque avec npy extension.

import numpy as np
a = [Link]([1,2,3,4,5])
[Link]('outfile',a)

Pour reconstruire un tableau à partir de [Link], utilisation load() fonction.

import numpy as np
b = [Link]('[Link]')
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 = [Link]([1,2,3,4,5])
[Link]('[Link]',a)
b = [Link]('[Link]')
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.