 Créer sur une suite d’entiers : fonction range().

Elle génère une suite arithmétique. range(10).

 Convertir le résultat en liste grâce à la fonction list(), le nombre de fin n’est jamais dans la
liste générée.

list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list(range(5, 10))

[5, 6, 7, 8, 9]

Avec un pas (le 3eme parametre)

list(range(0, 10, 3))

[0, 3, 6, 9]

list(range(-10, -100, -30))

[-10, -40, -70]

Accès aux éléments d’une liste : indiquer entre crochets [] l’indice de l’élément.

a = list(range(1,10,2))

[1, 3, 5, 7, 9]

a[0]

a[2]

La fonction len() renvoie le nombre d’éléments.

a = list(range(7,10))

[7, 8, 9]

len(a)

Lecture d’informations au clavier - la fonction input()

x = int(input("Donnez un entier : "))

Par défaut, la fonction input() renvoie une chaîne de caractères. Il faut donc utiliser la fonction int() la
convertir en entier.

La fonction type()

type(15)
 int
a = 15
type(a)
int
a = "toto"
type(a)
str

jour = ["lundi", "mardi", "mercredi", 1800, 20.357, "jeudi", "vendredi"]

type(jour)
list

a = 2 + 3j
type(a)
complex
a
(2+3j)

Tuples en Python
A partir des types de base (int, float, etc.), il est possible d'élaborer de nouveaux types. On les appelle
des types construits. Un exemple de type construit est le tuple.

Il permet de créer une collection ordonnée de plusieurs éléments. En mathématiques, on parle de p-

uplet.
Par exemple, un quadruplet est constitué de 4 éléments.

Les tuples ressemblent aux listes, mais on ne peut pas les modifier une fois créés.
On dit qu’un tuple n’est pas mutable.
On le définit avec des parenthèses.
a = (3, 4, 7)
type(a)
<class 'tuple'>
Module NumPy
Le module NumPy permet d’effectuer des calculs sur des vecteurs ou des matrices,
élément par élément, via un nouveau type d’objet appelé array.

>>> import numpy ou import numpy as np

1. Objets de type array

Les objets de type array correspondent à des tableaux à une ou plusieurs dimensions et permettent
d’effectuer du calcul vectoriel.

La fonction array() convertit une liste ou un tuple en un objet de type array.

Conversion d’une liste à une dimension en objet array :

import numpy as np
a = [1, 2, 3]
b=[Link](a)
type(b)

Nous avons converti la liste [1, 2, 3] en array. La fonction [Link]() accepte comme argument un
tuple, ou un objet de type range.
Par ailleurs, lorsqu’on demande à Python d’afficher le contenu d’un objet array, le mot array et les
symboles ([ et ]) sont utilisés pour le distinguer d’une liste (délimitée par les caractères [ et ]) ou d’un
tuple (délimité par les caractères ( et )).

Un objet array ne contient que des données du même type.

Mais il est possible de créer un objet array à partir d’une liste contenant des entiers et des chaînes de
caractères, dans ce cas, toutes les valeurs seront considérées comme des chaînes de caractères :

a = [Link]([1, 2, "tigre"])
a
array(['1', '2', 'tigre'], dtype='<U21')

b = [Link]([1, 2, 3.5])
b
array([1. , 2. , 3.5])

La fonction arange() permet de construire un array à une dimension :

a=[Link](10)
a

[Link](10, 0, -1)
array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])

La fonction arange() peut générer des objets array qui contiennent des entiers ou des floats
[Link](10.0)

On peut effectuer des opérations vectorielles élément par élément sur ce type d’objet, ce qui est bien
voulu lorsqu’on analyse de grandes quantités de données.

Exemple
v = [Link](4)
v
array([0, 1, 2, 3])
On ajoute 1 à chacun des éléments du tableau v :
v+1
array([1, 2, 3, 4])

On multiplie par 2 chacun des éléments de v :

v*2
array([0, 2, 4, 6])

v*v
array([0, 1, 4, 9])

 Array et dimensions
Il est aussi possible de construire des objets arrays à deux dimensions, il suffit de passer en argument
une liste de listes à la fonction array() :

v = [Link]([[1, 2], [3, 4], [5, 6]])

v
array([[1, 2],
[3, 4],
[5, 6]])

 On peut aussi créer des tableaux à trois dimensions en passant comme argument à la fonction
array() une liste de listes de listes :

w = [Link]([[[1, 2], [2, 3]], [[4, 5], [5, 6]]])

w

Un objet array à une dimension peut être assimilé à un vecteur et un array à deux dimensions à une
matrice. On peut généraliser ces objets mathématiques avec un nombre arbitraires de dimensions, on
parle alors de tenseur, représentés dans NumPy par array à n dimensions.

[Link] : le nombre de dimensions de l’array

[Link] : les dimensions sous forme d’un tuple
[Link] : le nombre total d’éléments du tableau

 Redimensionnement d’array
La méthode .reshape() renvoie un nouvel array avec les nouvelles dimensions spécifiées en argument :
a = [Link](0, 6)
a
array([0, 1, 2, 3, 4, 5])

[Link]
(6,)

b = [Link]((2, 3))
b
array([[0, 1, 2],
[3, 4, 5]])

[Link]
(2, 3)
La méthode. reshape() attend que les nouvelles dimensions soient compatibles avec la dimension
initiale de l’objet array, si non elle génère une erreur.

Par contre la méthode .resize() ne déclenche pas d’erreur et ajoute des 0 jusqu’à ce que le nouvel array
soit rempli, ou bien coupe la liste initiale :

Exemple
a = [Link](0, 6)
[Link]
(6,)

[Link]((3, 3), refcheck=False)

[Link]
(3, 3)

a
array([[0, 1, 2],
[3, 4, 5],
[0, 0, 0]])

b = [Link](0, 10)
[Link]
(10,)

[Link]((2, 3), refcheck=False)

il se peut que la fonction [Link]() répète l’array initial afin de remplir les cases manquantes dans le
cas d’un nouvel array plus grand que l’array initial.

a = [Link](0, 6)
[Link]
(6,)

c = [Link](a, (3, 5))

[Link]
(3, 5)

c
array([[0, 1, 2, 3, 4],
[5, 0, 1, 2, 3],
[4, 5, 0, 1, 2]])

Remarque
Si vous utilisez la fonction print(), l’affichage sera différent. Le mot array, les parenthèses et les
virgules disparaissent.

Ceci peut amener des confusions, en particulier entre un array 1D : [0 1 2 3 4 5 6 7 8 9] et une liste
contenant les mêmes éléments : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 Dans ce cas, seule la présence ou l’absence de virgules permet de savoir s’il s’agit d’un array ou d’une
liste.

 Méthodes de calcul sur les arrays et l’argument axis

Dans NumPy les array possèdent une multitude de méthodes. Nombre d’entre elles permettent de faire
des calculs de base comme la moyenne .mean(), .sum() pour la somme, .std() pour l’écart-type, .max()
pour le maximum, .min() pour le minimum,… etc.

import random
ma_liste = list(range(8))
[Link](ma_liste)
ma_liste
[2, 7, 6, 4, 0, 3, 1, 5]

a = [Link](ma_liste, (4, 2))

a

array([[2, 7],
[6, 4],
[0, 3],
[1, 5]])

print([Link]()) : 7

Il y a un argument très utile dans toutes ces méthodes c'est axis.

Pour un array 2D, axis=0 signifie qu’on fera l’opération le long de l’axe 0, à savoir les lignes.

print([Link](axis=0))
resultat : array([6, 7])

Le résultat est une tableau de valeurs.

Dans l’array récupéré, le premier élément vaut 6 (maximum de la 1ère colonne) et le second vaut 7
(maximum de la seconde colonne).

Avec axis=1, on fait varier les colonnes. On récupère ainsi une valeur par ligne :
[Link](axis=1)
array([7, 6, 3, 5])

 Indices
Pour accéder aux éléments d’un objet array, on peut utiliser les indices ou les tranches, comme avec
les listes :
1 >>> a = np. arange (10)
2 >>> a
3 array ([0 , 1, 2, 3, 4, 5, 6, 7, 8, 9])

print(a[1])

4 >>> a [5:]
5 array ([5 , 6, 7, 8, 9])

6 >>> a [::2]
7 array ([0 , 2, 4, 6, 8])

8 >>> a [1]
1

Objet array à deux dimensions

1 >>> a = np. array ([[1 ,2] ,[3 ,4]])
2 >>> a
array([[1, 2],
[3, 4]])

On peut récupérer une ligne complète (d’indice m), une colonne complète (d’indice n) ou bien un seul
élément.

a[i,:] renvoie la ligne d’indice i,

a[:,j] renvoie la colonne d’indice j.

a[i, j] renvoie l’élément à la ligne d’indice i et à la colonne d’indice j.

Pour un array 2D, si un seul indice est donné, par exemple a[i], on récupère la
ligne d’indice i sous forme d’array 1D.

a[: ,0] #1ère colonne

array ([1 , 3])

a[0 ,:] #1ère ligne

array ([1 , 2])

a[1 ,1]
4

a[0]
array([1, 2])

Copie d’arrays
a = [Link](5)
a
array([0, 1, 2, 3, 4])

b=a
b[2] = -300
b
array([ 0, 1, -300, 3, 4])

a
array([ 0, 1, -300, 3, 4]) # le tableau a est automatiquement modifié !!!!

Par défaut la copie d’arrays se fait par référence, comme pour tous les
conteneurs en Python (listes, tuples, dictionnaires, etc.).

Pour éviter ce problème, on peut soit utiliser la fonction [Link](), qui crée
une nouvelle copie distincte de l’array initial, soit la fonction [Link](),
comme pour les listes.

a = [Link]((2, 2), 0) # matrice des zéro

a
array([[0, 0],
[0, 0]])
b = [Link](a)
b[1, 1] = -300
b
a
c = [Link](a)
c[1, 1] = -500
c
a

Construction automatique de matrices

Il peut être parfois pénible de construire une matrice (array à deux dimensions) à l’aide d’une liste de
listes.
Le module NumPy possède quelques fonctions pratiques pour initialiser des matrices.

Par exemple, les fonctions zeros() et ones() construisent des objets array contenant des 0 ou des 1.

Il suffit de leur passer en argument un tuple indiquant les dimensions voulues.

[Link] ((2 , 3))
array ([[0. , 0., 0.] ,
[0. , 0., 0.]])

np. ones ((3 , 3))

Par défaut, les fonctions zeros() et ones() génèrent des floats, mais on peut demander des entiers en
passant l’option int en second argument :
[Link] ((2 ,3) , int)

Pour construire une matrice avec autre chose que des 0 ou des 1, utiliser la fonction full() :
np. full ((2 , 3), 7, int )
array ([[7 , 7, 7],
[7, 7, 7]])

np. full ((2 , 3), 7, float )

 Chargement d’un array depuis un fichier

La plupart des données à analyser se trouvent des fichiers, il faut les télécharger.

La fonction la plus simple est [Link](). Celle-ci lit un fichier organisé en lignes
et colonnes.

Soit le fichier donnees:

1 7 310
15 -4 35
78 95 79

La fonction prend en argument le nom du fichier et renvoie un array 2D

directement :
[Link]("d:/donnees")

array([[ 1., 7., 310.],

[ 15., -4., 35.],
[ 78., 95., 79.]])

Petit problème
Chaque ligne doit avoir le même nombre de colonnes, la fonction ne gère pas les données manquantes.
• Chaque donnée est convertie en float, si une chaîne de caractères est rencontrée la fonction renvoie
une erreur.
• Par défaut, les données doivent être séparées par n’importe quelle combinaison d’espace(s) et/ou de
tabulations.

Cette fonction [Link]() contient de nombreux arguments permettant de récupérer certaines lignes
ou colonnes du fichier, d’ignorer des lignes de commentaire, de changer le séparateur par défaut (par
la virgule pour les fichiers .csv)…

L’opération inverse consiste à enregistrer un array (résultat d'un traitement) dans un fichier par la
fonction [Link]()

a = [Link](range(1, 10), (3, 3)) #les données à sauvegarder

a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

[Link]("d:/[Link]", a)

Cette fonction [Link]() écrit par défaut les données comme des floats. Il existe de nombreuses
options possibles pour changer le format, les séparateurs, etc.

Pour aller plus loin

Il existe d’autres fonctions plus avancées telles que [Link](), gérant les données manquantes,
ou encore [Link]() et [Link](), permettant de lire des données au format binaire. De même, il
existe des fonctions ou méthodes permettant d’écrire au format binaire : [Link]() ou .tofile(). Le
format binaire possède en général l’extension .npy ou .npz lorsque les données sont compressées.
L’avantage d’écrire au format binaire est que cela prend moins de place pour de gros tableaux de
données.

 Concaténation d’arrays
Il peut être très utile de concaténer un ou plusieurs arrays. Il existe pour cela plusieurs fonctions dans
NumPy,
[Link]() : pour les arrays 1D, prend en argument un tuple contenant les arrays à concaténer :

a1 = [Link]((0, 1))
a2 = [Link]((3, 4))

[Link]((a1, a2))

Pour les arrays 2D, ça se complique un peu, car on peut concaténer des lignes ou des colonnes! Ainsi,
[Link]() prend un argument optionnel, à savoir axis.

Axis va indiquer à NumPy si on veut concaténer le long de l’axe 0 (les lignes) ou le long de l’axe 1
(les colonnes).
Exemple :
a1 = [Link]([Link](range(6)), (3, 2))
a1
array([[0, 1],
 [2, 3],
[4, 5]])

a2 = a1 * 5
a2
array([[ 0, 5],
[10, 15],
[20, 25]])

La concaténation doit être possible en termes de dimensionalité, il faut que les deux arrays a1 et a2
aient le même nombre de lignes ou de colonnes.

On concatène d’abord par ligne (axis=0), c’est-à-dire qu’on ajoute les lignes du second array a2 à
celles de a1 :
[Link]((a1, a2), axis=0)

array([[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 0, 5],
[10, 15],
[20, 25]])

Ensuite, on concatène par colonne (axis=1).

[Link]((a1, a2), axis=1)

array([[ 0, 1, 0, 5],
[ 2, 3, 10, 15],
[ 4, 5, 20, 25]])

Ces opérations de concaténation sont très importantes, surtout, par exemple si on a des données dans
plusieurs fichiers différents et qu’on veut les mettre dans un array unique pour les analyser.

 Algèbre linéaire
La transposée d'une matrice : fonction transpose() ou l'attribut .T.

Ainsi :
a = [Link] ([Link] (1, 10) , (3, 3))
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

[Link](a)
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])

a.T
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])

Multiplication de deux matrices : fonction dot()

a = [Link] ([Link] (4) , (2, 2))
a
array ([[0 , 1],
[2, 3]])
[Link](a, a)
array ([[ 2, 3],
[ 6, 11]])

Produit de deux matrice élément par élément : a * a

a*a
array ([[0 , 1],
[4, 9]])

Remarque
Dans le module NumPy, il existe des objets de type matrix pour lesquels les multiplications de
matrices sont différents.

Sous module Linalg de NumPy

 La fonction diag() permet de générer une matrice diagonale :
a = [Link]((1, 2, 3))
a
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])

 inv() renvoie l’inverse d’une matrice carrée,

 det() renvoie le déterminant
 eig() renvoie les vecteurs et valeurs propres.

a = np. resize (np. arange (4) , (2 ,2))

a
array ([[0 , 1],
[2, 3]])

La fonction eig() renvoie un objet EigResult, qui contient les valeurs propres (eigenvalues) et les
vecteurs propres (eigenvectors).

[Link] (a)
11 ( array ([ -0.56155281 , 3.56155281]) , array ([[ -0.87192821 , -0.27032301] ,
12 [ 0.48963374 , -0.96276969]]))

EigResult(eigenvalues=array([-0.56155281, 3.56155281]),
eigenvectors=array([[-0.87192821, -0.27032301], [ 0.48963374, -0.96276969]]))

On peut ensuite récupérer ces valeur par affectation multiple.

eigvals, eigvecs = [Link](a)
print(eigvals)
print(eigvecs)

[Link] (a )[0]
array ([ -0.56155281 , 3.56155281])
[Link] (a )[1]
array ([[ -0.87192821 , -0.27032301] ,
[ 0.48963374 , -0.96276969]])

 Parcours de matrice et affectation de lignes et colonnes

a = [Link]([Link](1, 10), (3, 3))
a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

Parcourir une matrice par ligne :

for row in a:
print(row)

[1 2 3]
[4 5 6]
[7 8 9]

Pour itérer sur les colonnes, on peut utiliser la transposée a.T :

for col in a.T:
print(col, type(col))

Il est possible d’utiliser la fonctionnalité d'affectation multiple avec les arrays NumPy :

a = [Link]([Link](1, 10), (3, 3))

a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

a1, a2, a3 = a
a1
array([1, 2, 3])

a2
array([4, 5, 6])

a3
array([7, 8, 9])

Affectation multiple sur les colonnes

c1, c2, c3 = a.T

c1
array([1, 4, 7])

 Masques booléens

[Link]((2, 2), True)

array([[ True, True],
 [ True, True]])

[Link]((2, 2), False)

application
a = [Link]([Link](1, 10), (3, 3))
a

a>5
array([[False, False, False],
[False, False, True],
[ True, True, True]])

a == 2
(a > 3) & (a % 2 == 0)
(a > 3) | (a % 2 == 0)

Il est conseillé de mettre entre parenthèses chaque condition afin d’éviter les ambiguïtés

Masques booléens
Les masques booléens sont des arrays de booléens qui sont utilisés en tant que indice d’un array initial.
Cela permet de récupérer ou de modifier une partie de l’array initial.

Il suffit d’utiliser un array et un opérateur de comparaison entre les crochets qui étaient dédiés à
l’indiçage :
a = [Link]([Link](1, 10), (3, 3))
a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

Pour afficher tous les éléments de l’array a qui sont supérieurs à 5 :

a[a > 5]
array([6, 7, 8, 9])

Tous les éléments qui sont égaux à 2 :

a[a == 2]

Les éléments non nuls :

a[a != 0]

Affecter la valeur -1 aux éléments supérieurs à 5 :

a[a > 5] = -1
a
array([[ 1, 2, 3],
[ 4, 5, -1],
[-1, -1, -1]])

a[(a > 3) | (a % 2 == 0)] = 0

a
array([[1, 0, 3],
[0, 0, 0],
[0, 0, 0]])

Une application possible des masques est de binariser une matrice de nombre :

import random
import numpy as np
a = [Link]([[Link]() for i in range(16)], (4, 4))
a
array([[0.58704728, 0.50212977, 0.70652863, 0.24158108],
[0.93102132, 0.41864373, 0.45807961, 0.98288744],
[0.48198211, 0.16877376, 0.14431518, 0.74784176],
[0.92913469, 0.08383269, 0.10670144, 0.14554345]])

seuil = 0.3
a[a < seuil] = 0
a[a > seuil] = 1
a
array([[1., 1., 1., 0.],
[1., 1., 1., 1.],
[1., 0., 0., 1.],
[1., 0., 0., 0.]])