Tableaux NumPy et calcul vectorisé

NumPy stocke les données numériques dans des tableaux afin qu’une seule expression puisse agir sur de nombreuses valeurs. Importe-le avec import numpy as np ; le nom court np est la façon habituelle d’appeler ses fonctions.

Lire la structure d’un tableau

Un ndarray est une grille rectangulaire dont les éléments partagent un même type de données. Une dimension est aussi appelée axe. Partons d’une petite table :

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])

Ses attributs répondent à quatre questions différentes :

L’axe 0 indexe les lignes ; l’axe 1 indexe les colonnes. Une table de données comportant une ligne par personne et des colonnes pour la taille, la masse et l’âge aurait pour forme (100, 3) pour 100 personnes. Le produit des éléments de la forme donne la taille du tableau.

Un vecteur n’a pas d’axe de lignes ou de colonnes

np.array([2, 4, 6, 8]) a pour forme (4,) et possède un axe. La virgule en fait un tuple à un élément. La forme (1, 4) a deux axes : une ligne et quatre colonnes. La forme (4, 1) a aussi deux axes, mais quatre lignes et une colonne. Ces tableaux contiennent quatre valeurs, mais se comportent différemment lorsqu’ils sont combinés à d’autres tableaux. np.array(7) est un tableau à zéro dimension : sa forme est () et son ndim vaut 0.

Les tableaux changent le sens des opérateurs

Une liste est un conteneur Python généraliste. Un tableau est conçu pour les calculs sur les positions correspondantes.

Dans l’addition de tableaux, 1 est associé à 3 et 2 à 4. Le tableau conserve la même taille.

Pourquoi les tableaux numériques sont efficaces

Un tableau numérique nouvellement créé stocke ensemble en mémoire des valeurs de même type. NumPy parcourt ces valeurs dans du code compilé, ce qui évite une opération distincte au niveau de Python pour chaque nombre. Un million de valeurs float64 occupent 8 000 000 octets pour le stockage des éléments, valeur accessible par a.nbytes sur un tableau de cette taille. Une liste Python stocke aussi des références vers des objets Python : elle nécessite donc beaucoup plus d’espace. Les gains de performance dépendent du calcul et de l’ordinateur.

La taille d’un tableau ne s’accroît pas par une méthode append en place. np.append(a, value) alloue un nouveau tableau. Pour des données recueillies une valeur à la fois, construis une liste Python et convertis-la une seule fois. Les données imbriquées fournies doivent former un rectangle : np.array([[1, 2], [3]]) déclenche ValueError car les longueurs de ses lignes diffèrent.

Reconnaître les résultats affichés

print(np.array([1, 2, 3])) affiche [1 2 3]. Un affichage interactif utilise array([1, 2, 3]). Pour np.array([5, 6])[0] sur un ordinateur 64 bits, NumPy 2 affiche np.int64(5) ; cette valeur participe aux calculs comme le nombre 5.

Choisis une fonction de création en te demandant ce que tu connais : les valeurs elles-mêmes, une forme et une valeur de remplissage, un pas ou un nombre de points requis. Ce choix permet au code d’exprimer comment les données doivent être construites.

Partir de valeurs ou d’une forme

np.array([3, 1, 4]) crée un vecteur. Une liste de listes de même longueur crée une table. Passe les valeurs sous forme d’une seule séquence ; np.array(1, 2, 3) ne fournit pas correctement trois éléments.

Pour une forme à plusieurs dimensions, les parenthèses comptent. np.zeros((2, 3)) passe un seul tuple. Dans np.zeros(2, 3), Python transmet 3 comme argument de type de données, ce qui provoque une erreur de type. Les zéros et les uns sont de type float64 par défaut ; full infère son type de données à partir de la valeur de remplissage. Ajoute dtype=int lorsque tu dois stocker des nombres entiers.

empty ne garantit ni des zéros ni des valeurs initiales ayant un sens. Ne lis un élément qu’après lui avoir affecté une valeur, pour chaque élément que tu vas utiliser. zeros est un choix plus simple lorsqu’une valeur initiale de zéro a un sens.

Choisir un pas ou un nombre de points

np.arange(start, stop, step) suit le principe de progression de range en Python. np.arange(2, 11, 3) donne [2 5 8] : on part de 2 et on ajoute 3 en restant en dessous de 11. Avec un seul argument, np.arange(5) part de 0 et donne [0 1 2 3 4].

Les pas en virgule flottante peuvent produire des bornes inattendues. Par exemple, np.arange(1, 1.3, 0.1) inclut la valeur affichée 1.3 car l’arrondi binaire influence le calcul de la suite. Pour une grille décimale avec un nombre fixe de points, utilise linspace :

grid = np.linspace(0, 1, 5)
# array([0.  , 0.25, 0.5 , 0.75, 1.  ])

Les deux bornes sont incluses par défaut. Cinq points forment quatre intervalles. Dix points entre 0 et 1 forment neuf intervalles : leur espacement est donc d’environ 0,111 ; des pas de 0,1 nécessitent 11 points.

Réutiliser une structure existante

np.zeros_like(a), np.ones_like(a) et np.full_like(a, value) créent de nouveaux tableaux avec la forme et le type de données de a. Le type hérité compte : remplir un modèle entier avec un décimal peut faire perdre la partie décimale, sauf si tu demandes un type à virgule flottante. np.eye(3) crée une matrice identité carrée avec des uns sur la diagonale et des zéros ailleurs.

Allouer une table de données une seule fois

Pour des précipitations en millimètres à trois stations sur quatre semaines :

rain = np.zeros((3, 4))
rain[0] = [12.0, 0.0, 5.5, 8.0]

La première affectation remplit une ligne et conserve la forme (3, 4). Si le nombre de mesures est connu, réserver la table entière évite d’allouer à répétition des tableaux plus grands. Si la quantité de données fournies est inconnue, accumule les valeurs dans une liste et appelle np.array une fois la collecte terminée.

Le type de données d’un tableau détermine ce qu’il peut stocker et la mémoire nécessaire à chaque valeur. Choisir le bon type évite aussi que les calculs perdent des informations sans avertissement.

Examiner le type de stockage

int64 contient des entiers sur 64 bits, float64 des nombres binaires à virgule flottante et bool des valeurs vrai ou faux. Les types Unicode tels que <U5 stockent du texte avec une longueur maximale en caractères. a.itemsize est le nombre d’octets par élément ; a.nbytes vaut a.size * a.itemsize. Un float64 utilise 8 octets et offre une précision d’environ 15 chiffres décimaux significatifs.

Sur les ordinateurs 64 bits classiques, les entiers fournis sont stockés sur 64 bits. NumPy 2 utilise aussi cette valeur par défaut sur Windows 64 bits. Des décimaux fournis donnent normalement le type float64.

L’inférence choisit un seul type partagé

np.array([1, 2.5]) devient [1. 2.5] : l’entier est représenté comme un nombre à virgule flottante. np.array([True, 2]) devient [1 2]. Mélanger nombres et texte peut transformer tout le tableau en texte, de sorte qu’une étiquette comme 'n/a' peut faire échouer les calculs ultérieurs. Examine dtype lorsque des données apparemment numériques ne peuvent pas être additionnées ou multipliées.

Convertir en connaissance de cause

astype renvoie une copie convertie :

x = np.array([1.7, -1.7, 2.5])
whole = x.astype(int)
# array([ 1, -1,  2])

Cette conversion tronque vers zéro ; elle n’arrondit pas. np.round(x).astype(int) donne [2 -2 2] car les valeurs exactement à mi-chemin sont arrondies vers la valeur paire la plus proche. Un texte comme '1.5' se convertit avec astype(float), mais 'n/a' déclenche ValueError. Nettoie les codes de valeur manquante avant la conversion.

Les affectations utilisent le type de données de destination. Après a = np.array([1, 2, 3]), l’affectation a[0] = 9.9 stocke 9 sans avertissement. Convertir d’abord tout le tableau en nombres à virgule flottante permet aux affectations ultérieures de conserver les décimales.

Les entiers de taille fixe peuvent dépasser leur capacité

Un int8 contient les valeurs de −128 à 127 ; un uint8 contient celles de 0 à 255. Additionner deux tableaux uint8 contenant 250 et 10 produit 4 par bouclage. Multiplier par 2 un tableau int8 contenant 100 produit −56. Un entier Python qui ne peut pas être représenté par le type du tableau, comme 300 ajouté à un tableau int8 dans NumPy 2, déclenche en revanche OverflowError. Passe les petits types entiers à des types plus larges avant des calculs susceptibles de dépasser leur plage.

Division et décimaux approximatifs

La division entière arrondit vers l’infini négatif, ce qui diffère de la troncature pour les résultats négatifs. La division ordinaire renvoie des résultats à virgule flottante pour des entiers en entrée.

De nombreuses fractions décimales sont approximatives en binaire. 0.1 + 0.2 == 0.3 est faux ; np.isclose compare les valeurs correspondantes avec une tolérance, et np.allclose donne une réponse unique pour les tableaux entiers.

Le marqueur de valeur manquante np.nan est un nombre à virgule flottante. Les tableaux d’entiers ne peuvent pas le stocker. np.array([1, 2, np.nan]) devient donc un tableau à virgule flottante ; convertir les valeurs manquantes en entiers ne les corrige pas et peut produire des résultats sans signification.

L’indexation repère les valeurs par leur position. L’extraction de tranches sélectionne une suite régulière de positions. Dans une table, écris un sélecteur pour chaque axe afin que le code indique les lignes et les colonnes dont tu as besoin.

Lire un vecteur

Pour a = np.array([10, 20, 30, 40, 50]), la position 0 contient 10 et la position −1 contient 50. Une tranche a la forme start:stop:step, avec la borne de fin exclue :

Omettre le début ou la fin étend la tranche jusqu’à l’extrémité correspondante. Une tranche peut dépasser le tableau et être raccourcie automatiquement. Une position isolée invalide, comme a[5], déclenche IndexError.

Donner à chaque axe de la table son propre sélecteur

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

m[1, 2] lit la ligne 1, colonne 2, et donne 6. La virgule sépare les axes. Un deux-points seul sélectionne l’axe entier : m[0, :] donne la première ligne [1 2 3], et m[:, 1] donne la deuxième colonne [2 5 8]. Pour un bloc, m[:2, 1:] sélectionne les lignes 0 et 1 et les colonnes 1 et 2, ce qui donne [[2 3] [5 6]].

Ne considère pas l’indexation par crochets successifs comme interchangeable avec l’indexation par virgule. m[1][2] trouve ici le même scalaire que m[1, 2]. Mais m[:][0] prend d’abord toutes les lignes, puis sélectionne la première ligne. Il ne sélectionne pas la première colonne, qui est m[:, 0].

Prévoir les axes qui restent

Un sélecteur entier unique supprime son axe. Une tranche conserve son axe même lorsqu’une seule position est sélectionnée. Ainsi, m[:, 1] a pour forme (3,), tandis que m[:, 1:2] a pour forme (3, 1). Les deux sélectionnent 2, 5 et 8, mais seul le second conserve un axe de colonne. Cette différence devient importante lorsqu’on soustrait ou multiplie des tableaux de formes différentes.

La même règle s’étend au-delà des tables. Si t.shape vaut (2, 3, 4), t[0] a pour forme (3, 4), t[0, 1] a pour forme (4,) et t[:, :, 0] a pour forme (2, 3). Les axes de fin omis dans l’indexation sont sélectionnés en entier.

Modifier les positions sélectionnées

Une affectation par indexation écrit dans le tableau existant. a[1:3] = 0 remplace les deux valeurs sélectionnées par zéro ; le scalaire est appliqué à toute la sélection. m[0] = [0, 0, 0] remplace une ligne complète. Les valeurs affectées doivent convenir à la forme de la sélection et sont converties à son type de données.

Pour quatre élèves et trois tests :

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores[2] correspond aux résultats du troisième élève [88 91 95]. scores[:, -1] donne les résultats du dernier test [92 58 95 80]. scores[1:3, :2] donne [[64 70] [88 91]] : deux élèves, chacun conservant deux colonnes de tests.

Une sélection peut partager ses données avec le tableau d’origine ou posséder des données indépendantes. Savoir dans quel cas tu te trouves évite que la modification d’une petite sélection change une table plus grande de façon inattendue.

Distinguer un alias, une vue et une copie

Pour a = np.arange(6) et b = a[2:5], l’affectation b[0] = 99 donne à a la valeur [0 1 99 3 4 5]. La première position de la vue correspond à la position 2 dans l’original. Cela diffère de l’extraction d’une tranche d’une liste Python, qui crée une nouvelle liste.

Copie avant de modifier lorsque l’original doit rester intact. Une petite vue conservée peut aussi maintenir en mémoire le grand tampon de données d’origine ; copier ce petit morceau lui permet d’être indépendant.

Sélectionner des positions quelconques

L’indexation avancée utilise une liste ou un tableau d’entiers. Elle permet de changer l’ordre des positions et de les répéter :

a = np.array([10, 20, 30, 40, 50])
a[[4, 0, 0]]
# array([50, 10, 10])

Pour m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), m[[0, 2]] sélectionne les première et troisième lignes. m[:, [2, 0]] sélectionne les dernière et première colonnes dans cet ordre, ce qui donne [[3 1] [6 4] [9 7]].

Deux listes d’entiers dans une même indexation sélectionnent des coordonnées appariées. m[[0, 2], [1, 2]] associe la ligne 0 à la colonne 1 et la ligne 2 à la colonne 2, ce qui produit [2 9]. Cette opération ne prend pas toutes les combinaisons. Pour obtenir le bloc formé par les deux lignes et les deux colonnes, utilise :

m[np.ix_([0, 2], [1, 2])]
# array([[2, 3], [8, 9]])

Sélectionner d’abord les lignes puis les colonnes avec m[[0, 2]][:, [1, 2]] donne le même bloc.

La lecture et l’affectation se comportent différemment

L’indexation avancée et le filtrage booléen renvoient des copies. Si c = a[[0, 1]], modifier c[0] laisse a inchangé. Mais a[[0, 1]] = -1 écrit directement dans ces positions du tableau d’origine. Une sélection enregistrée et une affectation par indexation sont des opérations différentes.

Cela explique aussi pourquoi des modifications chaînées peuvent ne pas atteindre la source. Dans a[[0, 1]][0] = -1, la première sélection est déjà une copie temporaire. L’écriture finale modifie ce tableau temporaire, et non a.

Vérifier directement le partage

np.shares_memory(x, y) vérifie si deux tableaux occupent une partie commune de la mémoire. Elle renvoie vrai pour une tranche ordinaire non vide et faux pour une copie issue d’une indexation avancée. L’attribut base peut identifier le tableau propriétaire de la mémoire, mais il ne désigne pas nécessairement le dernier tableau dont tu as extrait une tranche. Si a = np.arange(6), b = a[2:5] et c = b[0:2], alors c.base is a est vrai et c.base is b est faux. Utilise shares_memory pour vérifier précisément si deux tableaux partagent des données.

Un masque booléen indique quelles valeurs remplissent une condition. Une fois le masque créé, les mêmes valeurs vrai ou faux peuvent servir à sélectionner des valeurs, compter des événements ou choisir des valeurs de remplacement.

Construire et appliquer un masque

t = np.array([18.5, 22.0, 15.2, 25.8, 21.1])
warm = t > 20
t[warm]
# array([22. , 25.8, 21.1])

La comparaison produit [False True False True True]. L’indexation booléenne conserve les positions où le masque est vrai et renvoie une copie. Un masque à 1 dimension utilisé sur un axe doit avoir la même longueur que cet axe.

Pour combiner des conditions, utilise & pour ET, | pour OU et ~ pour NON. Place chaque comparaison entre parenthèses :

comfortable = (t > 18) & (t < 23)
t[comfortable]
# array([18.5, 22. , 21.1])

Les opérateurs Python and et or cherchent à obtenir une seule valeur de vérité pour un tableau entier et échouent avec les tableaux de plusieurs éléments. Omettre les parenthèses change aussi la manière dont Python regroupe l’expression, car les opérateurs bit à bit sont prioritaires sur les comparaisons.

Compter, mesurer ou tester des conditions

True contribue pour 1 et False pour 0. warm.sum() vaut 3 et warm.mean() vaut 0,6, la proportion de jours au-dessus de 20 °C. np.count_nonzero(warm) compte aussi les éléments vrais. warm.any() vérifie si au moins un jour est chaud ; warm.all() vérifie si tous les jours sont chauds.

Ces opérations répondent à des questions différentes de t[warm].mean(), qui calcule la température moyenne parmi les jours chauds. La moyenne d’un masque mesure une proportion ; la moyenne des mesures sélectionnées conserve l’unité de mesure.

Remplacer des valeurs ou choisir entre deux possibilités

Une affectation à travers un masque met à jour les positions sélectionnées. Avec t2 = t.copy(), la ligne t2[t2 < 16] = 16 porte les mesures basses à 16. np.clip(t, 16, 25) renvoie un nouveau tableau borné aux deux extrémités, [18.5 22. 16. 25. 21.1].

np.where(condition, x, y) construit un nouveau résultat en prenant x aux positions vraies et y aux positions fausses. np.where(t > 20, 'warm', 'cool') fournit une étiquette à chaque position d’origine. Le filtrage, lui, raccourcit le résultat. Avec une condition seule, np.where(t > 20) renvoie un tuple de tableaux d’indices, ici (array([1, 3, 4]),).

Conserver des valeurs ou des enregistrements complets

Un masque de même forme appliqué à un tableau à 2 dimensions extrait les éléments correspondants dans un seul vecteur aplati. Dans m[m > 5], la structure des lignes est perdue. Pour conserver des enregistrements entiers, déduis une valeur booléenne par ligne à partir d’une colonne :

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])
scores[scores[:, 2] >= 90]
# array([[78, 85, 92], [88, 91, 95]])

Repérer explicitement les valeurs manquantes

NaN n’est même pas égal à lui-même. Les comparaisons d’égalité et d’ordre avec NaN sont fausses ; l’inégalité est vraie. Ainsi, ni x == np.nan ni x != np.nan ne repère correctement les éléments présents et manquants. np.isnan(x) indique les positions manquantes, et x[~np.isnan(x)] conserve les valeurs présentes.

Modifier la forme change la manière dont les valeurs sont regroupées selon les axes. Remodeler, transposer et ajouter un axe sont des opérations différentes, même si certaines produisent la même forme finale.

Remodeler sans changer le nombre d’éléments

a = np.arange(6)
r = a.reshape(2, 3)
# array([[0, 1, 2], [3, 4, 5]])

L’ordre par défaut remplit une ligne à la fois : le dernier axe varie le plus vite. Remodeler les mêmes valeurs selon la forme (3, 2) donne [[0 1] [2 3] [4 5]]. Le produit des nouvelles dimensions doit être égal à la taille d’origine. Douze éléments conviennent à la forme (3, 4), mais pas à (5, 3).

Une dimension peut être indiquée par -1, ce qui laisse NumPy en déduire la longueur. np.arange(12).reshape(-1, 3) donne quatre lignes de trois éléments ; reshape(2, -1) donne deux lignes de six éléments. Deux dimensions inconnues ne sont pas autorisées, car leurs longueurs respectives ne peuvent pas être déduites du seul total.

La transposition permute les axes

Pour r ci-dessus, r.T vaut [[0 3] [1 4] [2 5]] et a pour forme (3, 2). Chaque ancienne colonne est désormais une ligne. Cette disposition diffère de celle de r.reshape(3, 2), même si les formes obtenues sont identiques.

Une transposition est utile lorsque l’opération suivante nécessite l’ordre inverse des axes. Un remodelage est utile lorsqu’une séquence possède déjà un regroupement qui a un sens, comme des mois regroupés en trimestres.

Transposer un tableau à 1 dimension ne crée pas une colonne

v = np.arange(3) n’a qu’un seul axe, donc v.T a toujours pour forme (3,). Ajoute explicitement un axe :

column = v[:, np.newaxis]  # shape (3, 1)
row = v[np.newaxis, :]     # shape (1, 3)

v.reshape(-1, 1) et np.expand_dims(v, 1) créent aussi une colonne. np.squeeze(column) supprime son axe de longueur un et renvoie un tableau de forme (3,). Ajouter un axe ne change aucune valeur, mais indique aux calculs ultérieurs comment les aligner.

Aplatissement et partage de mémoire

r.ravel() et r.flatten() énumèrent tous deux les valeurs dans un résultat à 1 dimension. ravel renvoie une vue lorsque c’est possible ; flatten crée toujours une copie. reshape(-1) est une autre façon de demander une disposition à 1 dimension, mais le partage de mémoire dépend de l’organisation des données en entrée. Le remodelage peut nécessiter une copie ; la transposition partage les données dans la vue du tableau qu’elle renvoie. Utilise .copy() lorsqu’un stockage indépendant est nécessaire.

Regrouper les valeurs mensuelles par trimestre

Pour monthly = np.array([120, 135, 150, 160, 155, 170, 180, 175, 165, 150, 140, 130]), monthly.reshape(4, 3) crée quatre lignes de trimestres, chacune contenant trois mois. Additionner chaque ligne avec .sum(axis=1) donne [405 485 520 420]. Le premier total est 120 + 135 + 150 = 405. Le remodelage fonctionne parce que les données fournies dans l’ordre chronologique regroupent déjà les mois de chaque trimestre.

L’assemblage combine les valeurs de plusieurs tableaux. Le découpage divise un tableau en morceaux. Détermine d’abord si l’opération doit prolonger un axe existant ou en créer un nouveau.

Concaténer selon un axe existant

np.concatenate([a, b], axis=0) assemble des vecteurs bout à bout. Assembler [1 2] avec [3 4 5] donne [1 2 3 4 5].

Pour deux tableaux ayant chacun la forme (2, 3), l’axe 0 ajoute des lignes et donne (4, 3). L’axe 1 ajoute des colonnes et donne (2, 6). Seul l’axe d’assemblage peut avoir des longueurs différentes. Ainsi, les formes (2, 3) et (2, 2) peuvent être assemblées selon l’axe 1 pour former (2, 5), mais pas selon l’axe 0, car leurs nombres de colonnes diffèrent.

Les tableaux doivent être passés ensemble sous forme de séquence, par exemple [a, b]. L’assemblage crée un nouveau tableau combiné et copie les données des tableaux fournis.

Empiler selon un nouvel axe

Pour p = np.array([1, 2, 3]) et q = np.array([4, 5, 6]) :

stack exige des tableaux de même forme en entrée et ajoute un axe. concatenate conserve le nombre d’axes. Les fonctions utilitaires expriment des dispositions courantes : vstack([p, q]) crée des lignes, hstack([p, q]) assemble ces tableaux à 1 dimension bout à bout et column_stack([p, q]) crée des colonnes. Le comportement de hstack avec des tableaux à 1 dimension explique pourquoi son seul nom ne suffit pas à prévoir la table obtenue.

Découper selon des bornes ou un nombre de parties

np.split(np.arange(10), [3, 7]) découpe avant les positions 3 et 7, ce qui donne [0 1 2], [3 4 5 6] et [7 8 9]. Les positions de découpage ne sont pas des longueurs de parties.

Un entier comme deuxième argument demande au contraire des parties égales : np.split(x, 3) demande trois morceaux égaux. Dix éléments ne peuvent pas être divisés également en trois morceaux de longueur entière : cela déclenche donc ValueError. np.array_split(np.arange(10), 3) autorise des longueurs inégales et produit 4, 3 et 3. Ces appels de découpage renvoient une collection de tableaux, et non un seul tableau avec un nouvel axe d’empilement.

Construire une table de mesures

h = np.array([1.62, 1.75, 1.80])  # meters
w = np.array([55.0, 72.5, 80.0])  # kilograms
data = np.column_stack([h, w])

La forme (3, 2) correspond à trois personnes, avec la taille et la masse en colonnes. L’expression data[:, 1] / data[:, 0] ** 2 calcule la masse divisée par la taille au carré pour chaque ligne, ce qui donne environ 21,0, 23,7 et 24,7 kg/m². Il est essentiel que les deux tableaux de mesures suivent le même ordre de personnes.

Si les données arrivent par lots, rassemble les tableaux des lots dans une liste Python et appelle concatenate une seule fois. Réassembler un tableau qui grandit à chaque passage dans une boucle copie ses données existantes à répétition.

La vectorisation exprime un calcul pour des tableaux entiers. NumPy effectue le travail répété sur chaque élément dans du code compilé, de sorte que l’expression Python peut rester proche du calcul recherché.

Traduire une boucle en calcul sur les positions correspondantes

prices = np.array([2.50, 4.00, 1.20])
qty = np.array([3, 1, 5])
line_totals = prices * qty
order_total = line_totals.sum()

Les produits sont [7.5 4. 6.] et leur somme est de 17,5. Chaque prix est associé à sa quantité. Une boucle Python qui met à jour un total produit le même résultat, mais demande à Python de traiter chaque paire séparément.

Tous les opérateurs arithmétiques agissent élément par élément : +, -, *, /, //, % et **. Un scalaire s’applique à chaque élément. 10 - np.array([1, 2, 3]) donne [9 8 7] ; l’ordre des opérandes reste important. Deux tableaux doivent avoir des formes égales ou compatibles avec la diffusion.

Distinguer le produit élément par élément du produit matriciel

* multiplie les éléments correspondants. Pour A = np.array([[1, 2], [3, 4]]) et B = np.array([[5, 6], [7, 8]]), A * B donne [[5 12] [21 32]]. La multiplication matricielle utilise @ et donnerait [[19 22] [43 50]]. Choisis * pour des mesures appariées comme un prix et une quantité.

Les comparaisons renvoient aussi une réponse par position

a == b produit un tableau booléen. Il ne vérifie pas si les deux tableaux sont égaux en tant qu’objets entiers. Une instruction if nécessite une seule valeur de vérité : if a == b: échoue donc pour des résultats à plusieurs éléments. np.array_equal(a, b) teste l’égalité exacte des tableaux entiers. Pour les décimaux approximatifs, np.allclose(a, b) vérifie leur correspondance à une tolérance près.

Comprendre les avertissements de division

Avec les réglages d’erreur par défaut de NumPy, une division en virgule flottante par zéro produit un avertissement et des valeurs spéciales :

np.array([1.0, -1.0, 0.0]) / 0
# array([ inf, -inf, nan])

np.isfinite repère les résultats qui ne sont ni infinis ni NaN. La division entière par zéro arrondie vers le bas renvoie, elle, des zéros entiers avec un avertissement. Ces zéros paraissent finis : examine donc les dénominateurs entiers avec (d == 0).any() avant une division entière arrondie vers le bas. Un avertissement mérite ton attention même si le programme continue.

Décider de modifier ou non en place

a += value modifie le stockage existant et conserve son type de données. Si a est un tableau d’entiers, a += 0.5 déclenche une erreur de conversion de type, car le résultat à virgule flottante ne peut pas être stocké selon la règle de conversion de cette opération. a = a + 0.5 crée un résultat à virgule flottante et associe a à ce résultat. Cela diffère de l’affectation d’un décimal à un élément entier, qui peut le tronquer sans avertissement.

Construire une expression en plusieurs étapes

Pour old = np.array([2.50, 4.00, 8.00]) et new = np.array([3.00, 3.00, 8.00]), (new - old) / old * 100 donne [20. -25. 0.]. Calcule d’abord chaque variation, puis divise-la par sa valeur d’origine, puis exprime le rapport en pourcentage. Les signes indiquent une hausse, une baisse et une absence de variation. Les valeurs d’origine doivent être non nulles pour ce calcul de pourcentage.

Une fonction universelle, ou ufunc, applique un calcul séparément à chaque position d’un tableau. Ces fonctions étendent la vectorisation au-delà des calculs arithmétiques ordinaires : racines, logarithmes, arrondis, comparaisons et autres opérations numériques.

Choisir une fonction adaptée aux tableaux

Les fonctions universelles unaires prennent une entrée. np.sqrt(np.array([1, 4, 9])) donne [1. 2. 3.], et np.abs(np.array([-2, 3])) donne [2 3]. np.exp est la fonction exponentielle, np.log est le logarithme népérien et np.log10 est le logarithme en base 10. Par exemple, np.exp(0) vaut 1,0 et np.log10(1000) vaut 3,0.

Le module Python math travaille sur des nombres individuels. math.sqrt(np.array([1, 4])) ne peut pas calculer les deux racines et déclenche une erreur de type. Utilise la version de NumPy pour les tableaux numériques. Les opérateurs appellent aussi des fonctions universelles : a + b correspond à np.add(a, b) et a * b à np.multiply(a, b).

Comparer les valeurs correspondantes ou réduire un tableau entier

Les fonctions universelles binaires prennent deux entrées. np.maximum([1, 5, 3], [4, 2, 6]) donne [4 5 6], en choisissant la plus grande valeur à chaque position. np.minimum choisit la plus petite et np.power élève les bases correspondantes aux puissances indiquées.

np.maximum(x, 0) fixe les éléments négatifs à zéro dans un nouveau résultat. Cette fonction diffère de np.max(x), une agrégation qui renvoie une seule valeur maximale. Pour [1, 5, 3], max donne 5 ; maximum nécessite une autre entrée et conserve la structure élément par élément.

Arrondir selon la règle voulue

np.round(x, 2) conserve deux décimales. Les valeurs exactement à mi-chemin suivent la règle du nombre pair : np.round([0.5, 1.5, 2.5]) donne [0. 2. 2.]. L’approximation binaire peut influencer les valeurs qui semblent à mi-chemin en décimal : interprète donc les décimaux affichés en tenant compte de leur représentation en virgule flottante.

Examiner les valeurs hors de l’ensemble de définition d’une fonction

Pour des entrées réelles à virgule flottante, np.sqrt(-1.0) renvoie NaN avec un avertissement, tandis que np.log(0.0) renvoie l’infini négatif avec un avertissement lorsque les réglages d’erreur sont ceux par défaut. Contrairement à math.sqrt(-1), ces appels ne s’arrêtent normalement pas sur une exception de domaine. Vérifie les entrées lorsque l’opération mathématique exige une plage limitée. np.isnan repère les NaN ; np.isfinite repère les valeurs qui ne sont ni NaN ni infinies ; np.isclose compare les valeurs avec une tolérance.

Combiner des fonctions universelles dans un calcul utile

Pour les tableaux de coordonnées x = np.array([3, 5, 8]) et y = np.array([4, 12, 15]), calcule la distance à l’origine avec np.sqrt(x ** 2 + y ** 2). L’élévation au carré donne [9 25 64] et [16 144 225] ; l’addition donne [25 169 289] ; les racines sont [5. 13. 17.]. np.hypot(x, y) calcule directement ces distances.

La diffusion permet à des tableaux de formes différentes de participer à des calculs élément par élément. L’alignement des axes détermine quelles valeurs sont appariées et lesquelles sont répétées.

Comparer les dimensions à partir de la droite

Aligne les formes par leur extrémité droite. Dans chaque paire, les longueurs d’axe doivent être égales ou l’une d’elles doit valoir 1. Les axes manquants à gauche comptent comme des axes de longueur 1. Un axe de longueur un est conceptuellement étiré pour correspondre à l’autre longueur ; NumPy n’a pas besoin de copier les valeurs répétées en entrée.

Pour (4, 3) et (3,), les dernières longueurs correspondent et valent 3. La dimension manquante à gauche se comporte comme si elle valait 1 et s’étire à 4. Le résultat est (4, 3) : le vecteur s’applique à chaque ligne. (4, 3) et (4,) échouent car les dernières longueurs, 3 et 4, diffèrent et aucune ne vaut 1. Une paire incompatible déclenche ValueError.

Centrer ou centrer et réduire les colonnes

X = np.array([[1, 10], [2, 20], [3, 30]])
centered = X - X.mean(axis=0)

Les moyennes des colonnes sont [2. 20.], de forme (2,). Elles s’alignent sur le dernier axe de (3, 2), ce qui donne [[-1. -10.] [0. 0.] [1. 10.]]. Diviser le résultat centré par X.std(axis=0) centre et réduit chaque colonne, ce qui produit environ −1,22, 0 et 1,22 de haut en bas dans les deux colonnes. La dispersion de chaque colonne doit être non nulle pour cette division.

Conserver un axe pour les calculs par ligne

Utilise une table de résultats pour quatre élèves et trois tests :

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores.mean(axis=1) a pour forme (4,). Il ne peut pas être diffusé avec (4, 3) pour appliquer une moyenne par ligne. Conserve l’axe supprimé :

row_mean = scores.mean(axis=1, keepdims=True)
centered = scores - row_mean

row_mean a maintenant pour forme (4, 1). Son premier axe de longueur 4 correspond aux lignes ; son dernier axe de longueur 1 s’étire sur trois colonnes. scores.mean(axis=1)[:, np.newaxis] crée la même forme. Pour la ligne [78, 85, 92], la soustraction de sa moyenne de 85 donne [-7. 0. 7.].

Utiliser la même règle pour construire une table

np.arange(1, 4)[:, np.newaxis] * np.arange(1, 5) combine (3, 1) et (4,). Les deux tableaux s’étendent jusqu’à la forme du résultat (3, 4), ce qui produit [[1 2 3 4] [2 4 6 8] [3 6 9 12]].

L’extension peut aussi être involontaire. Une colonne de forme (3, 1) moins un vecteur de forme (3,) crée les neuf différences entre toutes les paires, de forme (3, 3). Si tu voulais trois différences entre éléments correspondants, donne aux deux entrées la forme (3,), par exemple avec column.ravel().

Pondérer chaque colonne avant l’addition

Pour la même table de résultats et w = np.array([0.2, 0.3, 0.5]), scores * w applique les trois coefficients à chaque ligne. La somme avec .sum(axis=1) donne [87.1 62.8 92.4 74.8]. Le premier résultat est 15,6 + 25,5 + 46,0 = 87,1.

Une agrégation combine des valeurs pour obtenir moins de résultats : un total, une moyenne, une valeur extrême ou un indicateur de dispersion. Choisir l’axe fait partie du choix de la question, car il détermine quels groupes de valeurs sont combinés.

Réduire l’axe indiqué

Pour une table de forme (4, 3) avec quatre élèves et trois tests, une agrégation sans axis utilise les 12 valeurs. scores.sum() donne un total unique. scores.mean(axis=0) réduit l’axe des élèves et conserve trois moyennes de tests. scores.mean(axis=1) réduit l’axe des tests et conserve quatre moyennes d’élèves.

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

La somme globale est de 941. Les moyennes des colonnes sont [75.5 78.5 81.25] ; les moyennes des lignes sont environ [85. 64. 91.33 73.33]. Demande-toi quel axe doit disparaître. Dire « l’axe 0 signifie chaque ligne » inverse l’opération : l’axe 0 combine les lignes.

Choisir la grandeur à renvoyer

Les méthodes comme a.sum() et les fonctions comme np.sum(a) expriment la même opération de base. Les méthodes de NumPy évitent le comportement différent des fonctions intégrées de Python. Par exemple, la fonction Python sum(scores) additionne les tableaux correspondant aux lignes pour produire les totaux des colonnes, tandis que scores.sum() combine tous les éléments. La fonction Python max(scores) tente de comparer les lignes et déclenche une erreur liée à une valeur de vérité ambiguë.

Les positions diffèrent des valeurs

scores.mean(axis=1).argmax() vaut 2 : le troisième élève a la moyenne la plus élevée. argmax renvoie la première position lorsque plusieurs valeurs maximales sont ex æquo. Sans axe sur une table, il renvoie un indice du tableau aplati dans l’ordre par lignes ; scores.argmax() vaut 8. np.unravel_index(8, scores.shape) retrouve les coordonnées (2, 2).

Utilise keepdims=True lorsqu’un indicateur doit s’aligner sur la table d’origine. scores.sum(axis=1, keepdims=True) a pour forme (4, 1), ce qui convient pour une valeur de normalisation par ligne. Sans cet argument, le résultat a pour forme (4,).

Conserver les totaux intermédiaires lorsque l’ordre compte

np.cumsum([3, 1, 4, 1, 5]) donne [3 4 8 9 14]. Chaque position contient le total jusqu’à ce point. np.cumprod([1, 2, 3, 4]) donne de même [1 2 6 24]. np.diff([3, 1, 4, 1, 5]) donne les quatre variations entre valeurs voisines [-2 3 -3 4]. Sur une table, indique axis=1 pour obtenir des sommes cumulées distinctes sur les lignes.

Préciser la convention de dispersion

std et var divisent par défaut la somme des carrés des écarts par le nombre de valeurs : ddof=0. Utilise ddof=1 pour la formule d’échantillon, dont le diviseur est inférieur d’une unité. Pour [2, 4, 4, 4, 5, 5, 7, 9], la moyenne est de 5, l’écart-type par défaut est de 2,0 et l’écart-type d’échantillon est d’environ 2,14. Un compte rendu doit indiquer clairement la convention utilisée.

Les indicateurs fondés sur l’ordre décrivent la place des valeurs dans une distribution triée. Le tri permet aussi de classer les enregistrements, mais une table doit être traitée avec soin pour conserver ensemble les champs de chaque enregistrement.

Repérer le milieu et les quartiles

Pour x = np.array([12, 15, 11, 20, 18, 14]), l’ordre croissant est [11 12 14 15 18 20]. Avec six valeurs, np.median(x) calcule la moyenne des deux valeurs centrales, 14 et 15, ce qui donne 14,5. Lorsque l’effectif est impair, la médiane est l’unique valeur centrale.

np.percentile(x, q) prend un pourcentage de 0 à 100. np.quantile(x, q) prend la fraction équivalente de 0 à 1. Leur interpolation linéaire par défaut peut donner une valeur située entre des observations. Pour six valeurs, la position du 25e centile, en comptant à partir de zéro, est 0,25 × 5 = 1,25. Elle se trouve au quart du chemin entre 12 et 14, ce qui donne 12,5. Les 50e et 75e centiles valent 14,5 et 17,25, donc l’écart interquartile est de 4,75.

La médiane est moins sensible à une valeur extrême que la moyenne. Ajouter 200 à ces données fait passer la moyenne de 15,0 à environ 41,4 ; la médiane passe de 14,5 à 15,0. Aucun de ces deux indicateurs ne décrit à lui seul toute la distribution.

Choisir des données triées ou des positions de tri

np.sort(x) renvoie une copie triée. x.sort() modifie x et renvoie None, donc y = x.sort() ne place pas les valeurs triées dans y. Pour obtenir les valeurs dans l’ordre décroissant, utilise np.sort(x)[::-1].

Sur un tableau à 2 dimensions, le tri s’effectue par défaut selon le dernier axe, en triant chaque ligne indépendamment. axis=0 trie chaque colonne indépendamment. Aucune de ces opérations ne trie les enregistrements. Pour tab = np.array([[3, 1], [1, 2], [2, 0]]), np.sort(tab, axis=0) donne [[1 0] [2 1] [3 2]], en séparant des valeurs qui appartenaient à l’origine au même enregistrement.

Pour préserver les enregistrements, obtiens un ordre à partir de la colonne servant de clé et applique-le aux lignes entières :

order = tab[:, 0].argsort()
ranked = tab[order]
# array([[1, 2], [2, 0], [3, 1]])

Le même ordre d’indices peut réordonner des vecteurs associés. Si avg = np.array([85.0, 64.0, 91.33, 73.33]) et names = np.array(['Ana', 'Ben', 'Chen', 'Dara']), order = np.argsort(avg)[::-1] classe les moyennes dans l’ordre décroissant. names[order] donne ['Chen' 'Ana' 'Dara' 'Ben'].

Compter les valeurs distinctes et vérifier l’appartenance

np.unique renvoie les valeurs distinctes triées. Avec return_counts=True, elle renvoie aussi les effectifs correspondants :

colors = np.array(['red', 'blue', 'red', 'green', 'blue', 'red'])
values, counts = np.unique(colors, return_counts=True)

Les résultats sont ['blue' 'green' 'red'] et [2 1 3]. values[counts.argmax()] trouve la valeur la plus fréquente, 'red'. Les positions des effectifs correspondent à celles des valeurs distinctes.

np.isin(a, allowed) renvoie un masque indiquant l’appartenance à une collection. Pour a = np.arange(1, 6), np.isin(a, [2, 4]) donne [False True False True False], prêt à sélectionner ces valeurs ou les enregistrements associés.

Les données manquantes et les sous-ensembles filtrés nécessitent une règle explicite pour calculer les indicateurs. Un résultat numérique peut être erroné même lorsque l’opération sur le tableau s’exécute correctement : un code de valeur manquante peut être compté comme une mesure, ou un sous-ensemble vide peut être pris pour une moyenne ayant un sens.

Repérer les valeurs manquantes avant de calculer des indicateurs

NaN se propage dans les sommes et les moyennes ordinaires. Pour x = np.array([3.0, np.nan, 5.0]), x.sum() et x.mean() donnent tous deux NaN. np.nansum(x) donne 8,0 et np.nanmean(x) donne 4,0, en sautant la position manquante. Parmi les fonctions apparentées figurent nanmax, nanmin, nanstd et nanmedian. Si toutes les valeurs sont manquantes, nanmean renvoie NaN avec un avertissement, car aucune valeur observée ne reste.

Pour des mesures de capteur en °C :

r = np.array([21.5, np.nan, 22.1, 23.0, np.nan, 21.9])
missing = np.isnan(r)

missing.sum() vaut 2, missing.mean() vaut environ 0,33, et r[~missing] conserve quatre mesures. np.nanmean(r) vaut 22,125, en utilisant uniquement ces quatre valeurs. La comparaison r == np.nan ne repérerait pas les mesures manquantes.

Convertir d’abord les codes de valeur manquante

Un nombre comme −999 peut représenter des données manquantes dans un système d’entrée. NumPy le traite comme une mesure réelle jusqu’à ce que tu le remplaces :

v = np.array([12, -999, 15, -999, 9]).astype(float)
v[v == -999] = np.nan
np.nanmean(v)  # 12.0

Convertis d’abord les données en nombres à virgule flottante, car un tableau d’entiers ne peut pas stocker NaN. Ce remplacement ne convient que si −999 est défini comme le code de valeur manquante pour ces données.

Le remplacement modifie la distribution

Remplacer les températures manquantes par zéro donne une moyenne de 14,75 dans l’exemple, alors qu’aucune température de zéro n’a été observée. Les remplacer par la moyenne observée, 22,125, préserve cette moyenne mais réduit la dispersion apparente. Une valeur de remplacement est une estimation introduite : son effet doit donc être pris en compte dans la décision d’analyse.

Pour une table D à 2 dimensions, np.nanmean(D, axis=0) calcule un indicateur sur les valeurs observées de chaque colonne. Chaque colonne peut avoir un effectif différent. Pour supprimer les lignes contenant au moins une valeur manquante :

complete = ~np.isnan(D).any(axis=1)
clean_rows = D[complete]

La réduction crée une décision par ligne ; la négation conserve les lignes sans élément manquant. Avec D = np.array([[1., 2.], [np.nan, 4.], [5., np.nan], [7., 8.]]), cela conserve [[1. 2.] [7. 8.]].

Calculer un indicateur selon une condition ou par groupe

Pour les températures t, t[t > 20].mean() calcule la moyenne des seuls jours au-dessus de 20 °C. Dans des données regroupées, utilise un masque d’étiquettes correspondant : avec group = np.array(['A', 'B', 'A', 'B', 'A']) et value = np.array([10, 20, 14, 26, 12]), value[group == 'A'].mean() vaut 12,0 et la moyenne correspondante du groupe B vaut 23,0. Parcours np.unique(group) pour répéter ce calcul pour chaque groupe.

Avant de calculer un indicateur sur un sous-ensemble filtré, vérifie mask.any(). La moyenne d’une sélection vide est NaN avec un avertissement, tandis que sa somme est 0. Ce zéro peut être un total valide pour une sélection vide, mais il ne prouve pas qu’une mesure était présente.

Un générateur de nombres aléatoires permet l’échantillonnage, le mélange et la simulation. Une graine rend l’état initial reproductible, afin que tu puisses réexécuter une analyse tout en examinant sa logique.

Créer un objet Generator et le réutiliser

rng = np.random.default_rng(42)

NumPy recommande cette interface Generator pour le nouveau code. Son générateur de bits par défaut est PCG64. Sans graine, default_rng() obtient une nouvelle source d’entropie du système d’exploitation. Les anciens appels comme np.random.seed et np.random.rand utilisent un état global partagé ; les objets Generator permettent à une analyse de gérer directement son propre état.

Les valeurs pseudo-aléatoires proviennent d’un algorithme déterministe. Un même état initial et une même suite d’appels reproduisent la suite dans le même environnement. Chaque tirage fait évoluer l’état. Créer un nouvel objet Generator avec la graine 42 à chaque passage dans une boucle redémarre la suite et répète les mêmes premiers tirages au lieu de la poursuivre. Consigne la version de NumPy et le code en plus de la graine, car la compatibilité de la suite n’est pas garantie entre les versions ni dans tous les environnements. Pour les mots de passe ou les jetons de sécurité, utilise le module Python secrets.

Choisir une loi et une forme de sortie

size peut être un nombre d’éléments ou un tuple de forme. Pour normal, loc est la moyenne de la loi et scale est son écart-type. Une variance de 100 nécessite donc scale=10. La moyenne et l’écart-type observés dans un petit échantillon ne correspondent pas nécessairement de façon exacte aux paramètres de la loi.

Pour les tirages d’entiers, la borne supérieure est exclue par défaut. Un dé nécessite integers(1, 7), puisque integers(1, 6) ne peut pas tirer 6. integers(1, 6, endpoint=True) inclut la borne supérieure et modélise aussi un dé.

Échantillonner des valeurs avec ou sans remise

rng.choice(['heads', 'tails'], size=5) effectue cinq tirages avec remise. Une valeur peut apparaître plusieurs fois. Pour tirer des positions distinctes, utilise replace=False ; demander plus de positions que n’en contient la population déclenche ValueError. Les probabilités peuvent être fournies sous la forme p=[0.7, 0.3], dans le même ordre que les valeurs, et leur somme doit être égale à 1.

Un tirage sans remise empêche de sélectionner deux fois une même position en entrée. Si les données fournies contiennent elles-mêmes des doublons, des valeurs égales peuvent tout de même apparaître dans l’échantillon.

Mélanger les enregistrements sans séparer leurs champs

rng.shuffle(a) réorganise le tableau existant et renvoie None. rng.permutation(a) renvoie une copie mélangée. rng.permutation(10) donne les entiers de 0 à 9 dans un ordre aléatoire, utiles comme indices de lignes.

Pour un tableau à 2 dimensions, l’axe par défaut est 0 : les lignes complètes se déplacent ensemble. Les champs de chaque observation restent ainsi alignés. Pour mélanger deux tableaux associés de manière cohérente, génère une seule permutation des indices de leurs enregistrements communs et applique-la aux deux tableaux.

Une simulation vectorisée représente des épreuves répétées sous forme de tableaux, applique la règle de l’événement à ces tableaux et calcule des indicateurs sur les résultats. La forme du tableau doit montrer ce que contient une épreuve.

Transformer un événement en proportion

rng = np.random.default_rng(42)
rolls = rng.integers(1, 7, size=100_000)
estimate = (rolls == 6).mean()

Le masque est vrai pour chaque 6 observé. Sa moyenne estime la probabilité de cet événement, proche de 1/6, soit environ 0,1667. rolls.mean() répond à une autre question : la moyenne des faces obtenues, proche de 3,5. Une graine fixe reproduit une estimation ; elle ne rend pas cette estimation exacte.

La vectorisation évite le travail au niveau de Python pour chaque tirage, ce qui rend souvent les grandes simulations beaucoup plus rapides qu’une boucle. Le gain de vitesse dépend du calcul, de la taille du tableau et de l’ordinateur : ce n’est donc pas une propriété fixe de l’événement.

Utiliser une ligne par épreuve à plusieurs valeurs

Pour simuler deux dés à chaque épreuve :

dice = rng.integers(1, 7, size=(100_000, 2))
totals = dice.sum(axis=1)
p_seven = (totals == 7).mean()

La table contient 100 000 lignes d’épreuves et deux colonnes de dés. Réduire l’axe 1 produit un total par épreuve. Six des 36 paires ordonnées équiprobables ont une somme égale à 7, donc la probabilité estimée devrait être proche de 6/36. Réduire l’axe 0 donnerait au contraire deux totaux sur l’ensemble des épreuves et ferait perdre l’événement défini par épreuve.

Les simulations plus grandes restent variables

Pour des épreuves indépendantes, l’erreur-type d’une proportion estimée est :

Ici, $p$ est la probabilité de l’événement et $n$ le nombre d’épreuves. Pour obtenir un 6 avec un dé en 100 000 épreuves, elle est d’environ 0,0012. Une approximation normale situe environ 95 % des estimations à moins de 0,0023 de 1/6. Multiplier le nombre d’épreuves par 100 divise l’erreur-type par 10. Davantage de tirages ne corrigent pas un événement mal codé.

Construire et examiner une marche aléatoire

steps = rng.choice([-1, 1], size=1000) tire des pas vers la gauche ou vers la droite. walk = steps.cumsum() donne la position après chaque pas. Son maximum et son minimum repèrent les positions extrêmes atteintes. Pour trouver le premier point situé à au moins 10 unités du départ :

hit = np.abs(walk) >= 10
if hit.any():
    step_count = hit.argmax() + 1

argmax repère le premier élément vrai, mais renvoie aussi 0 lorsque tous les éléments sont faux. Le test any() distingue un passage effectif de l’absence de passage. Ajoute 1 car la position 0 du tableau est la position après le pas 1.

Pour plusieurs marches, rng.choice([-1, 1], size=(5000, 1000)).cumsum(axis=1) effectue le cumul séparément sur chaque ligne. walks[:, -1] sélectionne toutes les positions finales ; leur moyenne est proche de 0 et leur écart-type proche de la racine carrée de 1 000, soit environ 31,6.

Utiliser des permutations et des vérifications exactes

Une répartition aléatoire de 100 enregistrements peut utiliser idx = rng.permutation(100), puis data[idx[:80]] et data[idx[80:]]. Les deux tranches disjointes d’une même permutation attribuent chaque enregistrement exactement une fois. Pour une simulation, compare un cas simple à une réponse exacte, comme une moyenne de 3,5 pour un dé, avant de faire confiance à des résultats plus complexes.