Programmer, c'est créer des programmes (suite d'instructions données à l'ordinateur) !
Un ordinateur sans programme ne sait rien faire. Il existe différents langages qui permettent de programmer un ordinateur.
Le seul langage directement utilisable par le processeur est le langage machine (suite de 1 et de 0).
Aujourd'hui (presque) plus personne ne programme en langage machine (trop compliqué).
Les informaticiens utilisent des instructions (mots souvent en anglais) en lieu et place de la suite de 0 et de 1.
Ces instructions, une fois écrites par le programmeur, sont « traduites » en langage machine.
Un programme spécialisé assure cette traduction.
Ce système de traduction s'appellera interpréteur ou bien compilateur, suivant la méthode utilisée pour effectuer la traduction.
Il existe 2 grandes familles de langages de programmation :
ils sont très complexes à utiliser, car très éloignés du langage naturel, on dit que ce sont des langages « proches de la machine », en contrepartie ils permettent de faire des programmes très rapides à l'exécution.
L'assembleur est le langage de bas niveau. Certains "morceaux" de programmes sont écrits en assembleur encore aujourd'hui.
il sont eux plus "faciles" à utiliser, car plus proches du langage naturel (exemple : si a = 3 alors b = c).
Exemples de langages de haut niveau : C, C++ , Java, Python...
Pour cette année, en NSI, nous allons apprendre les bases de la programmation en utilisant le langage Python.
Première Utilisation
Sur votre espace réseau personnel de l’ENT, dans le dossier NSI (à créer si il n’existe pas), créer un sous dossier PROGRAMMATION et à l’intérieur un sous dossier Python_Bases.
lancer le logiciel Spyder.
Vous obtenez la fenêtre suivante :
Spyder se divise en plusieurs fenêtres, deux fenêtres vont principalement nous intéresser : la fenêtre "éditeur" et la fenêtre "interpréteur" ou "console".
On retrouve la même structure avec d’autres interfaces
L’interpréteur (ou console)
L’interpréteur, on le reconnait facilement.
C’est lui qui contient le triple chevron >>>
qui est l’invite de Python (prompt en anglais) et qui signifie que Python attend une commande.
On peut trouver aussi à la place un interpréteur en IPython.
L’esprit d’utilisation de l’interpréteur est un peu le même que celui d’une calculatrice.
L’éditeur
On peut y écrire des scripts, c’est-à-dire des programmes petits ou grands.
Pour l’instant contentons-nous de quelque chose de très simple :
Dans la fenêtre "éditeur", saisissez le programme suivante :
print("hello world !")
Sauvegarder le texte source du programme dans un fichier d'extension .py .
(On sauvegarde ici le fichier hello.py dans le répertoire NSI /PROGRAMMATION/ Python_Bases)
Cliquez sur le "triangle vert" afin d'exécuter le programme qui vient d'être saisi.
Vous devez voir le message "hello world !" apparaître dans la fenêtre de l'interpréteur
Définition du mot ordinateur d'après "Le Petit Larousse" :
"Machine automatique de traitement de l'information, obéissant à des programmes formés par des suites d'opérations arithmétiques et logiques."
Qui dit "traitement de l'information", dit donc données à manipuler. Un programme "passe" donc son temps à traiter des données.
Pour pouvoir traiter ces données, l'ordinateur doit les ranger dans sa mémoire (RAM - Random Access Memory).
La RAM se compose de cases dans lesquelles nous allons ranger ces données (une donnée dans une case).
Chaque case a une adresse (ce qui permet au processeur de savoir où sont rangées les données).
Alors, qu'est-ce qu'une variable ?
Eh bien, c'est une petite information (une donnée) temporaire que l'on stocke dans une case de la RAM.
On dit qu'elle est "variable", car c'est une valeur qui peut changer pendant le déroulement du programme.
Une variable est constituée de 2 choses :
Il est possible de stocker différents types de valeur dans une variable (on parle du type d'une variable) :
Voyons comment nous pouvons définir une variable et lui affecter une valeur.
Les termes « affecter une valeur » ou « assigner une valeur » à une variable sont équivalents.
Ils désignent l’opération par laquelle on établit un lien entre le nom de la variable et sa valeur (son contenu).
En Python comme dans de nombreux autres langages, l’opération d’affectation est représentée par le signe égale « ** = ** ».
Il faut s’efforcer cependant de bien les choisir : de préférence assez courts, mais aussi explicites que possible, de manière à exprimer clairement ce que la variable est censée contenir.
Par exemple, des noms de variables tels que compteur, cmpt ou cpt conviennent mieux que x pour exprimer un compteur.
Un bon programmeur doit veiller à ce que ses lignes d’instructions soient faciles à lire.
Sous Python, les noms de variables doivent en outre obéir à quelques règles simples :
un nom de variable est une séquence de lettres et de chiffres (0 → 9), qui doit toujours commencer par une lettre.
Seules les lettres ordinaires sont autorisées.
Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux tels que $, #, @,etc. sont interdits, à l’exception du caractère _ (souligné).
La casse est significative (les caractères majuscules et minuscules sont distingués).
Prenez l’habitude d’écrire l’essentiel des noms de variables en caractères minuscules (y compris la première lettre).
Il s’agit d’une simple convention, mais elle est largement respectée.
On doit écrire : point_de_vie (écriture privilégié sous python)
On peut écrire aussi : pointDeVie
Dans la partie "éditeur" de Spyder, saisissez le code suivant :
point_de_vie = 15
Après avoir exécuté le programme en cliquant sur le triangle vert, il est possible de connaitre la valeur référencée par une variable en utilisant la partie "console" de Spyder.
Dans le cas qui nous intéresse ici, tapez point_de_vie dans la console
Après avoir appuyé sur la touche "Entrée", vous devriez voir la valeur référencée par la variable point_de_vie s'afficher dans la console.
N.B. : Dans la suite la procédure sera toujours la même :
Écrire un programme dans lequel on attribue la valeur 12 à la variable point_de_force. La valeur référencée par la variable point_de_force devra ensuite être affichée dans la console.
Nous venons de voir qu'une variable peut référencer un nombre entier, mais elle peut aussi référencer un nombre à virgule :
i = 5.2
Prenez bien garde, nous utilisons un point à la place d'une virgule (convention anglo-saxonne).
Une variable peut donc référencer plusieurs types d'entités (pour l'instant nous n'en avons vu que deux, mais nous en verrons d'autres plus loin) : les nombres entiers ("integer" en anglais, abrégé en "int") et les nombres à virgule ("float" en anglais). Il est possible de connaitre le type de l'entité référencé par une variable à l'aide de l'instruction "type".
Testez le programme suivant :
a = 5.2
b = 12
tapez type(a) puis type(b) dans la console
Comme vous pouvez le constater, le type de la grandeur référencée par la variable a et le type de la grandeur référencée par la variable b s'affichent dans la console
Un ordinateur est bien évidemment capable d'effectuer des opérations mathématiques (arithmétiques).
Les signes utilisés sont classiques : +, - , * (multiplication), / (division), // (division euclidienne) ou encore % (modulo : reste d'une division euclidienne).
Il est tout à fait possible d'effectuer des opérations directement avec des nombres, mais il est aussi possible d'utiliser des variables.
Essayez d'écrire un programme qui additionnera le contenu de 2 variables (nom des variables : a et b). Le résultat de cette opération devra être référencé par une troisième variable nommée resultat (atention pas d'accent dans les noms de variable). Testez votre programme en utilisant la console pour vérifier la valeur référencée par la variable resultat.
D'après vous, que fait ce programme ?
a = 11
a = a + 1
Vérifiez votre réponse en exécutant le Programme (utilisation dans console pour déterminer la valeur référencée par la variable a à la fin du programme)
Détaillons ce qui se passe dans le "À faire vous-même 6":
La suite est un peu plus complexe, mais très importante à comprendre. Il va falloir lire la ligne "a = a + 1" de droite à gauche, décortiquons cette ligne :
Ce raisonnement peut être généralisé pour éviter des erreurs parfois difficiles à corriger : dans une égalité, commencer toujours par évaluer l'expression se trouvant à droite du signe égal.
Il est aussi possible d'effectuer des calculs plus complexes en utilisant par exemple des exposants, des racines carrées, des fonctions trigonométriques...
Pour utiliser ces fonctions mathématiques plus avancées, il est nécessaire d'ajouter une ligne au début de votre programme :
import math
Cette ligne permet d'importer (et donc d'utiliser) le module "math" (ce module contient toutes les fonctions mathématiques "classiques").
Voici quelques exemples :
Si vous avez besoin d'autres fonctions mathématiques, je vous invite à consulter la documentation de Python : https://docs.python.org/3/library/math.html
Quelles sont les valeurs référencées par les variables d, e, f, g, h et i après l'exécution du programme suivant :
import math
a = 5
b = 16
c = 3.14 / 2
d = b / a
e = b // a
f = b % a
g = math.pow(a,2)
h = math.sqrt(b)
i = math.sin(c)
Vérifiez vos réponses à l'aide de la console
À noter qu'il est tout à fait possible de "mélanger" des nombres entiers et des nombres à virgules ("3.14 / 2") dans une opération.
Écrire un programme permettant de répondre à la question suivante : "Quel est le type du résultat d'une addition d'un integer et d'un float ?"
Les variables peuvent aussi référencer des suites de caractères, que l'on appelle "chaîne de caractères".
Tester le code suivant :
ma_chaine = "Bonjour le monde !"
Vérifiez que la variable ma_chaine référence la chaîne de caractères "Bonjour le monde !"
L'utilisation du signe + ne se limite pas à l'addition. Il est aussi utilisé pour la concaténation.
D'après Wikipédia :
« Le terme concaténation (substantif féminin), du latin cum («avec») et catena(«chaîne, liaison»), désigne l'action de mettre bout à bout au moins deux chaînes. »
Comme vous avez pu le deviner en lisant la définition ci-dessus, la concaténation va concerner les chaînes de caractères.
Quelle est la chaîne de caractère référencée par la variable mon_expression après l'exécution du programme ci-dessous ? Validez votre réponse en testant ce programme.
a = "Hello"
b = "World"
mon_expression = a + b
Il est aussi possible de concaténer une chaîne de caractères et une ou plusieurs variables :
Testez le code suivant :
ma_chaine_1 = "Bonjour "
ma_chaine_2 = "le "
res = ma_chaine_1 + ma_chaine_2 + "monde!"
Les 2 variables ma_chaine_1 et ma_chaine_2 référencent 2 chaînes de caractères, nous avons donc bien ici une concaténation.
Mais que se passe-t-il si la variable référence un nombre (entier ou flottant) ?
Testez le code suivant :
mon_nombre = 5
res = "Nombre de personnes : " + mon_nombre
Comme vous pouvez le constater, nous avons droit à une erreur. En effet, il n'est pas possible de concaténer une chaîne de caractères et un nombre.
Python nous offre 2 solutions :
La méthode (nous verrons plus loin la notion de méthode) "str" permet de transformer un nombre en chaîne de caractères (si la transformation n'est pas possible, nous aurons une erreur)
Testez le code suivant :
mon_nombre = 5
mon_nombre = str(mon_nombre)
Quel est le type de la valeur référencée par la variable mon_nombre après l'exécution du programme ci-dessus ?
Testez le code suivant :
mon_nombre = 5
res = "Nombre de personnes : " + str(mon_nombre)
Tout fonctionne, car maintenant nous avons bien une concaténation entre 2 chaînes de caractères.
Les "fstring" (nouveauté de Python 3.5), permettent de résoudre ce problème de combinaison variable-chaîne de caractères.
Testez le code suivant :
mon_nombre = 5
res = f"Nombre de personnes : {mon_nombre}"
Notez la présence du "f" juste avant le guillemet et des accolades qui encadrent le nom de la variable. Il est possible, dans une même chaîne de caractères d'avoir plusieurs noms de variable.
Les fonctions permettent de décomposer un programme complexe en une série de sous-programmes plus simples. De plus, les fonctions sont réutilisables : si nous disposons d'une fonction capable de calculer une racine carrée, par exemple, nous pouvons l'utiliser un peu partout dans notre programme sans avoir à la réécrire à chaque fois (on parle de factorisation du code)
La notion de fonction en informatique est comparable à la notion de fonction en mathématiques.
Si nous avons y = 3x+2, pour une valeur donnée de x, nous aurons une valeur de y.
Exemple : x=4 donc y= 14 (y = 3.4+2=14, attention ici le point correspond au signe "multiplié").
La fonction en informatique est basée sur la même idée :
Voici la syntaxe employée en Python pour définir une fonction :
def nom_de_la_fonction(parametre):
instruction_1
instruction_2
return y
suite programme
La fonction renvoie la valeur contenue dans la variable y.
ATTENTION : Notez bien la présence du décalage entre la première ligne et les lignes suivantes. Ce décalage est appelé indentation, l'indentation permet de définir un bloc de code. Dans l'exemple ci-dessus, l'indentation nous permet de savoir que "instruction_1", "instruction_2" et "return y" constituent un bloc de code, ce bloc correspond au contenu de la fonction. "suite programme" ne fait pas partie de la fonction, car il n'est pas indenté. Pour indenter du code, il y a 2 solutions : mettre 4 espaces ou utiliser une tabulation. En Python il est conseillé d'utiliser les 4 espaces, mais ce n'est pas une obligation. Une chose est sûre, une fois que vous avez choisi une méthode, n'en changé surtout pas au cours d'un même programme !
Codons notre exemple (y=3x+2) en créant une fonction ma_fonction :
def ma_fonction(x):
y = 3 * x + 2
return y
Pour "utiliser" la fonction ma_fonction, il suffit d'écrire : ma_fonction (4) (dans ce cas précis, notre fonction renverra le nombre 14).
Testez le programme suivant (quelle est la valeur référencée par la variable solution après l'exécution du programme) :
def ma_fonction(x):
y = 3 * x + 2
return y
solution = ma_fonction(4)
Il faut savoir qu'au moment de l'exécution de votre programme le code ma_fonction(4) sera systématiquement remplacé par la valeur renvoyée par la fonction (toujours dans notre exemple le ma_fonction(4) sera remplacé par le nombre 14).
Codez en Python la fonction y = x2+2x+10
Il est possible d'écrire une fonction dans l'éditeur :
et d'utiliser la console (après exécution du programme) pour obtenir la valeur renvoyée par une fonction
Il est possible de faire passer plusieurs paramètres à une fonction.
Quel est le résultat renvoyé par la fonction ci-dessous si l'on saisit dans la console une_autre_fonction(5, 3)
def une_autre_fonction(x, b):
y = 3 * x + b
return y
Les paramètres peuvent être des chaînes de caractères (ainsi que la valeur retournée)
Quel est le résultat attendu après l'exécution du programme ci-dessous et la saisie dans la console de "dit_bonjour("toto", 14)" ?
def dit_bonjour(nom, age):
phrase = f"Bonjour {nom}, vous avez {age} ans."
return phrase
Attention : remarquez bien les guillemets autour du paramètre "toto" (c'est une chaîne de caractères)
Les paramètres ne sont pas obligatoires.
Testez la fonction suivante :
def ma_fon():
return "voici une fonction qui ne sert à rien"
Il faut aussi savoir qu'une fonction ne renvoie pas forcément de valeur (le mot clé return n'est pas obligatoire). Mais si elle ne renvoie pas de valeur, que fait-elle ? Elle peut faire plein de choses, par exemple elle peut tout simplement afficher une chaîne de caractères à l'aide d'un "print". Sachez que dans certains langages, on utilise les termes méthode ou procédure pour qualifier une fonction "qui ne renvoie rien".
Soit le programme suivant :
def dit_bonjour(nom, age):
phrase = f"Bonjour {nom}, vous avez {age} ans."
print(phrase)
Testez la fonction dit_bonjour à l'aide de la console (avec par exemple un dit_bonjour("toto", 14))
Analysez le programme suivant :
def fct():
i=5
fct()
Après avoir exécuté le programme ci-dessus, déterminez la valeur référencée par la variable i en utilisant la console.
Comme vous avez pu le constater, nous avons eu droit à une erreur : "NameError: name 'i' is not defined". Pourquoi cette erreur, la variable i est bien définie dans la fonction fct() et la fonction fct() est bien exécutée, où est donc le problème ?
En fait, la variable i est une variable dite locale : elle a été définie dans une fonction et elle "restera" dans cette fonction. Une fois que l'exécution de la fonction sera terminée, la variable i sera "détruite" (supprimée de la mémoire). Elle n'est donc pas accessible depuis "l'extérieur" de la fonction (ce qui explique le message d'erreur que nous obtenons).
Autre exemple de cette notion de variable locale :
Analysez le programme suivant :
i = 3
def fct():
i=5
fct()
Après avoir exécuté le programme ci-dessus, déterminez la valeur référencée par la variable i en utilisant la console.
Cette fois pas d'erreur, mais à la fin de l'exécution de ce programme, la variable i référence la valeur 3. En faite dans cet exemple nous avons 2 variables i différentes : la variable i "globale" (celle qui a été définie en dehors de toute fonction) et la variable i "locale" (celle qui a été définie dans la fonction). Ces 2 variables portent le même nom, mais sont différentes.
Une variable globale peut être "utilisée" à l'intérieur d'une fonction :
Analysez et testez le programme suivant :
i = 3
def fct():
print(i)
fct()
Quand on cherche à utiliser une variable dans une fonction, le système va d'abord chercher si cette variable se "trouve" dans l'espace local de la fonction, puis, s'il ne la trouve pas dans cet espace local, le système va aller rechercher la variable dans l'espace global. Pour le "print(i)" situé dans la fonction le système ne trouve pas de variable i dans l'espace local de la fonction "fct", il passe donc à l'espace global et trouve la variable i (nous avons donc 3 qui s'affiche). Il est important de bien comprendre que si le système avait trouvé une variable i dans l'espace local de la fonction, la "recherche" de la variable i se serait arrêtée là :
Analysez et testez le programme suivant :
i = 3
def fct():
i = 5
print(i)
fct()
Analysez et testez le programme suivant :
i = 3
def fct():
i = i + 1
fct()
Nous avons une erreur "UnboundLocalError: local variable 'i' referenced before assignment"
Pour pouvoir modifier une variable globale dans une fonction, il faut utiliser l'instruction "global" :
Analysez le programme suivant :
i = 3
def fct():
global i
i = i + 1
fct()
Après avoir exécuté le programme ci-dessus, déterminez la valeur référencée par la variable i en utilisant la console.
En faite, l'utilisation de "global" est une (très) mauvaise pratique, car cette utilisation peut entrainer des "effets de bord".
On parle d'effet de bord quand une fonction modifie l'état d'une variable globale. Dans notre exemple ci-dessus la fonction fct modifie bien la valeur référencée par la variable i : avant l'exécution de fct, la variable i référence la valeur 5, après l'exécution de la fonction fct la variable i référence la valeur 6. Nous avons donc bien un effet de bord.
Les effets de bord c'est "mal" ! Mais pourquoi est-ce "mal" ?
Les effets de bords provoquent parfois des comportements non désirés par le programmeur (évidemment dans des programmes très complexes, pas dans des cas simplistes comme celui que nous venons de voir dans l'Exercice 26). Ils rendent aussi parfois les programmes difficilement lisibles (difficilement compréhensibles). À cause des effets de bord, on risque de se retrouver avec des variables qui référenceront des valeurs qui n'étaient pas prévues par le programmeur. On dit aussi qu'à un instant donné, l'état futur des variables est difficilement prévisible à cause des effets de bord. En résumé, on évitera autant que possible l'utilisation du "global".
Un paradigme de programmation se propose d'éviter au maximum les effets de bords : la programmation fonctionnelle. Nous étudierons ce paradigme de programmation en terminale.
Si quelqu'un vous dit que "4 est égal à 5", vous lui répondez quoi ? "c'est faux". Si maintenant la même personne vous dit que "7 est égal à 7", vous lui répondrez bien évidemment que "c'est vrai".
En Python, ces deux «affirmations» ("4 est égal à 5" et "7 est égal à 7") s'écriront "4 == 5" et "7 == 7" (notez bien le double signe égal).
Dans la console, tapez :
4 == 5
En Python, "4 == 5" est appelé une expression, une expression est soit vraie ("True"), soit fausse ("False").
Pour l'instant nous avons vu deux grands types de données : les nombres (entier ou flottant) et les chaînes de caractères, il existe un troisième type tout aussi important que les deux premiers : les booléens. Un booléen est un type de données qui ne peut prendre que deux valeurs : vrai ("True") ou faux ("False"). Une expression (comme par exemple "4 == 5") est soit True, soit False.
ATTENTION : notez le double égal "==" qui permet de distinguer une expression et une affectation (référencement d'une valeur par une variable). Le fait de confondre le "simple égal" et le "double égal" est une erreur classique qu'il faut éviter.
Soit le programme suivant :
a = 4
b = 7
Quel est le résultat attendu après l'exécution de ce programme si vous saisissez dans la console "a==b" ?
Il est possible d'utiliser aussi l'opérateur "différent de" !=
Soit le programme suivant :
a = 4
b = 7
Quel est le résultat attendu après l'exécution de ce programme si vous saisissez dans la console "a!=b" ?
Notez aussi l'existence des opérateurs :
À chaque fois ces opérateurs sont True (vrai) ou False (faux).
Soit le programme suivant :
a = 4
b = 7
Quel est le résultat attendu après l'exécution de ce programme si vous saisissez dans la console "a<b" ?
Nous allons maintenant étudier une structure fondamentale en programmation le « si ...... alors.......sinon........».
L'idée de base est la suivante :
si expression:
suite_instruction1
sinon:
suite_instruction2
Si "expression" est True alors "suite_instruction1" est exécuté et "suite_instruction2" est ignoré.
Sinon (sous-entendu que "expression" est False) "suite_instruction2" est exécuté et "suite_instruction1" est ignoré.
Notez l'indentation "suite_instruction1" et de "suite_instruction2"
Soit le programme suivant :
a = 4
b = 7
if a < b:
print("Je suis toto.");
print("Je n'aime pas titi.")
else:
print("Je suis titi.")
print("Je n'aime pas toto.")
print("En revanche, j'aime le Python.")
Quel est le résultat attendu après l'exécution de ce programme ?
Vérifiez votre hypothèse en testant le programme.
Écrire une fonction qui prend en paramètre un age. Si age est supérieur ou égal à 18 ans, la fonction devra renvoyer la chaîne de caractères "Bonjour, vous êtes majeur.". Si age est inférieur à 18 ans, la fonction devra renvoyer "Bonjour, tu es mineur."
Soit le programme suivant :
def annonce(num, prov, dest):
if dest != "0":
msg = f"le train n° {num} en provenance de {prov} et à destination de {dest}, entre en gare."
else:
msg = f"le train n° {num} en provenance de {prov} entre en gare. Ce train est terminus Triffouillis-les-Oies."
return msg
Quel est le résultat attendu après l'exécution de ce programme si vous saisissez dans la console annonce("4557", "Paris", "Marseille") ? Et si vous saisissez dans la console annonce("5768", "Bonneville", "0") ? Vérifiez votre réponse en testant ce programme.
Vous êtes gérant d'un magasin et vous désirez écrire un programme Python qui calculera automatiquement le montant de la facture des clients. Tout client qui achète au moins 5 fois le même article se voit octroyer une remise de 5 % (uniquement sur le montant de l'achat de cet article). Afin de simplifier le problème, on considère qu'un client n'achète qu'un seul type d'article. Écrire une fonction qui prend en paramètre le prix unitaire de l'article et le nombre d'articles achetés. Cette fonction doit renvoyer le montant de la facture.
Un if peut contenir plusieurs conditions, nous aurons alors une structure de la forme :
si expression1 op_logique expression2:
suite_instruction1
sinon:
suite_instruction2
« op_logique » étant un opérateur logique.
Nous allons étudier 2 opérateurs logiques : le "ou" (noté en Python "or") et le "et" (noté en Python "and").
Par exemple (expression1 or expression2) est vrai si expression1 est vraie et expression2 est vraie.
Autre exemple (expression1 and expression2) est faux si expression1 est vraie et expression2 est faux.
Les résultats peuvent être regroupés dans ce que l'on appelle une table de vérité :
expression1 | expression2 | expression1 or expression2 |
---|---|---|
vrai | vrai | vrai |
vrai | faux | vrai |
faux | vrai | vrai |
faux | faux | faux |
expression1 | expression2 | expression1 and expression2 |
---|---|---|
vrai | vrai | vrai |
vrai | faux | faux |
faux | vrai | faux |
faux | faux | faux |
Soit le programme suivant :
a = 5
b = 10
if a > 5 and b == 10:
print ("Toto")
else:
print("Titi")
if a > 5 or b == 10:
print ("Tata")
else:
print("Tutu")
Quel est le résultat attendu après l'exécution de ce programme ? Vérifiez votre réponse en testant ce programme.
Il existe aussi l'opérateur logique "not" ("non" en français) :
expression | not(expression) |
---|---|
vrai | faux |
faux | vrai |
La notion de boucle est fondamentale en informatique. Une boucle permet d'exécuter plusieurs fois des instructions qui ne sont présentes qu'une seule fois dans le code.
La structure de la boucle while est la suivante :
while expression:
instruction1
instruction2
suite programme
Tant que l'expression s'évalue à "True", les instructions à l'intérieur du bloc (partie indentée) seront exécutées.
Soit le programme suivant :
i = 0
while i < 10:
print(f"i vaut : {i}")
i = i + 1
print("C'est terminé.")
Quel est le résultat attendu après l'exécution de ce programme ? Vérifiez votre réponse en testant le programme
Vous allez créer "un générateur automatique de punition" :
Écrire une fonction qui prendra 2 paramètres : une chaîne de caractère et un nombre entier
Par exemple :
Si on passe comme paramètres à notre fonction : "Je ne dois pas discuter en classe" et 3
La fonction devra permettre d'afficher :
Je ne dois pas discuter en classe
Je ne dois pas discuter en classe
Je ne dois pas discuter en classe
Écrire une fonction permettant d'afficher une table de multiplication. Cette fonction devra prendre en paramètre la table désirée.
Par exemple si l'on passe le paramètre 3 à la fonction, la fonction devra permettre d'afficher :
1 x 3 = 3
2 x 3 = 6
...
...
10 x 3 = 30
Il existe un autre type de boucle : la boucle for
La structure de la boucle for est la suivante :
for i in range(a, b)):
instruction1
instruction2
suite programme
Nous aurons ici une boucle où la variable i prendra toutes les valeurs entières comprises entre a et b (a inclus et b exclu).
Soit le programme suivant :
for i in range(0, 10)):
print(f"i vaut : {i}")
print("C'est terminé.")
Quel est le résultat attendu après l'exécution de ce programme ? Vérifiez votre réponse en testant le programme
Refaire l'exercice 37 avec la boucle for:
Refaire l'exercice 38 avec la boucle for:.
Auteur : Andjekel - Source : David Roche