Le jeu pour reviser le python
chargement...

Le JEU pour REVISER
les bases du
PYTHON
Par @Prof2NSI • Adaptation d'un jeu de Nicky Case




Découvrir les jeux de Nicky Case
chargement... C'est parti !



Ce jeu est principalement à destination d'élèves
entrant en Terminale NSI, pour leur permettre de revoir
les bases du python, après ou pendant les vacances d'été.

Ce jeu ne remplace pas un cours plus complet sur les notions
abordées, mais il peut tout à fait vous accompagner dans vos
révisions de Première sur un transat.
(Il est recommandé de jouer sur un ordinateur)
Révisons Jouons !


Si tu n'as pas encore installé de logiciel
pour programmer en python... il serait temps !

Je te propose de cliquer ci-dessous si tu as besoin :
Sinon, on continue : Let's go !
Minute tutoriel du jeu !
Tu devras parfois répondre à des questions en reliant des cercles pour avancer dans le jeu.
dessinez pour connecter coupez pour    déconnecter quand tu auras fini de gribouiller et de jouer, On continue !
↓ Chapitres, cours, codes et exercices ↓
Les
Variables
Python et les
Types de données
Commençons !

Les variables sont des éléments qui associent un nom à une valeur/donnée.

Cette valeur peut varier au fil du programme. Elle est stockée dans une case mémoire de la machine (généralement un ordinateur). La variable permet un accès à cette case mémoire, et lui donne un nom.

Avant d’être utilisée, une variable doit être initialisée.

Exemple : Prenons comme exemple une variable nommée « x » associée à la valeur 3 x = 3 # initialisation x = x + 10 print(x) # 13 x = 5 + 2 print(x) # 7 x change une 1ère fois de valeur : ancienne valeur de x + 10
x change une 2nde fois de valeur : 5 + 2
Compris ! Les variables ne peuvent pas avoir n’importe quel nom !

Jouons !
Relie au cercle les 5 noms valides pour des variables Python. tAILLE _secret e-mail i+j NxM while pi2 2pi e_mail
Passons à la suite !

La valeur possède toujours un type.

Ce type dépend de la nature de la donnée (nombre entier, nombre à virgule, chaîne de caractères, booléen, etc.).

Contrairement à d'autres langages, Python
possède un typage dynamique :
la variable n'est pas initialisée avec un type défini ; celui-ci peut changer au cours du programme.

La fonction type() donne le type d'une valeur.
print(type(13)) # Affiche int print(type("abcd")) # Affiche str va = 37 print(type(va)) # Affiche int
Testons tes connaissances...
Jouons !
Relie les types Python à leur définition . int float list str tuple dict bool Chaîne de caractères Booléen (Vrai/Faux) Flottant (nombre à virgule) Entier Dictionnaire Liste/Tableau modifiable Liste/Tableau non modifiable
Plus de détails sur les types

Jouons !
Relie au cercle le ou les valeurs de type int . 1.975 .175 -5 12 905 224 123456 "12"
Passons aux flottants

Jouons !
Relie au cercle le ou les valeurs de type float . -7.5 1.E10 3,14 1.975 2,618
Chaînes de caractères

Jouons !
Relie au cercle le ou les chaînes de caractères correctements écrites. "Python c'est facile" 'L'informatique, c'est pas automatique' "NSI signifie "Numérique et Sciences Informatique" 'Il est génial ce jeu !'
Les listes, tuples, etc.

Jouons !
Sélectionne dans les listes déroulantes le type de chacune de ces données .
Vite ! La suite !

Jouons !
Relie les opérations à leur résultat booléen . [1, 2, 3] != [1, 2, 3] -1 < 0 "a" in "chaine" 3 == 4 str(42) == "42" len(["a", "b", "c"]) > 2 True False










Fin du chapitre !

Fin du chapitre
En savoir plus :
Chapitre suivant
Les

Conditions

if, elif et else

Commençons !

Les conditions sont l’une des notions les plus importantes en programmation.
Elles sont utiles si l’on souhaite effectuer des instructions uniquement à certaines conditions.

Avant d’être utilisée, une variable doit être initialisée.

Cours :
Passons aux puzzles !
Jouons !
Le programme doit afficher "oui" si les variables var1 et var2 sont égales,
et "non" si elles ne le sont pas.
Relie le point jaune à la bonne comparaison et les points gris aux bons affichages..
if : else:

var1 <= var2 var1 = var2 var1 == var2 print("hein ?") print("non") print("oui")









Puzzle suivant
Le programme...
affiche '1' si les variables var1 et var2 sont égales,
sinon '2' si la variable var1 est strictement supérieure à var2, et sinon '3'.
Relie les points rougess aux bonnes conditions et les points gris aux bonnes comparaisons.
if else elif var1 >= var2 var1 < var2 var1 == var2 var1 > var2










print(1) print(2) print(3)
Qu'affiche ce programme ?

Jouons !
Que va afficher le programme en fonction des valeurs des variables ? Relie les initialisations des variables aux bons affichages ..
if var1 == var2 : elif var1 > var2 : else :

var1 = 3
var2 = 3
var1 = 1
var2 = 5
var1 = 7
var2 = 2
var1 = 50
var2 = -254
1 2 3
Programme suivant
Le programme...
ajoute 1 à total si va est égale à '3'.
Il ajoute 10 à total si va est positive ou égale à 0
Enfin, il ajoute 50 total si va est inférieure à 100 et supérieure à -10
Relie les points verts aux conditions et les points gris aux comparaisons.
if else elif va >= 0 va > 0 va < 100 va > 100 va > -10 va == 3










total += 1 total += 10 total += 50
Qu'affiche ce programme ?

On suppose que la variable total est initialisée à 0.
Que va afficher le programme en fonction des valeurs des variables ? Relie les initialisations des variables aux bons affichages ..
if va == 3 : if va > 0 : if va < 100 and va > -10 :

va = 3 va = -5 va = -500 va = 500 0 10 50 61
Programme suivant
Jouons !
Relie au point bleu les programmes qui affichent un résultat identique pour une même variable va (entier quelconque) quelque soit sa valeur.
La variable lettre est initialisée par une chaîne vide.
Programme 1 :
if va < 15: lettre = "a" if va >= 15 and va <= 30: lettre = "b" if va > 30: lettre = "c" print(lettre)
Programme 2 :
if va < 15: lettre = "a" elif va > 30: lettre = "c" else: lettre = "b" print(lettre)
Programme 3 :
if va > 30: lettre = "c" else: if va < 15: lettre = "a" else: lettre = "b" print(lettre)
Chapitre suivant
Les

Boucles

for et while

Commençons !

Les boucles sont l’une des notions les plus importantes en programmation.
Elles sont utilisées pour effectuer des répétitions.

Il en existe deux sortes :
  • Les boucles bornées : On sait à l’avance le nombre d’itération nécessaire.
  • Les boucles non bornées : On ne sait pas à l’avance le nombre d’itération nécessaire.

Commençons par les boucles bornées :
Des puzzles bornés !
C'est parti !
Sélectionne dans la liste déroulante ce que ce programme va afficher.

cha = "avion" compteur = 0 for lettre in cha: compteur += 1 print(compteur)
Boucle suivante

C'est parti !
Sélectionne dans la liste déroulante ce que ce programme va afficher.

cha = "parapluie" compteur = 0 for lettre in cha: if lettre != "a" and lettre !="i": compteur += 1 print(compteur)
Boucle suivante

Le programme...
affiche chaque lettre de la chaîne de caractères 'cha', le tout 3 fois.
Relie le point vert gris aux bonnes bornes.

3 [3] range(3) range(cha) cha [cha]








cha = "avion" for i in : for lettre in : print(lettre)
Prochaine double boucle

Le programme...
affiche 3 chaînes de caractères.
Relie les points jaunes aux chaînes affichées par le programme (dans l'ordre).

"a" "v" "i" "o" "n" "n" "o" "i" "v" "a" "v" "i" "o" "n" "n" "o" "i" "v" "i" "o" "n" "n" "o" "i" "o" "n" "n" "o"









cha = "avion" for i in range(3): for x in range(i, len(cha)): lettre = cha[x] print(lettre)
Avec une matrice ?

Le programme...
affiche les éléments de 'matrice'.
Relie le point bleu aux affichages correspondants .








[ ["a", "b", "c"], [1, 2, 3] ]
["a", "b", "c"]
[1, 2, 3]
"a"
"b"
"c"
[1, 2, 3]
["a", "b", "c"]
1
2
3
"a"
"b"
"c"
1
2
3
matrice = [["a", "b", "c"], [1, 2, 3]] for liste in matrice: for val in liste: print(val)
Boucles non-bornées

Tu sais maintenant utiliser des boucles for !

Rappel : Tu peux retrouver les codes des exercices en cliquant sur l'étoile en bas de ton écran.

Poursuivons avec les boucles non-bornées :
Jouons sans borne !
C'est parti !
Pour chaque proposition, sélectionne dans la liste déroulante combien d'itérations la boucle va effectuer.







while a != 3 and i < 5: a = a - 1 i = i + 1 print(a, i)
Chapitre suivant

C'est parti !
Sélectionne dans la liste déroulante combien d'itérations la boucle va effectuer.

cha = "un avion rouge" lettre = "" ind = 0 while lettre != "o": lettre = cha[ind] ind = ind + 1
Chapitre suivant
Les

fonctions

en Python

Commençons !

Une fonction est une suite d'instructions (comme les conditions et les boucles) que l'on peut appeler avec un nom (un peu à la manière d'une variable).

Elles sont plusieurs informations:
Un nom
Un/des paramètres
Un/des instructions
Un/des valeurs de retour
Un/des appels
Des puzzles bornés !
Compléter les fonctions...

avec la bonne structure pour qu'elles renvoient des calculs.
return input print function def definition void x, y a, b x / y a / b












addition(x, y): x + y suppression( ): x - y multiplication(a, b) a * b division(a, b):
Suite du programme

Compléter les appels de fonctions...

avec la bonne structure pour qu'elles affiches les calculs.
return input print addition suppression multiplication division
( (1, 9)) # Affiche 10 ( (4, 4)) # Affiche 16 ( (6, 2)) # Affiche 4 ( (9, 3)) # Affiche 3.0 ( (3, 8)) # Affiche -5
Programme suivant

Que retourne...

la fonction pour chaque appel ?
"a" "b" "c"










def fonction_une(va): if va < 15: return "a" elif va > 30: return "c" else: return "b"
print( fonction_une(5) ) print( fonction_une(35) ) print( fonction_une(-8) ) print( fonction_une(18) )
Prochaines fonctions

C'est parti !
Que va afficher le programme ?

def m1(): return 1 def m2(): return m1() + m1() def m3(): return m2() + m2() + m1() print(m3())
Dernière fonction

Que fait cette fonction ?
On supposera que les paramètres 'b' et 'c' sont des entiers positifs ou nuls et
'a' est une liste (dont la taille est supérieure ou égale à 'c')












def fonction_mystere(a, b, c): m = a[b] for i in range(b, c): if m > a[i]: m = a[i] return m
Qu'affiche la fonction ?
Affichages

Que va afficher la fonction ?

-2 1 2 3 5 8 12
liste = [1, 9, -2, 5, 3, 8, 12, 4, 2] print(fonction_mystere(liste, 0, 6)) print(fonction_mystere(liste, 3, 8)) print(fonction_mystere(liste, 5, 7))
Dernier chapitre
Ce chapitre arrive bientôt ! Merci pour votre patience :D A bientôt !
Les

Algorithmes

vus en Première

Commençons !



En Première, vous avez travaillé sur certains algorithmes très connus en informatique.

Commençons avec les algorithmes de tri et de recherches.

(Remarque : il n'y a pas de puzzle sur
l'algorithme dichotomique, désolé)



Cours :
Commençons par l'échange
Jouons !
Mettre dans l'ordre les instructions qui permettront d'échanger
les valeurs aux indices x et y de la liste L.
Attention, certaines instructions et points sont inutils.
Relie les instructions à leur bonne place ..
1 2 3 4 5
L[x] = L[y] L[x, y] = L[y, x] L[y] = tempo L[y] = L[x] L = L[y], L[x] tempo = L[x]
Recherchons le minimum !
Go !
Relie au point rouge les programmes
qui affichent la valeur minimale d'une liste L.
Programme 1 :
i_mini = 0 for j in L: if j < L[i_mini]: i_mini = j print(i_mini)
Programme 2 :
i_mini = 0 for j in range(len(L)): if L[j] < L[i_mini]: i_mini = j print(i_mini)
Programme 3 :
i_mini = 0 for j in L: if j < L[i_mini]: i_mini = L.index(j) print(i_mini)
Passons aux tris :)
Jouons !
Traduire chaque les instructions du tri sélection
en python en reliant les points..
Parcourir la liste L : i va de 0 à len(L)-1 i_mini = i # On trouve le minimum Parcourir la liste L : j va de i à len(L) Si L[j] < L[i_mini] i_mini = j Echange les valeurs i et i_mini # La liste est triée !

i_mini = j for i in range(n-1): if L[j] < L[i_mini]: L[i], L[i_mini] = L[i_mini], L[i] for j in range(i, len(L)) i_mini = i
Tri suivant

Jouons !
Traduire chaque les instructions du tri par insertion
en python en reliant les points..
Parcourir la liste L : i va de 1 à len(L) j = i # On trouve la position d'insertion Tant que l'élément j est plus petit que le précédent et que j est supérieur à 0 Echange les valeurs j et j-1 j = j-1 # La liste est triée !

j -= 1 while L[j-1] > L[j] and j > 0: j = i for i in range(1, len(L)): L[j-1], L[j] = L[j], L[j-1]
Partie suivante




Poursuivons avec les algorithmes gloutons
et k plus proches voisins !



Cours :
Petits gloutons !
Jouons !
Mettre dans l'ordre les principales instructions d'un algo glouton.
Relie les instructions à leur bonne place .
1 2 3 4 5 6 7 8 9
Tant que l'objectif est != de 0 et qu'il reste des éléments à parcourir Fin Tant que Trier les éléments dans l'ordre décroissant Soustraire l'élément à l'objectif et l'ajouter dans une liste Passer à l'élément suivant Sélectionner le premier élément Sélectionner les éléments et un objectif Si l'élément est inférieure ou égale à l'objectif Fin Si
Bonjour voisins !

Jouons !
Mettre dans l'ordre les principales instructions d'un algo KNN.
Relie les instructions à leur bonne place .
1 2 3 4 5 6
Trouver la catégorie majoritaire Trier les distances par ordre croissant Calculer les distances entre les données connues et la mystère Sélectionner les données connues, celle mystère et un k Sélectionner les k premières données Sélectionner les catégories parmi les données connues
Tu es un(e) pro en algo !
Les

Conclusions

du jeu

Commençons !
Ce chapitre arrive bientôt ! Merci pour votre patience :D A bientôt !
"Créé" par
@Prof2NSI
d'après le jeu Crowds

Le jeu Crowds (ou Sagesse/Folie des Foules) est
complètement open source

C'est pourquoi ce jeu de révisions l'est tout autant :)


Beaucoup d'amours à
NICKY CASE
Retrouvez tous ces jeux ici
et son Patreon <3
Enigme

pour activer l'option

et entrer ton nom dans la légende



Les programmeurs prennent le contrôle.
Les développeurs voient au delà de l'AZERTY.
Les joueurs savent chercher en quelques clics.


BONUS

Speen Run
BONUS

Speen Run
BONUS

Speen Run
VICTOIRE Valider Réessayer

Les cours

Tu retrouveras ici les cours présents dans ce jeu.

PDF récapitulatifs :
Tu trouveras d'autres codes et des exercices dans l'option "Codes des cours et Exercices" du menu.


•- •- • Chapitre 1 : Les variables et les types • -• -•

Le logiciel Anaconda

Le logiciel Anaconda est une distribution d'applications de développement pour les langages de programmation Python et R. Ce logiciel, libre et open source, vise à simplifier la gestion et l'apprentissage.
Télécharger Anaconda

Ce logiciel propose les applications Spyder et Jupyter.

Spyder est un IDE (Environnement de Développement Intégré) est un outil de développement Python.

L'application intègre directement les bibliothèques scientifiques de manipulation de données, telles que NumPy, Matplotlib, IPython, SciPy, etc.

Jupyter est une application de Notebook sur ordinateur.

Un notebook permet de combiner, dans un même document, du texte, du code, de la visualisation de données, etc.

Les noms des variables en Python

Les noms des variables en Python peuvent contenir :
  • des lettres minuscules
  • des lettres majuscules
  • des chiffres
  • des tirets bas
Les variables ne doivent pas commencer par un chiffre et ne doivent pas être constitué d’espace (il est aussi conseillé de ne pas mettre d’espace dans les noms des fichiers de programmation).

Il faut aussi éviter d’utiliser un mot déjà utilisé par Python (print, for, if, min, max, from, import, while, etc.).


Remarque : Une variable doit toujours être écrite de la même façon :
  • mavariable
  • MaVariable
  • MaVariable
  • maVariable
  • etc. sont toutes des variables différentes.
On nomme cela la « sensibilité à la casse ». Cette sensibilité ne s’applique pas qu’au Python, mais aussi à la plupart des langages de programmation, aux nommages de fichiers, etc.

Les types en Python

Les principaux types de données :
  • Les nombres :
    • Entier :       int
    • A virgule (flottant) :  float
  • Booléens :   bool
  • Dictionnaires :  dict
  • Séquences :
    • Chaînes de caractères :      str
    • Listes/Tableaux modifiables :   list
    • Listes/Tableaux non-modifiables :  tuple
La suite des exercices décrit plus en détails chacun de ces types.
En savoir plus maintenant

Les chaînes de caractères

Les chaînes de caractères sont de type str en Python. Les chaînes de caractères sont encadrées de guillemets ou d'apostrophes. Exemples :
    "C'est une chaîne de caractères"
    'Là aussi'
Pour écrire un guillemet dans une chaîne alors qu'ils encadrent cette chaîne, il faut placer un \ devant le guillemet (de même pour l'apostrophe). Exemple :
    "C'est une chaîne de caractères avec des \"guillemets\" à l'intérieur."
Les indices dans une chaîne de caractères (de même pour une liste, un tuple, etc.) :



Quelques manipulations des chaînes de caractères :
Pour notre exemple, la variable x est de type str.
  • len(x)    
    Retourne la taille de la chaîne de caractères.
  • x[i]     
    Retourne la lettre à l'indice i dans la chaîne.
  • x[i:j]   
    Retourne la sous-chaîne de l'indice i à l'indice j-1.
  • x + "chaine"
    Retourne la chaîne x suivie de "chaine". Exemple : si x = "la", on obtient "lachaine".
  • x = ""    
    Permet d'initialiser une chaîne vide.
Exemple python : ch = "chaine" # initialisation ch = ch + "s" print(ch) # Affiche "chaines" taille = len(ch) print(taille) # Affiche 7 print(ch[2]) # Affiche "a" print(ch[2:]) # Affiche "aines"

Les principales structures de données


Source

Leur structure

Principales manipulations et fonctions


Exemples de codes
Les listes : L = ["ab", "cd", "ef"] # initialisation L = L + ["g", "h"] print(L) # Affiche ["ab", "cd", "ef", "g", "h"] taille = len(L) print(taille) # Affiche 5 print(L[2]) # Affiche "ef" print(L[2:]) # Affiche ["ef", "g", "h"]
Il est possible de mettre une liste dans une liste: L = [ [1, 2, 3], ["a", "b", "c"] ] print(L[0]) # Affiche [1, 2, 3] print(L[1]) # Affiche ["a", "b", "c"] print(L[1][2]) # Affiche "c"
Les dictionnaires : dico = {"taille": 170, "age": 24, "yeux": "verts"} dico["age"] = dico["age"] + 1 print(len(dico) # Affiche 3 print(dico) # Affiche {"taille": 170, # "age": 25, # "yeux": "verts"} dico["cheveux"] = "court" print(len(dico) # Affiche 4 print(dico) # Affiche {"taille": 170, # "age": 25, # "yeux": "verts", # "cheveux": "court"} On observe que si la clé n'existe pas dans le dictionnaire, celle-ci est ajoutée.

Les booléens et les opérations

Le type booléen ne comporte que deux valeurs : vrai et faux (en python, True et False).

Certaines opérations permettent d’obtenir une valeur booléenne :
Les opérateurs de compariasons : Les variables x et y ont des valeurs quelconques.

Les expressions booléennes : Les variables x et y ont des valeurs booléennes.

Exemple python : print(333 == "333") # Affiche False print(True or False) # Affiche "True print(12 > 15 and 0 < 99) # Affiche False

Les calculs

Certaines opérations permettent de faire des calculs avec des nombres (int et float).

Les opérateurs : Les variables x et y ont des valeurs int ou float.


Les conversions de types

Pour convertir le type d'une valeur, on utilise des fonctions nommées avec le nouveau type.
Exemple python : print( str(333) ) # Affiche '333' print( float("257") ) # Affiche 257.0 print( tuple( [1, 2, 3] ) ) # Affiche (1, 2, 3)

En savoir plus sur les variables et les types

  • Ici
  • Ou ici
  • Ou demande à ton/ta prof de NSI :)


•- •- •- •- • Chapitre 2 : Les conditions • -• -• -• -•

Les trois étapes d’une condition


Seul if est obligatoire dans l’écriture d’une condition, elif et else sont optionnels.

La structure

  • if et elif sont toujours suivis de valeurs booléennes, d’opérations booléennes et/ou d’expressions booléennes (voir chapitre 1 du jeu).
  • if, elif et else sont ensuite suivis de deux points « : ».
  • Les instructions se situent sous les conditions, décalées par une tabulation.

Exemples de codes
x = 5 y = 6 c = 0 if x == y: # Si x est égale à y c = 10 else: # Sinon c = 20 print(c) # Affiche 10 ou 20 (ici, 20 car x != y) On observe que si la clé n'existe pas dans le dictionnaire, celle-ci est ajoutée.

En savoir plus sur les conditions

  • Ici
  • Ou ici
  • Ou demande à ton/ta prof de NSI :)


•- •- •- •- • Chapitre 3 : Les boucles • -• -• -• -•

Les boucles for : Introduction

Les boucles bornées sont aussi appelées des boucles for.
On les dit « bornée » puisque l’on connaît le nombre d’itérations nécessaires pour effectuer la boucle.

Exemples :
  • La boucle doit aller de6 à 52 inclus avec un pas de 1
    (6, 7, 8, 9, … , 51, 52 ; soit 47 itérations de la boucle).
  • La boucle doit aller de 0 à 11 inclus avec un pas de 2
    (0, 2, 4, 6, 8, 10 ; soit 6 itérations de la boucle).

Les boucles for : Structure

La structure Python de la boucle for est la suivante :

La variable de la boucle sera égale à un élément différent à chaque tour de boucle. La variable n’a pas besoin d’être définie à l’avance. Elle est souvent nommée « i » mais elle peut avoir n’importe quel nom (voire cours sur les variables).

La borne varie en fonction de l’utilisation. C’est elle qui détermine les éléments qui seront un à un attribués à la variable.
La borne peut être :

Les boucles for : Utilisations

Voici quelques exemples d’utilisations : avec range ou avec une liste, un tuple ou un dictionnaire.

Avec range

for i in range(5): print(i) # Affiche 0 1 2 3 4 for i in range(0, 5): print(i) # Affiche 0 1 2 3 4 for i in range(3, 12): print(i) # Affiche 3 4 5 6 7 8 9 10 11 for i in range(3, 12, 2): print(i) # Affiche 3 5 7 9 11 for i in range(11, 2, -2): print(i) # Affiche 11 9 7 5 3

Avec une liste, un tuple ou une chaîne

tab = ["a", "b", 5, 6, [True, 3]] for val in tab: print(val) # Affiche "a" "b" 5 6 [True, 3]

Avec un dictionnaire

dico = {"a": 1, "b": 5, "z": 9} for cle in dico: # Affiche "a" "b" "z" print(cle) for cle in dico.keys(): # Affiche "a" "b" "z" print(cle) for val in dico.values(): # Affiche 1 5 9 print(val) for cle, val in dico.items(): print("La cle :", cle, "et la valeur :", val) # Affiche "La cle : a et la valeur : 1" "La cle : b et la valeur : 5" "La cle : z et la valeur : 9" for it in dico.items(): cle = it[0] val = it[1] print("La cle :", cle, "et la valeur :", val) # Affiche "La cle : a et la valeur : 1" "La cle : b et la valeur : 5" "La cle : z et la valeur : 9"

Avec range et une liste

tab = ["a", "b", 5, 6, [True, 3]] for i in range(len(tab)): print(i) # Affiche 0 1 2 3 4 for i in range(len(tab)): print(tab[i]) # Affiche "a" "b" 5 6 [True, 3]

Les boucles while : Introduction

Les boucles non-bornées sont aussi appelées des boucles while.
On les dit « non-bornée » puisque l’on ne connaît pas le nombre d’itérations nécessaires pour effectuer la boucle.

Exemples :
  • La boucle doit s’arrêter lorsque la variable x est égale à 13
  • La boucle doit s’arrêter lorsque la variable num est inférieure à 0 ou lorsque la variable tab est différente de "nsi".

Les boucles while : Structure

La structure Python de la boucle while est la suivante :

La (ou les) condition(s) de la boucle donne un résultat booléen (voire le Chapitre 2 sur les conditions).
Si le résultat booléen des conditions de la boucle est :
  • True : la boucle continue
  • False : la boucle s’arrête

Exemple : La boucle suivante continue si x est égal à 5 et si y est strictement inférieur à 10. while x==5 and y<10: y += 1 La boucle s'arrête si x est différent de 5 ou/et si y est supérieur ou égal à 10

Les boucles while : Utilisations

Voici quelques exemples d’utilisations :

Conditions

i = 0 while i < 5: i = i + 1 print(i) a = 6 while a != 3: print(a) a = a - 1 a = 13 i = 2 while a > 3 and i < 5: a = a - 2 i = i + 1 print(a, i) a = 13 i = 2 while a > 3 or i < 5: a = a - 2 i = i + 1 print(a, i)

Comparaison avec une boucle for

for i in range(5): # Affiche 0 1 2 3 4 print(i) i = 0 while i < 5: # Affiche 0 1 2 3 4 print(i) i = i + 1

Parcours d'une liste (comparaison avec for)

tab = ["a", "b", 5, 6, [True, 3]] for i in range(len(tab)): print(tab[i]) # Affiche "a" "b" 5 6 [True, 3] i = 0 while i < len(tab): print(tab[i]) i = i + 1 # Affiche "a" "b" 5 6 [True, 3]

/!\ VIGILENCE

Les valeures des variables présentes dans la (ou les) condition(s) doivent être modifiées dans les instructions de la boucle afin d’atteindre un résultat False.
Si ce n’est pas le cas, le résultat ne passera jamais à False et la boucle sera infinie.

Exemple : i = 10 while i > 5: # Affiche 10 11 12 13 ... print(i) i = i + 1 # i ne sera jamais =< à 5.

En savoir plus sur les boucles



•- •- •- •- • Chapitre 4 : Les fonctions • -• -• -• -•

Les fonctions et les maths

Dans un premier temps, on peut comparer les fonctions en programmation aux fonctions mathématiques.
Une fonction mathématique à elle aussi :


Voici ça traduction en python :


Exemple :
def ma_fonction(x, y): return 2 * x + y / 3 a = ma_fonction(3, 6) b = ma_fonction(0, 12) print(a) print(b)

La structure d'une fonction

Comment indiqué précédemment, la structure d’une fonction est :


La structure à utiliser :


Exemple :
def fusion_chaine(ch1, ch2): fu = ch1 + " et " + ch2 return fu a = fusion_chaine("une", "deux") b = fusion_chaine("chat", "chien") print(a) # Affiche "une et deux" print(b) # Affiche "chat et chien"
Avec les couleurs :


L'utilisation des fonctions

Une fonction peut avoir plusieurs utilités :
  • Optimiser un programme
  • Ordonner un programme
  • Créer des modules

A. Optimiser un programme

Prenons le programme python suivant :
print("Partie 1") print(1, "a") print(2, "a") print(3, "a") print(4, "a") print(5, "a") print(6, "a") print(7, "a") print(8, "a") print("Partie 2") print(1, "b") print(2, "b") print(3, "b") print(4, "b") print(5, "b") print(6, "b") print(7, "b") print(8, "b") print(9, "b") print(10, "b")
Il est possible d’optimiser ce programme à l’aide de boucle for :
print("Partie 1") for i in range(1, 9): print(i, "a") print("Partie 2") for i in range(1, 11): print(i, "b")
C’est mieux ! Cependant, on remarque qu'il y a des ressemblances entre la première et la seconde partie du programme.
C’est là qu’intervienne les fonctions !
def fonction_boucle(lettre, nombre): for i in range(1, nombre+1): print(i, lettre) print("Partie 1") fonction_boucle("a", 8) print("Partie 2") fonction_boucle("b", 10)


/!\ Dans une fonction, il faut éviter d'utiliser "print" (voir la suite du cours)

B. Ordonner un programme

Supposons un programme de plusieurs milliers de ligne.
Pas facile de s’y retrouver !
Les fonctions peuvent permettre de créer des sous-parties au programme pour mieux s’y retrouver.
Conseils :
  • Il est généralement préférable d’écrire les fonctions en premiers, puis d’écrire le programme principal (appels des fonctions).
  • Si le programme est important, il est aussi possible de mettre le programme principal dans un fichier et les fonctions dans d’autres fichiers.

C. Créer des modules

Les modules, ou bibliothèques, sont des fichiers contenant des fonctions que l’on peut utiliser dans plusieurs programmes en même temps.
Python possède de nombreuses bibliothèques préinstallées (math, random, tkinter, etc.).
Il est possible d’en télécharger des préexistantes ou d’en créer soi-même.

Pour plus de détails sur les modules, RDV en classe de Terminale NSI :)

Vigilence /!\ Les effets de bord

Il est généralement déconseillé d’utiliser input et print dans une fonction.
Il est préférable de les utiliser dans le programme principal, et d’utiliser des paramètres et des return pour les interactions entre le programme principal et les fonctions.

Pourquoi ?

print, input, global et d’autres opérations d’entrée/sortie interagissent avec l’extérieur sans laisser de trace dans le programme principal.
On appelle cela un effet de bord. C’est un peu un « effet secondaire » de la fonction.
C’est généralement déconseillé d’en avoir pour pouvoir débugger plus efficacement un programme.

Une bonne fonction ne doit pas :
  • Avoir d’autres entrée/sortie que les paramètres et les return
  • Modifier une variable du programme principal (voir la suite)
  • Retourner un résultat différent pour un même paramètre ou groupe de paramètres (ex : le résultat de x*5 est toujours la même quand x = 2)

Attention à la modification des listes, tuples et dictionnaires :

Lorsque l’on passe une valeur en argument d’une fonction et qu’elle est modifié dans cette fonction, elle n’est pas modifiée dans le programme principal.
Exemple :
def fonction(x): x = 3 return x val = 2 fonction(val) print(val) # Affiche 2 re = fonction(val) print(re) # Affiche 3
Il y a une exception pour les listes, les tuples et les dictionnaires.
Exemple :
def fonction(li): li.append("b") ma_liste = [1, 2, 3] fonction(ma_liste) print(ma_liste) # Affiche [1, 2, 3, "b"] fonction(ma_liste) print(ma_liste) # Affiche [1, 2, 3, "b", "b"]
Il est conseillé de faire une copie de la liste/tuple/dictionnaire dans la fonction, puis de retourner la structure de données (c’est plus simple pour suivre les actions du programme).
Vous pouvez utiliser la fonction copy (liste/tuple/dico) ou deepcopy (fonctionne aussi sur les matrices : liste/tuple/dico dans les listes/tuples/dico) de la bibliothèque copy.
Exemple :
from copy import deepcopy def fonction(li): nouvelle_li = deepcopy(li) nouvelle_li.append("b") return nouvelle_li ma_liste = [1, 2, 3] fonction(ma_liste) print(ma_liste) # Affiche [1, 2, 3] re = fonction(ma_liste) print(re) # Affiche [1, 2, 3, "b"]
Précision : Parfois, nous n’avons pas le choix d’avoir des effets de bord (tout dépend du programme). L’important est de les réduire le plus possible.

En savoir plus sur les fonctions



•- •- • Chapitre 5 : Les algorithmes de 1ère • -• -•

Les algorithmes - Partie 1

Les algorithmes de tri et de recherche dichotomique :
Lien vers le PDF du cours : >>Ici<<

Les algorithmes - Partie 2

Les algorithmes gloutons et k plus proches voisins :
Lien vers le PDF du cours : >>Ici<<

En savoir plus sur les algorithmes

  • Ici
  • Et là
  • Ou demande à ton/ta prof de NSI :)


En quelques clics, vous avez réussi l'énigme ! Dans ce mode de jeu, vous ne pourrez plus utiliser les menus, ni passer un exercice sinon, vous recommencerez du début ! (de même si vous tentez de tricher) L'URL : /python/?speed=run

Les codes des cours et des exercices

Tu retrouveras ici les codes présents dans les cours et les puzzles de ce jeu.
Tu trouveras également des exercices pour t'entraîner.

•- •- •- • Chapitre 1 : Les variables et les types • -• -• -•

Récupérer les codes des cours et des exercices :
Sujets Codes et exercices Corrections
Variables Fichier X
Types Fichier Corrections
Chaines de caractères Fichier Corrections
Listes Fichier Corrections
Dictionnaires Fichier Corrections
Booléens et
Opérations booléennes
Fichier Corrections
Conversions Fichier X

•- •- •- •- • Chapitre 2 : Les conditions • -• -• -• -•

Récupérer les codes des cours et des exercices : Fichier (corrections incluses)

•- •- •- •- •- • Chapitre 3 : Les boucles • -• -• -• -• -•

Récupérer les codes des cours et des exercices :
  • Boucles bornées : Fichier (corrections incluses)
  • Boucles non-bornées : Fichier (corrections incluses)

•- •- •- •- • Chapitre 4 : Les fonctions • -• -• -• -•

Récupérer les codes des cours et des exercices : Fichier (corrections incluses)

•- •- •- •- • Chapitre 5 : Les algorithmes • -• -• -• -•

Récupérer les codes des cours et des exercices (corrections incluses) :
Algorihtmes Codes et exercices
Tris Fichier
Dichotomie Fichier
Glouton Fichier
K plus proches voisins Fichier