Main

Subpage of Tuto Python

Retour vers le tutoriel complet

Fonctions de base

Manipulation de matrices

Tous les indices démarrent en 0, comme en C et en JAVA

Vecteurs vs Matrices

Attention: en python, les vecteurs et les matrices sont très différents... Pour plus de simplicité, il est recommandé de tout mettre sous forme de matrice.

Pour voir si vous avez saisi la différence:

 v1 = np.arange(0, 10, 1) # vecteur
 v1.T                     # transposé d'un vecteur... Pas de différence

 v1 = v1.reshape((1,v1.size)) # matrice à une ligne
 v1.T # matrice colonne
[$[Get Code]]

Extraction de sous-matrices + modifications en bloc

le slicing fait référence à la syntaxe M[start:stop:step] pour extraire une partie d'un array :

A = np.array([1,2,3,4,5])
A[1:3]  # array([2, 3])

# On peut omettre n'importe lequel des argument dans M[start:stop:step]:
A[::] # indices de début, fin, et pas avec leurs valeurs par défaut
      # array([ 1, -2, -3,  4,  5])
A[::2] # pas = 2, indices de début et de fin par défaut
       # array([ 1, -3,  5])
A[:3] # les trois premiers éléments
      # array([ 1, -2, -3])
A[3:] # à partir de l'indice 3
      # array([4, 5])

# On peut utiliser des indices négatifs :
A[-1] # le dernier élément
      # 5
A[-3:] # les 3 derniers éléments
       # array([3, 4, 5])
[$[Get Code]]

Modification par tranche:

# Les tranches sont modifiables (affectation):
A[1:3] = [-2,-3] # array([ 1, -2, -3,  4,  5])
[$[Get Code]]

Sur des matrices (même fonctionnement)

# Définition amusante (on verra les boucles dans le chapitre suivant)
A = np.array([[n+m*10 for n in range(5)] for m in range(5)])
 #array([[ 0,  1,  2,  3,  4],
 #       [10, 11, 12, 13, 14],
 #       [20, 21, 22, 23, 24],
 #       [30, 31, 32, 33, 34],
 #       [40, 41, 42, 43, 44]])

# a block from the original array
A[1:4, 1:4]
 #array([[11, 12, 13],
 #       [21, 22, 23],
 #       [31, 32, 33]])

# sauts
A[::2, ::2]
 #array([[ 0,  2,  4],
 #      [20, 22, 24],
 #      [40, 42, 44]])
[$[Get Code]]

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

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)