====== Révision ======


===== Python Exemples =====

==== Print ====

<code>
print "(2+2)*3=12"
</code>

==== Programmation modulaire ====

<code>
from gturtle import *

def triangle50():
    forward(50)
    right(120)
    forward(50)
    right(120)
    forward(50)

makeTurtle()
triangle50()
left(45)
triangle50()
</code>
Ici on peut appeler triangle50() aussi une fonction ou une méthode.

==== Boucles, input et paramètres ====

=== Polygone ===

<code>
from gturtle import *

def polygone (n, cote):
    repeat n:
        forward(cote)
        right(360 / n)
        
def dessine_polygone():
    nb_cotes = input("Nombre de côtés : ")
    perimetre = input("Mesure du périmètre : ")
    polygone(nb_cotes, perimetre / nb_cotes)

makeTurtle()
hideTurtle()
dessine_polygone()
dessine_polygone()
  
</code>


=== Boucles while ===

<code>
while <codition>:
    <consigne>
</code>
Le consigne est répétée tant que la condition est remplie.


<code>
from gturtle import *

def spirale(cote, cote_max):
    while cote<cote_max:
        forward(cote)
        left(90)
        cote=cote+5

makeTurtle()
hideTurtle()
spirale(5, 150)
</code>


==== Branchements / Instructions conditionnelles ====


=== Instructions avec if ===

<code>
if <condition>:
    <instruction>
</code>

<code>
prenom = input("Prénom?")
if prenom =="Lisa":
    print "Bonjour Lisa!"
    print "Quel plaisir de vous revoir"
if prenom == "Gaston":
    print "Bonjour Gaston"
    print "Quelle plaisir de vous retrouver"
</code>

=== Instructions if else ===

<code>
if <condition>:
    <instruction 1>
else :
    <instruction 2>
</code>

<code>
a = 35
b = 33
if b > a:
    print("b is greater than a")
else:
    print("b is less than or equal to a")  
</code>

<code>
def minmax (a, b, c):
    if a>b:
        minimum = a
        maximum = b 
    else:
        minimum = b
        maximum = a
    if c < minimum:
        minimum = c
    if c>maximum:
        maximum = c   
    print (minimum, maximum)
    
minmax(5,3,17)

</code>

=== Instructions if elif ... else ===

<code>
if <condition 1>:
    <instruction 1>
elif <condition 2>:
    <instruction 2>
else :
    <instruction 3>
</code>

<code>
a = 35
b = 33
if b > a:
    print("b is greater than a")
elif a == b:
    print("a and b are equal")
else:
    print("b is less than a")  
</code>

===== Exercices de révision =====

==== Exercice R1 ====

Développez un programme “d’identification” qui permet à un utilisateur de se “loguer sur l’ordinateur”. Les logins valables sur l’ordinateur sont les suivants, mentionnés avec le mot de passe correspondant :

    TartempionJ (mot de passe: 8ahH8$8AHZ)

    DoeJ (mot de passe: Rikiki1_0)

Lorsque l’utilisateur DoeJ se connecte avec succès, le système de login doit afficher la phrase "Welcome back, John!". Lorsque c’est TartempionJ qui se connecte, le système doit lui répondre "Bonjour Monsieur Tartempion, comment allez-vous aujourd'hui?".

Tous les autres utilisateurs doivent recevoir le message “Accès refusé”. Si l’utilisateur saisit l’un des comptes utilisateur existants mais se trompe de mot de passe, il doit également recevoir le même message.

Commencez par dessiner dans votre cahier l’ordinogramme de ce programme. Complétez ensuite le programme ci-dessous directement dans l’éditeur:

Réflexion sécurité informatique

Dans ce programme, on stocke les mots de passe des utilisateurs “en clair”. Quel danger potentiel de sécurité cela peut-il poser? Comment pourrait-on résoudre ce problème?

<code>
user_name = input("Login: ")

if user_name == "DoeJ":
    print("Welcome back, John!")

print("Accès refusé")
</code>

==== Exercice R2 ====

Développez une commande est_bissextile(annee) qui prend en paramètre un nombre entier annee en guise d’une année de notre calendrier (par exemple 2020) et qui détermine si cette année est bissextile en affichant oui si elle est bissextile et non si ce n’est pas le cas. Voici un algorithme permettant de déterminer si une année est bissextile ou non :

Algorithme année bissextile

Soit A une année

Si A n’est pas divisible par 4, 

A n’est pas bissextile

Si l’année A est divisible par 4, elle est bissextile, 

sauf si elle est divisible par 100 et pas par 400.

=== Consignes ===
Pour vérifier si un nombre est divisible par un autre nombre, vous avez besoin de l'opérateur "%".

Commencez par dessiner un ordinogramme de cet algorithme avec la présentée au cours. Implémentez l’algorithme en question en Python dans l’éditeur ci-dessous.
Testez votre programme en appelant votre commande pour les années suivantes

    est_bissextile(2020)
    est_bissextile(2000)
    est_bissextile(1900)
    est_bissextile(1953)
    est_bissextile(1950)
    est_bissextile(1952)
    est_bissextile(1600)

S’il est correct, votre programme devrait afficher

    oui
    oui
    non
    non
    non
    oui
    oui

<code>
annee = input("Année :")

def est_bissextile(annee):
    # compléter le code ici

def test():
    est_bissextile(2020)
    est_bissextile(2000)
    est_bissextile(1900)
    est_bissextile(1953)
    est_bissextile(1950)
    est_bissextile(1952)
    est_bissextile(1600)

# test de la commande
# test()
</code>


==== Exercice R3 ====

Développez une commande spirale(nb_cotes, cote_initial, increment, angle, cote_max) qui dessine une spirale dont le premier côté dessiné vaut cote_initial et qui augmente à chaque fois la longueur des côtés de increment. La tortue doit tourner de angle degrés entre chaque côté.

Testez ensuite votre commande avec différentes valeurs pour les paramètres.

<code>
from gturtle import *
makeTurtle()

def spirale(nb_cotes, cote_initial, increment, angle):
# compléter le code ici
</code>