15 minutes de Python
Les commandes np.sum, np.cumsum, np.prod, np.cumprod
Commandes
np.sum(x): somme des coefficientsnp.cumsum(x): sommes partiellesnp.prod(x): produit des coefficientsnp.cumprod(x): produits partiels
Sur une matrice A, on peut préciser axis=0 (colonnes) ou axis=1 (lignes).
Exemple
import numpy as np
x = np.array([1,2,3,4])
print(np.sum(x))
print(np.cumsum(x))
print(np.prod(x))
print(np.cumprod(x))Explication
np.cumsum renvoie les sommes partielles \((1, 1+2, 1+2+3, ...)\). De même np.cumprod renvoie les produits partiels.
Trois commandes utiles aujourd’hui
Clique sur une carte pour voir l’instruction utile.
lmbda (méthode d’inversion).
np.cumprod(x)Un exercice pour vérifier ta maîtrise
On considère le tableau x défini par x = np.arange(1, n+1) où n est saisi par l’utilisateur.
- Créer
x. - Calculer la somme \(S = 1+2+\cdots+n\) à l’aide de
np.sum. - Construire le tableau des sommes partielles
s = np.cumsum(x)et affichers[-1]. - Construire le tableau des produits partiels
p = np.cumprod(x)et afficherp[-1].
import numpy as np
n = int(input("n = "))
x = np.arange(1, n+1)
S = np.sum(x)
print("S =", S)
s = np.cumsum(x)
print("dernier terme de s =", s[-1])
p = np.cumprod(x)
print("p =")
print(p)On veut obtenir un script correct répondant à la question posée.
On considère le tableau x défini par x = np.arange(1, n+1) où n est saisi par l’utilisateur.
- Créer
x. - Calculer la somme \(S = 1+2+\cdots+n\) à l’aide de
np.sum. - Construire le tableau des sommes partielles
s = np.cumsum(x)et affichers[-1]. - Construire le tableau des produits partiels
p = np.cumprod(x)et afficherp[-1].
Pour écrire le code :
- Créer les matrices demandées avec
np.array(ounp.zeros/np.ones/np.eye). - Effectuer les opérations (coefficient par coefficient avec
*ou produit matriciel avecnp.dot). - Afficher le résultat avec
print.
Et pour quelques minutes de plus…
Prendre en main la programmation, pas à pas.
Ces exercices sont conçus pour t’aider à maîtriser progressivement la programmation en Python, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de scripts complets.
L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque instruction, puis en apprenant à les utiliser par toi-même.
L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.
Niveau 1 Analyser un code
Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des scripts Python déjà écrits.
L’objectif est de comprendre la logique du programme, le rôle des variables, des boucles
et des conditions, et d’être capable de prévoir ce que le code affiche ou calcule.
Niveau 2 Compléter un code
Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro.
Le squelette du programme est fourni : il te reste à compléter certaines instructions
pour que le code fonctionne correctement.
Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.
Niveau 3 Écrire un code complet
Passer à l’autonomie.
Dans cette dernière série, tu écris un programme complet à partir d’une consigne.
Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale du script.
C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.
Contenu réservé aux membres
Il faut être membre et connecté pour accéder aux exercices et aux corrigés.