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

PDF récapitulatifs :

• Chapitre 1 : >>Ici<<
• Chapitre 2 : >>Là<<
• Chapitre 3 : >>Ici<<
• Chapitre 4 : >>Ici<<
• Chapitre 5 : >>Ici<< et >>Là<<

Tu trouveras d'autres codes et des exercices dans l'option "Codes des cours et Exercices" du menu.

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.

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 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 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 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"

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.

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

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.

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)

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

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

• 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.

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

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).

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 :

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 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".

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

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.

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

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)

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 :

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 :)

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.

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

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

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

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