Les maths du yeti


Le yeti explorateur de mathématiques

Python : les bases

Python dans Visual Studio Code

Ce tutoriel a pour objectif de vous familiariser avec un IDE ( Environnement de développement ) installé sur les poste du lycée.

Nous abrègerons son nom par la suite en VSCode.


Étape 1 : créer un fichier python dans VSCode

Ouvrez VSCode et créez un nouveau fichier (Raccourci CTRL + N )

Enregistrez-le sous le nom hello.py dans le dossier NSI/Langages_et_programmation/ de votre espace personnel.

Remarque : c'est l'extension du fichier qui permet au logiciel de savoir quel langage utiliser.

VSCode vous demandera d'installer une extension Python, acceptez.

Cette extension activera entre autre :

  • la possibilité de "lancer" le code depuis VSCode
  • l'auto-complétion , c'est à dire des propositions pour poursuivre le code en fonction de ce qui existe (variable déjà créées, type d'objet ...)
    C'est très pratique pour éviter les fautes de frappe lors de l'utilisation de variables.
  • la coloration syntaxique (coloration des mots clés, variables ...)
  • le linter (qui améliore la syntaxe du code, indique des erreurs) voir cet article pour des compléments
  • le debugger , nous en reparlerons plus loin
  • les snippets qui sont des raccourcis qui s'activent avec CTRL + espace (par exemple def vous propose un "modèle" pour créer une fonction)
  • le support des tests (nous en reparlerons dans un prochain chapitre)

Étape 2 : Créons du code.

Saisissez (sans copier coller pour tester l'autocomplétion), vous constaterez que en tapant le début de message sur la seconde ligne que l'éditeur vous propose la suite du texte. Appuyez sur les touches fléchées pour sélectionner le bon code, puis sur entrée

message = "hello world !"
message += " C'est moi"

autocomplétion

Ajoutez ensuite le code :

print(message)

Quand vous commencez à écrire print appuyez sur CTRL + espace vous obtiendrez la complétion et l'affichage de la documentation (en anglais) de la fonction.


Étape 3 : Exécuter le code.

Faites un clic droit sur un espace vide du fichier, puis cliquez sur "Exécuter le script dans un terminal"

En bas de la fenêtre, un TERMINAL s'ouvre et vous verrez le résultat recherché (puisqu'un print a été initié)

 

Une autre méthode est de sélectionner une ou plusieurs ligne et de taper CTRL + Entrée

Attention, dans ce cas, seules les lignes sélectionnées sont lancées dans l'interprétateur Python, si vous le faîtes juste sur print(message) vous obtiendrez un message d'erreur vous indiquant que la variable message n'est pas déclarée.

Par contre si vous sélectionnez toutes les lignes et que vous utilisez CTRL + Entrée alors vous obtiendrez l'affichage attendu.


Le debbuger

Un debugger (ou Débogueur) est un outil qui vous permettra de traquer les erreurs qui ne manqueront pas de survenir. C'est normal, on apprend de nos erreurs !

Pour cela, il permet d'exécuter le programme pas-à-pas — c'est-à-dire le plus souvent lignes par ligne —, d'afficher la valeur des variables à tout moment, de mettre en place des points d'arrêt sur des conditions ou sur des lignes du programme.


Ajoutez les lignes suivantes :

message = message.capitalize()
message 
= message.upper()
message 
= message + 4

Nous allons ajouter des "points d'arrets" à ce programme pour suivre l'évolution de la variable message au fil du script.

Pour cela, cliquez sur la gauche des numéros de lignes pour faire apparaître des points rouge comme ceci :

Ensuite appuyez sur F5 (ou sinon déboguer/démarrer le déboguage), cliquez ensuite sur python file.

La touche F5 permet d'avance d'un point d'arrêt à un autre.

Un clic droit sur une variable, puis sur "ajouter à la fenêtre espion"  permet de suivre plus particulièrement une variable.

Le dernier point d'arret devrait vous afficher une erreur assez explicite sur le problème soulevé par la dernière instruction.


LE TERMINAL.

Quittez le debugger (Maj + F5)

Le terminal est en bas de votre fenêtre  (CTRL + ù  ) ou ( menu :  Terminal /  nouveau terminal) pour le rouvrir si besoin.

C'est ici que vous pouvez entrer des lignes de commande directement à votre OS (windows, linux , MacOs ...)

Essayez la commande ls (ou dir sous Windows 7) qui liste les fichiers et dossiers de votre dossier de travail actuel.

Dernier test : dans le terminal : entrez la commande jupyter-notebook

Si vous obtenez un message d'erreur, merci de prévenir le professeur.

Cela termine ce tutoriel, n'hésitez pas à le relire en cours d'année.

TP variables et types.

Créez un fichier variables.py dans votre dossier NSI/Langages_de_programmation/1_variables_et_types/

Python est un langage à typage dynamique. Cela signifie que lorsqu'une variable est affectée, l'interpréteur trouvera automatiquement son type sans que l'utilisateur soit contraint de le préciser.

Pour connaître le type d'une donnée ou le type de la valeur d'une variable, il suffit d’utiliser la fonction type().

Entrez le code suivant dans votre fichier python :

= 3
= 3.14
= "Premier script de l'année"
= True
# Affichage des variables et de leurs types.
print("La variable a est de type ",type(a))
print("La variable b est de type "type(b))
print("La variable c est de type "type(c))
print("La variable d est de type "type(d))

Le code suivit d'un # est un commentaire qui n'est pas pris en compte par l'interpréteur Python.

Question : rappeler les différent types de variables rencontrés en commentaire dans votre fichier python.

 


Saisissez le code suivant :

largeur = 12
longueur = 7.5
aire = longueur*largeur

Question : Dans le code ci-dessus, quel sera le type de la variable aire ? Ecrivez votre réponse dans le code. Vérifiez avec python en ajoutant une ligne de code.


Saisissez le code suivant :

largeur = 12
longueur = 7
aire = longueur*largeur

 Question : Dans le code ci-dessus, quel sera le type de la variable aire ? Ecrivez votre réponse dans le code. Vérifiez avec python en ajoutant une ligne de code

Le type d'une variable obtenue suite à un calcul peut varier suivant les types des variables utilisées dans le calcul.


Voic un tableau des opération sur les nombres en python.

Opérations Symboles Exemples
addition + 2 + 4 donne 6
soustraction - 10 - 2 donne 8
multiplication * 8 * 7 donne 56
exponentiation (puissance) ** 4 ** 3 donne 4*4*4=64
 
division / 7 / 2 donne 3.5
reste de division entière %

9 % 4 donne 1

car 9 = 4*2 + 1

quotient de division entière //

7 // 3 donne 2

car 7 = 3*2 + 1

Testons un peu tout cela 😵

Question :Avant d'entrer le code suivant et d'afficher les résultats, écrivez ce que vous pensez être les valeurs de ces 6 variables avant de vérifer par vous-même !

priorite1 = 1 + 2 * 5 #Je pense que priorite1 vaut ...
priorite2 = (1 + 2* 5 #Je pense que priorite2 vaut ...
octet = 2**8 #Je pense que octet vaut ...
pair = 745 % 2 #Je pense que pair vaut ...
diviser1 = 15/2 #Je pense que diviser1 vaut ...
diviser2 = 15//2 #Je pense que diviser2 vaut ...

Conversions

Il existe deux genre de conversion de type, les implicites et les explicites

Les conversions implicites sont celles qui se produisent sans que le programmeur ne le demande, exemple :

num_int = 123
num_flo = 1.23
 
num_new = num_int + num_flo
 
print("type de num_int:"type(num_int))
print("type de num_flo:"type(num_flo))
 
print("Valeur de num_new:", num_new)
print("type de num_new:"type(num_new)) 

Ici nous assistons à une conversion implicite de int (entier) vers float (flottant) lors de l'addition.

 

Passons à l'autre type de conversion, celle qui est est explicitement demandée par le codeur. Voici une liste des fonctions de conversion :

Il existe plusieurs fonctions qui permettent de forcer le type d'une variable en un autre type :

  • int() : permet de modifier une variable en entier.
  • float() : permet la transformation en flottant.
  • str() : permet de transformer la plupart des variables d'un autre type en chaînes de caractère.
rep_utilisateur = input('Quel est ton age ?')

 Question :Compléter le code suivant pour afficher l'age de la personne l'année prochaine avec un affichage du style : 'L'an prochain tu aura x ans."

 

Compléments sur les print() .

Si vous donnez plusieurs paramètres à un print, ceux-ci seront afficher les uns à la suite des autres séparés par des espaces.

print("Dans un an tu auras : ",rep_utilisateur+1," ans")

 

Une autre méthode est de "formater" une chaine de caractère pour l'afficher ensuite avec print. Exemple :

article0 , article1, article2 = 'café'"thé""pain"
chaine3 = 'Pour les courses, pense à prendre du {0} et du {1} et du {2}'.format(article0, article1, article2)
print(chaine3)

{0} {1} {2} sont substitués par les valeurs des variables passées en arguments de la fonction format.

 


Affectation et mathématiques.

Attention à bien comprendre une affectation du genre a = a + 1

  • Pourquoi a et a + 1 ne peuvent pas être égaux ?
  • Que fait l'instruction a = a + 1 ?

TP fonctions.

Créez un fichier fonctions.py dans votre dossier NSI/Langages_de_programmation/2_fonctions/


En python la syntaxe pour déclarer une fonction est la suivante :

def min(nombre1, nombre2):
   
if nombre1 >= nombre2:
        resultat 
= nombre2
   
else:
        resultat 
= nombre1
   
return resultat
  • Le mot clé def
  • Le nom de la fonction , ici min
  • les paramètres entre parenthèses suivi des deux points :
  • Suite au deux points, le corps de la fonction est indenté, pour "sortir" du code de la fonction il faudra revenir à l'indentation précédent la fonction.
  • Le mot clé return donne la (ou les) valeurs de retour. Une fois appelé, ce mot clé fait sortir de la fonction.

Dans votre fichier fonctions.py saisissez le code de la fonction min.

Appelez la fonction en ajoutant la ligne

test = min(12,3)

La variable test contient le résultat de l'appel de la fonction avec les paramètres nombre1=12 et nombre2=3
Mais rien ne s'affiche, pourquoi ???

Eh bien parce vous n'avez pas demandé d'affichage. Ajoutez la ligne suivante :

print(test)

Voilà qui est mieux, nous aurions pu aussi utiliser le debugger (voir
Essayons, ajoutez un point d'arrêt au niveau de la ligne print(test), celle ci ne sera pas évaluée mais dna sle debugger vous verrez la variable test et sa valeur.

Un peu de spécification (on en reparlera...)

Améliorons la fonction avec le type des arguments et du retour, saisissez le code ci-dessous.

def min(nombre1 :float,nombre2 :float) -> float :
    if nombre1 >= nombre2:
        resultat = nombre2
    else :
        resultat = nombre1
    return resultat

Cette syntaxe n'est pas obligatoire mais elle vous aidera à spécifer correctement votre fonction.

Testez votre fonction avec des flottants.


Docstring

Ajoutez le "docstring" comme dans l'exemple ci-dessous, celui-ci est encadré par des triples "quotes" :

Le docstring est un fonctionnalité de Python qui permet de rédiger une documentation intégrée à la fonction.
L'intérêt, c'est que les docstrings sont récupérables  dynamiquement via l'attribut __doc__, ou grâce à la fonction primitive help( ). Ça permet notamment de faire de la documentation autogénérée.
Dans VSCode , si vous tapez CTRL + espace à la suite du nom de la fonction vous avez accès directement à votre documentation !


Les tests : super important !

Lorsque l'on créer une fonction, il faut avoir en tête un jeu d'exemple de paramètres et de résultats associés. En informatique, on peu tester très simplement si la fonction retourne les bonnes valeurs pour notre jeu de tests.

MAIS ATTENTION : SI LA FONCTION RÉUSSI LE JEU DE TEST, CELA NE PERMET PAS D'AFFIRMER QUE LA FONCTION EST CORRECTE !!! Mais nous avons sûrement éviter les grosses erreurs 😀

Voici comment faire des tests. Toujours avec la fonction min, nous aimerions que min(3,5) soit 3 | que min(-2,-5) soit -5 | que min(2.61,-2.61) soit -2.61 | et enfin que min(5,5) soit 5.
Voici comment faire, nous allons utiliser des tests unitaires avec la fonction assert() , d'autres méthode utilisant une classe seront vu plus tard.
Saisissez le code suivant à la suite de la définition de la fonction :

assertmin(5,3== 3 )

Exécutez le code, rien ne se passe : TANT MIEUX ! Cela veut dire que votre test s'est bien passé. Essayez en donnant un test qui doit échouer :

assertmin(5,3== 5 )

Si vous exécutez ce code, vous obtiendrez un message d'erreur : 

Traceback (most recent call last):
  File "e:/Maths/Dropbox/NSI/Premiere/2-Bases_Python/2-TP-fonctions/min.py", line 11, in <module>
    assert( min(5,3) == 5 )
AssertionError

 Ce qui signifie que votre test à échoué. Vous pouvez en saisir autant que vous le souhaitez, ne vous en privez pas, et pensez aux cas un peu extrêmes (valeur nulle, liste vide ...).

Saisissez les 3 "assert" correspondant à  | min(-2,-5) doit valoir-5 | min(2.61,-2.61) doit valoir-2.61 |  min(5,5) doit valoir 5 |

Si vous n'avez pas d'erreur, c'est bon, plus tard nous utiliserons la libraire unittest qui nous fournira un vrai retour sur les tests effectués.


EXERCICE 1 :

Faire une fonction nommée cube qui :

  • prend comme argument nombre : un float
  • retourne le cube (puissance 3) de l'argument nombre

Écrire un docstring et 4 tests


EXERCICE 2 :

Faire une fonction nommée volume_pave qui :

  • prend comme argument 3 flottants (longueur, largeur, hauteur)
  • retourne le volume du pavé droit dont les dimensions sont en arguments

Écrire un docstring et 4 tests

Remarque : il se peut que vous ayez quelques surprise avec les calculs de flottants ...


EXERCICE 3 :

Améliorer la fonction précédente pour afficher "Attention valeur négative" si l'un des paramètres est négatif.


EXERCICE 4 :

Faire une fonction nommée concat qui :

  • prend comme argument 2 chaînes de caractères (chaine1, chaine2)
  • retourne la concaténation des 2 chaînes en arguments

Écrire un docstring et 4 tests


Compléments

Il est possible de :

  • Créer une fonction sans argument, par exemple
    def salutation():
        return 'Bonjour !"
  • Donner un paramètre par défaut, celui-ci sera une paramètre effectif si l'utilisateur ne donne pas ce paramètre  :
    def salutation(civilite= 'madame'):
        return 'Bonjour " + civilite

    salutation() retourne "Bonjour madame"
    salutation('monsieur') retourne "Bonjour monsieur"

Pour les plus rapides , passez au TP : fonction bonus

TP fonctions bonus

Quelques exercices supplémentaires sur les fonctions pour ceux déjà à l'aise avec les boucles et les tests.

Pensez , même si cela n'est pas demander à documenter vos fonctions et à les tester avec des assert.


EXERCICE 1 :

Un gardien de phare va aux toilettes cinq fois par jour or les WC sont au rez-de-chaussée...

Écrire une procédure (donc sans retour)hauteurparcourue qui reçoit deux paramètres : le nombre de marches du phare et la hauteur de chaque marche (en cm), et qui affiche :

"Pour x marches de y cm,il parcourt z.zz m par semaine."

On n’oubliera pas :

  • qu’une semaine comporte 7 jours
  • qu’une fois en bas, le gardien doit remonter ;
  • que le résultat est à exprimer en m

EXERCICE 2 :

Écrire le script qui affiche en fonction d’une valeur saisie l’un des messages suivants :

—”Ce nombre est pair”

—”Ce nombre est impair, mais est multiple de 3”

—”Ce nombre n’est ni pair ni multiple de 3”


EXERCICE 3 :

Programme une fonction appelée affiche_une_table(n) qui dépend d’un paramètre n et qui affiche la table de multiplication par l’entier n.

Par exemple, la commande affiche_une_table(5)doit afficher : 1×5=5, 2×5=10. .


EXERCICE 4 :

Écrire une fonction qui prend trois nombres en paramètre et qui renvoie le plus petit d'entre eux.


EXERCICE 5 :

Écrire une fonction qui retourne une chaîne de caractère.

Par exemple : retourne("abcdef") = "fedcba"   et   retourne("radar") = "radar"


EXERCICE 6 :

En utilisant la fonction précédente, créer une fonction qui retourne True si une chaîne de caractère est un palindrome et qui retrourne False sinon.

 

 

TP boucle for.

Créez un fichier conditions.py dans votre dossier NSI/Langages_de_programmation/3_conditionnelle/


Pouvoir exécuter un bloc d’instructions plutôt qu’un autre suivant une condition fait parti des éléments fondamentaux des langages de programmation.

Bloc d’instruction A
si condition est vraie (True) alors
     Bloc d’instruction B
sinon
     Bloc d’instruction C
Bloc d’instruction D

Suivant la condition, le script exécuteras les instructions ABD ou les instructions ACD. Voyons comment faire avec le langage Python.


La syntaxe en python est la suivante :

instructionsA
if expression:
    instructionsB
else :
    instrcutionsC
instructionsD

Le mot clé if suivit de : et d'un retour à la ligne. Les instructions qui s'éxecutent si la condition est vraie sont indentée.
Le mot clé else suivit de : correspond à sinon. La fin de l'indentation pour l'instructionD signifie que celle-ci s'éxecutera après la boucle si/sinon.


Mise en pratique :

Notre objectif est de créer un petit jeu dans lequel un joueur doit chercher un nombre. On commence par définir un nombre appelé nombre_mystere

nombre_mystere = 42

Nous allons utiliser les fonctions vues dans le chapitre précédent.

  • La fonction s'appelle cherche_nombre
  • Un seul paramètre de type int
  • Pas de retour, (c'est ce que l'on appelle une procédure).
  • Si le nombre fourni en paramètre est égal au nombre mystère alors on affiche 'Bravo, vous avez trouvé !'

Saisissez le code suivant :

def cherche_nombre(nombre : int):
"""Petit jeu du nombre mystère"""
    if nombre == nombre_mystere:
        
print('Bravo, vous avez trouvé !')

Testez-le en appelant la fonction

cherche_nombre(42)

puis

cherche_nombre(21)

Le dernier appel n'est pas très satisfaisant car il n'y a pas de retour vis à vis de notre proposition. Améliorons cela avec un else .

def cherche_nombre(nombre : int):
   
"""Petit jeu du nombre mystère"""
    if nombre == nombre_mystere:
        
print('Bravo, vous avez trouvé !')
    
else:
        
print("Dommage.")

Cette fois, l'appel cherche_nombre(21) fournit un retour, c'est plus satisfaisant.

Mais nous pouvons encore l'améliorer en donnant une indication sur le nombre_mystere à chaque tentative. Mais avant un peu de théorie :


Les opérateurs

Une expression booléenne (True or False) peut contenir les opérateurs de comparaison suivants :

Opérateur Signification
x == y x est égal à y
x != y x est différent de y
x > y x est plus grand que y
x < y x est plus petit que y
x >= y x est plus grand ou égal à y
x <= y x est plus petit ou égal à y

Amélioration de notre jeu.

A chaque, essai, indiquons si la tentative est strictement supérieure ou inférieure au nombre mystère. Utilisons le mot clé elif contraction de else et de if.

def cherche_nombre(nombre : int):
   
"""Petit jeu du nombre mystère"""
    if nombre == nombre_mystere:
        
print('Bravo, vous avez trouvé !')
    
elif nombre < nombre_mystere:
        
print('Le nombre mystère est strictement supérieur à', nombre)
    
elif nombre > nombre_mystere:
        
print('Le nombre mystère est strictement inférieur à', nombre)

Testez cette fonction avec différents appels pour vérifier que cela fonctionne comme attendu.


A retenir :

  • Les conditions permettent d'exécuter certaines instructions dans certains cas, d'autres instructions dans un autre cas.

  • Les conditions sont marquées par les mot-clés if(« si »),elif (« sinon si »)  et else(« sinon »).

  • Les mot-clés if e telif doivent être suivis d'un test

  • Les booléens sont des données soit vraies (True) soit fausses (False).


Exercice 1

Ecrire une fonction nommée parite qui :

  • prend comme argument un nombre entier (nombre)
  • retourne un str : 'pair' si le nombre est pair et 'impair sinon

Écrire un docstring et 3 tests


Exercice 2

Ecrire une fonction nommée triangle_rectangle qui :

  • prend comme argument trois nombres (les 3 longueurs d'un triangle)
  • retourne un booléen : True si le triangle est rectangle

Écrire un docstring et 3 tests

 


BONUS Exercice 3

Ecrire une fonction nommée bissextile qui :

  • prend comme argument un nombre entier (nombre)
  • retourne un booléen suivant si l'année est bissextile ou non

Écrire un docstring et 3 tests

 

Une année est dite bissextile si c'est un multiple de 4, sauf si c'est un multiple de 100. Toutefois, elle est considérée comme bissextile si c'est un multiple de 400. Je développe :

  • Si une année n'est pas multiple de 4, on s'arrête là, elle n'est pas bissextile.

  • Si elle est multiple de 4, on regarde si elle est multiple de 100.

    • Si c'est le cas, on regarde si elle est multiple de 400.

      • Si c'est le cas, l'année est bissextile.

      • Sinon, elle n'est pas bissextile.

    • Sinon, elle est bissextile.

 

 

TP boucle bornée (for).

Créez un fichier boucle_for.py dans votre dossier NSI/Langages_de_programmation/4_boucle_bornee/


Dans un algorithme, il peut être nécessaire de répéter plusieurs fois la même (ou presque la même) série d’instructions.
Lorsque l’on connaît le nombre de répétitions à l’avance, on peut utiliser une boucle bornée ou boucle for.


Les tables de multiplication

L'instruction for parcourt toutes les valeurs d'un itérable (litéralement un objet qui peut être parcouru par une boucle for)
Commençons avec range qui sera très utilisé dans les boucles for.

def table(nombre : int):
   
for i in range(11):
       
print('i vaut',i)
table(
7)

Comme vous pouvez le constater, dans le corps de la boucle la variable i prend les valeurs de 0 à 10 (compris) .

Modifiez le range comme ce qui suit :

range(2,42)

Dans ce cas, les valeurs sont prises de 2 à 41 compris. Voir la documentation officielle pour plus d'info

Essayez : range(0, 30, 5) 

Modifions notre fonction pour obtenir le comportement attendu;

def table(nombre : int):
   
for i in range(11):
        resultat 
= nombre * i
       
print('{0} x {1} = {2}'.format(i,nombre,resultat))
 
table(7)

 A chaque tour de boucle, le calcul nombre*i est effectué. L'affichage est obtenu avec la fonction format qui remplace {0}, {1} et {2} par les valeurs des variables i, nombre et resultat.

Petit exercice, modifiez la fonction pour avoir la table jusqu'au nombre 20 au lieu de 10.


Le parcours de séquence

La boucle for est aussi capable de parcourir une chaine de caractère ou un tableau, c'est très pratique. Par exemple le code suivant peut être simplifié :

texte = "Bienvenue en NSI"
longueur_texte = len(texte)
for i in range(longueur_texte):
   
print(texte[i])

Dans cette version ci-dessus, longueur_texte est un variable qui contient le nombre de caractère du texte (espaces compris cette longueur est de 16). Ensuite texte[i] affiche le caractère de rang i dans le texte (le premier caractère étant de rang 0).

 

Il est possible de simplifier drastiquement la boucle. Voici la version simplifiée :

texte = "Bienvenue en NSI"
for caractere in texte:
   
print(caractere)

Ci-dessus, caractere est une varaible qui va prendre pour valeur chaque lettre dans le texte.

 

De la même façon, il est aisé de parcourir unn tableau :

beatles = ['John','Paul','Ringo','George']
for prenom in beatles:
   
print(prenom)

Application : la fonction qui compte.

On souhaite écrire une fonction nommée compte qui :

  • prend comme argument une chaine de caractrère (str) et une lettre (str)
  • retourne un entier : le nombre de fois ou la lettre apparait dans la chaine de caractère

Par exemple compte('queen','e') renvoie 2.

def compte(chaine : str,lettre : str) -> int:
   
"Compte le nombre de fois où la lettre apparait dans la chaine"
    compteur = 0
    for caractere in chaine:
       
if caractere == lettre:
            compteur 
+= 1
    return compteur
 
assert(compte('queen','e'== 2)

Ajoutez quelques tests à la fonction ci-dessus.


A retenir :

  • Une boucle sert à répéter une portion de code.

  • range(start,stop)  représente une séquence de nombres et est couramment utilisé pour itérer un certain nombre de fois dans les boucles

  • On peut parcourir une séquence grâce à la syntaxe for element in sequence:.


Exercice 1

Écrire une boucle qui affiche tous les nombres entiers impairs compris entre 0 et 100.


Exercice 2

Créer une boucle qui affiche la somme de tous les nombres entiers de 0 à 1000.


Exercice 3

Créer une boucle qui multiplie chaque nombre d'un talbeau par 5.

Exemple si le tableau est [2,3,9] Affichera 10 puis 15 puis 45


BONUS Exercice 4

Ecrire une fonction enleve_e qui :

  • prend en paramètre une chaine de caractère
  • retourne une chaine de caractère
  • la chaine obenue en retour est la chaine entrée en paramètre dans laquelle les lettres 'e' ont été supprimées

Par exemple enleve_e('test') retourne 'tst'

Ecire un docstring et quelques tests.

 

 

 

TP boucle non bornée (while).

Créez un fichier boucle_while.py dans votre dossier NSI/Langages_de_programmation/4_boucle_non_bornee/


Principe de la boucle while

Lorsque l’on veut répéter une suite d’instructions sans savoir combien de tours de boucle il faut effectuer alors il faudra utiliser une boucle non bornée.
C’est la boucle while (tant que en Français !).
Syntaxe python :

while expression :
    instruction1
instruction2

Mais, que se passe-t-il dans cette boucle ?

  1. l’expression (le prédicat) est évaluée
  2. Si elle est vraie (True), alors les instruction du corps de la boucle (ici instruction1) sont exécutées, on retourne à l’étape 1.
  3. Si elle est fausse (False), alors on ’sort’ de la boucle et on poursuit l’exécution des instructions qui suivent la boucle (ici instruction2) 


 Voici un exemple dans lequel ont cherche le premier terme pour lequel la somme des carrés dépasse 1000

 somme = 0

= 0
while somme < 1000:
    somme 
= somme + i**2
    i = i +1
print(somme)

 Tant que la somme ne dépasse pas 1000 , on ajoute le carré du nombre i puis on augment i de 1 unité.


Exemple avec la suite de Syracuse

On appelle suite de Syracuse une suite d'entiers naturels définie de la manière suivante : on part d'un nombre entier naturel plus grand que zéro ; s’il est pair, on le divise par 2 ; s’il est impair, on le multiplie par 3 et on ajoute 1. En répétant l’opération, on obtient une suite d'entiers positifs dont chacun ne dépend que de son prédécesseur. On arrête lorsque le terme obtenu vaut 1. Ainsi pour $n \geq 0$

$$ u_{n+1} = \begin{cases} \frac{u_n}{2} & \text{si }u_n\text{est pair} \\ 3u_{n}+1 & \text{sinon}\end{cases} $$

Voici, ci dessous le code d'une fonction permettant d'afficher la suite de syracuse pour un premier terme donné :

def syracuse(premier_terme : int) -> list:
   
"Retourne la suite de syracuse de 1er terme donné dans un tableau (type : list)"
    u = premier_terme
    liste 
= [u]
   
while u !=1 :
       
if u%2 == 0:
            u 
= u//2
        else:
            u 
= 3*u+1
        liste.append(u)
   
return liste
 
print(syracuse(12))

Le tableau réponse se nomme liste. Il est initialisé avec le premier terme. Ensuite, sauf si u=1, nous entrons dans la boucle while.
A chaque tour de boucle, la condition $u \neq 1$ est testée, si elle est vraie, alors on teste si u est pair ou impair, et on effectue les opérations correspondantes. liste.append(u) signifie que l'on ajoute u au tableau liste. On sort de la boucle lorsque $u=1$ et le retour s'effectue alors.

Testez cette fonction pour différentes valeurs. La conjecure de syracuse n'est pas démontrée à ce jour...


A retenir :

  • Une boucle sert à répéter une portion de code en fonction d'une condition.

  • On peut créer une boucle grâce au mot-clé while suivi d'une condition.


Exercice 1 :

Écrire un script qui donne le premier terme pour lequel la somme des cubes est strictement supérieure à 10000.

C'est à dire que l'on cherche $n$ tel que $1^3 + 2^3 + 3^3 + 4^3 + ... + n^3 > 10000$


Exercice 2

Vous souhaitez vous préparer à courir une distance de $x$ km et vous démarrez votre entraînement en courant $y$ km (avec $y<x$).

On imagine qu'après chaque entraînement vous courez une distance supérieure de 10 %

Par exemple il faudra 8 semaines pour atteindre les 10 km en commençant à 5km  ($ 5 \times 1.1^8 \approx 10.72$)

Écrire une fonction qui :

  • Se nomme entrainement
  • A deux paramètres formels x et y qui sont des flottants
  • Retourne un entier n qui représente le nombre d'entraînements à faire avant de parcourir la distance souhaitée (x)

Ajoutez la documentation et des tests en utilisant assert


Exercice 3 :

Le code Python ci-dessous permet d'afficher la face supérieure du dé lors de dix lancers successifs d'un dé à 6 faces.
On commence par importer la fonction 
randint du module random.
Cette fonction prend deux paramètres : par exemple 
randint(1, 6) retourne un entier aléatoire compris entre 1 et 6, les bornes sont incluses.

from random import randint
for k in range(10):
    print(randint(1, 6))

Écrire une fonction premier6() qui retourne le rang du premier 6 obtenu lorsqu'on lance successivement le dé.


BONUS Exercice 4

Écrire un programme qui fait deviner une valeur à un utilisateur, le programme demande une valeur tant que l'utilisateur n'a pas trouvé la bonne valeur.

La valeur à deviner peut être choisie aléatoirement.

Des indications peuvent être données à la personne qui cherche à deviner.

Vérifiez vos connaissances et compétences en programmation

Ci-dessous une feuille d'exercices et la correction sous forme de fichiers Python.

Conseils d'utilisation :

  • Cherchez les exercices sur papier avant de coder
  • Pensez à vos tests avant de réaliser vos fonctions
  • Testez vos fonctions !!!
  • Une fois les exercices faits, comparez avec la correction proposée. Attention, il peut y avoir plusieurs solutions !

Feuille d'exercice sur les bases en Python

Correction

Bilan sur les bases en python - complément pour les plus motivés

Téléchargez le  fichier zip 341,4 Kio , puis décompressez-le dans le dossier NSI/Langages_de_programmation/Bilan/

Lancez l'application jupyter notebook. (voir tutoriel )

A partir de l'arboresence, ouvrez le fichier Bilan_bases_python.ipynb et suivez les instructions.