Retour vers le tutoriel complet
Pour simplifier la syntaxe d'utilisation des fonctions présentes dans un sous-package:
m5 = random.randn(5,6) # appel direct sur random et non np.random
import numpy.random as rnd
rnd.randn(5,6)
Fonctions de base
ATTENTION aux changement de type implicite:
B = A[2,:] # extraction de la troisième ligne...
# il s'agit d'un vecteur !!!
B = A[2:3,:] # extraction de la troisième ligne...
# mais il s'agit d'une matrice (transposable) !!!
Opérations sur les matrices
Opérations classiques
v1[1] = 3 # affectation
a = m0[1,1] # accès en lecture
v1 = v1+ 3 # ou v1 += 3 % matrice + scalaire
# changement sur les toutes les valeurs de v1
# NB: le - fonctionne pareil
m1tr = m1.T; # transposée
Pour + - /, les opérations se font terme à terme... Mais pour la multiplication, il y a ambiguité.
Multiplications: 1. OPERATEUR *
m2 = np.ones((10,3)) * 2 # multiplication par un scalaire
m3 = m1 * m2; # multiplication terme à terme
Multiplications: 2. OPERATEUR dot, dédié aux produits matriciels
Opérations de base en python
2 manières de travailler: soit en logique objet, soit en logique impérative classique.
La plupart des méthodes existent en double (dans la classe Array
ou en static dans np
)
m1.min() # syntaxe objet
np.min(m1) # autre syntaxe
# distinction min/argmin
m1.argmin()
# travail en ligne/colonne
m1 = random.rand(3,4)
# array([[ 0.77846102, 0.22597046, 0.217657 , 0.28958186],
# [ 0.02133707, 0.03258567, 0.81939161, 0.2834734 ],
# [ 0.92120271, 0.68409416, 0.24285983, 0.61582659]])
m1.argmin() # 4
m1.argmin(0) # array([1, 1, 0, 1])
m1.argmin(1) # array([2, 0, 2])
# arrondis
np.round(m1)
np.ceil(m1)
np.floor(m1)
# tris
np.sort(m1) # ligne par ligne
np.sort(m1,0) # colonne par colonne
np.sort(m1,1) # ligne par ligne
# statistique de base
m1.mean() # 0.427 -> sur toute la matrice
m1.mean(0) # array([ 0.57366693, 0.31421676, 0.42663615, 0.39629395])
# colonne par colonne
m1.mean(1) # ligne par ligne
m1.std...
m1.sum...
m1.prod...
m1.cumsum...
Jouons avec le minimum
Retourner la valeur minimum entre 2 scalaires ou 2 matrices
Gestion particulière du minimum: on a souvent besoin de retourner la valeur minimum parmi 2. En C/JAVA/Matlab, cela est réalisé avec min
... Pas en python! => minimum
np.minimum(2,3) # 2
# entre 2 matrices
m1 = random.rand(3,4)
m2 = random.rand(3,4)
np.minimum(m1,m2) # matrice 3x4 contenant les valeurs min d'une comparaison terme à terme
# entre une matrice et un scalaire: pour seuiller
np.minimum(m1,0.5)
# array([[ 0.5 , 0.22597046, 0.217657 , 0.28958186],
# [ 0.02133707, 0.03258567, 0.5 , 0.2834734 ],
# [ 0.5 , 0.5 , 0.24285983, 0.5 ]])
Où se trouve le minimum entre 2 matrices
m1 = random.rand(3,4)
m2 = random.rand(3,4)
# SOL 1
m1<m2 # retourne une matrice de booléens correspondant aux tests terme à terme
# SOL 2
np.where(m1<m2, 0, 1)) # si c'est vrai -> 0, sinon 1
# array([[1, 1, 0, 0],
# [0, 0, 0, 1],
# [1, 0, 0, 1]])
Applications
Application 1: mean/std
Calculer la moyenne et l'écart-type des deux épreuves (cf données de la première partie du tutoriel).
Application 2: génération aléatoire
Nous souhaitons générer aléatoirement les notes de la question précédente sachant que:
- Le nombre d'élèves est n=15
- Les notes sont tirées selon une loi gaussienne d'écart-type 4. Utiliser la commande
np.random.randn
pour générer les tirages puis multiplier par l'écart-type. - La première épreuve à une moyenne de 10, la seconde, une moyenne de 8 (on veut donc décaler la première colonne de 10 et la seconde de 8)
- On veut être sûr que les notes sont supérieures ou égales à 0 (utiliser
maximum
) - On veut être sûr que les notes sont inférieures ou égales à 20 (utiliser
minimum
) - On veut des notes entières (utiliser
round
)