1

Numpy ?

• Numpy est un package pour Python spécialisé dans la manipulation des

tableaux (array), pour nous essentiellement les vecteurs et les matrices
• Les tableaux « numpy » ne gère que les objets de même type
• Le package propose un grand nombre de routines pour un accès rapide
aux données (ex. recherche, extraction), pour les manipulations diverses
(ex. tri), pour les calculs (ex. calcul statistique)
• Les tableaux « numpy » sont plus performants (rapidité, gestion de la
volumétrie) que les collections usuelles de Python
• Les tableaux « numpy » sont sous-jacents à de nombreux packages
dédiés au calcul scientifique sous Python.
• Attention, un vecteur est en réalité une matrice à 1 seule dimension

Il n’est pas possible de tout aborder dans ce support. Pour aller plus loin, voir
absolument le manuel de référence (utilisé pour préparer ce diaporama).
http://docs.scipy.org/doc/numpy/reference/index.html

2
Création à la volée, génération d’une séquence, chargement à partir d’un fichier

CRÉATION D’UN VECTEUR

3
Création via une saisie manuelle

Préalable important : np sera l’alias utilisé

import numpy as np pour accéder aux
importer le module
routines de la librairie
« numpy »
« numpy ».

Création manuelle à a = np.array([1.2,2.5,3.2,1.8]) Noter le rôle des [ ] pour

partir d’un ensemble de délimiter les valeurs

valeurs
#type de la structure
print(type(a)) #<class ‘numpy.ndarray’>
#type des données
print(a.dtype) #float64
#nombre de dimensions
Informations sur la
print(a.ndim) #1 (on aura 2 si matrice, etc.)
structure #nombre de lignes et col
print(a.shape) #(4,) → on a tuple ! 4 cases sur la 1ère dim (n°0)
#nombre totale de valeurs
print(a.size) #4, nb.lignes x nb.colonnes si matrice
4
Typage des données

#création et typage implicite

a = np.array([1,2,4])
print(a.dtype) #int32

Le typage des valeurs #création et typage explicite – préférable !

peut être implicite ou a = np.array([1,2,4],dtype=float)
explicite print(a.dtype) #float64
print(a) #[1. 2. 4.]

#un vecteur de booléens est tout à fait possible

b = np.array([True,False,True,True], dtype=bool)
print(b) #[True False True True]

Création d’un array d’objets # la donnée peut être un objet python

complexes (autres que les a = np.array([{"Toto":(45,2000)},{"Tata":(34,1500)}])
types de base) est possible print(a.dtype) #object

– 5
Création d’une séquence de valeurs

#suite arithmétique de raison 1

a = np.arange(start=0,stop=10)
print(a) #[0 1 2 3 4 5 6 7 8 9], attention dernière valeur est exclue

#suite arithmétique de raison step

a = np.arange(start=0,stop=10,step=2)
print(a) #[0 2 4 6 8]

#suite linéaire, nb. de valeurs est spécifié par num

a = np.linspace(start=0,stop=10,num=5)
print(a) #[0. 2.5 5. 7.5 10.], la dernière valeur est incluse ici

#vecteur de valeurs identiques 1 – 1 seule dim et 5 valeurs

a = np.ones(shape=5)
print(a) # [1. 1. 1. 1. 1.]

#plus généralement – répétition 5 fois (1 dimension) de la valeur 3.2

a = np.full(shape=5,fill_value=3.2)
print(a) #[3.2 3.2 3.2 3.2 3.2]
– 6
Chargement à partir d’un fichier - Conversions
1 seule colonne
pour l’instant

Les données peuvent

#charger à partir d'un fichier
être stockées dans un #typage explicite possible
fichier texte (loadtxt a = np.loadtxt("vecteur.txt",dtype=float)
pour charger, savetxt print(a) #[4. 5. 8. 16. 68. 14. 35.]
pour sauver)
Remarque : si besoin, modifier le répertoire par défaut avec la
fonction chdir() du module os (qu’il faut importer au préalable)

#liste de valeurs
lst = [1.2,3.1,4.5]
Conversion d’une print(type(lst)) #<class ‘list’>
collection (type standard #conversion à partir d'une liste
Python) en type array de a = np.asarray(lst,dtype=float)
« numpy » print(type(a)) #<class ‘numpy.ndarray’>
print(a) #[1.2 3.1 4.5]

– 7
Redimensionnement
#vecteur de valeurs
a = np.array([1.2,2.5,3.2,1.8])
Rajouter une valeur en #ajouter une valeur , placée en dernière position
dernière position a = np.append(a,10)
print(a) #[1.2 2.5 3.2 1.8 10.]

#suppression via indice

Suppression d’une b = np.delete(a,2) #une plage d’indices est aussi possible
valeur via son indice print(b) #[1.2 2.5 1.8 10.]

a = np.array([1,2,3])
#redimensionnement
Redimensionnement
#1 valeur pour vecteur, couple de valeurs pour matrice
explicite a.resize(new_shape=5)
print(a) #[1 2 3 0 0], les nouvelles cases mises à 0

#concatenation 2 vecteurs
Concaténation de 2 x = np.array([1,2,5,6])
y = np.array([2,1,7,4])
vecteurs
z = np.append(x,y)
print(z) #[1 2 5 6 2 1 7 4]
– 8
 Accéder aux valeurs via des indices ou des conditions
EXTRACTION DES VALEURS

– 9
Accès indicé – Plages d’indices – v = np.array([1.2,7.4,4.2,8.5,6.3])
#toutes les valeurs
print(v)
#ou
print(v[:]) # noter le rôle du : , il faut lire ici début à fin
#accès indicé - première valeur
print(v[0]) # 1.2 – Noter que le 1er indice est 0 (zéro)
#dernière valeur
print(v[v.size-1]) #6.3, v.size est ok parce que v est un vecteur
#plage d'indices contigus
print(v[1:3]) # [7.4 4.2]
#extrêmes, début à 3 (non-inclus)
print(v[:3]) # [1.2 7.4 4.2] Remarque : Mis à part
#extrêmes, 2 à fin les singletons, les
print(v[2:]) # [4.2 8.5 6.3] vecteurs générés sont
#indice négatif de type numpy.ndarray
print(v[-1]) # 6.3, dernier élément
#indices négatifs
print(v[-3:]) # [4.2 8.5 6.3], 3 derniers éléments
– 10
Accès indicé – Ecriture générique - v = np.array([1.2,7.4,4.2,8.5,6.3])

La notation générique des indices est : début:fin:pas

fin est non inclus dans la liste

#valeur n°1 à n°3 avec un pas de 1

print(v[1:4:1]) # [7.4, 4.2, 8.5]

#le pas de 1 est implicite

print(v[1:4]) # [7.4, 4.2, 8.5]
#n°0 à n°2 avec un pas de 2
print(v[0:3:2]) # [1.2, 4.2]

#le pas peut être négatif, n°3 à n°1 avec un pas de -1

print (v[3:0:-1]) # [8.5, 4.2, 7.4]

#on peut exploiter cette idée pour inverser un vecteur -- ou bien utiliser flip()
print(v[::-1]) # [6.3, 8.5, 4.2, 7.4, 1.2]

– 11
Accès par conditions – Indiçage booléen – v = np.array([1.2,7.4,4.2,8.5,6.3])

#extraction avec un vecteur de booléens

#si b trop court, tout le reste est considéré False
#si b trop long, erreur
b = np.array([False,True,False,True,False],dtype=bool)
print(v[b]) # [7.4 8.5]

#on peut utiliser une condition pour l'extraction

print(v[v < 7]) # [1.2 4.2 6.3]

#parce que la condition est un vecteur de booléen

b=v<7
print(b) # [True False True False True]
print(type(b)) # <class ‘numpy.ndarray’>

#on peut utiliser la fonction extract()

print(np.extract(v < 7, v)) # [1.2 4.2 6.3]

– 12
Tri et recherche -- v = np.array([1.2,7.4,4.2,8.5,6.3])

#recherche valeur max

print(np.max(v)) # 8.5
Remarque : L’équivalent
#recherche indice de valeur max existe pour min()
print(np.argmax(v)) # 3

#tri des valeurs

print(np.sort(v)) # [1.2 4.2 6.3 7.4 8.5]

#récupération des indices triés

print(np.argsort(v)) # [0 2 4 1 3]

#valeurs distinctes
a = np.array([1,2,2,1,1,2])
print(np.unique(a)) # [1 2]

– 13
 CALCULS SUR LES VECTEURS

– 14
Calculs (statistiques) récapitulatifs – v = np.array([1.2,7.4,4.2,8.5,6.3])

#moyenne
print(np.mean(v)) # 5.52

#médiane
print(np.median(v)) # 6.3

#variance
print(np.var(v)) # 6.6856

#quantile
print(np.percentile(v,50)) #6.3 (50% = médiane)

#somme
print(np.sum(v)) # 27.6

#somme cumulée
print(np.cumsum(v)) # [1.2 8.6 12.8 21.3 27.6]

La librairie n’est pas très fournie, nous aurons besoin de SciPy (et autres)
– 15
Calculs entre vecteurs – Le principe « elementwise »
#calculs entre vecteurs
x = np.array([1.2,1.3,1.0])
y = np.array([2.1,0.8,1.3]) Principe : Les calculs se font élément par élément
#multiplication
print(x*y) # [2.52 1.04 1.3] (elemenstwise) entre vecteurs « numpy » - On a le
#addition même principe sous R, mais sans la réplication si
print(x+y) # [3.3 2.1 2.3]
les dimensions ne concordent pas.
#multiplication par un scalaire
print(2*x) # [2.4 2.6 2. ]
#comparaison de vecteurs
x = np.array([1,2,5,6])
y = np.array([2,1,7,4])
b=x>y
print(b) # [False True False True]
La liste des fonctions est longue.
#opérations logiques Voir -
a = np.array([True,True,False,True],dtype=bool) http://docs.scipy.org/doc/nump
b = np.array([True,False,True,False],dtype=bool) y/reference/routines.logic.html
#ET logique
np.logical_and(a,b) # [True False False False]
#OU exclusif logique
np.logical_xor(a,b) # [False True True True]
– 16
Fonctions matricielles

x = np.array([1.2,1.3,1.0]) Principe : Des fonctions

y = np.array([2.1,0.8,1.3])
spécifiquement matricielles
#produit scalaire existent, certaines s’appliquent à
z = np.vdot(x,y) des vecteurs
print(z) # 4.86

#ou l’équivalent calculé

print(np.sum(x*y)) # 4.86

#norme d'un vecteur

n = np.linalg.norm(x)
print(n) # 2.03

#ou l’équivalent calculé

import math
print(math.sqrt(np.sum(x**2))) # 2.03

– 17
Opérations ensemblistes

Principe : Un vecteur de valeurs (surtout

entières) peut être considéré comme un
#opérations ensemblistes
x = np.array([1,2,5,6]) ensemble de valeurs.
y = np.array([2,1,7,4])

#intersection
print(np.intersect1d(x,y)) # [1 2]

#union – attention, ce n’est pas une concaténation

print(np.union1d(x,y)) # [1 2 4 5 6 7]

#différence c.à-d. qui sont dans x et pas dans y

print(np.setdiff1d(x,y)) # [5 6]

– 18
Références

(n’achetez pas des livres sur Python)

Site de Python
Welcome to Python - https://www.python.org/
Python 3.4.3 documentation - https://docs.python.org/3/index.html

Portail Python
Page Python de Developpez.com

Quelques cours en ligne

P. Fuchs, P. Poulain, « Cours de Python » sur Developpez.com
G. Swinnen, « Apprendre à programmer avec Python » sur Developpez.com
« Python », Cours interactif sur Codecademy

POLLS (KDnuggets)
Data Mining / Analytics Tools Used
Python, 4ème en 2015
What languages you used for data mining / data science?
Python, 3ème en 2014 (derrière R et SAS)

– 19