1ère partie : affichage - répétitions d'instruction - Les variables - lecture d'une entrée
Répondez aux questions ci-dessous en écrivant le code correspondant dans les cellules
1- Ecrivez le code permettant d'afficher :" Bonjour je suis en terminale spécialité NSI"
# votre code ci-dessous
2- Ecrivez le code qui permettra d'écrire 20 fois : "Bonjour"
# votre code ci-dessous
3- Ecrire un programme qui permet d'afficher trois fois : "Bonjour !" et une fois "Comment vas-tu ?"
# votre code ci-dessous
XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX
XXXXXXXXXX# votre code ci-dessous
Sachant qu'un sportif répète ces trois étapes pendant 3 jours de suite, vous devez afficher la distance totale qu'il a parcourue à la fin du 1er jour, à la fin du 2e jour, puis à la fin de l'algoréathlon complet.
Afin de rendre l'affichage convivial, vous souhaitez mettre les trois valeurs sur une même ligne, avec une espace entre chaque valeur et la suivante.
Important : pour écrire ce programme, vous devez mémoriser la distance parcourue en un jour en lui donnant un nom, puis utiliser ce nom pour calculer les trois réponses.
# votre code ci-dessous
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
5 10 15 20 25Écrivez un programme qui affiche une table de multiplication allant jusqu'à 20 fois 20.
Pour vous aider à résoudre cet exercice, répondez aux questions suivantes :
Dois-je utiliser une ou des variables, et si oui quelles sont leurs rôles ?
Dois-je modifier les valeurs de ces variables ? Et si oui comment ?
Dois-je faire une ou des boucles et si oui, de combien de tours ?
Comment vais-je afficher le résultat ?# votre code ci-dessous
7- Votre programme doit demander un entier à l'utilisateur qui représente le nombre de lignes souhaité, et écrira autant de fois que demandé la phrase « Je dois suivre en cours ».
Exemple
entrée :
3
sortie :
Je dois suivre en cours
Je dois suivre en cours
Je dois suivre en cours# votre code ci-dessous
# Exécutez la cellule
a = (1<3)
print(a)
# expression 1
(5<3) and (3!=2)
# expression 2
(15//2==1) and (15%2==0)
Qu'en concluez-vous quand au rôle de l'opérateur AND ?
# expression 3
x=1
(x<2) or (x==3)
Qu'en concluez-vous quand au rôle de l'opérateur OR ?
# expression 4
not(2==4)
Qu'en concluez-vous quand au rôle de l'opérateur NOT ?
Si la somme est supérieure ou égale à 10, alors vous devez payer une taxe spéciale (36 pièces).
Sinon, vous payez deux fois la somme des valeurs des deux dés.
Votre programme devra afficher selon le cas le texte « Taxe spéciale ! » ou bien « Taxe régulière », puis la somme à payer (sans indiquer l'unité).
Réfléchissez aux variables dont vous aurez besoin
Quel(s) test(s) allez-vous effectuer ?
Que devez-vous afficher en cas de réussite à ces tests ? et en cas d'échec ?# votre code ci-dessous
2ème partie : les boucles
Précisions sur la boucle for
# tester le code ci-dessous
nombre = 0
for loop in range(10):
print(nombre)
nombre = nombre + 1
On peut réaliser la même chose d'une manière bien plus simple.
# tester le code ci-dessous
for loop in range(10):
print(loop)
En effet, loop est en fait une variable ! On peut donc l'utiliser comme n'importe quelle variable, en particulier pour l'afficher. On peut également utiliser un autre nom de variable
# tester les codes suivants
for nombre in range(10):
print(nombre)
print()
for i in range(7):
print(i)
En pratique range(10) se comporte comme la suite de valeurs 0, 1, ..., 9 et ce code revient à dire :
Pour chaque valeur dans [0, 1, ..., 9] affecter cette valeur à la variable "nombre" et Afficher le contenu de la variable "nombre"
On peut visualiser la suite de valeur contenue dans le range
Tester les codes ci-dessous
list(range(5))
list(range(3,7))
list(range(1,10,2))
list(range(5,0,-1))
La fonction range() peut être utilisée avec 3 paramètres debut, fin et pas : range(debut,fin,pas).
L'entier debut est compris, l'entier fin est exclu.
La fonction range() peut être utilisée avec 2 paramètres debut et fin : range(debut,fin). Dans ce cas, le pas est égal à 1 par défaut.
La fonction range() peut être utilisée avec 1 seul paramètre fin : range(fin). Dans ce cas, debut est ègal à 0 par défaut, et pas à 1 par défaut.
Application :
A l'aide de la combinaison list(range()), obtenir dans chacune des cellules ci-dessous, les listes suivantes :
- $[2,4,6,8,10,12]$
- $[10,8,6,4,2]$
- $[3,6,9,12]$
- $[0,1,2,3,4,5]$
On veut l'affichage suivant :
1 janvier
2 janvier
3 janvier
...
31 janvier
# votre code ci-dessous
Utilisation de la variable de boucle : Notion d'accumulateur
for i in range(10):
print(i)
print(i)
Comme le montre l'exemple ci-dessus, la variable i est considéré comme une variable de boucle, c'est une variable ordinaire qui a initialement la valeur 0 et qui est incrémentée de 1 à chaque tour de la boucle. On peut choisir n'importe quel noms pour cette variable. Des noms tels que i, j, k, m, n, index ou compteur sont fréquemment utilisés.
La variable de boucle est aussi appelée "compteur de boucle". Elle permet de savoir combien de tours de boucle ont déjà été effectués.
Le compteur de boucle permet de mettre en place un accumulateur, c'est-à-dire une variable qui est utilisée pour stocker les différents résultats successifs d'un calcul qui avance progressivement à chaque tour de boucle. On économise ainsi de la mémoire : on ne garde en mémoire par exemple que la somme des valeurs déjà rencontrées ou le dernier état, et non tous les états intermédiaires.
La variable qui sert d'accumulateur doit être initialisée avant la boucle.
Exemple : calcul de la somme des entiers de 1 à 100
somme = 0 # La variable somme joue le rôle de l'accumulateur
for i in range(101):
somme = somme + i # à chaque tour de boucle, on met à jour la valeur de l'accumulateur en lui ajoutant i
print(somme) # On affiche la valeur finale de l'accumulateur
Remarque : il existe une formule qui permet de calculer cette somme sans effectuer toutes les additions, qui sera vue en cours de Spécialité Maths : $1+2+3+...+n = \frac{n(n+1)}{2}$.
# votre code ci-dessous
forRemarque : il est interdit d'utiliser ** ici !
# votre code ci-dessous
La boucle while : une répétition conditionnée
# Tester le code ci-dessous
i = 0
while i < 5:
print(i)
i= i + 1
print("Fini !")
Le mot de passe correct est : 123456.
# votre code ci-dessous
Mais personne ne sait exactement combien de dépenses différentes ont été effectuées durant l'année écoulée !
Votre programme devra demander des entiers (positifs) et afficher leur somme. On ne sait pas combien il y aura d'entiers, mais le calcul se termine toujours par la valeur -1 (qui n'est pas une dépense, juste un marqueur de fin).
Exemple
entrée :
1000
2000
500
-1
sortie :
3500# votre code ci-dessous
3ème partie : les variables de type construit
Les listes
# exécutez le code ci-dessous
classe = ["première NSI",20,"2022"]
print(classe[0])
print(classe[1])
print(classe[2])
Exemple
entrée :
3
sortie :
25# votre code ci-dessous
Parcourir une liste
Vous savez que les indices du tableau correspondent donc à un intervalle de valeur depuis l'indice 0.
De plus le message d'erreur d'accès en dehors du tableau utilise le mot range
A ce titre il forme donc un itérable et peut donc être parcouru par une boucle for
# tester le code ci-dessous
L = [24, 12, 36, 48, 7, "Hello", 5]
for i in range(7):
print(L[i], end=" ")
Dans l'exemple ci-dessus, la variable de boucle i a pris les valeurs indiquées dans le range soit, 0, 1, 2, 3 et 4
L[i] permet alors d'accéder aux différentes données contenues dans la liste L.
Ce parcours de liste est un grand classique et doit absolument être compris.
Votre programme devra demander 10 entiers, le poids (en kilogrammes) qu'il faut acheter pour chaque ingrédient.
Il devra calculer le coût total de ces achats.
Exemple
entrée :
1
1
1
1
1
1
1
1
1
1
sortie :
134
ici 134 correspond à : 1x9 + 1x5 + 1x12 + 1x15 ... + 1x20# votre code ci-dessous
Modifier les élements d'une liste
Comme pour toute autre variable il est bien sûr possible de modifier les éléments d'une liste.
Par exemple si on souhaite déclarer un tableau de taille 7 puis modifier les valeurs aux indices 0 et 6, on utilise le code ci-dessous.
# tester le code ci-dessous
prix = [0] * 7
print(prix)
print()
prix[0] = 124
prix[6] = 421
print(prix)
Trier une liste
# Tester le code ci-dessous
poids = [45, 80, 2]
# Tri le tableau
poids.sort()
# Affiche le tableau
for indice in range(3):
print(poids[indice])
la méthode sort() appelée sur la liste à trier permet donc de trier la liste dans l'ordre croissant.
Cette méthode peut être utile dans certains cas, par exemple lorsque l'on cherche la plus grande valeur d'un tableau, si on le trie, celle-ci est alors à la fin du tableau.
18-
On démarre de la liste hauteur ci-dessous.
Que doit-on écrire pour obtenir la taille de la liste ?
Ecrivez alors une boucle for qui parcourt la liste hauteur et affiche ses éléments en utilisant la réponse à la question précédente.
Ecrivez une boucle for qui parcourt la liste sans utiliser range
# Compléter le code ci-dessous pour répondre aux questions précédentes.
hauteur = [10, 48, -5, 99, -20, 4, 32, 16, 0, 100, 42]
tailleDeListe = ...
for ... in range(....):
....
for ....
....
19- Ecrivez le code qui permet d'obtenir la liste [1,2,3,4,5,6] à partir des deux listes ci-dessous
# votre code ci-dessous
L1=[1,2,3]
L2=[4,5,6]
20- Ecrivez le code qui permet d'ajouter le chiffre 42 à la fin de la liste L1
Ecrivez le code qui permet de supprimer le chiffre que vous venez d'ajouter
# votre code ci-dessous
L1=[1,2,3]
D'autres méthodes et fonctions permettant d'agir sur les listes
Tester les codes ci-dessous et déduisez-en le rôle des méthodes ou fonctions présentées
liste = [22, 5, 3, 10]
del liste[1]
print(liste)
print(sum(liste))
liste.remove(3)
print (liste)
liste = [1,2,3,4]
liste.insert(1,22)
print(liste)
liste.extend([5,6])
print(liste)
Création d'une liste par compréhension
On peut créer une liste de différentes manières. Soit en écrivant directement ces valeurs comme dans les exemples précédents : L = [1, 2, 3] , soit par duplication par exemple : L = [0]*10
Cependant, il existe une méthode qui permet de créer des listes rapidement, notamment lorsque'elle contiennent de nombreuses valeurs : l'allocation par compréhension.
On utilise la syntaxe suivante :
ma_liste=[ val for i in range (0,f) ]
ma_liste est le nom de la variable
val est une valeur qui sera ajoutée dans la liste (f-0) fois# Tester le code ci-dessous
ma_liste=[ 0 for i in range (0,10) ]
print(ma_liste)
Cette création de liste par compréhension permet de rajouter une condition
# Tester le code ci-dessous
liste=[1,7,9,15,5,20,10,8]
ma_liste=[ i for i in liste if i>10]
print(ma_liste)
print()
ma_liste=[ i**2 for i in liste if i<10]
print(ma_liste)
21- Étant donné une liste d’entiers telle que t=[5, 2, 0, 3, 7, 10], construisez la liste L dont les éléments sont 10 fois les éléments de t, c’est-à-dire [50, 20, 0, 30, 70, 100].
# votre code ci-dessous
# votre code ci-dessous
23- A partir de la liste suivante L = [-4 , -2 , 0, 2, 4] créer une nouvelle liste contenant les valeurs de la liste L doublées, puis à partir de cette nouvelle liste créer une liste contenant uniquement les valeurs positives
# votre code ci-dessous
Liste (ou tableau) à 2 dimensions
Pour représenter le tableau suivant en python :
| 120 | 145 | 87 |
| 12 | 67 | 89 |
| 90 | 113 | 85 |
# le tableau de l'exemple est donc codé ainsi
tableau=[[120,145, 87],[12, 67, 89],[90, 113, 85]]
# tester la code ci-dessous
print(tableau[0])
print(tableau[0][1])
Vous remarquez donc que pour cibler un élément particulier de la matrice, on utilise la notation avec "doubles crochets" : tableau[indiceLigne][indiceColonne].
Ainsi, print(tableau[0][1]) correspondra à la valeur de la 1ère ligne, 2ème colonne du tableau soit 145.
Application :
Afficher le 3ème elément de la 2ème ligne
# votre code ci-dessous
Parcourir une liste de liste
Comme pour le parcours d'une liste simple, une boucle for qui parcourt les indices est tout à fait conseillé.
Cependant, vous avez vu qu'il faut en fait deux indices, celui des lignes et celui des colonnes.
Il faut donc deux boucles for imbriquées pour parcourir ce type de liste.
tableau=[[120,145,87], [12,67,89], [90,113,85],[123,45,89]]
Nb_colonne=3
Nb_ligne=4
for ..... :
for ......:
print(tableau[..][..])
Création d'une liste de liste
On peut également créer ce type de tableau en utilisant une allocation (liste ou tableau bidimensionnelle par compréhension) .
Ainsi, l'instruction suivante permet de créer une liste bidimensionnelle de taille 3 x 3 ne contenant que des 0 :
tableau=[[0 for j in range(0,3)] for i in range(0,3)]
print(tableau)
24- Créer le tableau suivant :
[[0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34]]en utilisant le principe des listes par compréhension
# votre code ci-dessous
Les chaînes de caractères
Indice du terme d'une chaîne de caractères. Longueur d'une chaîne de caractères
Le premier caractère d'une chaîne de caractères **char** est obtenu en tapant **char[0]**, le caractère suivant **char[1]**, etc.Si char="car" alors le premier caractère 'c' de la chaîne a pour indice 0, le second 'a' a pour index 1, et le dernier 'r' a pour rang 2. Les mots indice, index ou rang sont synonymes.
La fonction Python len() renvoie la longueur ou la taille de la chaîne de caractères char, c'est-à-dire le nombre n de caractères qui composent la chaîne char. Attention, si la chaîne char contient n valeurs alors le dernier caractère de la chaîne est char[n-1] que l'on peut aussi obtenir par char[len(L)-1].
# Tester le code ci-dessous
chaine="Antoine"
print(chaine[0])
print(chaine[1])
print(chaine[2])
print(len(chaine))
print(chaine[len(chaine)-1])
print(chaine[len(chaine)])
print(chaine[len(chaine)]) renvoie un message d'erreur car l'index 8 n'existe pas, d'où le message "index out of range".
Application :
On considère la chaîne de caractères phrase="L'homme est un loup pour l'homme".
Compléter la ligne 2 en utilisant len(L) pour afficher le dernier caractère de phrase.
phrase="L'homme est un loup pour l'homme"
print(...)
Affichage d'une partie de la chaîne
En utilisant les indices, on peut afficher une partie seulement de la chaîne.On appelle cette technique : Le slicing
# Tester le code ci-dessous
chaine="Antoine"
print (chaine [1:4])
print (chaine [2:])
print (chaine [-1])
print (chaine [-6:])
Application :
On considère la chaîne de caractères phrase="L'homme est un loup pour l'homme".
Compléter la ligne 2 en utilisant pour afficher les caractères : "est un loup"
phrase="L'homme est un loup pour l'homme"
print(...)
Parcourir une chaine de caractère
Comme pour les listes, une chaine de caractère est un itérable, on peut donc le parcourir pour récupérer chacune des valeurs de l'itérable (les caractères ici)La boucle for est donc appropriée pour la parcours d'une chaine de caractère.
Soit on la parcours en utilisant les indices :
Exemple :
# Tester le code ci-dessous
texte = "Bonjour"
for indice in range(len(texte)):
print(texte[indice])
Soit on parcours directement les éléments de la chaine (les caractères donc) car une chaine est un itérable.
Exemple :
# Tester le code ci-dessous
texte = "Bonjour"
for caractère in texte:
print(caractère)
La concaténation
La concaténation des chaînes de caractères **char1** et **char2** se fait avec l'opérateur +.char1 + char2 correspond à la seule chaîne composée des charactères de char1 suivis des caractères de char2.
Il est à noter que la chaîne char1 + char2 diffère de la chaîne char2 + char1 comme le montre la cellule Code suivante :
# Tester le code ci-dessous
char1="bonjour "
char2="Pierre "
print(char1 + char2)
print(char2 + char1)
# tester le code ci-dessous et expliquer le résultat
# modifier votre code pour rectifier le problème observé
age= 18
res= "J ai "+ age +" ans"
print (res)
Modifier une chaine existante
L'affectation n'est pas possibleContrairement aux listes, il n'est pas possible de modifier une lettre d'une chaîne de caractères à l'aide d'une affectation.
Exécuter le code suivant pour vous en convaincre.
nom = "Antoine"
nom[0]='B'
25- Ecriture d'un texte "en miroir"
Vous décidez d’écrire un programme permettant l'écriture en miroir d'un texte afin de rendre vos copies illisibles par le commun des mortels.
Les lettres seront donc inversées et donc écrites de droite à gauche.
Entrée
Une ligne de texte qu’il faut inverser.
Sortie
vous devez l’afficher de manière inversée.
Exemple
entrée :
Rien ne sert de courir il faut partir à point
sortie :
tniop à ritrap tuaf li riruoc ed tres en neiR# votre code ci-dessous
26- Pour compliquer encore davantage, vous avez décidé de supprimer l’ensemble des voyelles (et les espaces) d’un texte.
Entrée
Une ligne du texte à modifier
Sortie
le texte sans aucune voyelle, ni espace.
Exemple
entrée :
AUTANT EN EMPORTE LE VENT
sortie :
TNTNMPRTLVNT# votre code ci-dessous
Les Tuples
Un tuple est un type de variable ressemblant fortement à la liste. Il s'écrit de la manière suivante :
mon_tuple=(5,8,6,9)
print(mon_tuple[1])
print(len(mon_tuple))
mon_tuple[0]=7
Indice du terme d'un tuple
Le premier élément d'un tuple mon_tuple est obtenu en tapant mon_tuple[0], l'élément suivant avec mon_tuple[1], etc.
Si mon_tuple=(5,8,6,9) alors le premier élément 5 du tuple a pour indice 0, le second 8 a pour index 1, et le dernier 9 a pour rang 3. Les mots indice, index ou rang sont synonymes.
La fonction Python len() renvoie la longueur ou la taille du tuple mon_tuple, c'est-à-dire le nombre n d'éléments qui composent le tuple mon_tuple. Attention, si le tuple mon_tuple contient n valeurs alors le dernier élément du tuple est mon_tuple[n-1] que l'on peut aussi obtenir par mon_tuple[len(mon_tuple)-1].
Comme vous pouvez le constater, un tuple est créé en utilisant des ().
il n'est pas possible de modifier un élément d'un tuple à l'aide d'une affectation.
Parcourir un tuple
Comme pour les listes et les chaines de caractère, un tuple est un itérable, on peut donc le parcourir pour récupérer chacune des valeurs de l'itérable (les éléments du tuple ici)
La boucle for est donc appropriée pour la parcours d'un tuple
Soit on la parcours en utilisant les indices :
Exemple :
# Tester le code ci-dessous
mon_tuple = (5,8,6,9)
for indice in range(len(mon_tuple)):
print(mon_tuple[indice])
Soit on parcours directement les éléments du tuple car un tuple est un itérable.
Exemple :
# Tester le code ci-dessous
mon_tuple = (5,8,6,9)
for element in mon_tuple:
print(element)
Comme pour les listes et les chaînes de caractères, on peut utiliser la concaténation
#C tester le code ci-dessous
mon_tuple = (5,8,6,9)
autre_tuple = (10,11,12,13)
print(mon_tuple + autre_tuple)
On pourrait s'interroger sur l'intérêt d'utiliser un tuple puisqu'une liste permet plus de choses ! La réponse est simple : les opérations sur les tuples sont plus "rapides".
Quand vous savez que votre liste ne sera pas modifiée, il est préférable d'utiliser un tuple à la place d'une liste.
Les dictionnaires
Comme les listes ou les tuples, les dictionnaires permettent de stocker des données.
Chaque élément d’un dictionnaire est composé de 2 parties, on parle de paires « clé/valeur » séparées par ":"
# exemple de dictionnaire
dico = {"Nom": "Levy", "Prenom": "Stéphane", "Date de naissance": "Lointaine"}
print(dico)
Chaque paire du dictionnaire est séparée par une virgule, et le dictionnaire est délimitée par des accolades.
Dans l’exemple précédent :
- "Nom","Prenom" et "Date de naissance" sont des clés.
- "Levy", "Stéphane" et "Lointaine" sont des valeurs.
La clé "Nom" est associée à la valeur "Levy", la clé "Prenom" à la valeur "Stéphane" et la clé "Date de naissance" à la valeur "Lointaine"
Dans les dictionnaires, - les clés peuvent être : des chaînes de caractères, des nombres ou des tuples (mais pas des listes)
- les valeurs peuvent être n'importe quel type de variable.
Indexation d'un dictionnaire
Dans le cas des variables de types liste, chaîne de caractères et tuples, on pouvait accéder au contenu de la vaiable en utilisant l'indice de l'élément (ou le rang ou l'index)
Exemple :
liste = [25, 89, 6]
print(liste[1]) renvoie la valeur 89 qui correspond à l'elément à l'indice 1 dans la liste
Dans le cas des dictionnaires, il n'y a pas d'indice comme dans les cas précédents, c'est la clé qui remplace l'indice
# Tester le code ci-dessous
dico={"Nom": "Levy", "Prenom": "Stéphane", "Date": "longtemps"}
print(dico["Nom"])
print('Bonjour je suis {} {} et je suis né il y a {}'.format(dico["Prenom"],dico["Nom"],dico["Date"]))
Modifier un dictionnaire
Les dictionnaires font partie des variables de type mutable. On peut donc modifier un dictionnaire.
On peut y ajouter un couple clé / valeur, comme dans l'exemple ci-dessous :
# tester le code ci-dessous
dico={"Nom": "Levy", "Prenom": "Stéphane", "Date de naissance": "longtemps"}
dico["lieu de naissance"]="Quelque part"
print(dico["lieu de naissance"])
On peut supprimer une paire clé / valeur en utilisant l'instruction del.
On utilise la clé à supprimer.
# tester le code ci-dessous
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
del mes_livres["Roman"]
print(mes_livres)
On peut modifier une valeur existante.
On utilise alors la clé correspondant à la valeur à modifier.
# tester le code ci-dessous
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
mes_livres["BD"] = mes_livres["BD"] + 1
mes_livres["Roman"] = 189
print(mes_livres)
print(len(mes_livres))
Afin de comprendre le code précédent, nous pouvons faire un parrallèle avec les listes
dans la liste :
liste = [850, 160, 47]
Pour modifier la 2ème valeur par un 189, vous auriez écrit : liste[1] = 189
pour le dico :
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
Vous n'avez pas d'indice à votre disposition mais vous avez une clé (une sorte d'indice qui aurait un nom)
Vous écrivez alors : mes_livres["Roman"] = 189
Parcourir un dictionnaire
Comme pour toutes les variables que l'on a vu, on parcourt les dictionnaire en utilisant une boucle for.
Comme il n'y a pas d'indice, on ne peut donc pas utiliser la méthode classique de parcours des indices
On va donc parcourir directement les eléments du dictionnaire car c'est un itérable.
# tester le code ci-dessous
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
for element in mes_livres:
print(element)
L'exemple précédent montre qu'un parcours sur les eléments permet d'obtenir les clés du dictionnaire concerné.
Il existe d'autres méthodes de parcours qui permettent de récupérer uniquement les valeurs mais aussi les couples clé / valeur
Un autre parcours de clé
# tester le code ci-dessous
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
for livres in mes_livres.keys():
print(livres)
Un parcours des valeurs
# tester le code ci-dessous
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
for qte in mes_livres.values():
print(qte)
Un parcours à la fois des clés et des valeurs
# tester le code ci-dessous
mes_livres={"BD": 850, "Roman": 160, "Science": 47}
for livres,qte in mes_livres.items():
print(livres,qte)
27- on utilise le dictionnaire suivant :
d = {"voiture": 25, "vélo": 55, "train": 20}
Construisez une liste ne contenant que les clés du dictionnaire dont les valeurs sont inférieures à 40.
Vous pouvez le faire ne une seule ligne en utilisant la création de liste par compréhension
# votre code ci-dessous
tab = [{'nom': 'toto', 'num': 2}, {'nom': 'titi', 'num': 5}, {'nom': 'tata', 'num': 4}]
tab_nom = []
for t in tab :
if t['num'] > 3:
tab_nom.append(t['nom'])
29- On utilise un tableau et des dictionnaires pour stocker des noms et des numéros de téléphone :
tab_tel = [{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}]
Votre programme prend en entrée le tableau tab_tel ci-dessus et un nom : n
Il doit renvoyer le numéro de téléphone de n si ce dernier existe. Dans le cas où n n'existe pas, il doit renvoyer -1
# votre code ci-dessous
tab_tel = [{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}]
4ème partie : les fonctions
Une fonction possède un nom (éviter les caractères accentuées et les mots réservés du langage python comme max, min, sort....), des entrées qui sont des paramètres (ou encore appelés arguments), et une sortie renvoyée généralement par l'instruction return.
Exemple :
Exécutez la cellule Code suivantes :
def f(x):
return 5*x-2
print(f(3))
Ici la fonction python a pour :
- nom f.
- paramètre $x$.
- sortie le résultat du calcul $5x-2$ qui renvoyé par l'instruction return.
Il est à noter que :
- la première ligne d'une fonction commence par
defet se termine par un: (deux-points). - Après le : (deux-points), à la ligne 2, il y a une indentation qui marque le début du corps de la fonction.
- Lorsque l'indentation se termine, on sort de la fonction.
- Lorsque vous faites un appel de fonction, vous devez impérativement préciser la valeur du ou des paramètres. Ligne 4 : f(3). Le paramètre $x$ prend la valeur 3.
- le parenthésage dans l'instruction
print()est obligatoire contrairement à l'instructionreturn.
Exemple :
Entrée
table(2)
tireruntrait("-",27)
table(3)
Sortie
2 4 6 8 10 12 14 16 18 20
---------------------------
3 6 9 12 15 18 21 24 27 30 # votre code ci-dessous
31- Modifier la fonction table de l'exercice 3 qui en plus de pouvoir choisir la base permet également le choix du début et de la fin des termes à afficher.
Vous améliorerez l'affichage du résultat (cf. exemple)
Exemple :
Entrée
table(8,13,16)
Sortie
13 x 8 = 104
14 x 8 = 112
15 x 8 = 120
16 x 8 = 128# votre code ci-dessous
5ème partie : exercices
On dispose ici de deux tableaux de même longueur. Il s'agit de calculer le nombre de différences entre les deux tableaux. Par exemple avec :
tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p']
tab_2 = ['a', 'g', 's', 'u', 'c', 'k', 'p', 'l', 't', 'v', 'p']il y a trois différences entre les deux tableaux : aux indices 2, 5 et 8.
Question 1 :
Compléter la fonction compter_differences ci-dessous qui prend en paramètre deux tableaux tab_1 et tab_2 de même longueur et renvoie le nombre de différences entre les deux tableaux.
Question 2 : Pour quelle raison était-il difficilement envisageable d'effectuer un parcours par élément ?
def compter_differences(tab_1, tab_2):
compteur = ...
for ... in range(...) :
if ... != ...:
compteur = ... + ... # il y a une autre possibilité d'écriture pour cette ligne
return ...
tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p']
tab_2 = ['a', 'g', 's', 'u', 'c', 'k', 'p', 'l', 't', 'v', 'p']
compter_differences(tab_1, tab_2)
La factorielle d'un entier n, positif ou nul, vaut :
- le produit des entiers de 1 à n si n est supérieur ou égal à 1,
- 1 si n est égal à 0.
Question 1 :
Compléter la fonction factorielle ci-dessous qui prend en paramètre un entier n >= 0 et renvoie la factorielle de ce nombre.
On réfléchira à la valeur initiale de la variable facto.
Question 2 :
Compléter l'instruction de la cellule suivante afin d'obtenir un tableau avec les 51 premières factorielles, c'est à dire ce tableau :
[1, 1, 2, 6, 24, 120, 720, ... , 30414093201713378043612608166064768844377641568960512000000000000]
def factorielle(n):
facto = ...
for ... in range(..., ...) :
facto = ... * ...
return ...
print(factorielle(7))
premieres51 = [ ... for ... in .... ]
À un jeu de plateau, il faut lancer un dé cinq fois et calculer un score. On calcule le score comme suit :
- le score est égal à la somme des dés,
- si le dernier dé est un cinq alors le score est diminué de neuf points,
- si le dernier dé est un six alors le score est doublé.
Compléter la fonction ci-dessous qui prend en argument un seul 5-uplet (tuple de 5 éléments) correspondant au lancer de cinq dés et calcule le score correspondant (Attention : la fonction ne prend PAS en argument cinq entiers !).
from random import randint
def score(des):
score = des[0] + ... + ... + ... + ...
if ... == ... :
score = ...
elif ... == ... :
score = ...
return ...
print(score(...))
On souhaite décorer des chaînes de caractères en leur rajoutant des caractères de décoration aux extrémités. Plus précisément on souhaite leur rajouter les caractères suivants à gauche : '☆✶✧✲⁕✫_'
Et les mêmes dans l'ordre inverse du côté droit : '_✫⁕✲✧✶☆'
Par exemple, la version décorée de la chaîne 'bonjour' est '☆✶✧✲⁕✫_bonjour_✫⁕✲✧✶☆'.
Question 1 :
Compléter la fonction etoiler_chaines ci-dessous qui prend en paramètre tab une liste de chaînes de caractères et renvoie un nouveau tableau nv_tab dont les éléments sont les chaînes de caractères de tab en versions étoilées.
Question 2 :
Dans votre définition du tableau nv_tab en compréhension, avez-vous choisi de parcourir tab par indice ou par élément ?
def etoiler_chaines(tab):
nv_tab = [ ... + ... + ... for ... in ... ]
return nv_tab
print(etoiler_chaines(...))
Compléter la fonction fois_deux qui prend en paramètre un tableau de nombres entiers et renvoie un nouveau tableau comportant les mêmes nombres multipliés par deux.
def fois_deux(tab):
nv_tab = [ ... * ... for ... in ... ]
return nv_tab
print(fois_deux([26, 4, 9, 78, 12, 67, 1584, -5]))
Question 1 :
Compléter la fonction mot_le_plus_long ci-dessous qui prend en paramètre un tableau non vide tab de mots et renvoie un 2-uplet constitué :
- du mot le plus long,
- et de la longueur de ce mot le plus long.
En cas d'égalité entre plusieurs mots ayant la longueur maximale, on renverra celui ayant le plus petit indice.
Question 2 : Modifier votre fonction pour qu'en cas d'égalité, elle renvoie le mot le plus long ayant le plus grand indice.
def mot_le_plus_long(tab):
longueur_max = len(tab[0])
mot_max = tab[0]
for mot in tab :
if ... > longueur_max :
longueur_max = ...
mot_max = ...
return ..., ...
print(mot_le_plus_long(['bonjour','salut','coucou','hello','bonjoue']))
En programmation informatique, une permutation consiste à intervertir les valeurs de deux variables. Il s'agit d'une opération courante, mais rarement intégrée aux langages de programmation et jeu d'instructions des processeurs. De nombreux algorithmes, en particulier des algorithmes de tri, utilisent des permutations.
Pour un tableau on peut facilement permuter deux valeurs en utilisant la double affectation (qui utilise sans le montrer des 2-uplets). Par exemple pour permuter les valeurs 999999999 et 333 d'indices 2 et 8 dans le tableau suivant :
tab = [1, 22, 999999999, 4444, 55555, 666666, 7777777, 88888888, 333]
C'est à dire effectuer :
_______________________________________________
| |
V |
[1, 22, 999999999, 4444, 55555, 666666, 7777777, 88888888, 333]
| Λ
|_______________________________________________|Il suffit d'écrire l'instruction suivante : tab[2], tab[8] = tab[8], tab[2]
Il est primordial de noter qu'une permutation ainsi effectuée est une mutation du tableau qui ne nécessite pas de créer un nouveau tableau. En conséquence, sur un tableau passé en paramètre à une fonction, une mutation effectuée dans le corps de la fonction mutera le tableau à l'extérieur de la fonction.
Question 1 : On souhaite inverser un tableau en effectuant des permutations selon le plan suivant :
Sur ce tableau de longueur 7 ci-dessous, lorsqu'on souhaite permuter selon ce plan la valeur d'indice i = 2, quel est l'indice j de la valeur qui va être permutée avec elle ?
- j = 7 - 1 - i
- j = 7 - i
- j = 7 + 1 - i
def inverser(tab):
for ... in range(...) :
tab[...], tab[...] = tab[...], tab[...]
print(inverser([1,22,99999,4444,55555,66666,7777777,88888888,333]))
Les habitants adorent les constructions en forme de pyramide ; de nombreux bâtiments officiels ont d'ailleurs cette forme. Pour fêter les 150 ans de la construction de la ville, le gouverneur a demandé la construction d'une grande et majestueuse pyramide à l'entrée de la ville. Malheureusement, en ces périodes de rigueur budgétaire, il y a peu d'argent pour ce projet. Les architectes souhaitent cependant construire la plus grande pyramide possible étant donné le budget prévu.
Votre programme doit d'abord lire un entier : le nombre maximum de pierres dont pourra être composée la pyramide. Il devra ensuite calculer et afficher un entier : la hauteur de la plus grande pyramide qui pourra être construite, ainsi que le nombre de pierres qui sera nécessaire.
Exemple 1
entrée :
20
sortie :
3
14
Exemple 2
entrée :
26042
sortie :
42
25585
# votre code ci-dessous
Voici une suite :
Pour passer d’une ligne à la suivante, il suffit de lire à haute voix en comptant les nombres !
Par exemple la ligne 1211 est lue « un un (pour 1), un deux (pour 2), deux un (pour 1 1) », la ligne d’après est donc 111221.
Cette dernière ligne se lit « trois uns, deux deux, un un » donc la ligne suivante sera 312211.
Programmer une fonction lecture(mot) qui calcule et renvoie la lecture de la chaîne mot.
Par exemple
lecture("1211") renvoie "111221".
- Indications. Vous pouvez utiliser trois variables : une variable qui lit chaque caractère du mot, une variable correspondant au caractère précédent, un compteur à incrémenter si ces deux caractères sont égaux.
- Algorithme. Si vous n’y arrivez pas tout seul, voici les grandes lignes d’un algorithme possible.
Pour chaque caractère du mot :
— si le caractère est le même que le caractère précédent, incrémenter le compteur,
— sinon, rajouter au mot à créer la valeur du compteur suivie du caractère précédent.
À la fin, il faut aussi rajouter au mot à créer la valeur du compteur suivie du caractère précédent.
Question. Trouvez le premier mot qui contient 33.
# votre code ci-dessous