Une sélection d'exercices pour apprendre la programmation Python

1
2
3
4
5
6
7
8
9
10
11
12
13
# affichage des 20 premiers termes de la table de multiplication par 7, 
# avec signalement des multiples de 3 : 
  
i = 1		# compteur : prendra successivement les valeurs de 1 à 20 
while i < 21: 
    # calcul du terme à afficher : 
    t = i * 7 
    # affichage sans saut à la ligne : 
    print(t, end = ' ') 
    # ce terme est-il un multiple de 3 ? (utilisation de l'opérateur modulo) : 
    if t % 3 == 0: 
        print("*", end = ' ')   # affichage d'un astérisque dans ce cas 
    i = i + 1		# incrémentation du compteur dans tous les cas

1
2
3
4
5
6
7
8
debut_table, fin_table = 1, 20 
marqueur = '*' # l'astérisque pour signaler les multiples de 3 
  
for i in range(debut_table, fin_table + 1): 
    t = i * 7 
    print(t, end = ' ') 
    if t % 3 == 0:  
        print(marqueur, end = ' ')

1
2
3
4
5
6
7
8
debut_table, fin_table = 1, 20 
marqueur = '*' # l'astérisque pour signaler les multiples de 3 
  
table_de_7 = (i * 7 for i in range(debut_table, fin_table + 1)) # création d'un générateur 
# print(type(table_de_7)) # table_de_7 de type <class 'generator'> 
  
for e in table_de_7: 
    print(e, marqueur + ' ' if e % 3 == 0 else '', end = '')

1
2
3
4
s = 1  
while s <= 16384:  
    print(s, "euro(s) =", s * 1.65, "dollar(s)")  
    s = s * 2

print(f"{s} euro(s) = {s * 1.65} dollar(s)")

1
2
3
4
a, c = 1, 1  
while c < 13:  
    print(a) 
    a, c = a * 3, c + 1

1
2
3
4
a = 1 
for _ in range(12): 
    print(a) 
    a = a * 3

1
2
3
4
5
6
7
8
9
10
# -*- coding : utf8 -*-  
"""Calcul d'un prix TTC."""  
  
# Programme principal =========================================================  
prixHT = float(input("Prix HT (0 pour terminer) ?"))  
while prixHT > 0:  
    print("Prix TTC : {:.2f}\n".format(prixHT * 1.196)) 
    prixHT = float(input("Prix HT (0 pour terminer) ?")) 
  
print("Au revoir !")

1
2
3
4
5
6
7
8
9
  
# -*- coding : utf8 -*-   
"""Calcul d'un prix TTC."""   
  
# Programme principal =========================================================     
while (prixHT := float(input("Prix HT (0 pour terminer) ?"))) > 0:   
    print("Prix TTC : {:.2f}\n".format(prixHT * 1.196))   
  
print("Au revoir !")

1
2
3
4
5
6
7
8
9
10
  
# -*- coding : utf8 -*-   
"""Calcul d'un prix TTC."""   
  
# Programme principal =========================================================     
print("Prix HT (0 pour terminer) ?") 
for prixHT in iter(input, "0"):   
    print("Prix TTC : {:.2f}\n".format(float(prixHT) * 1.196))   
    print("Prix HT (0 pour terminer) ?") 
print("Au revoir !")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  
# -*- coding : utf8 -*- 
"""Somme d'entiers et nombre d'entiers supérieurs à 100.""" 
  
# Programme principal ========================================================= 
somme, nombreTotal, nombreGrands = 0, 0, 0 
  
x = int(input("x (0 pour terminer) ?")) 
while x > 0: 
    somme += x 
    nombreTotal += 1 
    if x > 100: 
        nombreGrands += 1 
    x = int(input("x (0 pour terminer) ?")) 
  
print("\nSomme :", somme) 
print(nombreTotal, "valeur(s) en tout, dont", nombreGrands, "supérieure(s) à 100")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  
# -*- coding : utf8 -*-  
"""Somme d'entiers et nombre d'entiers supérieurs à 100."""  
  
# Programme principal =========================================================  
somme, nombreTotal, nombreGrands = 0, 0, 0  
  
while (x := int(input("x (0 pour terminer) ?"))) > 0:  
    somme += x  
    nombreTotal += 1  
    print(x) 
    if x > 100:  
        nombreGrands += 1 
  
print("\nSomme :", somme)  
print(nombreTotal, "valeur(s) en tout, dont", nombreGrands, "supérieure(s) à 100")

1
2
3
4
5
6
7
8
9
  
n = 1	# numéro de la case   
g = 1	    # nombre de grains à y déposer   
# Pour la variante, il suffit de définir g comme <float>   
# en remplaçant la ligne ci-dessus par :  g = 1.   
  
while n < 65 :   
    print(n, g)   
    n, g = n + 1, g * 2

1
2
3
4
5
6
  
nb_cases = 64 
g = 1 
for n in range(1, nb_cases + 1): 
    print(n, g) 
    g *= 2

1
2
3
4
5
6
  
nb_cases = 64 
g = 1 
for n in range(1, nb_cases + 1): 
    print("{} {:.2E}".format(n, g)) # E : notation exponentielle, avec 2 chiffres après la décimale 
    g *= 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
1 1.00E+00 
2 2.00E+00 
3 4.00E+00 
4 8.00E+00 
5 1.60E+01 
6 3.20E+01 
7 6.40E+01 
8 1.28E+02 
... 
61 1.15E+18 
62 2.31E+18 
63 4.61E+18 
64 9.22E+18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def fibonacci (sequence_length): 
    """ 
        retourne une liste de valeurs calculées 
        selon la suite de Fibonacci comprenant 
        sequence_length éléments ; 
    """ 
    sequence = [0, 1] 
    if sequence_length < 1: 
        print("La suite de Fibonacci commence avec au moins 1 élément") 
        return 
    if 0 < sequence_length < 3: 
        return sequence[:sequence_length] 
    for i in range(2, sequence_length):  
        sequence.append(sequence[i-1] + sequence[i-2]) 
    return sequence

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
def fibonacci(n):  
    """  
        retourne le terme d'indice n de la suite de Fibonacci (F0=0, F1=1) 
    """  
    assert n >= 0, "La suite de Fibonacci commence à l'indice 0, F0=0"  
    if n == 0: 
        return 0 
    elif n == 1: 
        return 1 
    else: 
        return fibonacci(n-2) + fibonacci(n-1) 
  
print([fibonacci(n) for n in range(17)]) # suite F0 à F16

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# -*- coding : utf8 -*-  
"""Nombre de fois qu'un entier est divisible par 2."""  
  
# Programme principal =========================================================  
n = int(input("Entrez un entier strictement positif :"))  
while n < 1:  
    n = int(input("Entrez un entier STRICTEMENT POSITIF, s.v.p. :"))  
save = n  
  
cpt = 0  
while n % 2 == 0:  
    n /= 2  
    cpt += 1  
  
print(save, "est", cpt, "fois divisible par 2.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  
# -*- coding : utf8 -*-  
"""Diviseurs propres d'un entier."""  
  
# Programme principal =========================================================  
n = int(input("Entrez un entier strictement positif :"))  
while n < 1:  
    n = int(input("Entrez un entier STRICTEMENT POSITIF, s.v.p. :"))  
  
i = 2 # plus petit diviseur possible de n  
cpt = 0 # initialise le compteur de divisions  
p = n / 2 # calculé une fois dans la boucle  
  
print("Diviseurs propres sans répétition de", n, " :", end=' ')  
while i <= p :  
    if n % i == 0:  
        cpt += 1  
        print(i, end=' ')  
    i += 1  
  
if not cpt :  
    print("aucun ! Il est premier.")  
else : 
    print("(soit", cpt, "diviseurs propres)")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
# -*- coding : utf8 -*-  
"""Approximation de 'e'."""  
  
# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  
def fact(n) :  
    r = 1  
    for i in range(1, n+1) :  
        r *= i  
    return r  
  
# Programme principal =========================================================  
n = int(input("n ? "))  
exp = 0.0  
for i in range(n+1) :  
    exp = exp + 1.0 / fact(i)  
  
print("Approximation de 'e' : {:.6f}".format(exp))

1
2
3
4
5
6
7
8
9
10
11
  
# -*- coding : utf8 -*-  
"""Approximation de 'e'."""    
n = int(input("n ? ")) 
factorielle  = 1 # initialisation, 1! = 1 
exp = 1.0  
  
for i in range(1, n+1): # i = 1, 2, 3, ..., n 
    factorielle *= i 
    exp += 1.0 / factorielle 
print("Approximation de 'e' : {:.8f}".format(exp))

1
2
3
4
5
6
7
8
9
10
11
12
 
n ? 5 
Approximation de 'e' : 2.71666667 
 
n ? 10 
Approximation de 'e' : 2.71828180 
 
n ? 15 
Approximation de 'e' : 2.71828183 
 
n ? 20 
Approximation de 'e' : 2.71828183

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env python3 
# coding: utf-8 
  
def tapisserie(n): 
	# Le bord 
	bord="+" 
	for i in range(n+1): bord +="-" 
	bord+="+" 
  
	# La boucle d'affichage 
	print(bord) 
	for i in range(n+1): 
		tapis="" 
		for j in range(n-i): tapis+="#" 
		tapis+=" " 
		for j in range(i): tapis+="#" 
		print("|" + tapis + "|") 
	# for 
	print(bord) 
# tapisserie() 
  
tapisserie(10)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/usr/bin/env python3 
# coding: utf-8 
  
def tapisserie(n): 
	# Le bord 
	bord="+" 
	for i in range(n+1): bord +="-" 
	bord+="+" 
  
  	# La ligne du tapis 
	ligne=" " 
	for i in range(i): ligne+="#" 
  
	# La boucle d'affichage 
	print(bord) 
	for i in range(n+1): 
		# Décalage puis affichage de la ligne 
		ligne=ligne[1:] + ligne[0] 
		print("|" + ligne + "|") 
	# for 
	print(bord) 
# tapisserie() 
  
tapisserie(10)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/env python3 
# coding: utf-8 
  
def tapisserie(n): 
	# Le bord 
	print("+" + "-" * (n+1) + "+") 
  
	# La boucle d'affichage 
	for i in range(n+1): 
		print("|" + "#" * (n-i) + " " + "#" * i + "|") 
  
	# Le bord 
	print("+" + "-" * (n+1) + "+") 
# tapisserie() 
  
tapisserie(10)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/usr/bin/env python3 
# coding: utf-8 
  
# La fonction qui calcule la monnaie  
def monnaie(somme):  
	# Pour éviter le souci de l'imprécision des flottants, on commence par convertir la somme en entier (et éventuellement l'arrondir) 
	somme=round(somme * 100) 
	# Il faudra en tenir compte dans le calcul 
  
	# La plage des valeurs disponibles  
	valeurs=(100, 50, 20, 10, 5, 2, 1, 0.50, 0.20, 0.10, 0.05, 0.02, 0.01)  
  
	# Le résultat  
	res=dict()  
  
	# On boucle sur chaque valeur  
	for v in valeurs: 
		# On récupère le décalage de la somme  
		vv=round(v * 100) 
  
		# On calcule le nombre maximum pouvant donner cette valeur  
		q=somme//vv 
  
		# Si ce nombre a un sens  
		if q != 0:  
			# On le stocke dans le dictionnaire  
			res[v]=q 
  
			# La somme, elle, récupère ce qui reste  
			somme%=vv 
		# if  
	# for  
  
	# Le calcul est terminé, on retourne le résultat  
	return res  
# monnaie()  
  
# Test  
somme=81.43  
for (k, v) in monnaie(somme).items():  
	print("{:>.{}f}€: {}".format(k, 2 if isinstance(k, float) else 0, v))

1
2
3
4
>>> 0.6 / 3 
0.19999999999999998 
>>> 0.2 * 3 
0.6000000000000001

1
2
3
4
for v in valeurs: 
	(q, somme)=divmod(somme, round(v * 100)) 
	if q != 0: res[v]=q 
# for

1
2
3
4
5
6
7
50€: 1 
20€: 1 
10€: 1 
1€: 1 
0.20€: 2 
0.02€: 1 
0.01€: 1

1
2
3
4
5
6
7
8
def rang_etoiles(n): 
    seuils = (300, 650, 1300, 2250, 4000, 10000) 
    rg = '' 
    i = 0 
    while i < len(seuils) and n >= seuils[i]: 
        rg += '*' 
        i += 1 
    return rg

1
2
3
4
5
def rang_etoiles(n): 
	seuils = (300, 650, 1300, 2250, 4000, 10000) 
	for (i, s) in enumerate(seuils): 
		if n < s: break 
	return "*" * i

1
2
3
4
5
6
7
8
9
def max_sous_tableau(tab): 
	somme_maxi = tab[0] 
	for j in range(len(tab)): 
		for i in range(0, j+1): 
			somme_maxi = max(somme_maxi, sum(tab[i : j+1])) 
	return somme_maxi 
  
  
print(max_sous_tableau([2, -2, -3, 2, 3, -4, 2, 3, -1]))

1
2
def max_sous_tableau_en_une_ligne(tab): 
    return max(sum(tab[i : j + 1]) for j in range(len(tab)) for i in range(j + 1))

1
2
3
4
5
6
7
8
9
10
11
def max_sous_tableau_v2(tab): 
    candidates = [[tab[0]]] 
    for element in tab[1::]: 
        candidate = candidates[-1] + [element] if sum(candidates[-1]) > 0 else [element] 
        candidates.append(candidate) 
    #print(candidates) 
    meilleure_candidate = max(candidates, key=sum) 
    return sum(meilleure_candidate) 
  
tab = [2, -2, -3, 2, 3, -6, 2, 3, -1] 
print(max_sous_tableau_v2(tab))

[[2], [2, -2], [-3], [2], [2, 3], [2, 3, -6], [2], [2, 3], [2, 3, -1]]

1
2
3
4
  
[[2], [2, -2], [-3], [2], [2, 3], [2, 3, -6], XXXX, ........] 
                                  +--------+ 
                                      i=5

1
2
3
4
  
[[2], [2, -2], [-3], [2], [2, 3], [2, 3, -6], [2], XXXXXX, .......] 
                                  +--------+  +-+ 
                                      i=5     i=6

1
2
3
4
  
[[2], [2, -2], [-3], [2], [2, 3], [2, 3, -6], [2], [2, 3], .......] 
                                  +--------+  +-+  +----+ 
                                      i=5     i=6   i=7

1
2
3
4
  
[[2], [2, -2], [-3], [2], [2, 3], [2, 3, -6], [2], [2, 3], [2, 3, -1]] 
                          +----+                   +----+ 
                          somme=5                  somme=5

[[2], [2, -2], [-3], [2], [2, 3], [2, 3, -6], [2], [2, 3], [2, 3, -1]]

[2, 0, -3, 2, 5, -1, 2, 5, 4 ]

1
2
3
4
5
6
def max_sous_tableau_v3(tab): 
	total = somme = tab[0] 
	for element in tab[1:]: 
		somme = max(element, somme + element) # ou somme = max(somme, 0) + element 
		total = max(total, somme) 
	return total