NSI Première

Exercices Python fiche 1     Correction


Sans Machine

Exercice 1
On donne le script suivant ci-dessous.
Quelle est la valeur finale de x ?

In [60]:
x = 1
n = 5
while n > 1:
    x = x * n
    n = n - 1
In [61]:
print(x)
120

Exercice 2
On donne le script suivant ci-dessous.
Quelle est la valeur finale de x ?

In [62]:
x = 0
for i in range(2):
    x = x + i
    for j in range(3):
        x = x + j
In [63]:
print(x)
7

Ecrire des fonctions

Exercice 3
Ecrire une fonction plus_grand qui possède deux paramètres, des nombres réels.
Les préconditions : les paramètres a et b sont des nombres réels.
La postcondition : Votre fonction devra renvoyer le plus grand des deux nombres.

In [64]:
def plus_grand(a, b):
    """
    Détermine le plus grand de deux nombres
    @param a: (float) nombre réel 
    @param b: (float) nombre réel
    @return: (float) la fonction renvoie le plus grand des deux nombres a et b

    """
    if a > b:
        return a
    else:
        return b 
In [65]:
plus_grand(-12, 21)
Out[65]:
21

Exercice 4
Ecrire une fonction plus_grand_bis qui possède trois paramètres, des nombres réels.
Les préconditions : les paramètres a, b et c sont des nombres réels.
La postcondition : Votre fonction devra renvoyer le plus grand des trois nombres.

In [66]:
# Version 1
def plus_grand_bis_1(a, b, c):
    """
    Détermine le plus grand de trois nombres
    @param a: (float) nombre réel 
    @param b: (float) nombre réel
    @param c: (float) nombre réel
    @return: (float) la fonction renvoie le plus grand des trois nombres a, b et c

    """
    if a > b:
        if a > c:
            return a
        else:
            return c
    else:
        if b > c:
            return b
        else:
            return c
        

# Version 2
def plus_grand_bis_2(a, b, c):
    """
    Détermine le plus grand de trois nombres
    @param a: (float) nombre réel 
    @param b: (float) nombre réel
    @param c: (float) nombre réel
    @return: (float) la fonction renvoie le plus grand des trois nombres a, b et c

    """
    if a > b and a > c:
        return a
    elif b >= a and b > c:
        return b
    else:
        return c
In [67]:
plus_grand_bis_1(-12, 21, 3)
Out[67]:
21
In [68]:
plus_grand_bis_2(-12, 21, 3)
Out[68]:
21

Exercice 5
Ecrire une fonction carre qui prend en paramètre un entier strictement positif k et qui renvoie la somme des k premiers carrés non nuls.

In [69]:
def carre(k):
    """
    Calcul la somme des k premiers carrés non nul
    @param k: (int) nombre entier strictement positif
    @return: (int) la somme des carrés
    """
    assert k > 0 and isinstance(n, int),"Vous devez entrer un entier strictement positif"
    somme = 0
    for i in range(1, k+1): # On commence à 1, premiers carrés non nul
        somme = somme + i**2
    return somme
In [70]:
carre(4)
Out[70]:
30

Exercice 5
1) Ecrire une fonction somme_diviseurs qui prend en paramètre un entier naturel non nul et qui renvoie la somme de ses diviseurs.

In [71]:
def somme_diviseurs(n):
    """
    Calcul la somme des diviseurs d'un entier naturel
    @param n: (int) nombre entier strictement positif
    @return: (int) la somme des diviseurs de cet entier
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier strictement positif"
    somme = 0
    for i in range(1, n+1): # On commence à 1, premiers carrés non nul
        if n % i == 0:
            somme = somme + i
    return somme
In [72]:
somme_diviseurs(6)
Out[72]:
12

2) Un entier naturel n est parfait si la la somme de ses diviseurs est égale à 2n.
Ecrire une fonction parfait qui prend en argument un entier naturel non nul et qui renvoie True s'il est parfait False sinon.

In [73]:
def parfait(n):
    """
    Détermine si un entier naturel est parfait
    @param n: (int) nombre entier strictement positif
    @return: (bool) retourne True si le nombre est parfait, sinon False
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier naturel non nul"
    if somme_diviseurs(n) == 2 * n:
        return True
    else:
        return False

# Une autre version

def parfait_bis(n):
    """
    Détermine si un entier naturel est parfait
    @param n: (int) nombre entier strictement positif
    @return: (bool) retourne True si le nombre est parfait, sinon False
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier naturel non nul"
    return somme_diviseurs(n) == 2 * n
In [74]:
parfait(12)
Out[74]:
False
In [75]:
parfait_bis(6)
Out[75]:
True

3) Déterminer les nombres parfaits inférieurs à 100 puis les trois premiers nombres parfaits.

In [76]:
# Nombres parfaits inférieurs à 100
for i in range(1, 100):
    if parfait(i):
        print(i)
6
28
In [77]:
# Nombres parfaits compris entre 100 et 1000
for i in range(100, 1000):
    if parfait(i):
        print(i)
496

Exercice 7
Ecrire une fonction jeu qui prend en paramètre un entier strictement positif n, simule n fois le tirage d'un nombre choisi au hasard parmis les nombres 1, 2, 3, 4, 5, 6 et renvoie le pourcentage de 6 obtenus.
Utiliser cette fonction pour n = 1000
Utiliser la fonction randint du module random : from random import randint </p>

In [78]:
from random import randint

def jeu(n):
    """
    Calcul le pourcentage de 6 obtenue sur n tirages aléatoires
    @param n: (int) nombre entier strictement positif
    @return: (float) le pourcentage de 6 obtenu
    """
    assert n > 0 and isinstance(n, int),"Vous devez entrer un entier strictement positif"
    pourcentage_6 = 0
    for i in range(n):
        if randint(1, 6) == 6:
            pourcentage_6 = pourcentage_6 + 1
    return 100 * pourcentage_6 / n
In [59]:
jeu(1000)
Out[59]:
15.8
In [ ]: