Bienvenue dans cette nouvelle activité. Vous apprendrez ici les bases nécessaires à la programmation Python. Cette activité est séparée en différentes parties que vous devez lire et suivre rigoureusement.

Après cette activité vous devez être capable de rédiger vos programmes vous-même.

Il est important de comprendre chaque ligne de code que vous testerez ici.

N’hésitez pas à appeler le professeur en cas d’incompréhension ou de doute !

Thonny

Dites bonjour à Thonny, votre nouveau compagnon !

Thonny est un IDE (Environnement de Développement Intégré) qui permet à la fois d’éditer des scripts (programmes) en langage Python et de les interpréter (exécuter).

Sur les ordinateurs du lycée vous le trouverez dans le raccourci nommé « NSI ».

Chez vous, vous pouvez le télécharger sur le site officiel de Thonny.

C’est dans l’éditeur que vous écrirez vos programmes en langage Python. Pour les exécuter il vous suffit ensuite de cliquer sur la flèche verte dans le menu supérieur. Le programme donnera alors son résultat dans la fenêtre de la console.

Un programme est constitué d’une suite d’instruction.

Une instruction est une ligne de code qui va être exécuté par l’interpréteur.

Dans la console (fenêtre « interpréteur ») vous pouvez directement rentrer des instructions simples.

Dans la console, écrire l’instruction suivante et appuyer sur entrée.

print("hello")

Attention à ne pas oublier les guillemets quand vous voulez directement afficher un message. Si vous les oubliez voici l’erreur qui peut se produire :

NameError: name 'hello' is not defined

L’interpréteur cherche en fait a afficher la valeur de la variable hello qu’il ne connait puisqu’elle n’est pas défini. Nous allons apprendre ce qu’est une variable sur le prochain chapitre.

Au moment d’exécuter un programme il est fort probable que vous rencontriez des erreurs. Il est alors important de savoir les déchiffrer pour débuguer son code rapidement. Avant d’appeler votre professeur pour résoudre le problème, cherchez par vous-même !

Les variables

Les variables sont des éléments dont la valeur pourra changer en fonction des besoins. Il s’agit d’une sorte de boite de stockage (tiroir) dont le contenu pourra varier.

Pour définir une variable on écrit son nom suivi du signe « = » puis de sa valeur qu’on veut lui assigner.

Dans la console, écrire l’instruction suivante et appuyer sur entrée.

message = "hello"

Ici, la variable message contient la chaine de caractère « hello ».

Dans la console, écrire l’instruction suivante et appuyer sur entrée.

print(message)

L’interpréteur a cette fois trouvé la variable message et l’a affiché.

Il est possible de rédiger cette suite d’instruction dans l’éditeur de Thonny pour ensuite les exécuter à la suite automatiquement.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme en cliquant sur la flèche verte.

message="hello"
print(message)

Le même résultat se produit. Normal !

Une variable peut être de différents types. C’est ce que nous allons voir dans le chapitre suivant.

Une variable peut aussi ne prendre aucune valeur. Dans ce cas on dit qu’elle est sans valeur et on l’a définie par : myVar = None (None est l’équivalent de null dans d’autres langages).

Le nom des variables en Python peut être constitué de lettres minuscules (a à z), de lettres majuscules (A à Z), de nombres (0 à 9) ou du caractère souligné (_). Vous ne pouvez pas utiliser d’espace dans un nom de variable.

Par ailleurs, un nom de variable ne doit pas débuter par un chiffre et il n’est pas recommandé de le faire débuter par le caractère _ (sauf cas très particuliers).

De plus, il faut absolument éviter d’utiliser un mot « réservé » par Python comme nom de variable (par exemple : print, range, for, from, etc.).

Enfin, Python est sensible à la casse, ce qui signifie que les variables TesT, test ou TEST sont différentes.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme en cliquant sur la flèche verte.

prenom = "Victor"
print("Bienvenue",prenom)

Ici, la commande print a été utilisé avec 2 éléments afin de les afficher à la suite. Pour cela il suffit de les séparer par des virgules.

Les types primitifs

Voici les 4 types primitifs que nous étudierons principalement :

Booléen (bool)

Une variable booléenne peut prendre seulement deux valeurs : True ou False.

On utilisera ces termes lorsque l’on aura besoin de vérifier si une condition est vraie par exemple.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

a = True
print(type(a))

La commande « type » retourne le type de la variable rentrée en paramètre.

Ce script permet de déclarer la variable a comme booléenne en lui assignant directement la valeur True et d’afficher son type.

Entier (int)

Lorsque l’on affecte à une variable un nombre entier alors cette variable est automatiquement de type entière.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

a = 4
print(type(a))

Flottant (float)

Lorsque l’on affecte à une variable un nombre qui n’est pas entier alors cette variable est automatiquement de type flottante.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

a = 4.6
print(type(a))

Si maintenant on effectue des opérations sur une variable son type peut être redéfini.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

a = 4
b = 3
a = a/b
print(a)
print(type(a))

A la première déclaration la variable a était de type int puis, avec l’opération qui a donné en résultat un nombre à virgule, la nouvelle affectation est de type float.

Chaine de caractères (str)

Un caractère est un symbole unique, par exemple une lettre minuscule « a », une lettre majuscule « A », un symbole spécial « & », un symbole représentant un chiffre « 4 », un espace » « . Pour désigner un caractère il faut le mettre entre guillemets simples ‘a’ ou double « a ».

Une chaine de caractère est une séquence de caractère.

Les chaines de caractères s’apparente finalement à un tableau (ou une liste – type que nous verrons plus tard) où chaque caractère est mis dans une case.

Le premier caractère de la chaine est situé à l’index 0 du tableau, le deuxième à l’index 1, le troisième à l’index 2, …, et le n^ième caractère à l’index n-1.

On peut donc accéder à un ou plusieurs caractères précisément de manière très simple.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

message = "Hello World"
print(message[0])
print(message[0:3])
print(message[-1])
print(message[5])
print(message[0::3])
print(message[::-1])

Analysez le résultat de chaque instruction pour les comprendre.

Il est parfois très utile de vouloir connaitre la longueur d’une chaine de caractères (càd le nombre de caractère qui la compose). Pour cela il existe une fonction prédéfinie sur Python qui retourne la longueur d’un objet. Cette fonction se nomme len (pour length, longueur en anglais).

message = "Hello World"
print(len(message))

Il existe aussi de nombreuses méthodes (les méthodes sont des fonctions propre à un type d’objet particulier) permettant d’effectuer des opérations spéciales sur les chaines de caractères. Vous en retrouverez quelques unes sur ce lien.

Une chaine de caractère peut aussi être vide on la définira alors comme suit :

message = ""

On peut aussi concaténer (assembler) plusieurs chaines de caractères ensemble.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

message = "Bonjour"
pseudo = "Zerator"
message_perso = message + " " + pseudo
print(message_perso)

Il existe aussi d’autres types de variables plus complexes que nous verrons dans une autre séquence.

Les opérateurs mathématiques

Python peut évidemment effectuer des opérations mathématiques (additions, soustractions, multiplication, etc) entre différentes variables contenant des valeurs numériques.

Python reconnait et accepte les opérateurs mathématiques suivants :

Opérateur	Nom
+	Addition
–	Soustraction
*	Multiplication
/	Division
%	Modulo
**	Puissance
//	Division entière

Le modulo correspond au reste d’une division Euclidienne (division entière) tandis que l’opérateur // permet d’obtenir le résultat entier d’une division (ou la partie entière de ce résultat pour être tout à fait exact).

Le résultat de 13//3, par exemple, sera 4 tandis que le résultat de 13%3 sera 1 car dans le cas d’une division entière 13/3 = 4 avec reste = 1.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

a=17
b=17/4
print(b)
c=17//4
print(c)
d=17%4
print(d)

Analyser les résultats obtenus.

L’opérateur puissance permet d’élever le nombre à gauche de l’opérateur à une certaine puissance mentionnée à droite de l’opérateur. La “puissance” correspond à la multiplication d’un nombre par lui même. Par exemple, écrire 2 ** 4 correspond à multiplier 2 par lui-même 4 fois ( = 2 * 2 * 2 * 2 = 16).

Les commentaires

Plus l’année va passer plus les programmes que vous rédigerez vont devenir complexe. Dans bien des cas il sera difficile, pour quelqu’un d’autre que vous, de comprendre votre code en une lecture. Pour compenser ce problème, vous êtes autorisés à écrire des notes dans votre programme que l’ordinateur ignore. Ces notes s’appellent des commentaires.

En Python, une ligne d’instructions qui contient le symbole # (dièse) signifie un commentaire. Le reste de la ligne sera ignoré quand le programme sera exécuté.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

a = 1 # Affectation de la valeur 1 à la variable a.
b = 2
c = 3
print(a) # Affichage de la valeur de la variable a.
# print(b)
print(c)

On observe alors que le script s’est exécuté sans problème mais que la valeur de la variable b n’a pas été affichée que l’instruction est commenté.

On utilise donc les commentaires pour décrire son code mais aussi passer sous silence certaines instructions. Cela peut être utile lorsque l’on veut exécuté qu’une seule partie de son code.

Pour commenter ou décommenter d’un seul coup plusieurs lignes on peut surligner ces lignes puis aller chercher la fonction commenter/décommenter dans le menu Edition de Thonny.

Cette année lorsque votre code sera complexe vous devrez le documenter (en mettant des commentaires).

Exercices

Faire les Exercices – 1ère partie

Les fonctions

En plus de devenir plus complexe, vos programmes vont devenir plus long avec des blocs d’instructions pouvant apparaitre à plusieurs reprises.

Pour éviter de s’y perdre, une approche efficace est de décomposer le programme en sous-programmes avec une tâche bien spécifique. Ces sous-programmes pourront alors être rappelé plusieurs fois dans le programme principale.

Une solution dans le langage Python est de définir des fonctions.

La syntaxe générale est la suivante :

def nom_fonction (liste des paramètres):
    bloc d'instructions
    return liste des valeurs renvoyées

Analyse :

Le mot clé def annonce que l’on va écrire une fonction ;
On commence par écrire le nom de notre fonction ;
Ensuite, entre parenthèses, on écrit ses paramètres séparés par des virgules ;
On termine la ligne par un deux points (:) ;
On indente (retrait par rapport à la marge (touche TAB)) et écrit toutes les instructions devant être exécutées ;
Enfin, le mot clé return permet de renvoyer le contenu d’une ou plusieurs variables (séparées par des virgules s’il y en a plusieurs)

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def carre(x):
    return x*x

Rien ne se passe, c’est normal. Vous avez simplement mis dans la mémoire la fonction carre. Nous pouvons maintenant l’appelé.

Dans la console, écrivez l’instruction suivante et appuyez sur entrée.

carre(4)

Cette fois-ci la fonction a été exécuté avec x = 4, elle a donc retourné la valeur 4 * 4 = 16.

x est appelé ici « paramètre » ou « argument » de la fonction carre.

Une fonction peut aussi prendre plusieurs arguments.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def formule(x,y,z):
    return 3*x+2*y-z

resultat = formule(2,3,4)
print(resultat)

Ici on a créé une variable resultat à laquelle on affecte la valeur retournée par la fonction formule.

Autre exemple avec les chaines de caractères.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def accueil(p):
    message = "Bonjour"
    message_perso = message + " " + p
    print(message_perso)
    
accueil("Ultia")
accueil("MisterMV")
accueil("Jeel")

Ici, on voit bien l’intérêt des fonctions pour ne pas répéter plusieurs fois les mêmes instructions.

Les opérateurs de comparaison

Nous avons pour l’instant vu seulement des instructions qui s’exécutaient successivement. Nous allons maintenant vouloir exécuter des instructions seulement dans certains cas. Pour juger ces cas nous allons avoir besoin de opérateur de comparaison.

Un opérateur de comparaison permet de comparer la valeur d’une variable à une certaine autre valeur donnée.

Voici ci-dessous les différents opérateurs de comparaison disponibles en Python :

Opérateur	Définition
==	Permet de tester l’égalité en valeur et en type
!=	Permet de tester la différence en valeur ou en type
<	Permet de tester si une valeur est strictement inférieure à une autre
>	Permet de tester si une valeur est strictement supérieure à une autre
<=	Permet de tester si une valeur est inférieure ou égale à une autre
>=	Permet de tester si une valeur est supérieure ou égale à une autre

Le résultat d’une comparaison sera une variable booléenne (qui peut donc prendre que deux valeurs : True ou False).

Dans la console, écrivez les instructions suivantes et appuyez sur entrée après chacune de ces instructions.

4 == 5

4 != 5

4 + 4 == 8

8 > 9

10 <= 12

"hello" == "hello"

Analyser les résultats obtenus.

Grâce à ces comparaisons et à l’introduction de structures conditionnelles nous allons pouvoir décider d’exécuter un code particulier en fonction du résultat de la comparaison.

Les structures conditionnelles (if/else/elif)

Les structures de contrôle conditionnelles (ou plus simplement conditions) vont nous permettre d’exécuter différents blocs de code selon qu’une condition spécifique soit vérifiée ou pas.

Nous allons très souvent utiliser les conditions avec des variables : selon la valeur stockée dans une variable, nous allons vouloir exécuter un bloc de code plutôt qu’un autre.

Python nous fournit les structures conditionnelles suivantes :

La condition if (“si”);
La condition if…else (“si…sinon”);
La condition if…elif…else (“si…sinon si… sinon”).

La syntaxe générale est la suivante :

if (condition):
    bloc d'instructions
elif (condition):
    bloc d'instructions
else :
    bloc d'instruction

Les conditions feront appel aux opérateurs de comparaison.

Essayons avec des exemples :

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def test(a,b):
    if a == b :
        print("Egalité")
    
test(4,5)
test(2,2)
test(2,3)

Analyser le résultat obtenu.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def test(a,b):
    if a == b :
        print("Egalité")
    else :
        print("Il n'y a pas d'égalité")


test(4,5)
test(2,2)
test(2,3)

Analyser le résultat obtenu.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def test(a,b):
    if a == b :
        print("Egalité")
    elif a < b :
        print("a inférieur à b")
    else :
        print("a supérieur à b")

test(4,5)
test(2,2)
test(2,3)

Analyser le résultat obtenu.

Les opérateurs booléens

Les opérateurs booléens vont permettre d’associer plusieurs expressions de comparaison.

Par exemple si l’on veut tester qu’une variable est supérieure à 8 ET inférieure à 15, au lieu d’écrire deux structures conditionnelles if à la suite, on va utiliser l’opérateur booléen ET.

En python l’opérateur ET se note « and« .

Dans la console, écrivez les instructions suivantes et appuyez sur entrée après chacune de ces instructions.

v = 7

v > 8

v < 15

v > 8 and v < 15

v = 14

v > 8 and v < 15

Finalement, le résultat de l’opération logique ET avec 2 expressions sera vrai si les 2 expressions sont vraies.

On peut réunir les différents cas de figure dans ce qu’on appelle table de vérité :

expression1	expression2	expression1 and expression2
vrai	vrai	vrai
vrai	faux	faux
faux	vrai	faux
faux	faux	faux

Nous serons aussi amené à utiliser l’opérateur logique OU qui se note « or« .

Le résultat de l’opération logique OU avec 2 expressions sera vrai si au moins une des 2 expressions est vraie.

Voilà sa table de vérité :

expression1	expression2	expression1 or expression2
vrai	vrai	vrai
vrai	faux	vrai
faux	vrai	vrai
faux	faux	faux

Vous pouvez essayer les différentes combinaisons vous-même.

v1 = True
v2 = False
print(v1 or v2)

La boucle for

La boucle for permet d’exécuter un code d’une manière répétitive un certain nombre de fois.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

for i in range (10):
    print(i)

L’instruction « print(i) » a été répétée 10 fois. La boucle for initialise la variable i à 0 pour l’emmener la valeur donnée après « range » – 1 par pas de 1. Donc de 0 à 9, ce qui fait bien 10.

La variable i est créée au moment où l’on définit la boucle for. On peut très bien lui donner un autre nom. On peut aussi décider de l’initialiser à un autre nombre que 0.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

for indice in range (4,10):
    print(indice)

On peut aussi faire augmenter la variable différemment à chaque passage de boucle.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

for indice in range (4,20,2):
    print(indice)

Nous verrons aussi d’autre cas d’utilisation de la boucle for.

On pourra alors répéter plusieurs instructions plusieurs fois grâce à la boucle for.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

v=1
for i in range (10):
    v=v*2
    print(v)

Analyser le résultat obtenu.

La boucle for permet aussi de parcourir tous les éléments d’un objet.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

message = "Salut c'est cool"
for i in range (16) :
    print(message[i])

Ce script permet d’afficher un à un les caractères de la variable message.

Pour éviter de compter les caractères de la variable message et la rentrer dans les paramètre de la boucle on peut utiliser la fonction len vu plus haut :

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

message = "Salut c'est cool"
for i in range (len(message)) :
    print(message[i])

Pour encore nous faciliter la tâche, avec le boucle for, Python nous permet de parcourir directement les éléments d’une chaine de caractère ou d’un autre objet.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

message = "Salut c'est cool"
for element in message :
    print(element)

On sera aussi amené à utiliser des boucles imbriquées.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

for i in range (5):
    for j in range (3):
        print(i*j)

Analyser le résultat obtenu.

La boucle while

La boucle while (qui signifie « tant que ») permet aussi de répéter plusieurs fois une ou plusieurs instructions mais cette fois-ci avec nombre de fois non défini.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

def repetition(n):
    i = 0
    while (i != n):
        print("Bienvenue")
        i+=1
        
repetition(5)

Note : l’instruction « i+=1″ permet d’ajouter 1 à la variable i (donc équivaut à « i=i+1 »).

Analyser le résultat obtenu.

Finalement, la boucle sera exécuté tant que la condition (entre parenthèse) est vraie après le while.

Dans l’éditeur, écrire les instructions suivantes puis exécuter le programme :

motdepasse = input("Rentrez le mot de passe : ")
while (motdepasse != "1234"):
    print("mot de passe erroné")
    motdepasse = input("Rentrez le mot de passe : ")
print("mot de passe correct !")

Note : la fonction « input() » permet de demander à l’utilisateur du programme de rentrer une valeur. Ici la valeur rentré sera stocké dans la variable « motdepasse« .

Analyser le résultat obtenu.

Exercices

Faire les Exercices – 2ème partie