Prise en main de Python

Vous allez ici vous familiariser avec la syntaxe Python et ses types de données (tuples, listes, dictionnaires) en faisant quelques exercices dont certains sont issus de la banque nationale de sujets de Baccalauréat pour la spécialité NSI (Numérique et Sciences de l’informatique).

Vous utiliserez un Jupyter Notebook en tant que compte rendu pour l’ensemble de l’activité. Celui-ci est à rendre sur le “Moodle du lycée”.

Vous veillerez à reporter l’intitulé des questions dans des cellules “Markdown” avant de fournir votre code dans une ou plusieurs cellules Python.

Les réponses seront SYSTÉMATIQUEMENT justifiées.

Figure 1. Exemple de compte-rendu attendu

Source de ce notebook : prise-en-main-python.ipynb

🖮 Travail n° 1 : Bases du langage

Parmi les quatre expressions suivantes, laquelle s’évalue en True ?
Propositions :
1. False and (True and False)
2. False or (True and False)
3. True and (True and False)
4. True or (True and False)
Solution

Proposition D : True or (True and False)
Si a vaut False et b vaut True, que vaut l’expression booléenne not(a and b) ?
Propositions :
1. 0
2. False
3. True
4. None
Details

not(a and b) renvoie True
On exécute le code suivant
```
a = 2
b = 3
c = a ** b
d = c % b
```
Quelle est la valeur de d à la fin de l’exécution ?
Propositions :
1. 4
2. 3
3. 2
4. 1
Solution

Réponse C : d vaut 2
La variable x contient la valeur 3, la variable y contient la variable 4. Quelle expression s’évalue en True parmi les quatre propositions suivantes ?
Propositions :
1. x == 3 or y == 5
2. x == 3 and y == 5
3. x != 3 or y == 5
4. y < 4
Solution

Réponse A : x == 3 or y == 5
À quelle affectation sont équivalentes les instructions suivantes, où a, b sont des variables entières et c une variable booléenne ?
```
if a==b:
  c = True
elif a > b+10:
  c = True
else:
  c = False
```
Propositions :
1. c = not(a > b+10)
2. c = (a==b) and (a > b+10)
3. c = not(a==b)
4. c = (a==b) or (a > b+10)
Solution

Réponse D : c = (a==b) or (a > b+10)
Sachant que l’expression not(a or b) a la valeur True, quelles peuvent être les valeurs des variables booléennes a et b ?
Propositions :
1. True et True
2. False et True
3. True et False
4. False et False
Solution

Réponse D : False et False
Soient a et b deux booléens. L’expression booléenne not(a and b) or a est équivalente à :
Propositions :
1. False
2. True
3. not(b)
4. not(a) or not(b)
Solution

Réponse B : True
On considère l’extrait de code suivant :
```
while (a < 20) or (b > 50):
  print('on boucle')
print('on est sorti de la boucle')
```
Donner les intervalles de valeurs pour les variables a et b qui permettent de mettre fin à cette boucle ?

Solution

a∈[20,∞[ et b∈]∞,50]
Quelle est la valeur de x à la fin de l’exécution du script Python suivant ?
```
x = 1
for i in range(10):
  x = x * 2
```
Solution

x vaut 1024
La fonction ajoute(n,p) dont le code est partiellement donné ci-dessous doit calculer la somme de tous les entiers compris entre n et p (n et p compris).

Par exemple, ajoute(2,4) doit renvoyer 2+3+4 = 9.

Compléter le code Python et tester la fonction.
```
def ajoute(n,p):
  somme = 0
  # code à compléter
  return somme
```
Solution
def ajoute(n,p): somme = 0 idx = n while idx <= p : somme = somme + idx idx += 1 return somme
La documentation de la bibliothèque random de Python précise que random.randint(a,b) renvoie un entier aléatoire tel que a ≤ N ≤ b.

Compléter la 2^ème ligne du code suivant avec une expression utilisant random.randint() pour retourner un entier choisi aléatoirement dans l’ensemble {-4 ; -2 ; 0 ; 2 ; 4}
```
import random
r = #compléter
print("r vaut {}".format(r))
```
Solution

import random r = -4 + (random.randint(0,4) * 2) print("r vaut {}".format(r))

🖮 Travail n° 2 : Tuples

Donner le code d’une fonction qui permet de calculer la moyenne d’une série de nombre passée à la fonction sous forme de tuple.

def moyenne(unTuple):
   # A compléter
   pass (1)
m = moyenne((8, 12, 9, 15, 18))
print("Moyenne : {}".format(m))

1	`pass` est une instruction Python qui ne fait rien. Ici, on l’utilise simplement pour que le code donné soit valide (on ne peut pas avoir le corps d’une fonction vide)

Solution

def moyenne(unTuple):
    somme = 0
    for elt in unTuple:
        somme = somme + elt
        print(somme)
    print(len(unTuple))
    return (somme / len(unTuple))
m = moyenne((8, 12, 9, 15, 18))
print("Moyenne : {}".format(m))

Donner le code d’une fonction Python nommée trouverMinimum() qui retourne la plus petite valeur du tuple (0, 1, 2, 2, -5*-5, 9, -2*3, 16, -(5*9), 6*4) passé en argument

def trouverMinimum(unTuple):
   #A compléter
   pass
monTuple = (0, 1, 2, 2, -5*-5, 9, -2*3, 16, -(5*9), 6*4)
min =  trouverMinimum(monTuple)
print("Minimum du tuple {} : {}".format(monTuple, min))

Solution

def trouverMinimum(unTuple):
    min = None
    for elt in unTuple:
        if ((min == None) or (elt < min)):
            min = elt
    return min
monTuple = (0, 1, 2, 2, -5*-5, 9, -2*3, 16, -(5*9), 6*4)
min =  trouverMinimum(monTuple)
print("Minimum du tuple {} : {}".format(monTuple, min))

🖮 Travail n° 3 : Listes

Donner le code d’une fonction extraireNbPairs() qui retourne une liste des nombres pairs et positifs trouvés dans la liste passée en argument

def extraireNbPairsPositifs(uneListe) :
    #A compléter
   pass
maListe = [0, -2, 5, -9, 2**3, 4*5, 9//2]
lesNbsPairsPositifs = extraireNbPairsPositifs(maListe)
print("La liste {} contient les nombres pairs positifs suivant : {}".format(maListe, lesNbsPairsPositifs))

Solution

def extraireNbPairsPositifs(uneListe) :
    #A compléter
    pairs = []
    for elt in uneListe :
        if ((elt%2 == 0) and (elt>0)):
            pairs.append(elt)
    return pairs
maListe = [0, -2, 5, -9, 2**3, 4*5, 9//2]
lesNbsPairsPositifs = extraireNbPairsPositifs(maListe)
print("La liste {} contient les nombres pairs positifs suivant : {}".format(maListe, lesNbsPairsPositifs))

Donner le code d’une fonction Python qui décompose en binaire le nombre entier qui lui est passé en argument grâce à la méthode des divisions successives.

def decomposerEnBinaire(unEntier) :
   #A compléter
   pass
monEntier = 57;
print("La décomposition en binaire de {} donne : {} ".format(monEntier, decomposerEnBinaire(monEntier)))
# doit afficher :
# La décomposition en binaire de 57 donne [1, 1, 1, 0, 0, 1]

Solution

def decomposerEnBinaire(unEntier) :
    bin = []
    while unEntier != 0:
        bin.append(unEntier % 2)
        unEntier = unEntier // 2
    bin.reverse()
    return bin
monEntier = 57;
print("La décomposition en binaire de {} donne {} : ".format(monEntier, decomposerEnBinaire(monEntier)))
# doit afficher :
# La décomposition en binaire de 57 donne [1, 1, 1, 0, 0, 1]

En utilisant une liste de compréhension (voir par exemple Les compréhensions de liste python link ), donner le code Python d’une fonction calculerNbValeursBinaires() qui permet de créer une liste indiquant le nombre de valeurs codables avec des nombres binaires dont le nombre de bits est également indiqué dans une liste

def calculerNbValeursBinaires(uneListe):
    #A compléter
    pass
nbBits = [0, 1, 2, 3, 8, 10, 16]
nbValeursBinaires = calculerNbValeursBinaires(nbBits)
for i in range(len(nbBits)):
    print("Avec {} bit(s) on peut coder {} valeurs binaires".format(nbBits[i], nbValeursBinaires[i]))

Affichage attendu

Avec 1 bit(s) on peut coder 2 valeurs binaires
Avec 2 bit(s) on peut coder 4 valeurs binaires
Avec 3 bit(s) on peut coder 8 valeurs binaires
Avec 8 bit(s) on peut coder 256 valeurs binaires
Avec 10 bit(s) on peut coder 1024 valeurs binaires
Avec 16 bit(s) on peut coder 65536 valeurs binaires

Solution

def calculerNbValeursBinaires(uneListe):
    l = [2**x for x in uneListe]
    return l
nbBits = [1, 2, 3, 8, 10, 16]
nbValeursBinaires = calculerNbValeursBinaires(nbBits)
for i in range(0,len(nbBits)):
    print("Avec {} bit(s) on peut coder {} valeurs binaires".format(nbBits[i], nbValeursBinaires[i]))

🖮 Travail n° 4 : Dictionnaires

Soit le dictionnaire fruitsNoyaux = {"Pomme":False, "Abricot":True, "Cerise":True, "Raisin":False, "Banane":False, "Mangue":True, "Pêche":True} qui indique pour chaque fruit s’il est à noyau ou pas.

Donner le code qui permet d’afficher uniquement les fruits à noyau.
Solution
fruitsNoyaux = {"Pomme":False, "Abricot":True, "Cerise":True, "Raisin":False, "Banane":False, "Mangue":True, "Pêche":True} for k,v in fruitsNoyaux.items(): if v is True: print(k, end=" ")
On considère le code Python suivant qui remplit puis affiche les 2 premiers éléments d’une liste de dictionnaires data initialisée avec le contenu du fichier arctic-api.json qui est au format JSON (source : https://global-warming.org/api/arctic-api )
```
import json
with open('arctic-api.json') as f:
  jsonDoc = json.load(f)
data = jsonDoc['result']
print(data[0:2])
```
```
[{"year":"1979","extent":7.05,"area":4.58},{"year":"1980","extent":7.67,"area":4.87}]
```
La valeur de la clé extent indique pour chaque année au mois de septembre l’extension de la banquise arctique en millions de km².
1. Ouvrir le fichier arctic-api.json dans un éditeur de texte ou le navigateur web et l’analyser pour savoir comment le code donné en exemple affiche les 2 premiers dictionnaires.
2. Donner l’instruction qui permet d’afficher l’extension de la banquise en 1980
  
  Solution
  
  print(data[1]['extent'])
3. Donner le code Python qui affiche, parmi les données présentes dans le fichier et qui ont été récoltées de 1979 à 2019, les 10 années où l’extension de la banquise a été minimale.
  
  S’aider de How do I sort a list of dictionaries by a value of the dictionary?
  
  Solution
  
  import json with open('arctic-api.json') as f: jsonDoc = json.load(f) #print(jsonDoc) data = jsonDoc['result'] #print(data) sortedYears = sorted(data, key=lambda k: k['extent']) for y in sortedYears[:9]: print("{} -> {}".format(y['year'], y['extent']))

🞄 🞄 🞄