Main

Retour vers le tutoriel complet

Pour simplifier la syntaxe d'utilisation des fonctions présentes dans un sous-package:

from numpy import random
m5 = random.randn(5,6) # appel direct sur random et non np.random

import numpy.random as rnd
rnd.randn(5,6)
[$[Get Code]]

Fonctions de base

ATTENTION aux changement de type implicite:

A = np.random.rand(5,3) # matrice 5x3
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) !!!
[$[Get Code]]

Opérations sur les matrices

Opérations classiques

 # soient les variables définies dans la question précédente
 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
 
[$[Get Code]]

Pour + - /, les opérations se font terme à terme... Mais pour la multiplication, il y a ambiguité.

Multiplications: 1. OPERATEUR *

 m1 = np.ones((10,1)) * np.array([1,2,3]) # Attention, produit matriciel
 m2 = np.ones((10,3)) * 2                 # multiplication par un scalaire
 m3 = m1 * m2;            # multiplication terme à terme                        
[$[Get Code]]

Multiplications: 2. OPERATEUR dot, dédié aux produits matriciels

 m1 = np.ones((10,1)).dot(np.array([[1,2,3]])) # Bien mieux: moins d'ambiguité!
[$[Get Code]]

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)

 # recherche du min dans une matrice
 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...
[$[Get Code]]

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

 # entre 2 valeurs
 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       ]])
[$[Get Code]]

Où se trouve le minimum entre 2 matrices

 # 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]])
[$[Get Code]]

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)