Python en mathématiques - Niveau 1

Boucle for : exercices supplémentaires

Plus tard ! Les exercices de cette page peuvent (doivent) être réservés à une seconde lecture.

De plus, ces exercices utilisent tous un affichage dans leurs spécifications. Ils sont bien évidemment hors programme de lycée et ils n'ont d'autres but que de vous exercer à programmer.

table de multiplication

Écrire une fonction en Python, nommée table(), qui respecte le cahier des charges suivant :

Paramètres un entier naturel n
Valeur renvoyée /
Affichage la table de multiplication correspondante (de 1*n à 12*n)

		
		
  • Une solution
  • Fonction et procédure

		
		

On distingue parfois les notions de fonction et procédure au sens suivant :

  • Une procédure peut avoir des paramètres, mais ne renvoie aucun résultat. Une fonction Python telle que celle que nous avons définie dans l'exercice pourrait donc être nommée procédure : elle ne renvoie rien, elle se contente de faire des affichages.
  • Une fonction renvoie un résultat calculé à partir des données qu'on lui donne en entrée (valeurs des paramètres). Une fonction ne devrait pas avoir d'effet de bord. On peut la comparer à la notion de fonction en mathématique.

En fait, en langage Python, s'il n'y a pas d'objet renvoyé explicitement dans le code, la fonction renvoie l'objet None.

Associativité de la somme

Pour trois réels $a$, $b$, $c$ quelconques, on a : $a + (b + c) = (a + b) + c$ (associativité). Mais il n'en va pas ainsi pour les nombres en machine...

Déterminer, en langage Python, quelle proportion des triplets (a, b, c) de flottants entre 0 et 10 ayant au plus un chiffre après la virgule ne vérifie pas l'égalité a + (b + c) = (a + b) + c.

  • Un code possible
  • Une autre version

		
		

Avec ce petit programme, on constate que l'égalité n'a pas lieu pour environ un quart des triplets (a, b, c) considérés.

Une version avec numpy (pour une documentation en français, suivez ce lien. La bibliothèque numpy n'est pas nécessairement incluse dans votre distribution Python. Un « tutoriel » pour installer des modules supplémentaires est disponible à la page [Sources] → [Modules complémentaires]) :


from numpy import arange

def test_associativite(a,b,c) :
    return (a+b)+c == a+(b+c)

compteur_assoc = 0
compteur_triplets = 0

for a in arange(0, 10, 0.1) :
    for b in arange(0, 10, 0.1) :
        for c in  arange(0, 10, 0.1) :
			 
            compteur_assoc = compteur_assoc + test_associativite(a,b,c)
            compteur_triplets += 1
			
print("Proportion de triplets pour lesquels (a+b)+c = a+(b+c) : ", compteur_assoc/compteur_triplets)

Le pourcentage obtenu n'est pas tout à fait le même que précédemment : c'est normal, la liste des nombres 0.1, 0.2, 0.3, ... est ici obtenue en ajoutant le pas 0.1 (ce qui pose des problèmes d'arrondi), tandis que dans le code précédent, on obtenait ces nombres en divisant par 10 des entiers. Les triplets intervenants dans les deux boucles ne sont donc pas les mêmes.

On explicite un peu les différences avec les codes ci-dessous :

  1. Le code :
    
    from numpy import arange
    
    Ln = list(arange(0, 10, 0.1))
    print(Ln)
    			
    donne (début d'affichage) :
    [0.0, 0.10000000000000001, 0.20000000000000001, 0.30000000000000004, 
    0.40000000000000002, 0.5, 0.60000000000000009, 
    0.70000000000000007, 0.80000000000000004, 0.90000000000000002, 1.0, 
    1.1000000000000001, 1.2000000000000002, 1.3, 1.4000000000000001, 1.5,
    		
  2. Tandis que :
    
    Lp = list( A/10 for A in range(0,100)) 
    print(Lp)
    			
    donne (début d'affichage) :
    [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 
    0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5,  

Somme des premiers entiers

  1. Écrire une fonction (procédure) en Python, nommée ligne(), qui respecte les spécifications suivantes :
    Paramètres un entier naturel non nul n et un entier i tel que 1 $ \leqslant$ i $ \leqslant$ n
    Valeur renvoyée /
    Affichage ligne comportant i symboles '☻' suivi de n-i symboles '☺'
    Copiez/collez ces symboles unicodes dans votre programme.
  2. Écrire une fonction (procédure) en Python, nommée carre(), qui respecte les spécifications suivantes :
    Paramètres un entier naturel non nul n
    Valeur renvoyée /
    Affichage n lignes, la ligne i étant le résultat de l'appel ligne(i, n)
  3. En déduire une formule close pour la somme $ \sum_{j=1}^{n} j \ + \ \sum_{j=1}^{n-1} j $.
  4. En déduire une formule close pour la somme $ 1 + 2 + 3 + \dots + n $.
  • Complément sur print()
  • Question 1
  • Question 2
  • Question 3
  • Question 4

L'instruction :


print( variable, end='fin')
		

affiche à l'écran le contenu de la variable suivi du mot fin.
Par défaut, le paramètre end a la valeur \n. Cette valeur signifie que l'on passe à la ligne après avoir écrit le contenu de la variable. Si l'on veut coller plusieurs affichages les uns derrière les autres, il faut utiliser end = '' (chaîne vide).

Première possibilité


		
		

Deuxième possibilité

Pour dupliquer k fois une chaîne, Python offre le raccourci 'chaine' * kk est de type int. D'où la seconde écriture :


		
		

		
		

Lorsqu'on lance carre(n), on obtient $1 + 2 + 3 + \dots + n$ symboles ☻ et $ (n-1) + (n-2) + (n-3) + \dots + 2 + 1 $ symboles ☺.

Comme la figure est un carré de côté n : $$ \sum_{j=1}^{n} j \ + \ \sum_{j=1}^{n-1} j = n^2 $$

En ajoutant n de chaque côté dans la formule précédente : $$2 \sum_{j=1}^{n} j = n^2 + n $$ On en déduit : $$ \sum_{j=1}^{n} j = \frac{1}{2} \times n (n+1) $$