Les bases de Python 2 : Numpy

Ce tutoriel présente numpy (prononcé num-pye, rime avec eye), une bibliothèque Python permettant d’effectuer des calculs numériques en Python. Nous apprendrons à créer et à manipuler des tableaux numpy, qui sont des structures matricielles utiles pour contenir de grandes quantités de données.

Suivez les instructions ci-dessous pour télécharger le tutoriel et l’ouvrir dans l’Environnement de test.

Télécharger le cahier d’exercices

Télécharger le carnet de notes du tutoriel Python basics 2

Pour visualiser ce notebook sur le Sandbox, vous devrez d’abord le télécharger sur votre ordinateur, puis le charger sur le Sandbox. Assurez-vous d’avoir suivi les prérequis de configuration listés dans Python basics 1 : Jupyter, puis suivez ces instructions :

  1. Téléchargez le cahier en cliquant sur le lien ci-dessus.

  2. Dans l’Environnement de test, ouvrez le dossier Training.

  3. Cliquez sur le bouton Transférer les fichiers comme indiqué ci-dessous.

Bouton de téléchargement.

  1. Sélectionnez le notebook téléchargé à l’aide du navigateur de fichiers. Cliquez sur OK.

  2. Le cahier de solutions apparaîtra dans le dossier Training. Double-cliquez dessus pour l’ouvrir.

Vous pouvez maintenant utiliser le cahier d’exercices comme une version interactive de cette page Web.

Note

Le cahier d’exercices devrait ressembler au texte et au code ci-dessous. Cependant, les sorties du cahier d’exercices sont vides (c’est-à-dire qu’aucun résultat n’apparaît après les cellules de code). Suivez les instructions du cahier pour exécuter les cellules du cahier d’exercices. Reportez-vous à cette page pour vérifier que vos résultats sont similaires.

Introduction à numpy

Afin de pouvoir utiliser numpy, nous devons importer la bibliothèque numpy en utilisant le mot spécial import. Pour éviter de taper numpy à chaque fois que nous voulons utiliser une de ses fonctions, nous pouvons fournir un alias en utilisant le mot spécial as. Nous allons surnommer numpy np :

[1]:
import numpy as np

Note: Si nous n’importons pas numpy (import numpy), nous ne pouvons utiliser aucune des fonctions de numpy. Si vous oubliez d’importer des paquets, vous risquez d’obtenir une erreur indiquant que name is not defined (« le nom n’est pas défini »).

Maintenant, nous avons accès à toutes les fonctions disponibles dans numpy en tapant np.name_of_function. Par exemple, l’équivalent de 1 + 1 en Python peut être fait dans numpy :

[2]:
np.add(1,1)
[2]:
2

Par défaut, le résultat d’une fonction ou d’une opération est affiché sous la cellule contenant le code. Si nous voulons réutiliser ce résultat pour une opération ultérieure, nous pouvons l’affecter à une variable. Par exemple, appelons la variable a :

[3]:
a = np.add(2,3)

Nous venons de déclarer une variable a qui contient le résultat de la fonction. Nous pouvons maintenant utiliser ou afficher cette variable, à n’importe quel moment de ce cahier. Par exemple, nous pouvons afficher son contenu en tapant le nom de la variable dans une nouvelle cellule :

[4]:
a
[4]:
5

L’un des concepts fondamentaux de numpy est le tableau array. Ils peuvent contenir des données multidimensionnelles. Pour déclarer un tableau numpy de manière explicite, on fait :

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

Note: Le tableau défini ci-dessus n’a qu’une seule dimension.

La plupart des fonctions et opérations définies dans numpy peuvent être appliquées aux tableaux. Par exemple, avec l’opération précédente add :

[6]:
arr1 = np.array([1,2,3,4])
arr2 = np.array([3,4,5,6])

np.add(arr1, arr2)
[6]:
array([ 4,  6,  8, 10])

Nous pouvons également ajouter des tableaux en utilisant la notation pratique suivante :

[7]:
arr1 + arr2
[7]:
array([ 4,  6,  8, 10])

Les tableaux peuvent être découpés en tranches et en dés. Nous pouvons obtenir des sous-ensembles de tableaux en utilisant la notation d’indexation qui est [ start : end : stride ]. Voyons ce que cela signifie :

[8]:
arr = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])

print(arr[5])
print(arr[5:])
print(arr[:5])
print(arr[::2])
5
[ 5  6  7  8  9 10 11 12 13 14 15]
[0 1 2 3 4]
[ 0  2  4  6  8 10 12 14]

Essayez de jouer avec les index pour comprendre la signification de start, end et stride. Que se passe-t-il si vous ne spécifiez pas de début ? Quelle valeur numpy utilise-t-il à la place ?

Note: Les index Numpy commencent sur 0, la même convention utilisée dans les listes Python.

Les index peuvent également être négatifs, ce qui signifie que l’on commence à compter par la fin. Par exemple, pour sélectionner les 2 derniers éléments d’un tableau, nous pouvons faire :

[9]:
arr = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])

arr[-2:]
[9]:
array([14, 15])

Les tableaux Numpy peuvent avoir plusieurs dimensions. Les dimensions sont indiquées à l’aide de crochets imbriqués [ ]. La convention dans numpy est que les crochets extérieurs représentent la première dimension et que les crochets intérieurs contiennent la dernière dimension.

dessin

La cellule suivante déclare un tableau à 2 dimensions de forme (1, 9).

Tip: Remarquez les crochets (doubles) imbriqués [[ ]]. Comme il y a deux crochets, cela indique que le tableau est bidimensionnel.

[10]:
np.array([[1,2,3,4,5,6,7,8,9]])
[10]:
array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])

Pour visualiser la forme (dimensions) d’un tableau numpy, nous pouvons ajouter le suffixe .shape à une expression de tableau ou à une variable contenant un tableau numpy.

[11]:
arr1 = np.array([1,2,3,4,5,6,7,8,9])
arr2 = np.array([[1,2,3,4,5,6,7,8,9]])
arr3 = np.array([[1],[2],[3],[4],[5],[6],[7],[8],[9]])

arr1.shape, arr2.shape, arr3.shape, np.array([1,2,3]).shape
[11]:
((9,), (1, 9), (9, 1), (3,))

Les tableaux Numpy peuvent contenir des valeurs numériques de différents types. Ces types peuvent être répartis dans les groupes suivants :

  • Entiers

    • Non signé

      • 8 bits : uint8

      • 16 bits : uint16

      • 32 bits : uint32

      • 64 bits : uint64

    • Signé

      • 8 bits : int8

      • 16 bits : int16

      • 32 bits : int32

      • 64 bits : int64

  • Flotteurs

    • 32 bits : float32

    • 64 bits : float64

Nous pouvons rechercher le type d’un tableau en utilisant le suffixe .dtype.

[12]:
arr = np.ones((10,10,10))

arr.dtype
[12]:
dtype('float64')

Les tableaux Numpy stockent normalement des valeurs numériques mais ils peuvent aussi contenir des valeurs booléennes, bool'. Le booléen est un type de données qui peut avoir deux valeurs possibles : True (Vrai) ou False (Faux). Par exemple :

[13]:
arr = np.array([True, False, True])

arr, arr.shape, arr.dtype
[13]:
(array([ True, False,  True]), (3,), dtype('bool'))

Nous pouvons opérer avec des tableaux booléens en utilisant les fonctions numpy pour effectuer des opérations logiques telles que and et or.

[14]:
arr1 = np.array([True, True, False, False])
arr2 = np.array([True, False, True, False])

print(np.logical_and(arr1, arr2))
print(np.logical_or(arr1, arr2))
[ True False False False]
[ True  True  True False]

Ces opérations sont commodément proposées par numpy avec les symboles * (et), et + (ou).

**Remarque : Ici, les symboles * et + n’effectuent pas de multiplication et d’addition comme avec les tableaux numériques. Numpy détecte le type des tableaux impliqués dans l’opération et modifie le comportement de ces opérateurs.

[15]:
print(arr1 * arr2)
print(arr1 + arr2)
[ True False False False]
[ True  True  True False]

Les tableaux booléens sont souvent le résultat de la comparaison d’un tableau numérique avec certaines valeurs. Ceci est parfois utile pour détecter les valeurs qui sont égales, inférieures ou supérieures à un nombre dans un tableau numpy. Par exemple, si nous voulons savoir quelles valeurs dans un tableau sont égales à 1, et les valeurs qui sont supérieures à 2, nous pouvons le faire :

[16]:
arr = np.array([1, 3, 5, 1, 6, 3, 1, 5, 7, 1])

print(arr == 1)
print(arr > 2)
[ True False False  True False False  True False False  True]
[False  True  True False  True  True False  True  True False]

Vous pouvez utiliser un tableau booléen pour masquer les valeurs « fausses » d’un tableau numérique. Le tableau retourné ne contient que les valeurs numériques qui sont au même index que les valeurs True dans le tableau mask.

[17]:
arr = np.array([1,2,3,4,5,6,7,8,9])
mask = np.array([True,False,True,False,True,False,True,False,True])

arr[mask]
[17]:
array([1, 3, 5, 7, 9])

Exercices

2.1 Utilisez la fonction numpy ``add”” pour ajouter les valeurs ``34”” et ``29”” dans la cellule ci-dessous.

[ ]:
# Use numpy add function to add 34 and 29


2.2 Déclarer un nouveau tableau dont le contenu est [5,4,3,2,1] et le découper pour sélectionner les 3 derniers éléments.

[ ]:
# Substitute the ? symbols by the correct expressions and values

# Declare the array

arr = ?

# Slice array for the last 3 items only

arr[?:?]

2.3 Sélectionnez tous les éléments du tableau ci-dessous, sauf le dernier, [15].

[ ]:
arr = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])

# Substitute the ? symbols by the correct expressions and values

arr[?]

2.4 Utilisez arr comme défini en 2.3. Excluez le dernier élément de la liste, mais ne sélectionnez maintenant qu’un élément sur trois. Rappelez-vous que le troisième indice indique stride, s’il est utilisé.

Introduction: Le résultat devrait être [0,3,6,9,12].

[ ]:
# Substitute the ? symbols by the correct expressions and values

arr[?:?:?]

2.5 Vous devrez combiner les comparaisons de tableaux et les opérateurs logiques pour résoudre cette question. Trouvez les valeurs du tableau suivant qui sont supérieures à 3 et inférieures à 7. Le résultat doit être un tableau booléen.

Introduction: Si vous êtes bloqué, relisez la section sur les tableaux booléens.

[ ]:
arr = np.array([1, 3, 5, 1, 6, 3, 1, 5, 7, 1])

# Use array comparisons (<, >, etc.) and logical operators (*, +) to find where
# the values are greater than 3 and less than 7.

boolean_array = ?

2.6 Utilisez votre tableau booléen de 2.5 pour masquer les valeurs False de arr.

Introduction: Le résultat devrait être [5, 6, 5].

[ ]:
# Use your resulting boolean_array array from 2.5
# to mask arr as defined in 2.5


Conclusion

Numpy est une bibliothèque de calcul numérique fondamentale dans la programmation Python et il est utile de comprendre son fonctionnement. Ensuite, nous explorerons le traçage de données géospatiales à l’aide de matplotlib.