Skip to article frontmatterSkip to article content

contenu de ce notebook (sauter si déjà acquis)

la taille (en nombre d’octets) des éléments d’un numpy.ndarray existant est constante
une modification peut causer une conversion de la valeur ou une erreur

calculs de temps d’exécution avec %timeit

rappels

import numpy as np

tableaux multi-dimensionnels numpy

création d’un tableau multi-dimensionnel

le code

matrice = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15],
    [16, 17, 18, 19, 20]
]

mat = np.array(matrice)

print(mat)

print(type(mat))
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]
<class 'numpy.ndarray'>

type et taille mémoire des éléments du tableau

# le code
matrice = [
    [1, 2, 3],
    [4, 5, 6]
]
mat = np.array(matrice)
mat.dtype, mat.itemsize, mat.nbytes
(dtype('int64'), 8, 48)

taille, forme, dimension du tableau

# le code
print(mat.shape)
print(mat.size, mat.shape[0] * mat.shape[1])
print(mat.ndim, len(mat.shape))
(2, 3)
6 6
2 2

création d’un tableau avec le type des éléments

# le code
matrice = [
    [-128, -78, -32],
    [17, 5, 127]
]
mat = np.array(matrice)

print(mat.min(), mat.max())
print(mat.dtype)
-128 127
int64

# le code avec type
matrice = [
    [-128, -78, -32],
    [17, 5, 127]
]
mat = np.array(matrice, dtype=np.int8)
mat
array([[-128, -78, -32], [ 17, 5, 127]], dtype=int8)
# le code avec erreur
matrice = [
    [-128, -78, -32],
    [17, 5, 127]
]
try:
    mat = np.array(matrice, dtype=np.uint8)
    # soit affichage du tableau avec les négatifs convertis implicitement par complément à 2
    # soit échec: "Python integer -128 out of bounds for uint8"
    mat
except OverflowError as e:
    print(e)
Python integer -128 out of bounds for uint8

exercice

  1. créez un tableau pour stocker la matrice ci-dessous avec le plus petit type entier non signé
l = [[  0,   8,  34,   8],
     [255,  61, 128, 254]]
# votre code ici

modifier le type des éléments d’un tableau existant

# le code
l = [[  0,   8,  34,   8],
     [255,  61, 128, 254]]

mat = np.array(l)
print(    mat     )
mat1 = mat.astype(np.int8) # des conversions sont effectuées
print(    mat1    )
print(    mat     )
[[  0   8  34   8]
 [255  61 128 254]]
[[   0    8   34    8]
 [  -1   61 -128   -2]]
[[  0   8  34   8]
 [255  61 128 254]]

numpy calcule à taille constante

# le code
l = [-1, 2, 3]
mat = np.array(l) # vous laissez numpy inférer le type
print(    mat    )
print(    mat*100    )
print(    mat.dtype    )
[-1  2  3]
[-100  200  300]
int64

# le code
l = [-1, 2, 3]
mat = np.array(l, np.int8) # vous imposez le type
print(    mat    )
print(    mat*100    )
[-1  2  3]
[-100  -56   44]

autres constructeurs de numpy.ndarray

tableau de zéros numpy.zeros

# le code
zorro = np.zeros(shape=(4, 5))
zorro
array([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]])
# le second code
zorro1 = np.zeros(shape=(4, 5), dtype=np.uint64)
zorro1
array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], dtype=uint64)
# votre code ici

tableau non-initialisé numpy.empty

exercice

  1. créez un tableau de forme (3, 5) de valeurs non-initialisées
    de type entiers signés sur 8 bits
  2. affichez-le
  3. que contient-il ?
# votre code ici

tableau de valeurs régulièrement espacées

# exemple avec arange
# comme avec le range() de Python
# la deuxième borne est exclue
np.arange(0, 5)
array([0, 1, 2, 3, 4])
# exemple avec linspace
from matplotlib import pyplot as plt

X = np.linspace(-np.pi, np.pi, 30)
Y = np.sin(X)
plt.plot(X, Y)
<Figure size 640x480 with 1 Axes>
# pour éviter l'affichage superflu, ajoutez un ;
plt.plot(X, Y);
<Figure size 640x480 with 1 Axes>

tableaux de valeurs aléatoires

générateur de valeurs aléatoires entières

# le code
borne_inf = 10
borne_sup = 20
np.random.randint(borne_inf, borne_sup)
15
# le code
np.random.randint(10, 20, size=(2, 3, 5))
array([[[17, 18, 17, 10, 12], [10, 15, 17, 13, 16], [14, 19, 14, 18, 12]], [[19, 13, 17, 15, 11], [19, 14, 18, 10, 10], [14, 19, 11, 19, 17]]])

générateur de valeurs aléatoires réelles

# le code
np.random.rand()
0.5071736138934126
# le code
np.random.randn(2, 3, 1)
array([[[-1.13883641], [ 0.01680743], [ 0.73579143]], [[-0.43809415], [-0.26126171], [ 0.05268127]]])

exercice génération aléatoire et affichage couleur

avec la fonction numpy.random.randint dont l’aide est obtenue en tapant

np.random.randint?

  1. construisez une image de 10 x 10 pixels en format RBG
    i.e. chaque pixel est composé de 3 valeurs entières entre 0 et 255 inclus

  2. affichez l’image avec plt.imshow

# votre code ici

comparaison des temps de création tableaux

(avancé)

# le code
%timeit 1 + 1
36.2 ns ± 11.7 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

# le code
%timeit -n 10000 1 + 1
9.91 ns ± 0.221 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%%timeit
a = 1
a + 1
59.3 ns ± 17.6 ns per loop (mean ± std. dev. of 7 runs, 10,000,000 loops each)

exercice

comparez les temps d’exécution de

# votre code ici
numpy
Python-numérique - introduction
numpy
la mémoire