# ex_II07a_if_elif_else.py

n=int(input('Tapez un nombre: '))
if n>100: 
    print("Ce nombre est plus grand que 100. " )
elif n<10: 
    print("Ce nombre est plus petit que 10. " )
else: 
    print("Ce nombre est compris entre 10 et 100. " )

# ex_II08a_Punition_ringarde.py

punitionRingarde = " Je dois écrire 100 fois un texte inutile "
nn = 0

while (nn < 100):
    print(punitionRingarde)
    nn = nn + 1

# ex_II09a_Nombre_secret.py
'''
Petit programme qui nous demande de trouver un nombre
entre 10 et 99, pas essai successifs.
'''

print ("Le nombre a trouvé est composé de 2 chiffres" )
print (" " )
nbSecret = 79
nbEssai = 0
while (nbEssai != nbSecret):
    nbEssai = int(input ("Quel est mon nombre ? " ))
    if nbEssai > nbSecret :
        print ("mon nombre est plus petit ! " )
    if nbEssai < nbSecret :
        print ("mon nombre est plus grand ! " )

print ("Bravo ! Tu as trouvé mon nombre ! " )

# ex_II10a_Affiche_livret.py
'''
Affiche le livret d'un nombre introduit pas l'utilisateur
'''

nb = int(input ("Quel livret ? " ))
aa = 1
while (aa < 11): 
	print(str(nb) + " x " + str(aa) + " = " + str(nb * aa ) ) 
	aa += 1

# ex_III01a_Break.py
'''
Exemple d'utilisation de l'instruction "break"
'''

print ('Devinez le nombre qui se cache . . . ' )
while (1 < 2): 
    nn = int(input("Tapez un chiffre : "))
    if (nn == 3): 
        print ("OUI" )
        break
    else:
        print ("NON" )

# ex_III02a_Table_multiplication.py
'''
Affichage d'une table de multiplication de 1x1 à 11x11
'''
aa = 1
bb = 1
while (aa < 12):
  print("\nla table de " , aa)  # \n correspond à un retour à la ligne
  while (bb < 12):
    print(aa , "x" , bb , "=" , aa*bb)
    bb += 1 # Ajoute 1 à bb
  bb = 1
  aa += 1 # Ajoute 1 à aa

# ex_III03a_Tant_que_Tant_que_Tant_que.py
'''
Trois while de suite, imbriqué l'un dans l'autre.
'''
nbSecret = 659
aa = bb = cc = 0

while (aa < 10):
  while (bb < 10):
    while (cc < 10):
      nbGenerer = 100 * aa + 10 * bb + cc
      #print(aa, bb, cc)
      if (nbGenerer == nbSecret):
        print("Bravo, vous avez réussi trouver le mot de passe ! ")
        print( nbGenerer )
      cc = cc + 1
    cc = 0
    bb += 1 # Ajoute 1 à bb
  bb = 0
  aa += 1

# ex_III04a_Equ_2e_degre.py
'''
Donne les solutions réelles d'une équation du second degré
'''
print("résolveur d ’équations du 2ème degré : a xˆ2 + b x + c = 0 ")

aa = float( input( "que vaut le coefficient a ?" ) ) 
bb = float( input( "que vaut le coefficient b ?" ) ) 
cc = float( input( "que vaut le coefficient c ?" ) ) 

delta = bb**2 - 4*aa*cc

if (delta < 0):
    print( "Il n’existe pas de solution réelle ! " )
elif (delta == 0):
    xx = -bb / (2* aa )
    print( "La solution est : " + str(xx) )

else:
    x1 = (-bb + delta **0.5) / (2 * aa )
    x2 = (-bb - delta **0.5) / (2 * aa )
    print( " les solutions sont : " + str( x1) + " et " + str( x2) )

# ex_III05a_Jeu_de_Nim.py
'''
Jeu de Nim,
Il y a deux joueurs.
Un tas commence avec 30 allumettes.
Chacun à leur tour, un joueur doit enlever 1, 2 ou 3 allumettes du tas.
Celui qui pend la dernière allumette a perdu.
La stratégie gagnante est simple.
Une variante est d'interdire de prendre le même nombre d'allumettes
que le joueur précédent.
'''
nb_allumettes = 30

joueur1 = input( ' Quel est ton nom joueur 1 ? ' )
joueur2 = input( ' Quel est ton nom joueur 2 ? ' )

while ( nb_allumettes > 0) :
    print ( '−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−' )
    print ( ' Information : Il reste ', nb_allumettes, 'allumettes.' )
    print ( '−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−' )

    nb_enleve = 4
    while( (nb_enleve > 3) or (nb_enleve < 1) or (nb_enleve > nb_allumettes)):
        try:
            nb_enleve = int(input( "Combien enleves−tu d’allumettes " + joueur1 + " ? " ))
            if ( nb_enleve > 3):
                print ('Tu ne peux pas enlever plus que 3 allumettes ! ' )
            elif ( nb_enleve < 1):
                print ('Il faut enlever au moins une allumette ! ' )
            elif ( nb_enleve > nb_allumettes ):
                print ("Tu ne peux pas enlever autant d’allumettes ! " )
            else:
                nb_allumettes = nb_allumettes - nb_enleve
                joueur1, joueur2 = joueur2, joueur1 # échange le nom des joueurs.

            if ( nb_allumettes == 0 ):
                print ( "******************** \n \n \n \n " )
                print ( joueur1, ' a gagné ! ', joueur2, ' a perdu, car il a pris la dernière allumette.')
                break

            if ( nb_allumettes == 1 ):
                print ( "******************** \n \n \n \n " )
                print ( joueur2, ' a gagné ! ', joueur1, ' doit prendre la dernière allumette ! ! ! ')
                nb_allumettes = 0 # assure de sortir de la boucle principale
                break
        
        except:
            print("Entre un chiffre entre 1 et 3")

# ex_III05b_Jeu_de_Nim.py
'''
Variante du jeu de Nim,
Il y a deux joueurs.
Un tas commence avec 30 allumettes.
Chacun à leur tour, un joueur doit enlever 1, 2 ou 3 allumettes du tas.
Celui qui pend la dernière allumette a perdu.
La variante est qu'il est interdit de prendre le même nombre d'allumettes
que le joueur précédent.
'''
nb_allumettes = 30
nb_precedent = 0  # nombre d'allumettes prise par le joueur précédent

joueur1 = input( ' Quel est ton nom joueur 1 ? ' )
joueur2 = input( ' Quel est ton nom joueur 2 ? ' )

while ( nb_allumettes > 0) :
    print ( '−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−' )
    print ( ' Information : Il reste ', nb_allumettes, 'allumettes.' )
    print ( '−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−' )

    nb_enleve = 4
    while( (nb_enleve > 3) or (nb_enleve < 1) or (nb_enleve > nb_allumettes)):
        try:
            nb_enleve = int(input( "Combien enleves−tu d’allumettes " + joueur1 + " ? " ))
            if ( nb_enleve > 3):
                print ('Tu ne peux pas enlever plus que 3 allumettes !' )
            elif ( nb_enleve < 1):
                print ('Il faut enlever au moins une allumette !' )
            elif ( nb_enleve == nb_precedent):
                print ('Tu ne peux pas prendre le même nombre d''allumette que le joueur précédent !' )
            elif ( nb_enleve > nb_allumettes ):
                print ("Tu ne peux pas enlever autant d’allumettes !" )
            else:
                nb_allumettes = nb_allumettes - nb_enleve
                joueur1, joueur2 = joueur2, joueur1 # échange le nom des joueurs.
                nb_precedent = nb_enleve # mémorise le nombre d'allumettes prises par le joueur précédent.
                
            if ( nb_allumettes == 0 ):
                print ( "******************** \n \n \n \n " )
                print ( joueur1, ' a gagné ! ', joueur2, ' a perdu, car il a pris la dernière allumette.')
                break
        
        except:
            print("Entre un chiffre entre 1 et 3")

# ex_III06a_Devine_mon_nombre.py
'''
Un joueur doit deviner le nombre caché par l'ordinateur.
Des indications lui sont données.
Lorsqu'il a trouvé, un joli dessin lui est présenté.
Utilise la librairie "random"
'''
import random

nbCache = random.randint(10, 99)
print("J'ai caché un nombre entre 10 et 99, essaye de le deviner")

nbTentatives = 0

while True:
  nbTentatives += 1
  try:
    nbEssai = int(input("Tapez un nombre entre 10 et 99 : "))

    if (nbEssai == nbCache):
      print ("Bravo, tu as trouvé en", nbTentatives, "tentatives.")
      break
    elif abs( nbEssai - nbCache ) <= 2:
      print("C’est bouillant !")

    elif abs( nbEssai - nbCache ) <= 5:
      print("C’est chaud !")

    elif abs( nbEssai - nbCache ) <= 10:
      print("C’est tiede !")

    elif abs( nbEssai - nbCache ) <= 20:
      print ("C’est froid !")

    else:
      print ("C’est glacé !")
  except:
    print("Entrez un nombre entre 10 et 99")
    
print( "Vous avez trouvé le nombre caché en", nbTentatives, "tentatives !" )

if (nbTentatives < 2):
  print( "Sacré coup de chance ! ! !")
elif (nbTentatives < 5):
  print ( "Joli score !")
elif nbTentatives < 8 :
  print ("Le score est acceptable.")
else :
  print( "pas terrible comme score ! ! !")

print() # pour sauter une ligne

ligne = 0
largeurMax = 4

while (ligne < largeurMax):
  largeur = 1* ( ( largeurMax ) - ligne )
  nbDiese = 2* ligne + 1
  print ( largeur * ' ' + nbDiese * '#' )
  ligne = ligne + 1

while (ligne >= 0):
  largeur = 1* ( ( largeurMax ) - ligne )
  nbDiese = 2* ligne + 1
  print ( largeur * ' ' + nbDiese * '#' )
  ligne = ligne - 1

# ex_IV01a_Rebonds_ball.py
'''
Simulation de rebonds d'une balle, avec perte d'énergie à chaque rebond.
Avec gestion d'erreur d'entrée : try: ... except: ...
'''
while True :
    h0 = float(input( 'Quelle est la hauteur initiale en [m] ? ' ))
    if (h0 >= 0):
        break
    
while True :
    eps = float(input( 'Quel est le coefficient de rebond ? ' ))
    if (eps >= 0) and (eps < 1):
        break

while True :
    try:
        nbr = int(input( 'Combien de rebonds de balle ? ' ))
        if (nbr < 0):
            print('Un nombre positif de rebonds :', end=' ')
        else:
            break
    except ValueError:
        print('Un nombre entier de rebonds :', end=' ')
        

rebonds = 0
g = 9.81
h = h0

while (rebonds < nbr):
    print('rebond', rebonds, ' ', h)
    v = (2 * g * h) ** 0.5
    v1 = eps * v
    h = (v1 **2) / (2 * g )
    rebonds = rebonds + 1

print( 'Après', rebonds, 'rebonds la balle atteint une hauteur de', h, ' mètres.')

# ex_IV02a_Test_nombre_premier.py
'''
Test si un nombre donné par l'utilisateur est un nombre premier.
'''
while True :
    nn = int(input( 'Entrez un nombre entier supérieur à 1 : '))
    if (nn > 1):
        break
      
isPremier = True
if (nn % 2 == 0) and (nn != 2):
    print( 'Le nombre n’est pas premier, car il est divisible par 2 !')
    isPremier = False

mm = 3 # diviseurs possibles du nombre nn
while (mm <= nn**0.5):  # On teste avec tous les nombres <= racine carrée de nn.
    if (nn % mm == 0):
        print ('Le nombre', nn, "n’est pas premier, car il est divisible par", mm, '!')
        isPremier = False
        break
    mm = mm + 2 # essaye la division avec le prochain nombre impair.

if (isPremier):
    print( 'Le nombre', nn, 'est premier !')

# ex_IV03a_Jeu_de_memory.py
'''
Un joueur doit mémoriser une suite de nombre et les écrire ensuite.
Utilise la librairie random.
'''
from random import *

c = n = 0

while True:
    a = randint(1 , 4 )
    print (100 * '\n' + 'Le nouveau nombre est ' + str( a ) )
    c = a + c * 10
    b = int(input( '\nRedis tous mes nombres : ' ))
    if (b != c):
        print( "FAUX, c'était          :", c )
        break
    n = n + 1

print( 'Nb de réussites :', n)

# ex_V04a_Cherche_un_caractere.py
'''
Compte le nombre de "e" dans une chaîne de caractères.
'''
chaine = input("Taper une chaine de caractères, \
je vous dirai le nombre de 'e' qu'elle contient.\n")

lesE="eéèêëEÈË" #Astuce : on va tester différents "e", on les groupe dans une chaîne

nCompte = 0 # Compte le nombre de 'e' dans la chaîne
nn = 0
while (nn < len(chaine)):
  if (chaine[nn] in lesE):
    #  in   permet de vérifier si un élément fait partie d'une séquence
    nCompte += 1
  nn += 1

if (nCompte > 0):
    print("Il y a", nCompte, "caractères 'e' dans la chaîne :", chaine)
else:
    print("Il n'y a pas de 'e' dans la chaine :", chaine)

# ex_V06a_Compte_nombre_e.py
'''
Compte le nombre de "e" dans une chaîne de caractères,
en utilisant une boucle "for"
'''
chaine = input("Taper une chaine de caractères, \
je vous dirai le nombre de 'e' qu'elle contient.\n")

nCompte = 0 # Compte le nombre de 'e' dans la chaîne

for car in chaine:
  if (car == "e"):
    nCompte += 1

print("Il y a", nCompte, "'e' dans la chaîne :", chaine)

# ex_V07a_Insert_des_etoiles.py
'''
Insert une étoile entre chaque lettre d'une chaîne de caractères.
De deux manières différentes, avec une boucle 'while' et avec une boucle 'for'
'''

# Demande une chaine de caractères, mais pas vide.
chaine = ""
while (chaine == ""):
  chaine = input ("Donnez-moi une chaine que j'y insère des * !\n")

chaineEtoile = chaine[0]
nn = 1
while (nn < len(chaine)):
    chaineEtoile += "*" + chaine[nn]
    nn += 1
    
print(chaineEtoile)

# === Autre manière en utilisant une boucle for

chaineEtoile2 = chaine[0]
for car in chaine[1:]: # Prend tous les caractères de la chaîne, sauf le premier.
    chaineEtoile2 += "*" + car

print(chaineEtoile2)

# ex_V08a_Inverse_une_chaine_de_caracteres.py
'''
Inverse l'ordre des caractères d'une chaîne entrée par l'utilisateur.
De deux manières différentes, avec une boucle 'while' et avec une boucle 'for'.
'''

# Demande une chaine de caractères, mais pas vide.
chaine = ""
while (chaine == ""):
  chaine = input ("Donnez-moi une chaine que je l'inverse !\n")

chaineInverse=""
nn = len(chaine)
while (nn > 0):
    nn-=1
    chaineInverse += chaine[nn]
    
print(chaineInverse)

# *** Version avec une boucle 'for'

chaineInverse2 = ""
for car in chaine:
    chaineInverse2 = car + chaineInverse2

print(chaineInverse2)

# ex_V09a_Test_palindrome.py
'''
Test si une chaîne entrée par l'utilisateur est un palindrome.
Un palindrome est une chaîne qui est identique à la chaîne inversée.
De deux manières différentes, avec une boucle 'while' et avec une boucle 'for'.
Normalement, on devrait enlever les espaces et signes de ponctuations.
'''

# Demande une chaine de caractères, mais pas vide.
chaine = ""
while (chaine == ""):
  chaine = input ("Donnez-moi une chaine que je teste si c'est un palindrome.\n")

nLast = len(chaine) - 1
nn = len(chaine) // 2
while (nn > 0):
  nn -= 1
  if (chaine[nn] != chaine[nLast - nn]):
    print("Votre chaîne n'est PAS un palindrome.")
    break

if (nn == 0):
  print("La chaine suivante est un palindrome :\n", chaine)

# *** Version avec une boucle 'for'

chaineInverse2 = ""
for car in chaine:
    chaineInverse2 = car + chaineInverse2

if (chaine == chaineInverse2):
  print("Votre chaîne est un palindrome.")
else:
  print("Votre chaîne n'est PAS un palindrome.")

#!/usr/bin/python
# -*- coding: utf-8 -*-
# ex_V90a_Jeu_de_de.py
'''
Jeu de dé à deux joueurs.
On part d'une valeur initiale, par exemple Somme = 21
On lance un dé à 6 faces.
Chaque joueur à son tour tourne le dé d'un quart de tour.
La valeur obtenue est enlevée à la somme.
Le premier qui arrive à 0 ou moins a perdu.
'''

import random
import sys # pour afficher du texte en couleur

color = sys.stdout.shell # Pour pouvoir écrire en couleur.

# Valeur de départ. Un nombre au hasard entre 24 et 32
Somme = random.randint(24,32) 

# On lance le dé au hasard
ValDe = random.randint(1,6) # un nombre au hasard entre 1 et 6

while (Somme > 0):
  # Boucle du jeu
  color.write("La somme vaut : " + str(Somme) + \
              ". Le dé montre la face : " + str(ValDe) + "\n", "console")

  # Demande un nombre au joueur, en testant qu'il est possible.
  color.write("Joueur n°1, en entrez la nouvelle face : ", "stdout")
  nJoueur1 = int(input())
  while (nJoueur1 < 1) or (nJoueur1 > 6) \
     or (nJoueur1 == ValDe) or (nJoueur1 == 7 - ValDe):
      color.write("Entrée non valide\n", "stderr")
      color.write("Joueur, en entrez la nouvelle face : ", "stdout")
      nJoueur1 = int(input())

  ValDe = nJoueur1
  Somme = Somme - nJoueur1
  color.write("La somme vaut : " + str(Somme) + \
              ". Le dé montre la face : " + str(ValDe) + "\n", "console")

  if (Somme <= 0):
    color.write("Vous avez perdu.\n", "stderr")
    break

  # L'ordinateur joue au hasard, en testant qu'il est possible.
  nJoueur2 = random.randint(1,6)
  while (nJoueur2 == ValDe)or (nJoueur2 == 7 - ValDe):
    nJoueur2 = random.randint(1,6)

  ValDe = nJoueur2
  Somme = Somme - nJoueur2

  color.write("L'ordinateur a joué : " + str(nJoueur2) + "\n", "STRING")

  if (Somme <= 0):
    color.write("L'ordinateur a perdu.\n", "stderr")
    break

color.write("Terminé avec la somme : " + str(Somme) + "\n", "console")

# ex_VI01a_Testons_livret_de_7.py
# Tapez : help(livretDe7)  pour avoir de l'aide sur la fonction.

def livretDe7():
#=============
    ''' Affiche le livret de 7.'''
    nn=1
    while nn<11:
        print(nn*7,end=" ")
        nn+=1
    print()

livretDe7()

# ex_VI01b_Testons_livret.py
# Tapez : help(livretDe)  pour avoir de l'aide sur la fonction.
'''
Affiche le livret d'une base choisi par l'utilisateur.
Montre également la gestion d'exception.
"int(lettre)" génère une exception, qui est traitée dans
la partie "except:". Ici, on sort simplement du programme.
'''

def livretDe(base):
#=============
    ''' Affiche le livret d'une base choisie pas l'utilisateur.'''
    nn=1
    while nn<11:
        print(nn*base,end=" ")
        nn+=1
    print()


while True:
    try:
        aa=int(input("Quelle base ? (Taper Q pour quitter) : "))
    except:
        print("Au revoir...")
        break
    livretDe(aa)

# ex_VI02a_Fonction_avec_plusieurs_parametres.py
# Tapez : help(tableMulti)  pour avoir de l'aide sur la fonction.

def tableMulti(base, debut, fin):
# ===============================
    ''' Génère la table de multiplication de "base" de debut à fin'''
    nn=debut
    while (nn<fin):
        print(nn*base, end=" ")
        nn+=1

# Utilisation de la fonction "tableMulti"
# Pour générer plusieurs tables de multiplications.
tt, dd, ff = 11, 5, 10 
while (tt<21):
    tableMulti(tt, dd, ff)
    print()
    tt, dd, ff = tt +1, dd +3, ff +5 

# ex_VI03a_Les_parametres_facultatifs_d_une_fonction.py
# Tapez : help(essai)  pour avoir de l'aide sur la fonction.
'''
Montre que l'on peut définir des paramètres facultatifs,
qui ont une valeur par défaut.
Montre également que si on nomme les paramètres,
leur ordre n'est pas important.
'''

def essai(x, y=0):
# ===============================
    ''' Un essai de paramètre facultatif '''
    return(x+y)

print(essai(21))
print(essai(21, 2))
print(essai(21, y=2))
print(essai(y=2, x=21))

# ex_VI04a_Testons_une_variable_est_elle_la_meme_que_dans_la_boucle.py
# Tapez : help(chezMoi)  pour avoir de l'aide sur la fonction.
'''
Montre qu'une variable locale à une fonction ne peut pas changer
la variable de même nom définie à l'extérieur de la fonction.
'''

#rr = 130
def chezMoi():
#=============
    ''' Montre que la variable "rr" est locale à la fonction\
        et ne modifie pas la variable "rr" définie à l'extérieur de la fonction.'''
    pp=100
    rr=200
    print("chezMoi:", end=" ")
    print(pp, end=" ")
    print(qq, end=" ")
    print(rr)

# boucle principale
pp, qq = 111, 120
chezMoi()
print("dehors :", end=" ")
print(pp, end=" ")
print(qq, end=" ")
print(rr)

# ex_VI04b_Testons_une_variable_est_elle_la_meme_que_dans_la_boucle.py
# Tapez : help(chezMoi)  pour avoir de l'aide sur la fonction.
'''
Montre qu'en définissant une variable "global" dans une fonction
elle peut changer la variable de même nom définie à l'extérieur de la fonction.
'''

#rr = 130
def chezMoi():
#=============
    ''' Montre que les variables "rr" et "pp" sont globals\
        et modifient les variables "rr" et "pp" définient à l'extérieur de la fonction.'''
    global pp, rr
    pp=100
    rr=200
    print("chezMoi:", end=" ")
    print(pp, end=" ")
    print(qq, end=" ")
    print(rr)

# boucle principale
pp, qq = 111, 120
chezMoi()
print("dehors :", end=" ")
print(pp, end=" ")
print(qq, end=" ")
print(rr)

# ex_VI06a_Fonction_retournant_une_chaine.py
# Tapez : help(ligneCar)  pour avoir de l'aide sur la fonction.

def ligneCar(nn, car):
#=====================
    ''' Retourne une chaîne de caractères qui répète nn fois le caractère "car"'''
    chaine=""
    for ii in range(0,nn): # range(0, nn) donne les nombre de  0 à  nn-1
        chaine += car
    return chaine

def hmi_ligneCar():
#==================
    lettre=input("Quelle lettre ? ")
    nb=int(input("Combien de fois la répéter ? (<=0 pour quitter) : "))
    if (nb<=0):
        return False
    
    print(ligneCar(nb,lettre))
    return True

while hmi_ligneCar():
    continue

# ex_VI07a_Fonction_retournant_un_livret_dans_une_chaine.py

def livretDe(base):
#==================
    ''' Retourne le livret de "base" dans une chaîne de caractères'''
    nn = 1
    resultat = ""
    while (nn<11):
        resultat = resultat + " " + str(nn*base)
        nn += 1
    return resultat

while True:
    try:
        aa = int(input("Quelle base ? (Taper une lettre pour quitter) : "))
    except:
        break
    print(livretDe(aa))

# ex_VI08a_Fonction_retournant_un_reel.py

def surfCercle(rr):
#==================
    ''' Retourne l'aire d'un disque de rayon "rr"'''
    from math import pi
    return pi*rr**2

def hmi_surfCercle():
#====================
    ''' Calcule plusieurs aires, de rayon introduit par l'utilisateur'''
    rayon = float(input("Quel est le rayon du cercle ? (<=0 pour quitter) : "))
    if (rayon <= 0):
        return False
    print(surfCercle(rayon))
    return True

while hmi_surfCercle():
    continue

# ex_VI09a_Fonction_maximum.py
# Fonction qui retourne le maximum de 3 nombres

def maximum(n1, n2, n3):
#=======================
    ''' Retourne le maximum des trois nombres donnés'''
    if (n1 > n2):
        # Le maximum est n1 ou n3
        if (n1 > n3):
            return n1
        else:
            return n3
    else:
        # le maximum est n2 ou n3
        if (n2 > n3):
            return n2
        else:
            return n3

# Dans tous les exemples ci-dessous, l'affichage donne le nombre  : 7
print(maximum(2, 5, 7))
print(maximum(5, 2, 7))
print(maximum(2, 7, 5))
print(maximum(7, 2, 5))

# ex_VI10a_Compter_une_occurence.py
# Fonction compte combien de fois un caractère apparaît dans une chaîne donnée

def CompteCar(car, ch):
#======================
    ''' Retourne le nombre de fois que le caractère car apparaît dans la chaîne ch'''
    nbCar=0  # compte le nombre de caractères
    for cc in ch:
        if cc == car:
            nbCar += 1; # un caractère a été trouvé

    return nbCar

# Test de la fonction
print("Nombre de caractères =", CompteCar("e", "Cette phrase est un exemple"))

# ex_VI12a_Compter_les_mots.py
# Fonction qui retourne le nombre de mots contenu dans une phrase
# La fonction est assez subtile, pas facile à trouver.

def compteMot(phrase):
#=====================
    '''Compte le nombre de mots se trouvant dans la phrase donnée.
    (un mot etant tout ensemble de caracteres inclus entre des espaces)'''
    nbMot = 0 # Compteur du nombre de mots

    # Il faut avoir un ou plusieurs espaces suivit d'un caractère pour comptabiliter un mot.
    separateur=True  # comme si on avait un espace en début de phrase.
    for car in phrase:
        if car==" ":
            separateur=True
        elif separateur:
            nbMot+=1
            separateur=False
        else:
            separateur=False
            
    return nbMot

# Autre fonction identique, selon un algorithme différent.
def compteMot2(phrase):
#======================
    '''Compte le nombre de mots se trouvant dans la phrase donnée.
    (un mot etant tout ensemble de caracteres inclus entre des espaces)'''
    nbMot = 0 # Compteur du nombre de mots

    # Il faut avoir un ou plusieurs espaces suivit d'un caractère pour comptabiliter un mot.
    nn = 0 # compte où on en est dans la phrase
    while (nn < len(phrase)):
        while ( (nn < len(phrase)) and (phrase[nn] == " ") ): # saute les espaces consécutifs
            nn += 1;

        if (nn < len(phrase)):
            nbMot+=1 # on comptabilise un mot
                
        while ( (nn < len(phrase)) and (phrase[nn] != " ") ): # saute caractères non espaces consécutifs
            nn += 1;
            
    return nbMot

# Test de la fonction
print("Nombre de mots =", compteMot("Cette   phrase est un exemple qui contient neuf mots"))
print("Nombre de mots =", compteMot2("Cette   phrase est un exemple qui contient neuf mots"))

# ex_VI13a_serie_approcher_pi_sur_2
# Voici un code utilisant une fonction, pour approcher le nombre pi/2

def FractionCalcule(k):
#======================
    return (float(2*k + 2) / (2*k + 1) * (2*k + 2) / (2*k + 3))

n = 0
produit = 1

while n < 100000:
    produit = produit * FractionCalcule(n)
    n = n + 1
    
print("Le nombre pi est environs égale à ", 2*produit)

# ex_VII01a_turtle_carre.py
# À l'aide du module "turtle",
# dessine un carré de taille et de couleur choisie

from turtle import *

# défini la position et la taille de la fenêtre.
setup(width=900, height=950, startx=10, starty=15)
speed(0) # vitesse maximale de dessin
delay(0) # va encore plus vite

def carre(taille, couleur="black"):
    color(couleur)
    c = 0
    while (c < 4):
        forward(taille)
        right(90)
        c += 1

# Test la fonction carre
up()
goto(-400,0) # se positionne plus à gauche de la fenêtre
down()
carre(200, 'blue')

up()
forward(300)
down()
carre(200)

# ex_VII02a_turtle_defi_1.py
# À l'aide du module "turtle",
# dessine un carré de taille, de couleur et d'orientation choisies,
# dessine un triangle de taille, de couleur et d'orientation choisies.

from turtle import *

# défini la position et la taille de la fenêtre.
setup(width=900, height=950, startx=10, starty=15)
speed(0) # vitesse maximale de dessin
delay(0) # va encore plus vite

def carre(taille, couleur="black", angle=0):
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 4):
        forward(taille)
        right(90)
        c += 1

def triangle(taille, couleur="black", angle=0):
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 3):
        forward(taille)
        right(120)
        c += 1

# Test la fonction carre
def test1():
    up()
    goto(-400,0) # se positionne plus à gauche de la fenêtre
    down()
    carre(200, 'blue')

    up()
    forward(300)
    down()
    carre(200)

    up()
    forward(300)
    down()
    carre(200, 'green', 30)


# Test la fonction triangle
def test2():
    up()
    goto(-400,0) # se positionne plus à gauche de la fenêtre
    down()
    triangle(200, 'blue')

    up()
    forward(300)
    down()
    triangle(200)

    up()
    forward(300)
    down()
    triangle(200, 'green', 30)


# Test une suite de carrés et de triangles
def test3():
    up()
    goto(-440,0) # se positionne plus à gauche de la fenêtre
    down()

    # Dessine une suite de 5 carrés rouge et 5 triangles bleus
    nn = 0
    while (nn < 5):
        carre(40+20*nn, 'red')
        up()
        forward(50+20*nn)
        down()
        triangle(40+20*nn, 'blue')
        up()
        forward(50+20*nn)
        down()
        nn += 1

test3()

# ex_VII03a_turtle_defi_2.py
# À l'aide du module "turtle",
# dessine un carré de taille, de couleur et d'orientation choisies,
# dessine un triangle de taille, de couleur et d'orientation choisies,
# dessine une étoile à 5 branches de taille, de couleur et d'orientation choisies.

from turtle import *

# défini la position et la taille de la fenêtre.
setup(width=900, height=950, startx=10, starty=15)
speed(0) # vitesse maximale de dessin
delay(0) # va encore plus vite

def carre(taille, couleur="black", angle=0):
    '''dessine un carré'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 4):
        forward(taille)
        right(90)
        c += 1

def triangle(taille, couleur="black", angle=0):
    '''dessine un triangle'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 3):
        forward(taille)
        right(120)
        c += 1

def etoile5(taille, couleur="black", angle=0):
    '''dessine une étoile à 5 branches'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 5):
        forward(taille)
        right(180 - 36)
        c += 1

# Test la fonction carre
def test1():
    up()
    goto(-400,0) # se positionne plus à gauche de la fenêtre
    down()
    carre(200, 'blue')

    up()
    forward(300)
    down()
    carre(200)

    up()
    forward(300)
    down()
    carre(200, 'green', 30)


# Test la fonction triangle
def test2():
    up()
    goto(-400,0) # se positionne plus à gauche de la fenêtre
    down()
    triangle(200, 'blue')

    up()
    forward(300)
    down()
    triangle(200)

    up()
    forward(300)
    down()
    triangle(200, 'green', 30)


# Test une suite de carrés et de triangles
def test3():
    up()
    goto(-440,0) # se positionne plus à gauche de la fenêtre
    down()

    # Dessine une suite de 5 carrés rouge et 5 triangles bleus
    nn = 0
    while (nn < 5):
        carre(40+20*nn, 'red')
        up()
        forward(50+20*nn)
        down()
        triangle(40+20*nn, 'blue')
        up()
        forward(50+20*nn)
        down()
        nn += 1


# Test une suite de 9 d'étoiles à 5 branches
def test4():
    up()
    goto(-440,0) # se positionne plus à gauche de la fenêtre
    down()

    nn = 0
    while (nn < 9):
        taille = 100 - 5*(nn - 4)**2
        etoile5(taille, 'blue')
        up()
        forward(taille+10)
        down()
        nn += 1

test4()

# ex_VII04a_turtle_defi_3.py
# À l'aide du module "turtle",
# dessine un carré de taille, de couleur et d'orientation choisies,
# dessine un triangle de taille, de couleur et d'orientation choisies,
# dessine une étoile à 5 branches de taille, de couleur et d'orientation choisies,
# dessine une étoile à 6 branches de taille, de couleur et d'orientation choisies.

from turtle import *

# défini la position et la taille de la fenêtre.
setup(width=900, height=950, startx=10, starty=15)
speed(0) # vitesse maximale de dessin
delay(0) # va encore plus vite

def carre(taille, couleur="black", angle=0):
    '''dessine un carré'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 4):
        forward(taille)
        right(90)
        c += 1

def triangle(taille, couleur="black", angle=0):
    '''dessine un triangle'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 3):
        forward(taille)
        right(120)
        c += 1

def etoile5(taille, couleur="black", angle=0):
    '''dessine une étoile à 5 branches'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    c = 0
    while (c < 5):
        forward(taille)
        right(180 - 36)
        c += 1

def etoile6(taille, couleur="black", angle=0):
    '''dessine une étoile à 6 branches'''
    seth(angle) # défini l'orientation de la tortue
    color(couleur)
    triangle(taille, couleur, angle)
    up()
    right(90)
    forward(taille*0.577) # 0.577 = sin(120°) / (3 * sin(30°))
    down()
    triangle(taille, couleur, angle+60)
    seth(angle)
    up()
    left(90)
    forward(taille*0.577)
    down()
    seth(angle)

# Test la fonction carre
def test1():
    up()
    goto(-400,0) # se positionne plus à gauche de la fenêtre
    down()
    carre(200, 'blue')

    up()
    forward(300)
    down()
    carre(200)

    up()
    forward(300)
    down()
    carre(200, 'green', 30)


# Test la fonction triangle
def test2():
    up()
    goto(-400,0) # se positionne plus à gauche de la fenêtre
    down()
    triangle(200, 'blue')

    up()
    forward(300)
    down()
    triangle(200)

    up()
    forward(300)
    down()
    triangle(200, 'green', 30)


# Test une suite de carrés et de triangles
def test3():
    up()
    goto(-440,0) # se positionne plus à gauche de la fenêtre
    down()

    # Dessine une suite de 5 carrés rouge et 5 triangles bleus
    nn = 0
    while (nn < 5):
        carre(40+20*nn, 'red')
        up()
        forward(50+20*nn)
        down()
        triangle(40+20*nn, 'blue')
        up()
        forward(50+20*nn)
        down()
        nn += 1


# Test une suite de 9 d'étoiles à 5 branches
def test4():
    up()
    goto(-440,0) # se positionne plus à gauche de la fenêtre
    down()

    nn = 0
    while (nn < 9):
        taille = 100 - 5*(nn - 4)**2
        etoile5(taille, 'blue')
        up()
        forward(taille+10)
        down()
        nn += 1


# Test une suite de carrés, de triangles et d'étoiles
# N'est pas exactement le dessin du cours, mais c'est joli.
def test5():
    up()
    goto(-120,-140) # se positionne plus à gauche de la fenêtre
    down()

    nn = 0
    while (nn < 10):
        taille = 20 + 10*nn

        etoile6(taille, 'blue', 60*nn)
        up()
        forward(taille+10)
        down()
        carre(taille, 'red', 60*nn)
        up()
        forward(taille+10)
        down()
        etoile5(taille, 'blue', 60*nn)
        up()
        forward(taille+10)
        down()
        triangle(taille, 'red', 60*nn)
        up()
        forward(taille+10)
        right(90)
        forward(taille*0.66)
        down()

        nn += 1

test5()

# s12af2_turtle_flocon_Koch.py
# Série 12, activité F.2
# Utilisant la turtle et
# Dessin de flocon de Koch, récursif

# c.f. https://docs.python.org/3/library/turtle.html
# c.f. https://docs.python.org/3/library/turtle.html#turtle.speed
from turtle import *
#from random import randrange

def segment(taille, niveau):
   "Un segment de Koch"
   if niveau == 0:
      forward(taille)
   else:
      # angle = 40 + randrange(31)
      segment(taille//3, niveau-1)
      left(angle)
      segment(taille//3, niveau-1)
      right(2*angle)
      segment(taille//3, niveau-1)
      left(angle)
      segment(taille//3, niveau-1)

def flocon(taille, niveau):
   "Un flocon de Koch"
   segment(taille, niveau)
   right(120)
   segment(taille, niveau)
   right(120)
   segment(taille, niveau)
   right(120)

# Fonction  __main__
setup(width=900, height=950, startx=10, starty=15)
title("Flocon de Koch")
speed(0) # 0 = vitesse maximale, 10 = rapide,  1 = lent
delay(0) # va encore plus vite

up()
goto(-420, 200)
down()

angle=60  # angle = 60 pour un flocon de Koch standard
flocon(729, 3)    

# ex_VIII01a_le_type_de_donnee_list.py

Li1 = [ 1 , 2 , 3 ]
print (type ( Li1 ))
print (Li1)
#
Li2 =[27 , "Bonjour  comment  allez-vous  ?" , 3.1415 , Li1 ]
print (type ( Li2 ))
print (Li2)
#
Li3=range ( 1 , 4 , 1 )
print (type ( Li3 ))
print (Li3)
#
Li4 = [ ]
print (type ( Li4 ))
print (Li4)
#
Li5 =[ Li1 , Li2 , Li3 , Li4 ]
print (type ( Li5 ))
print (Li5)

# La liste  Li5  est une liste de listes
# Vu qu'un élément de  Li2  est une liste,
# Li5  contient un élément qui est une liste qui contient une liste !
# Clairement les éléments d'un objet de type "list"
# ne sont pas obligatoirement du même type.

#----------------------------------------------------
print("Conversions de listes...")
print("Concersion de string en liste : ", end="")
li11 = list("bonjour")
print(li11)
print("Concersion de list en string : ", end="")
li11[0] = 'B'
str11 = "".join(li11) # c.f. https://www.w3schools.com/python/ref_string_join.asp
print(str11)

# ex_VIII02a_l_instruction_list.py

txt="Bonjour ,  comment  allez-vous  ?"
Li = list( txt ) # Crée un objet de type "list", à partir d'un "string"
                 # Décompose le "string" en ses caractères.
print( Li )
print(type( txt ))
print(type( Li ))

# ex_VIII03a_operation_sur_les_listes_de_nombres.py

Li = [ -2, 3.14, 37, -786.2 ]
print(Li)
print(min( Li ))
print(max( Li ))
print(sum( Li ))

t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin',\
        'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']

# ex_VIII04a_operation_sur_les_listes.py

Li1 = [ 1, 2, " bonjour " ]
Li2 = [ [ 3, list( "texte" ) ] , [ ] , 7.56 , "a" ]

print(Li1)
print(Li2)
print(len ( Li1 ) ,  len ( Li2 ))

Li = Li1 + Li2
print(Li)

Li3 = 2 * Li1
print(Li3)

# ex_VIII05a_test_d_appartenance.py

texte="Bonjour, comment allez-vous  ?"
Li = list(texte) + [[ 1, 2, 3 ], 7 ]
print(Li)

print("o"  in  Li)
print("o"  in texte)
print(1  in  Li)
print(7 not in  Li)
print([1,2,3]  in  Li)
print([2,1,3]  in  Li)

# ex_VIII06a_elements_d_une_liste.py

texte = "Bonjour, comment allez-vous ?"
Li = list( texte )
print("a :", Li)
print("b :", len(Li))

print("c :", Li[0])
print("d :", Li[5])

print("e :", Li[1])
print("f :", Li[3])

print("g :", Li[3 : 9 : 2 ])
print("h :", Li[3 : ])
print("i :", Li[: 3 ])

print("j :", Li[ : : 2 ])
print("k :", Li[ 1 :  1 : 2 ])
print("l :", Li[ : :  1 ])

# ex_VIII07a_modulo.py

jour = ['dimanche','lundi','mardi','mercredi','jeudi','vendredi','samedi']
a, b = 0, 0
while (a < 25):
     a = a + 1
     b = a % 7
     print('{:3d}'.format(a), jour[b]) # c.f. https://pyformat.info/

# ex_VIII09a_fusion_organisee_de_listes.py

t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin',\
      'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']
t3 = []
for nn in range(0,len(t1)): # nn varie de 0 à len(t1)-1
     t3.append(t1[nn])
     t3.append(t2[nn])

# Affiche la nouvelle liste.  "\n" insert un retour à la ligne.
print("Nouvelle liste :\n", t3)

# ex_VIII10a_afficher_proprement.py

t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin',\
      'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']
for elem in t2:
     print(elem, end=" ")

# ex_VIII11a_le_plus_grand_vaut.py
# Recherche du plus grand élément d'une liste de nombres.

Li = [32, 5, 12, 8, 3, 75, 2, 15]

# Méthode évidente, en utilisant une méthode de la liste.
print("Le max. de la liste vaut :", max(Li))

# Méthode qui cherche les deux plus grand éléments de la liste.
if (Li[0] > Li[1]):
    Max1 = Li[0]  # est le plus grand
    Max2 = Li[1]  # est le 2ème plus grand
else:    
    Max1 = Li[0]
    Max2 = Li[1]

# Cherche les deux plus grand éléments de la liste
for elem in Li[2::]:
    print(elem)
    if (elem >= Max1):
        Max2 = Max1  # 2ème plus grand élément
        Max1 = elem
    elif (elem >= Max2):
        Max2 = elem # le 2ème plus grand élément change.

print("Les deux plus grands éléments de la liste sont :\n", Max2, Max1)

# Autre manière de faire, qui modifie la liste
newMax1 = max(Li)
Li.remove(newMax1)
newMax2 = max(Li)
Li.append(newMax1) # pour ne pas perdre un élément de la liste
print("Les deux plus grands éléments de la liste sont :\n", newMax2, newMax1)

# ex_VIII12a_separer_en_divers_listes.py
# Sépare une liste de nombres en ses éléments pairs et ses éléments impairs

Li = [32, 5, 12, 8, 3, 75, 2, 15]

Paires = []
Impaires = []

# Cherche les deux plus grand éléments de la liste
for elem in Li:
    if (elem % 2 == 0): # Nombre pair, car divisible par 2
        Paires.append(elem)
    else:
        Impaires.append(elem)

print("Les nombres pairs de la liste sont :\n", Paires)
print("Les nombres impairs de la liste sont :\n", Impaires)

# ex_VIII14a_le_plus_grand_est_place.py
# Sépare une liste de nombres en ses éléments pairs et ses éléments impairs

Li = [32, 5, 12, 8, 3, 75, 2, 15]

Max1 = max(Li)
Max1pos = Li.index(Max1)
print("Le plus grand nombre de la liste est :", Max1)
print("Il est placé en position :", Max1pos)

# s01a_ex01_jeu_du_beseu.py
# Série 1, exercice 1
'''
Le jeu du beseu.
Programme qui affiche les nombres entiers de 1 à 30 (ou plus),
qui affiche "beseu" à la place des multiples de 7 et des nombres terminant par 7 et
qui affiche le sens, soit "droite" soit "gauche".
'''

import time # pas indispensable, pour ne pas afficher trop rapidement.

nn = 0
sens = "droite"  # le sens
while (nn < 30):
    nn += 1
    if (nn % 10 == 7) or (nn % 7 == 0):
        if (sens == "droite"):
            sens = "gauche"
        else:
            sens = "droite"
 
        print("beseu")
    else:
        print(sens, nn)

    time.sleep(0.1)

# s01a_ex02_compte_voyelles.py
# Série 1, exercice 2
'''
Compte le nombre de voyelles se trouvant dans un texte.
'''

chaine = input("Taper une chaine de caractères, je vous dirai le nombre de 'e' qu'elle contient.\n")

lesVoyelles="aàâAÀÂeéèêëEÈËiîïiIÏÎoôöOÔÖuùüûUÙÜÛyY" #Astuce : on va tester différentes voyelles, on les groupe dans une chaîne

nCompte = 0 # Compte le nombre de voyelles dans la chaîne
nn = 0
while (nn < len(chaine)):
  if (chaine[nn] in lesVoyelles):
    #  in   permet de vérifier si un élément fait partie d'une séquence
    nCompte += 1
  nn += 1

if (nCompte > 0):
    print("Il y a", nCompte, "voyelles dans la chaîne :", chaine)
else:
    print("Il n'y a pas de voyelles dans la chaine :", chaine)

# s01a_ex03_fonction_a_deviner.py
# Série 1, exercice 3
'''
Fonction qui prend deux nombres entiers en entrée.
Tant que les deux nombres sont positifs, remplace le plus grand par la différence entre le plus grand et le plus petit.
À la sortie de la boucle, un des deux nombres est nul.
L'autre nombre est affiché.
'''

def adeviner(nb1, nb2):
#======================
    ''' À commenter pour indiquer ce que calcule cette fonction. '''
    nb10 = nb1 # mémorise les valeurs de nb1 et nb2
    nb20 = nb2
    while (nb1 > 0) and (nb2 > 0):
        if (nb2 > nb1): # Assure que nb1 > nb2
            nb2 = nb2 - nb1
        else:
            nb1 = nb1 - nb2

    if (nb1 == 0):
        sol = nb2
    else:
        sol = nb1
        
    print("Le résultat entre", nb10, "et", nb20, "est", sol)

adeviner(60, 42)
adeviner(1092, 1001)
adeviner(714285, 999999)
adeviner(60, 15)

print(714285 / 142857)
print(999999 / 142857)

# s01a_ex04_turtle_marche_aleatoire.py
# Série 1, exercice 4
# Utilisant : turtle
# Simulation d'une marche aléatoire, la marche de l'ivrogne
# L'ivrogne tourne aléatoirement d'un angle de 90°, ou ne tourne pas

# c.f. https://docs.python.org/3/library/turtle.html
# c.f. https://docs.python.org/3/library/turtle.html#turtle.speed
from turtle import *
from random import randrange

setup(width=700, height=550, startx=10, starty=15) # Position et dimension de la fenêtre graphique
title("Marche aléatoire, marche de l'ivrogne")
speed(0) # 0 = vitesse maximale, 10 = rapide,  1 = lent
delay(0) # va encore plus vite

down()
nn = 0 # compte le nombre de pas fait par l'ivrogne.
while (nn < 200):
    nn += 1
    # Aléatoirement, tourne à gauche ou à droite
    aleat = randrange(3) # tire un nombre entier entre 0 et 2
    if (aleat == 0):
        left(90)
    elif (aleat == 1):
        right(90)
    # else: continue tout droit.

    # puis avance de ... pixels.
    forward(5)

# s01a_ex05_automate_1d_non_commente.py
# Automate cellulaire en une dimension

str = 30*" "    # 
Li = list(str)  # Conversion de la chaine en liste
Li[15] = "*"    # 
Li2 = Li.copy() # 

# 
for elem in Li:
    print(elem, end="") #
print()

# 
for repete in range(1,90):

    # 
    for nn in range(2, len(Li)-2):

        # 
        cpt = 0
        for kk in range(nn-2, nn+3):
            if (Li[kk] == "*"):
                cpt += 1
        
        if (cpt == 1):    # 
            Li2[nn] = "*"
        elif (cpt == 3):    # 
            Li2[nn] = " "
        else:                # 
            Li2[nn] = Li[nn]

    Li = Li2.copy() # 

    # 
    for elem in Li:
        print(elem, end="")
    print()

# s01a_ex05_automate_1d_commente.py
# Automate cellulaire en une dimension

str = 30*" "    # Création d'une chaine de caractère de 30 espaces
Li = list(str)  # Conversion de la chaine en liste
Li[15] = "*"    # Remplace le 15e élément de la liste par une étoile
Li2 = Li.copy() # Duplification de la liste

# Affiche les éléments de la liste
for elem in Li:
    print(elem, end="") # affiche un élément de la liste, sans retour de ligne.
print()

# Répète 90 fois une suite d'instructions
for repete in range(1,90):

    # Boucle sur tous les éléments de la liste, sauf les deux premiers et les deux derniers
    for nn in range(2, len(Li)-2):

        # Compte le nombre d'étoiles dans les 5 "voisins" de la position  nn
        cpt = 0
        for kk in range(nn-2, nn+3):
            if (Li[kk] == "*"):
                cpt += 1
        
        if (cpt == 1):    # Si un seul voisin, change l'élément  nn en  "*"
            Li2[nn] = "*"
        elif (cpt == 3):    # Si trois voisins, change l'élément  nn  en  " "
            Li2[nn] = " "
        else:                # Sinon, laisse inchangé l'élément  nn
            Li2[nn] = Li[nn]

    Li = Li2.copy() # Copie la nouvelle liste dans l'originale

    # Affiche les éléments de la liste
    for elem in Li:
        print(elem, end="")
    print()

# s01a_ex05_turtle_marche_aleatoire_multiple.py
# Série 1, exercice 4
# Utilisant : turtle
# Simulation d'une marche aléatoire, la marche de l'ivrogne
# L'ivrogne tourne aléatoirement d'un angle de 90°, ou ne tourne pas

# c.f. https://docs.python.org/3/library/turtle.html
# c.f. https://docs.python.org/3/library/turtle.html#turtle.speed
from turtle import *
from random import randrange

MAXTurtle = 10 # nombre de tortues noires + 1 pour la rouge

setup(width=700, height=550, startx=10, starty=15) # Position et dimension de la fenêtre graphique
title("Marche aléatoire, marche de l'ivrogne")
speed(0) # 0 = vitesse maximale, 10 = rapide,  1 = lent
delay(0) # va encore plus vite

colorlist = ["#8000ff","#8000ff", "yellow", "green", "black", "blue", "brown", "purple", "cyan", "magenta"]
            # c.f. https://matplotlib.org/examples/color/named_colors.html

aList = list()
for ii in range(MAXTurtle+1):
    aList.append(Turtle(shape="classic")) # “arrow”, “turtle”, “circle”, “square”, “triangle”, “classic”.
    aList[ii].color(colorlist[ii % len(colorlist)])
    aList[ii].speed(0) # 0 = vitesse maximale, 10 = rapide,  1 = lent
    #aList[ii].turtlesize(0.5)

#down()
nn = 0 # compte le nombre de pas fait par l'ivrogne.
while (nn < 300):
    nn += 1
    for ii in range(MAXTurtle+1):
        # Aléatoirement, tourne à gauche ou à droite
        aleat = randrange(3) # tire un nombre entier entre 0 et 2
        if (aleat == 0):
            aList[ii].left(90)
        elif (aleat == 1):
            aList[ii].right(90)
        # else: continue tout droit.

        # puis avance de ... pixels.
        aList[ii].forward(5)

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI00a_premiers_pas_avec_tkinter.py
Commence à utiliser la librairie graphique standard de python
'''

from tkinter import *  # importe toutes les classes du module tkinter

fen1 = Tk()
# instanciation d’un objet à partir d’une classe :
# Avec la classe Tk(), nous en créons une instance la fenêtre fen1
        
tex1 = Label(fen1, text='Bonjour tout le monde !', fg='red')
# objet "widget" tex1 créé par instanciation de la classe Label()

tex1.pack() # active une méthode associée à l’objet tex1

bou1 = Button(fen1, text='Quitter', command = fen1.destroy)
# création d’un autre widget « esclave » : un bouton.

bou1.pack()
# méthode pack() pour adapter la géométrie de la fenêtre au nouvel objet

fen1.mainloop()
# démarrage du réceptionnaire d’événements associé à la fenêtre

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI00b_premiers_pas_avec_tkinter.py
Commence à utiliser la librairie graphique standard de python
'''

from tkinter import *  # importe toutes les classes du module tkinter

fen1 = Tk()
# instanciation d’un objet à partir d’une classe :
# Avec la classe Tk(), nous en créons une instance la fenêtre fen1

# Permet de positionner la fenêtre sur l'écran et de définir
# les dimensions de la fenêtre.
hauteur = 300
largeur = 600
xpos = 400
ypos = 300
fen1.wm_geometry("%dx%d+%d+%d" % (largeur, hauteur, xpos, ypos))
# Définit la position et les dimensions de la fenêtre.

#fen1.wm_geometry("+%d+%d" % (xpos, ypos))
# Ne définit que la position, hauteur et largeur par défaut.

        
tex1 = Label(fen1, text='Bonjour tout le monde !', fg='red')
# objet "widget" tex1 créé par instanciation de la classe Label()

tex1.pack() # active une méthode associée à l’objet tex1

bou1 = Button(fen1, text='Quitter', command = fen1.destroy)
# création d’un autre widget « esclave » : un bouton.

bou1.pack()
# méthode pack() pour adapter la géométrie de la fenêtre au nouvel objet

fen1.mainloop()
# démarrage du réceptionnaire d’événements associé à la fenêtre

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI01a_trace_de_lignes_dans_un_canevas.py
Utilisation de tkinter pour tracer des lignes dans un canevas
'''

from tkinter import *  # importe toutes les classes du module tkinter
from random import randrange

# --- définition des fonctions gestionnaires d'événements : ---
def drawline():
#==============
    "Tracé d'une ligne dans le canevas can1"
    global x1, y1, x2, y2
    can1.create_line(x1,y1,x2,y2,width=2,fill=coul)

    # modification des coordonnées pour la ligne suivante :
    y2, y1 = y2+10, y1-10


def changecolor():
#=================
    "Changement aléatoire de la couleur du tracé"
    global coul
    pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
    c = randrange(8) # => génère un nombre aléatoire de 0 à 7
    coul = pal[c]

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
x1, y1, x2, y2 = 10, 190, 190, 10 # coordonnées de la ligne
coul = 'dark green' # couleur de la ligne

fen1 = Tk()
# Création du widget principal ("maître") :
# instanciation d’un objet à partir d’une classe :
# Avec la classe Tk(), nous en créons une instance la fenêtre fen1

# Permet de positionner la fenêtre sur l'écran
xpos = 400
ypos = 300
fen1.wm_geometry("+%d+%d" % (xpos, ypos))

fen1.title("Tacer des lignes avec tkinter") # titre de la fenêtre

# création des widgets "esclaves" :
can1 = Canvas(fen1, bg='dark grey', height=200, width=200)
can1.pack(side=LEFT)
bou1 = Button(fen1, text='Quitter', command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Tracer une ligne', command=drawline)
bou2.pack()
bou3 = Button(fen1, text='Autre couleur', command=changecolor)
bou3.pack()

fen1.mainloop() # démarrage du réceptionnaire d’événements associé à la fenêtre

fen1.destroy() # destruction (fermeture) de la fenêtre

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI01b_trace_de_lignes_dans_un_canevas.py
Utilisation de tkinter pour tracer des lignes dans un canevas

Exemple d'appel de plusieurs fonctions en pressant sur un bouton.
'''

from tkinter import *  # importe toutes les classes du module tkinter
from random import randrange

# --- définition des fonctions gestionnaires d'événements : ---
def drawline():
#==============
    "Tracé d'une ligne dans le canevas can1"
    global x1, y1, x2, y2
    can1.create_line(x1,y1,x2,y2,width=2,fill=coul)

    # modification des coordonnées pour la ligne suivante :
    y2, y1 = y2+10, y1-10


def changecolor():
#=================
    "Changement aléatoire de la couleur du tracé"
    global coul
    pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
    c = randrange(8) # => génère un nombre aléatoire de 0 à 7
    coul = pal[c]
    return True

def combine_funcs(*funcs):
#=========================
# Sert à appeler plusieurs fonctions en une seule fonction !
    def combined_func(*args, **kwargs):
        for f in funcs:
            f(*args, **kwargs)
    return combined_func

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
x1, y1, x2, y2 = 10, 190, 190, 10 # coordonnées de la ligne
coul = 'dark green' # couleur de la ligne

fen1 = Tk()
# Création du widget principal ("maître") :
# instanciation d’un objet à partir d’une classe :
# Avec la classe Tk(), nous en créons une instance la fenêtre fen1

# Permet de positionner la fenêtre sur l'écran
xpos = 400
ypos = 300
fen1.wm_geometry("+%d+%d" % (xpos, ypos))

fen1.title("Tacer des lignes avec tkinter") # titre de la fenêtre

# création des widgets "esclaves" :
can1 = Canvas(fen1, bg='dark grey', height=200, width=200)
can1.pack(side=LEFT)
bou1 = Button(fen1, text='Quitter', command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Tracer une ligne', command=drawline)
bou2.pack()
bou3 = Button(fen1, text='Autre couleur', command=changecolor)
bou3.pack()

# Manière d'appeler deux fonctions (ou plus) avec un seul bouton.
bou4 = Button(fen1, text='Ligne & couleur', command=combine_funcs(changecolor, drawline))
bou4.pack()
# On aurait également pu écrire une fonction qui appelle les deux fonctions désirées.

# Autre manière d'appeler deux fonctions comme une seule :
bou5 = Button( fen1, text='2 Lignes & couleurs',
               command=lambda:[changecolor(), drawline(),changecolor(), drawline()])
bou5.pack()

fen1.mainloop() # démarrage du réceptionnaire d’événements associé à la fenêtre
fen1.destroy() # destruction (fermeture) de la fenêtre

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI03a_trace_de_lignes_dans_un_canevas.py
Utilisation de tkinter pour tracer des lignes dans un canevas
Les lignes sont horizontales et verticales
'''

from tkinter import *  # importe toutes les classes du module tkinter
from random import randrange

# --- définition des fonctions gestionnaires d'événements : ---
def drawline():
#==============
    "Tracé d'une ligne dans le canevas can1"
    global x1, y1, x2, y2
    can1.create_line(x1,  3,  x1, 203,     width=2, fill=coul)
    can1.create_line( 3, y1, 203, y1, width=2, fill=coul)

    # modification des coordonnées pour les lignes suivantes :
    x1 = x1+10
    y1 = y1+10


def changecolor():
#=================
    "Changement aléatoire de la couleur du tracé"
    global coul
    pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
    c = randrange(8) # => génère un nombre aléatoire de 0 à 7
    coul = pal[c]

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
x1, y1 = 3, 3 # coordonnées de la ligne
coul = 'dark green' # couleur de la ligne

fen1 = Tk()
# Création du widget principal ("maître") :
# instanciation d’un objet à partir d’une classe :
# Avec la classe Tk(), nous en créons une instance la fenêtre fen1

# Permet de positionner la fenêtre sur l'écran
xpos = 400
ypos = 300
fen1.wm_geometry("+%d+%d" % (xpos, ypos))

fen1.title("Tacer des lignes avec tkinter") # titre de la fenêtre

# création des widgets "esclaves" :
can1 = Canvas(fen1, bg='dark grey', height=208, width=208)
can1.pack(side=LEFT)
bou1 = Button(fen1, text='Quitter', command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Tracer une ligne', command=drawline)
bou2.pack()
bou3 = Button(fen1, text='Autre couleur', command=changecolor)
bou3.pack()

fen1.mainloop() # démarrage du réceptionnaire d’événements associé à la fenêtre

fen1.destroy() # destruction (fermeture) de la fenêtre

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI05a_lignes_avec_viseur.py
Utilisation de tkinter pour tracer des lignes dans un canevas
Les lignes sont horizontales et verticales
Un viseur est tracé, si le bouton est cliqué.
'''

from tkinter import *  # importe toutes les classes du module tkinter
from random import randrange

# --- définition des fonctions gestionnaires d'événements : ---
def drawline():
#==============
    "Tracé d'une ligne dans le canevas can1"
    global x1, y1, x2, y2
    can1.create_line(x1,  3,  x1, 203,     width=2, fill=coul)
    can1.create_line( 3, y1, 203, y1, width=2, fill=coul)

    # modification des coordonnées pour les lignes suivantes :
    x1 = x1+10
    y1 = y1+10

def drawline2():
#==============
    "Tracé de lignes de viseur dans le canevas can1"
    can1.create_line(104 - 20, 104     , 104 + 20, 104,      width=2, fill="red")
    can1.create_line(104     , 104 - 20, 104     , 104 + 20, width=2, fill="red")


def changecolor():
#=================
    "Changement aléatoire de la couleur du tracé"
    global coul
    pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
    c = randrange(8) # => génère un nombre aléatoire de 0 à 7
    coul = pal[c]

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
x1, y1 = 3, 3 # coordonnées de la ligne
coul = 'dark green' # couleur de la ligne

fen1 = Tk()
# Création du widget principal ("maître") :
# instanciation d’un objet à partir d’une classe :
# Avec la classe Tk(), nous en créons une instance la fenêtre fen1

# Permet de positionner la fenêtre sur l'écran
xpos = 400
ypos = 300
fen1.wm_geometry("+%d+%d" % (xpos, ypos))

fen1.title("Tacer des lignes avec tkinter") # titre de la fenêtre

# création des widgets "esclaves" :
can1 = Canvas(fen1, bg='dark grey', height=208, width=208)
can1.pack(side=LEFT)
bou1 = Button(fen1, text='Quitter', command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Tracer une ligne', command=drawline)
bou2.pack()
bou4 = Button(fen1, text='Trace le viseur', command=drawline2)
bou4.pack()
bou3 = Button(fen1, text='Autre couleur', command=changecolor)
bou3.pack()

fen1.mainloop() # démarrage du réceptionnaire d’événements associé à la fenêtre

fen1.destroy() # destruction (fermeture) de la fenêtre

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI08a_deux_dessins.py
Utilisation de tkinter pour tracer des deux types de dessins.
'''

from tkinter import *

def cercle(x, y, r, coul ='black'):
#==================================
    "tracé d'un cercle de centre (x,y) et de rayon r"
    can.create_oval(x-r, y-r, x+r, y+r, outline=coul)
    
def figure_1():
#==============
    "dessiner une cible"
    # Effacer d'abord tout dessin préexistant :
    can.delete(ALL)

    # tracer les deux lignes (vert. Et horiz.) :
    can.create_line(100, 0, 100, can.winfo_height() -5, fill ='blue')
    can.create_line(0, 100, can.winfo_width() -5, 100, fill ='blue')
    
    # tracer plusieurs cercles concentriques :
    rayon = 15
    while rayon < 100:
        cercle(100, 100, rayon)
        rayon += 15 

    # affiche les dimensions du canvas.
    # 2 pixels de plus que lors de la création !
    print(can.winfo_width())
    print(can.winfo_height())

def figure_2():
#==============
    "dessiner un visage simplifié"
    # Effacer d'abord tout dessin préexistant :
    can.delete(ALL)

    # Les caractéristiques de chaque cercle sont
    # placées dans une liste de listes :
    cc = [[100, 100, 80, 'red'], # visage
          [70, 70, 15, 'blue'], # yeux
          [130, 70, 15, 'blue'], 
          [70, 70, 5, 'black'], 
          [130, 70, 5, 'black'],
          [44, 115, 20, 'red'], # joues
          [156, 115, 20, 'red'],
          [100, 95, 15, 'purple'], # nez
          [100, 145, 30, 'purple']] # bouche

    # on trace tous les cercles à l'aide d'une boucle :
    ii =0
    while ii < len(cc): # parcours de la liste
        el = cc[ii] # chaque élément est lui-même une liste
        cercle(el[0], el[1], el[2], el[3])
        ii += 1

##### Programme principal : ############
fen = Tk()
can = Canvas(fen, width=200, height=200, bg='ivory')
can.pack(side=TOP, padx=5, pady=5)
b1 = Button(fen, text='dessin 1', command=figure_1)
b1.pack(side=LEFT, padx=3, pady=3)
b2 = Button(fen, text='dessin 2', command=figure_2)
b2.pack(side=RIGHT, padx=3, pady=3)

# Affiche des valeurs incorrectes
print(can.winfo_width())
print(can.winfo_height())

# fen.update() permet de récupérer des valeurs correctes de taille de canvas.
# 2 pixels de plus que lors de la création.
fen.update()
print(can.winfo_width())
print(can.winfo_height())

fen.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI09a_olympique.py
Utilisation de tkinter pour tracer des 5 anneaux olympiques
'''

from tkinter import *

def cercle(x, y, r, coul ='black'):
#==================================
    "tracé d'un cercle de centre (x,y) et de rayon r"
    can.create_oval(x-r, y-r, x+r, y+r, outline=coul, width=5)
    # c.f. http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/create_oval.html

def figure_1():
#==============
    "dessin des 5 anneaux olympique"
    # Effacer d'abord tout dessin préexistant :
    can.delete(ALL)

    # Les caractéristiques de chaque cercle sont
    # placées dans une liste de listes :
    cc = [[ 50,  80, 40, 'cyan'],   # 'cyan' = '#00FFFF' 
          [100,  80, 40, 'black'],  # 'black' = '#000000' 
          [150,  80, 40, 'red'],    # 'red' = '#FF0000' 
          [ 75, 110, 40, 'yellow'], # 'cyan' = '#00FFFF' 
          [125, 110, 40, 'green']]  # 'green' = '#00FF00' 

    # on trace tous les cercles à l'aide d'une boucle :
    ii =0
    while ii < len(cc): # parcours de la liste
        el = cc[ii] # chaque élément est lui-même une liste
        cercle(el[0], el[1], el[2], el[3])
        ii += 1

##### Programme principal : ############
fen = Tk()
can = Canvas(fen, width=200, height=200, bg='#808080') # '#FFFFFF' = 'white'
can.pack(side=TOP, padx=5, pady=5)
b1 = Button(fen, text='Olympique', command=figure_1)
b1.pack(side=LEFT, padx=3, pady=3)
b2 = Button(fen, text='Quitter', command=fen.destroy)
b2.pack(side=RIGHT, padx=3, pady=3)
fen.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI09b_olympique.py
Utilisation de tkinter pour tracer des 5 anneaux olympiques
Un tracé par bouton pressé
'''

from tkinter import *

def cercle(x, y, r, coul ='black'):
#==================================
    "tracé d'un cercle de centre (x,y) et de rayon r"
    can.create_oval(x-r, y-r, x+r, y+r, outline=coul, width=5)
    # c.f. http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/create_oval.html

def figure_1(param):
#===================
    "dessin des 5 anneaux olympique"
    # Les caractéristiques de chaque cercle sont
    # placées dans une liste de listes :
    cc = [[ 50,  80, 40, 'cyan'],   # 'cyan' = '#00FFFF' 
          [100,  80, 40, 'black'],  # 'black' = '#000000' 
          [150,  80, 40, 'red'],    # 'red' = '#FF0000' 
          [ 75, 110, 40, 'yellow'], # 'cyan' = '#00FFFF' 
          [125, 110, 40, 'green']]  # 'green' = '#00FF00' 

    # on trace le cercle sélectionné dans "param"
    el = cc[param] # Sélectionne le cercle désiré
    cercle(el[0], el[1], el[2], el[3])
    
##### Programme principal : ############
fen = Tk()
can = Canvas(fen, width=200, height=200, bg='#808080') # '#FFFFFF'='white'  '#808080'='gray'
can.pack(side=TOP, padx=5, pady=5)
for nn in range(0,5):
    bb = Button(fen, text='Olympique' + str(nn), command=lambda arg=nn : figure_1(arg))
    bb.pack(side=LEFT, padx=3, pady=3)
    
# Pour le bouton de fermeture de l'application
b9 = Button(fen, text='Quitter', command=fen.destroy)
b9.pack(side=RIGHT, padx=3, pady=3)
fen.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI12a_Calculatrice.py
Création d'une calculatrice minimaliste.
Utilisant la bibliothèque graphique tkinter et le module math.
'''

from tkinter import *
from math import *

# définition de l'action à effectuer si l'utilisateur actionne
# la touche "enter" alors qu'il édite le champ d'entrée :

def evaluer(event):
     chaine.configure(text = "Résultat = " + str(eval(entree.get())))

# ----- Programme principal : -----
fenetre = Tk()
entree = Entry(fenetre)
entree.bind("<Return>", evaluer)
chaine = Label(fenetre)
entree.pack()
chaine.pack()
fenetre.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI13a_detection_souris.py
Détection de la position de la souris et des clics de la souris.
'''

from tkinter import *

def pointeur(event):
#===================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    chaine.configure( text = "Clic détecté en X =" + str(event.x) \
                      + ", Y =" + str(event.y) \
                      + ", x_root =" + str(event.x_root)
                      + ", y_root =" + str(event.y_root)
                      + ", num =" + str(event.num)
                      + ", char =" + str(event.char)
                      + ", keysym =" + str(event.keysym)
                      + ", keycode =" + str(event.keycode)
                      + ", widget =" + str(event.widget)
                      + ", width =" + str(event.width)
                      + ", height =" + str(event.height)
                      + ", type =" + str(event.type))

fen = Tk()
cadre = Frame(fen, width =200, height =150, bg="light yellow")
cadre.bind("<Button-1>", pointeur)
cadre.bind("<Button-2>", pointeur)
cadre.bind("<Shift-Button-3>", pointeur)  # Ne réagit que si "Shift" est aussi pressé.
#cadre.bind("<Enter>", pointeur)  # Entrée de la souris dans le cadre
#cadre.bind("<Leave>", pointeur)  # Sortie de la souris du cadre
#cadre.bind_all("<Return>", pointeur)
#cadre.bind_all("a", pointeur)
#cadre.bind_all("<space>", pointeur)
#cadre.bind_all("<Key>", pointeur) # Pour toutes les touches
#cadre.bind_all("<KeyRelease>", pointeur) # Pour toutes les touches
cadre.pack()
chaine = Label(fen)
chaine.pack()

fen.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI14x_methode_grid.py
Utilisation de la méthode "grid" pour contrôler la disposition des widgets
'''

from tkinter import *

fen1 = Tk()
txt1 = Label(fen1, text = 'Premier champ :')
txt2 = Label(fen1, text = 'Second :')
entr1 = Entry(fen1)
entr2 = Entry(fen1)
txt1.grid(row =0, sticky =E)
txt2.grid(row =1, sticky =E)
entr1.grid(row =0, column =1)
entr2.grid(row =1, column =1)
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI14y_methode_grid.py
Utilisation de la méthode "grid" pour contrôler la disposition des widgets
'''

from tkinter import *

fen1 = Tk()
# Permet de positionner la fenêtre sur l'écran
fen1.wm_geometry("+%d+%d" % (400, 100))
# Définit la position de la fenêtre.
# Pour définir également la dimension :
# fen1.wm_geometry("%dx%d+%d+%d" % (largeur, hauteur, xpos, ypos))

# création de widgets 'Label' et 'Entry' :
txt1 = Label(fen1, text ='Premier champ :')
txt2 = Label(fen1, text ='Second :')
txt3 = Label(fen1, text ='Troisième :')
entr1 = Entry(fen1)
entr2 = Entry(fen1)
entr3 = Entry(fen1)

# création d'un widget 'Canvas' contenant une image bitmap :
can1 = Canvas(fen1, width =160, height =160, bg ='white')
photo = PhotoImage(file ='martin_p.png')
item = can1.create_image(80, 80, image =photo)

# Mise en page à l'aide de la méthode 'grid' :
txt1.grid(row =1, sticky =E)
txt2.grid(row =2, sticky =E)
txt3.grid(row =3, sticky =E)
entr1.grid(row =1, column =2)
entr2.grid(row =2, column =2)
entr3.grid(row =3, column =2)
can1.grid(row =1, column =3, rowspan =3, padx =10, pady =5)

# démarrage :
fen1.mainloop()

# ex_XXI14z_magie.py
'''
Un tour de magie.
Une personne calcule sur une calculatrice le produit suivant :
117 * n1 * n2 * n3
n1, n2, n3 sont trois nombres de deux chiffres.
Du résultat qu'il obtient,
Il choisi la position d'un chiffre différent de zéro.
Il tape la suite des chiffres qui apparaîssent dans le résultat,
sauf le chiffre qui apparaît à la position qu'il a choisi.
Lorsque c'est fait, en cliquant sur le bouton "Magique",
l'ordinateur indique quelle est le chiffre que la personne a omise.
'''

from tkinter import *  # importe toutes les classes du module tkinter

def Magique():
#=============
    '''Fonction appelée pour réaliser le tour de magie'''
    string_entry1 = entry1.get()    
    list_nbr = list(string_entry1)
    somme = 0
    # Boucle pour faire la somme des chiffres donnés dans l'"entry1"
    for ch in list_nbr:
        somme += int(ch)
        #print(somme)

    # Affichage du chiffre omis par la personne
    chiffre_manquant = 9 - (somme % 9)
    #print("Le chiffre manquant est :", chiffre_manquant)
    entry2.delete(0, END)
    entry2.insert(0, chiffre_manquant)
    entry2.insert(0, "Le chiffre manquant est : ")

def Magique2(event):
#===================
    # Puisque cette fonction est appelée lors d'un événement,
    # elle a un paramètre. Elle est donc différente de la fonction
    # "Magique", qui n'a pas de paramètre.
    Magique()
    
def Quitter(event):
#================
    '''Ferme la fenêtre et quitte le programme'''
    fen1.destroy()
    
#------ Programme principal -------

# Les variables suivantes seront utilisées de manière globale :
coul = 'red'
numCoul = 4

fen1 = Tk()
# Création du widget principal ("maître") :

# Permet de positionner la fenêtre sur l'écran
xpos = 400
ypos = 300
fen1.wm_geometry("+%d+%d" % (xpos, ypos))

fen1.title("Quelques dessins simples avec tkinter") # Titre de la fenêtre

# création des widgets "esclaves" :

# création de widgets 'Label' et 'Entry' :
Label(fen1, text ='Voici un tour de magie qui vous surprendra.').grid(row=1, columnspan=2, sticky =W)
Label(fen1, text ='Sur une calculatrice, faites le calcule suivant :').grid(row=2, columnspan=2, sticky =W)
Label(fen1, text ='117 * nb1 * nb2 * nb3 :').grid(row=3, columnspan=2, sticky =W)
Label(fen1, text ='nb1, nb2 et nb3 sont trois nombres de deux chiffres').grid(row=4, columnspan=2, sticky =W)
Label(fen1, text ='que vous choisissez comme vous voulez.').grid(row=5, columnspan=2, sticky =W)
Label(fen1, text ='Du résultat obtenu, choisissez la position...').grid(row=6, columnspan=2, sticky =W)
Label(fen1, text ='').grid(row=7, columnspan=2, sticky =W)
Label(fen1, text ='Tapez la suite des chiffres, en omettant celui de la case choisie :').grid(row=8, columnspan=2, sticky =W)

Label(fen1, text ='Chiffres :').grid(row=9, column=0, sticky =W)
Label(fen1, text ='Chiffre manquant :').grid(row=10, column=0, sticky =W)
entry1 = Entry(fen1, width=30)
entry2 = Entry(fen1, width=30)

# Mise en page à l'aide de la méthode 'grid' :
entry1.grid(row =9,  column=1, sticky=W)
entry2.grid(row =10, column=1, sticky=W)

# c.f. http://effbot.org/tkinterbook/grid.htm
bouQuit = Button(fen1, text='Quitter', command=fen1.destroy)
bouQuit.grid(row =11, column=1, sticky=E)

bouTest = Button(fen1, text='Magique', command=Magique)
bouTest.grid(row =11, column=0, sticky=W)

fen1.bind("<Return>", Magique2) # Pour effectuer la divination magique !
fen1.bind("<KP_Enter>", Magique2) # Pour effectuer la divination magique en pressant sur le "enter" du clavier numérique
fen1.bind("<Escape>", Quitter) # Pour quitter le programme en pressant la touche "Esc"

fen1.mainloop() # Démarrage du réceptionnaire d’événements associé à la fenêtre
try:
    fen1.destroy() # Destruction (fermeture) de la fenêtre
except:
    # On ne fait rien.
    print("terminé")
    

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI15a_animation_grid.py
Animation d'un objet dans une fenêtre.
'''

from tkinter import *

# procédure générale de déplacement :
def avance(gd, hb):
    global x1, y1
    x1, y1 = x1 +gd, y1 +hb
    can1.coords(oval1, x1, y1, x1+30, y1+30)

# gestionnaires d'événements :
def depl_gauche():
    avance(-10, 0)

def depl_droite():
    avance(10, 0)

def depl_haut():
    avance(0, -10)

def depl_bas():
    avance(0, 10) 

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
x1, y1 = 10, 10 # coordonnées initiales

# Création du widget principal ("maître") :
fen1 = Tk()
fen1.title("Exercice d'animation avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(x1,y1,x1+30,y1+30,width=2,fill='red')
can1.pack(side=LEFT)
Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)
Button(fen1,text='Gauche',command=depl_gauche).pack()
Button(fen1,text='Droite',command=depl_droite).pack()
Button(fen1,text='Haut',command=depl_haut).pack()
Button(fen1,text='Bas',command=depl_bas).pack()

# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI15a_deux_astres.py
Deux objets dans une fenêtre.
Avec 4 bouttons par objets, permet de déplacer chacun de ses objets
En permanence la distance entre les objets sont affichés.

Introduction de plusieurs notions :
1) avec l'instruction 'labmda', appel depuis un bouton d'une fonction avec des paramètres.
2) adjonction d'un texte dans un canvas
3) modification du texte du canvas
4) calcul de la racine carrée (sqrt) d'un nombre et mise au carré (**)
5) formattage d'un nombre à firgule pour l'afficher avec deux chiffres après la virgule, c.f. https://pyformat.info/
'''

from tkinter import *
import math   # c.f. https://docs.python.org/3/library/math.html

def deplacement(Num_Objet, dx, dy):
#==================================
    # Procédure générale de déplacement de la boule numéro : Num_Objet,
    # de  dx  horizontalement et  dy  verticalement.
    global x1, y1, x2, y2
    if (Num_Objet == oval1):
        x1, y1 = x1 + dx, y1 + dy
        can1.coords(oval1, x1, y1, x1+30, y1+30)
    if (Num_Objet == oval2):
        x2, y2 = x2 + dx, y2 + dy
        can1.coords(oval2, x2, y2, x2+30, y2+30)

    distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2) # Distance en pixels entre les deux boules.
    
    # Permet de modifier le contenu du texte    
    # Pour formatter la conversion en string d'un nombre, c.f. : https://pyformat.info/
    can1.itemconfigure(text1, text='Distance =' + '{:9.2f}'.format(distance) + ' px')

    # Cette manière ne permet pas de formatter le nombre à son affichage.
    # can1.itemconfigure(text1, text='Distance =' + str(distance) + ' px')

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
x1, y1 = 10, 10 # coordonnées initiales de la première boule
x2, y2 = 20, 100 # coordonnées initiales de la deuxième boule

# Création du widget principal ("maître") :
fen1 = Tk()
fen1.title("Animation de deux astres avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(x1,y1,x1+30,y1+30,width=2,fill='red')
oval2 = can1.create_oval(x2,y2,x2+30,y2+30,width=2,fill='blue')
# label1 = can1.create_(fen1, text ='Donnez une date,')

# text1 est un numéro référençant l'objet 'text1' du canevas can1
text1 = can1.create_text( 10,280,    # position x, y
                          anchor=W,  # NW, N, NE, W, E, SW, S, SE, CENTER (défaut)
                          fill="darkblue",
                          font="Arial 20 italic bold",
                          text="Distance = ")
can1.pack(side=LEFT) # insertion du canvas dans la fenêtre.

# Création d'une série de 9 boutons
Button(fen1,text='Gauche 1',command=lambda arg1=1, arg2=-10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Droite 1',command=lambda arg1=1, arg2=10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Haut 1',command=lambda arg1=1, arg2=0, arg3=-10 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Bas 1',command=lambda arg1=1, arg2=0, arg3=10 : deplacement(arg1, arg2, arg3) ).pack()

Button(fen1,text='Gauche 2',command=lambda arg1=2, arg2=-10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Droite 2',command=lambda arg1=2, arg2=10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Haut 2',command=lambda arg1=2, arg2=0, arg3=-10 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Bas 2',command=lambda arg1=2, arg2=0, arg3=10 : deplacement(arg1, arg2, arg3) ).pack()

Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)

# Pour que l'affichage de la distance se fasse dès le départ
deplacement(1, 0, 0) # donc pas de déplacement.
    
# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI15b_deux_astres.py
Deux objets dans une fenêtre.
Avec 4 bouttons par objets, permet de déplacer chacun de ses objets
En permanence la distance entre les objets sont affichés.

On reprend le programme ex_XXI15a_deux_astres.py
On simplifie, en utilisant les coordonnées des objets et non des variables intermédiaires.

Avec plusieurs notions :
1) avec l'instruction 'labmda', appel depuis un bouton d'une fonction avec des paramètres.
2) adjonction d'un texte dans un canvas
3) modification du texte du canvas
4) calcul de la racine carrée (sqrt) d'un nombre et mise au carré (**)
5) formattage d'un nombre à firgule pour l'afficher avec deux chiffres après la virgule, c.f. https://pyformat.info/
'''

from tkinter import *
import math   # c.f. https://docs.python.org/3/library/math.html

def deplacement(Num_Objet, dx, dy):
#==================================
    # Procédure générale de déplacement de la boule numéro : Num_Objet,
    # de  dx  horizontalement et  dy  verticalement.

    can1.move(Num_Objet, dx, dy) # Déplacement de l'objet
    
    Pos1 =can1.coords(oval1) # = [left, top, right, bottom], coordonnées de l'objet : oval1
    Pos2 =can1.coords(oval2) # = [left, top, right, bottom], coordonnées de l'objet : oval2
    
    distance = math.sqrt((Pos2[0] - Pos1[0])**2 + (Pos2[1] - Pos1[1])**2) # Distance en pixels entre les deux boules.
    
    # Permet de modifier le contenu du texte    
    # Pour formatter la conversion en string d'un nombre, c.f. : https://pyformat.info/
    # c.f. http://effbot.org/tkinterbook/canvas.htm
    can1.itemconfigure(text1, text='Distance =' + '{:9.2f}'.format(distance) + ' px')

    # Cette manière ne permet pas de formatter le nombre à son affichage.
    # can1.itemconfigure(text1, text='Distance =' + str(distance) + ' px')

#------ Programme principal -------

# Création du widget principal ("maître") :
fen1 = Tk()
fen1.title("Animation avec la souris de deux astres avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

# text1 est un numéro référençant l'objet 'text1' du canevas can1
text1 = can1.create_text( 10,280,    # position x, y
                          anchor=W,  # NW, N, NE, W, E, SW, S, SE, CENTER (défaut)
                          fill="darkblue",
                          font="Arial 20 italic bold",
                          text="Distance = ")

can1.pack(side=LEFT) # insertion du canvas dans la fenêtre.

# Création d'une série de 9 boutons
Button(fen1,text='Gauche 1',command=lambda arg1=1, arg2=-10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Droite 1',command=lambda arg1=1, arg2=10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Haut 1',command=lambda arg1=1, arg2=0, arg3=-10 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Bas 1',command=lambda arg1=1, arg2=0, arg3=10 : deplacement(arg1, arg2, arg3) ).pack()

Button(fen1,text='Gauche 2',command=lambda arg1=2, arg2=-10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Droite 2',command=lambda arg1=2, arg2=10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Haut 2',command=lambda arg1=2, arg2=0, arg3=-10 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Bas 2',command=lambda arg1=2, arg2=0, arg3=10 : deplacement(arg1, arg2, arg3) ).pack()

Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)

# Pour que l'affichage de la distance se fasse dès le départ
deplacement(1, 0, 0) # donc pas de déplacement.
    
# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI15c_deux_astres.py
On reprend  ex_XXI15b_deux_astres.py
On rajoute la fonctionnalité teste, que lors de la pression sur le bouton pour faire descendre
la boule bleue, elle descent tand que l'on appuie sur le bouton
C'est une incursion dans l'animation automatique, qui est vu dans : ex_XXI25a_animation_automatique.py
c.f. Bouge_bas_bleu ...   et
l'instruction : fen1.after(50, Bouge_bas_bleu)
'''

from tkinter import *
import math   # c.f. https://docs.python.org/3/library/math.html

def deplacement(Num_Objet, dx, dy):
#==================================
    # Procédure générale de déplacement de la boule numéro : Num_Objet,
    # de  dx  horizontalement et  dy  verticalement.

    can1.move(Num_Objet, dx, dy) # Déplacement de l'objet
    
    Pos1 =can1.coords(oval1) # = [left, top, right, bottom], coordonnées de l'objet : oval1
    Pos2 =can1.coords(oval2) # = [left, top, right, bottom], coordonnées de l'objet : oval2
    
    distance = math.sqrt((Pos2[0] - Pos1[0])**2 + (Pos2[1] - Pos1[1])**2) # Distance en pixels entre les deux boules.
    
    # Permet de modifier le contenu du texte    
    # Pour formatter la conversion en string d'un nombre, c.f. : https://pyformat.info/
    # c.f. http://effbot.org/tkinterbook/canvas.htm
    can1.itemconfigure(text1, text='Distance =' + '{:9.2f}'.format(distance) + ' px')

    # Cette manière ne permet pas de formatter le nombre à son affichage.
    # can1.itemconfigure(text1, text='Distance =' + str(distance) + ' px')

def Bouge_bas_bleu():
#==================== 
    # Déplacement de la boule bleue vers le bas
    if Click_Bouge_bas_bleu > 0:
        deplacement(oval2, 0, 1)
        fen1.after(50, Bouge_bas_bleu) # demande de rappeler la fonction Bouge_bas_bleu après 50 [ms]

def Bouge_bas_bleu_go(event):
#============================ 
    # Déplacement de la boule bleue vers le bas
    global Click_Bouge_bas_bleu
    Click_Bouge_bas_bleu = 1
    Bouge_bas_bleu()

def Bouge_bas_bleu_stop(event):
#============================== 
    # Arrête le déplacement de la boule bleue vers le bas
    global Click_Bouge_bas_bleu
    Click_Bouge_bas_bleu = 0

#------ Programme principal -------

# les variables suivantes seront utilisées de manière globale :
Click_Bouge_bas_bleu = 0 # Est mis à 1 pour que la boule bleu bouge vers le bas

# Création du widget principal ("maître") :
fen1 = Tk()
fen1.title("Animation de deux astres avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

# text1 est un numéro référençant l'objet 'text1' du canevas can1
text1 = can1.create_text( 10,280,    # position x, y
                          anchor=W,  # NW, N, NE, W, E, SW, S, SE, CENTER (défaut)
                          fill="darkblue",
                          font="Arial 20 italic bold",
                          text="Distance = ")
can1.pack(side=LEFT) # insertion du canvas dans la fenêtre.

# Création d'une série de 9 boutons
Button(fen1,text='Gauche 1',command=lambda arg1=1, arg2=-10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Droite 1',command=lambda arg1=1, arg2=10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Haut 1',command=lambda arg1=1, arg2=0, arg3=-10 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Bas 1',command=lambda arg1=1, arg2=0, arg3=10 : deplacement(arg1, arg2, arg3) ).pack()

Button(fen1,text='Gauche 2',command=lambda arg1=2, arg2=-10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Droite 2',command=lambda arg1=2, arg2=10, arg3=0 : deplacement(arg1, arg2, arg3) ).pack()
Button(fen1,text='Haut 2',command=lambda arg1=2, arg2=0, arg3=-10 : deplacement(arg1, arg2, arg3) ).pack()
btn2bas = Button(fen1,text='Bas 2')
btn2bas.pack()

# Ainsi, la boule bleu part vers la bas lorsque l'on clique dessus.
btn2bas.bind("<Button-1>", Bouge_bas_bleu_go)
btn2bas.bind("<ButtonRelease-1>", Bouge_bas_bleu_stop)

Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)

# Pour que l'affichage de la distance se fasse dès le départ
deplacement(1, 0, 0) # donc pas de déplacement.
    
# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI16a_moins_de_boutons.py
Deux objets dans une fenêtre.

On reprend le programme ex_XXI15b_deux_astres.py, duquel on enlève des boutons
et on ajoute des fonctionnalités de la souris.
On positionne les objets en les cliquant-glissant avec la souris.

Avec plusieurs notions :
1) avec l'instruction 'labmda', appel depuis un bouton d'une fonction avec des paramètres.
2) adjonction d'un texte dans un canvas
3) modification du texte du canvas
4) calcul de la racine carrée (sqrt) d'un nombre et mise au carré (**)
5) formattage d'un nombre à firgule pour l'afficher avec deux chiffres après la virgule, c.f. https://pyformat.info/
'''

from tkinter import *
import math   # c.f. https://docs.python.org/3/library/math.html

def Mouse_press(event):
#======================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    # c.f. http://effbot.org/tkinterbook/canvas.htm

    # Converti les coordonnées de la souris en coordonnées du canvas
    x = can1.canvasx(event.x)
    y = can1.canvasy(event.y)

    if (0 == 1) and (event.num == 1): # pour des informations et le développement
        # c.f. : http://effbot.org/tkinterbook/canvas.htm#coordinate-systems
        # Voir aussi :  "find_closest"  ;  "find_enclosed"  ;  "find_overlapping"
        print(can1.find_closest(x, y), end=" ... ") # affiche le numéro de l'objet du canvas le plus proche de la souris
        print(can1.find_overlapping(x, y, x, y), end=" ... ") # affiche les numéros des objets du canvas où l'on a cliqué
        print(len(can1.find_overlapping(x, y, x, y)), end=" ... ") # nombre d'objets où l'on a cliqué
        print("   ", event.num, event.type)

    global gloNum, glPosDX, glPosDY
    objectsList = can1.find_overlapping(x, y, x, y)
    if (len(objectsList) > 0):
        gloNum = objectsList[0] # objet sélectionné

        # Position de l'objet sur lequel on a cliqué
        Pos =can1.coords(gloNum) # = [left, top, right, bottom], coordonnées de l'objet : oval1
        
        # Mémorise le décalage entre l'endroit où l'on a cliqué sur l'objet et la position de l'objet
        glPosDX = Pos[0] - x
        glPosDY = Pos[1] - y

def Mouse_move(event):
#======================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    # c.f. http://effbot.org/tkinterbook/canvas.htm

    # can1.itemconfigure(text1, text = 'X =' + str(event.x) + 'Y =' + str(event.y))

    # Converti les coordonnées de la souris en coordonnées du canvas
    x = can1.canvasx(event.x)
    y = can1.canvasy(event.y)
    
    if (gloNum != 0):
        # Un objet est délectionné, déplace-le
        can1.coords(gloNum, x+glPosDX, y+glPosDY, x+glPosDX+30, y+glPosDY+30)
    
        Pos1 =can1.coords(oval1) # = [left, top, right, bottom], coordonnées de l'objet : oval1
        Pos2 =can1.coords(oval2) # = [left, top, right, bottom], coordonnées de l'objet : oval2
        
        distance = math.sqrt((Pos2[0] - Pos1[0])**2 + (Pos2[1] - Pos1[1])**2) # Distance en pixels entre les deux boules.
        
        # Permet de modifier le contenu du texte    
        # Pour formatter la conversion en string d'un nombre, c.f. : https://pyformat.info/
        # c.f. http://effbot.org/tkinterbook/canvas.htm
        can1.itemconfigure(text1, text='Distance =' + '{:9.2f}'.format(distance) + ' px')


def Mouse_release(event):
#========================
    # Plus d'objet sélectionné.
    global gloNum
    gloNum = 0

def Reset():
#===========
    # Pour remettre les objets à une place fixe.
    can1.coords(oval1, 20,  20, 20+30,  20+30)
    can1.coords(oval2, 30, 100, 30+30, 100+30)

#------ Programme principal -------
# Variables globales
gloNum = 0 # numéro de l'objet du canvas sélectionné par un clique, lorsque le clique est maintenu

# Pour mémoriser le décalage entre l'endroit où l'on a cliqué sur l'objet et la position de l'objet
glPosDX = 0
glPosDY = 0

# Création du widget principal ("maître") :
fen1 = Tk()
fen1.title("Animation avec la souris de deux astres avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

# text1 est un numéro référençant l'objet 'text1' du canevas can1
text1 = can1.create_text( 10,280,    # position x, y
                          anchor=W,  # NW, N, NE, W, E, SW, S, SE, CENTER (défaut)
                          fill="darkblue",
                          font="Arial 20 italic bold",
                          text="Distance = ")

# c.f. : https://www.python-course.eu/tkinter_events_binds.php
can1.bind("<Motion>", Mouse_move) # à chaque déplacement de la souris, la fonction  est appelée
can1.bind("<Button-1>", Mouse_press) # à chaque click gauche de la souris, la fonction est appelée
can1.bind("<ButtonRelease-1>", Mouse_release) # à chaque click gauche relaché de la souris, la fonction est appelée

can1.pack(side=LEFT) # insertion du canvas dans la fenêtre.

# Création du bouton pour quitter
Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)

# Pour repositionner les objets à des places par défaut.
Button(fen1,text='Reset',command=Reset).pack(side=BOTTOM)
    
# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI22a_avec_une_jolie_trace.py

On reprend le programme ex_XXI16a_Moins_de_boutons.py
Lorsque l'on déplace un objet, il laisse une trace.
On a aussi la possibilité d'effacer le dessin tracé.
'''

from tkinter import *
import math   # c.f. https://docs.python.org/3/library/math.html

def Mouse_press(event):
#======================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    # c.f. http://effbot.org/tkinterbook/canvas.htm

    # Converti les coordonnées de la souris en coordonnées du canvas
    x = can1.canvasx(event.x)
    y = can1.canvasy(event.y)

    if (0 == 1) and (event.num == 1): # pour des informations et le développement
        # c.f. : http://effbot.org/tkinterbook/canvas.htm#coordinate-systems
        # Voir aussi :  "find_closest"  ;  "find_enclosed"  ;  "find_overlapping"
        print(can1.find_closest(x, y), end=" ... ") # affiche le numéro de l'objet du canvas le plus proche de la souris
        print(can1.find_overlapping(x, y, x, y), end=" ... ") # affiche les numéros des objets du canvas où l'on a cliqué
        print(len(can1.find_overlapping(x, y, x, y)), end=" ... ") # nombre d'objets où l'on a cliqué
        print("   ", event.num, event.type)

    global gloNum, glPosDX, glPosDY
    objectsList = can1.find_overlapping(x, y, x, y)
    if (len(objectsList) > 0):
        gloNum = objectsList[0] # objet sélectionné

        # Position de l'objet sur lequel on a cliqué
        Pos =can1.coords(gloNum) # = [left, top, right, bottom], coordonnées de l'objet : oval1
        
        # Mémorise le décalage entre l'endroit où l'on a cliqué sur l'objet et la position de l'objet
        glPosDX = Pos[0] - x
        glPosDY = Pos[1] - y

def Mouse_move(event):
#======================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    # c.f. http://effbot.org/tkinterbook/canvas.htm

    # can1.itemconfigure(text1, text = 'X =' + str(event.x) + 'Y =' + str(event.y))

    # Converti les coordonnées de la souris en coordonnées du canvas
    x = can1.canvasx(event.x)
    y = can1.canvasy(event.y)
    
    if (gloNum != 0):
        # Un objet est délectionné, déplace-le

        Pos =can1.coords(gloNum) # = [left, top, right, bottom], coordonnées de l'objet sélectionné
        
        can1.coords(gloNum, x+glPosDX, y+glPosDY, x+glPosDX+30, y+glPosDY+30)
    
        Pos1 =can1.coords(oval1) # = [left, top, right, bottom], coordonnées de l'objet : oval1
        Pos2 =can1.coords(oval2) # = [left, top, right, bottom], coordonnées de l'objet : oval2
        
        distance = math.sqrt((Pos2[0] - Pos1[0])**2 + (Pos2[1] - Pos1[1])**2) # Distance en pixels entre les deux boules.
        
        # Permet de modifier le contenu du texte    
        # Pour formatter la conversion en string d'un nombre, c.f. : https://pyformat.info/
        # c.f. http://effbot.org/tkinterbook/canvas.htm
        can1.itemconfigure(text1, text='Distance =' + '{:9.2f}'.format(distance) + ' px')

        # Trace une ligne entre les positions initiale et finale du centre de l'objet
        if (gloNum == oval1): # Sélectionne la couleur en fonction de l'objet sélectionné.
            theColor = "red"
        else:
            theColor = "blue"
    
        can1.create_line(Pos[0] + 30//2, Pos[1] + 30//2, x+glPosDX+30//2, y+glPosDY+30//2, width=2, fill=theColor)


def Mouse_release(event):
#========================
    # Plus d'objet sélectionné.
    global gloNum
    gloNum = 0

def Reset():
#===========
    # Pour remettre les objets à une place fixe. Et effacer les traits
    global oval1, oval2
    can1.coords(oval1, 20,  20, 20+30,  20+30)
    can1.coords(oval2, 30, 100, 30+30, 100+30)

    # Efface tous les objets dans le canvas
    can1.delete(ALL)

    # Recrée les deux boules de bases.
    oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
    oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

#------ Programme principal -------
# Variables globales
gloNum = 0 # numéro de l'objet du canvas sélectionné par un clique, lorsque le clique est maintenu

# Pour mémoriser le décalage entre l'endroit où l'on a cliqué sur l'objet et la position de l'objet
glPosDX = 0
glPosDY = 0

# Création du widget principal ("maître") :
fen1 = Tk()

# Permet de positionner la fenêtre sur l'écran
xpos = 500
ypos = 100
fen1.wm_geometry("+%d+%d" % (xpos, ypos))
fen1.title("Animation avec la souris de deux astres avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

# text1 est un numéro référençant l'objet 'text1' du canevas can1
text1 = can1.create_text( 10,280,    # position x, y
                          anchor=W,  # NW, N, NE, W, E, SW, S, SE, CENTER (défaut)
                          fill="darkblue",
                          font="Arial 20 italic bold",
                          text="Distance = ")

# c.f. : https://www.python-course.eu/tkinter_events_binds.php
can1.bind("<Motion>", Mouse_move) # à chaque déplacement de la souris, la fonction  est appelée
can1.bind("<Button-1>", Mouse_press) # à chaque click gauche de la souris, la fonction est appelée
can1.bind("<ButtonRelease-1>", Mouse_release) # à chaque click gauche relaché de la souris, la fonction est appelée

can1.pack(side=LEFT) # insertion du canvas dans la fenêtre.

# Création du bouton pour quitter
Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)

# Pour repositionner les objets à des places par défaut.
Button(fen1,text='Reset',command=Reset).pack(side=BOTTOM)
    
# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI22b_avec_une_jolie_trace.py

On reprend le programme ex_XXI22b_avec_une_jolie_trace.py
Le canvas prend toute la taille de la fenêtre, moins la place pour les boutons.
Lorsque la fenêtre est redimensionnée, le canvas aussi et le texte est déplacé.
c.f. :
def Canvas_resise(event):
can1.bind("<Configure>", Canvas_resise) # Appel de la fonction au redimentionnement de la fenêtre.
can1.pack(side=LEFT, fill="both", expand=True) # insertion du canvas dans la fenêtre.
def Window_resise(event):  Montre comment obtenir des informations sur la fenêtre et l'écran.
'''

from tkinter import *
import math   # c.f. https://docs.python.org/3/library/math.html

def Mouse_press(event):
#======================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    # c.f. http://effbot.org/tkinterbook/canvas.htm

    # Converti les coordonnées de la souris en coordonnées du canvas
    x = can1.canvasx(event.x)
    y = can1.canvasy(event.y)

    if (0 == 1) and (event.num == 1): # pour des informations et le développement
        # c.f. : http://effbot.org/tkinterbook/canvas.htm#coordinate-systems
        # Voir aussi :  "find_closest"  ;  "find_enclosed"  ;  "find_overlapping"
        print(can1.find_closest(x, y), end=" ... ") # affiche le numéro de l'objet du canvas le plus proche de la souris
        print(can1.find_overlapping(x, y, x, y), end=" ... ") # affiche les numéros des objets du canvas où l'on a cliqué
        print(len(can1.find_overlapping(x, y, x, y)), end=" ... ") # nombre d'objets où l'on a cliqué
        print("   ", event.num, event.type)

    global gloNum, glPosDX, glPosDY
    objectsList = can1.find_overlapping(x, y, x, y)
    if (len(objectsList) > 0):
        gloNum = objectsList[0] # objet sélectionné

        # Position de l'objet sur lequel on a cliqué
        Pos =can1.coords(gloNum) # = [left, top, right, bottom], coordonnées de l'objet : oval1
        
        # Mémorise le décalage entre l'endroit où l'on a cliqué sur l'objet et la position de l'objet
        glPosDX = Pos[0] - x
        glPosDY = Pos[1] - y

def Mouse_move(event):
#======================
    # c.f. http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm
    # c.f. http://tkinter.fdex.eu/doc/event.html
    # c.f. http://effbot.org/tkinterbook/canvas.htm

    # can1.itemconfigure(text1, text = 'X =' + str(event.x) + 'Y =' + str(event.y))

    # Converti les coordonnées de la souris en coordonnées du canvas
    x = can1.canvasx(event.x)
    y = can1.canvasy(event.y)
    
    if (gloNum != 0):
        # Un objet est délectionné, déplace-le

        Pos =can1.coords(gloNum) # = [left, top, right, bottom], coordonnées de l'objet sélectionné
        
        can1.coords(gloNum, x+glPosDX, y+glPosDY, x+glPosDX+30, y+glPosDY+30)
    
        Pos1 =can1.coords(oval1) # = [left, top, right, bottom], coordonnées de l'objet : oval1
        Pos2 =can1.coords(oval2) # = [left, top, right, bottom], coordonnées de l'objet : oval2
        
        distance = math.sqrt((Pos2[0] - Pos1[0])**2 + (Pos2[1] - Pos1[1])**2) # Distance en pixels entre les deux boules.
        
        # Permet de modifier le contenu du texte    
        # Pour formatter la conversion en string d'un nombre, c.f. : https://pyformat.info/
        # c.f. http://effbot.org/tkinterbook/canvas.htm
        can1.itemconfigure(text1, text='Distance =' + '{:9.2f}'.format(distance) + ' px')

        # Trace une ligne entre les positions initiale et finale du centre de l'objet
        if (gloNum == oval1): # Sélectionne la couleur en fonction de l'objet sélectionné.
            theColor = "red"
        else:
            theColor = "blue"
    
        can1.create_line(Pos[0] + 30//2, Pos[1] + 30//2, x+glPosDX+30//2, y+glPosDY+30//2, width=2, fill=theColor)


def Mouse_release(event):
#========================
    # Plus d'objet sélectionné.
    global gloNum
    gloNum = 0

def Reset():
#===========
    # Pour remettre les objets à une place fixe. Et effacer les traits
    global oval1, oval2
    can1.coords(oval1, 20,  20, 20+30,  20+30)
    can1.coords(oval2, 30, 100, 30+30, 100+30)

    # Efface tous les objets dans le canvas
    can1.delete(ALL)

    # Recrée les deux boules de bases.
    oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
    oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

def Canvas_resise(event):
#========================
    # Est appelé à chaque modification de la taille du canvas.
    # Repositionne le texte en fonction de la taille du canvas.
    large, hauteur = event.width, event.height # Largeur et hauteur du canvas    
    can1.coords(text1, 10, hauteur-20) # repositionne le texte
    
def Window_resise(event):
#========================
    # est appelé à chaque redimensionnement de la fenêtre principale.
    # Ne sert à rien ici, juste pour info.
    # print("Window resize", event.x, event.y, event.width, event.height)
    print( "Window resize"
         , fen1.winfo_width(), fen1.winfo_height()  # dimension de la fenêtre
         , fen1.winfo_reqheight(), fen1.winfo_reqwidth()
         , fen1.winfo_screenwidth(), fen1.winfo_screenheight() # Dimensions de l'écran
         )
    
#------ Programme principal -------
# Variables globales
gloNum = 0 # numéro de l'objet du canvas sélectionné par un clique, lorsque le clique est maintenu

# Pour mémoriser le décalage entre l'endroit où l'on a cliqué sur l'objet et la position de l'objet
glPosDX = 0
glPosDY = 0

# Création du widget principal ("maître") :
fen1 = Tk()

# Permet de positionner la fenêtre sur l'écran
xpos = 500
ypos = 100
fen1.wm_geometry("+%d+%d" % (xpos, ypos))
fen1.title("Animation avec la souris de deux astres avec tkinter")

# création des widgets "esclaves" :
can1 = Canvas(fen1,bg='dark grey',height=300,width=300)
oval1 = can1.create_oval(20,  20, 20+30,  20+30,width=2,fill='red')
oval2 = can1.create_oval(30, 100, 30+30, 100+30,width=2,fill='blue')

# text1 est un numéro référençant l'objet 'text1' du canevas can1
text1 = can1.create_text( 10,280,    # position x, y
                          anchor=W,  # NW, N, NE, W, E, SW, S, SE, CENTER (défaut)
                          fill="darkblue",
                          font="Arial 20 italic bold",
                          text="Distance = ")

# c.f. : https://www.python-course.eu/tkinter_events_binds.php
can1.bind("<Motion>", Mouse_move) # à chaque déplacement de la souris, la fonction  est appelée
can1.bind("<Button-1>", Mouse_press) # à chaque click gauche de la souris, la fonction est appelée
can1.bind("<ButtonRelease-1>", Mouse_release) # à chaque click gauche relaché de la souris, la fonction est appelée
can1.bind("<Configure>", Canvas_resise) # Appel de la fonction au redimentionnement de la fenêtre.
fen1.bind("<Configure>", Window_resise) # Appel de la fonction au redimentionnement de la fenêtre.

#can1.pack(side=LEFT) # insertion du canvas dans la fenêtre.

# Une manière de faire en sorte que le canvas s'adapte au dimensions de la fenêtre.
# c.f. https://stackoverflow.com/questions/47115684/python-tkinter-frame-canvas-resize
can1.pack(side=LEFT, fill="both", expand=True) # insertion du canvas dans la fenêtre.

# Création du bouton pour quitter
Button(fen1,text='Quitter',command=fen1.destroy).pack(side=BOTTOM)

# Pour repositionner les objets à des places par défaut.
Button(fen1,text='Reset',command=Reset).pack(side=BOTTOM)
    
# démarrage du réceptionnaire d’évènements (boucle principale) :
fen1.mainloop()

#!/usr/bin/python3
# -*- coding: utf-8 -*-
'''
ex_XXI25a_animation_automatique.py
Animation
'''

from tkinter import *

# définition des gestionnaires d'événements :

def move():
#==========
    "déplacement de la balle"
    global x1, y1, dx, dy, flag
    x1, y1 = x1 +dx, y1 + dy
    
    if x1 >210:
        x1, dx, dy = 210, 0, 15
    if y1 >210:
        y1, dx, dy = 210, -15, 0
    if x1 <10:
        x1, dx, dy = 10, 0, -15
    if y1 <10:
        y1, dx, dy = 10, 15, 0
        
    can1.coords(oval1,x1,y1,x1+30,y1+30)
    
    if flag > 0: 
        fen1.after(50, move) # Demande au système d'appeler la fonction "move" après 50 millisecondes

def stop_it():
#=============
    "arrêt de l'animation"
    global flag 
    flag =0

def start_it():
#==============
    "démarrage de l'animation"
    global flag
    if flag ==0: # pour ne lancer qu’une seule boucle 
        flag =1
        move()  # que se passe-t-il si "move()" est désindenté ?


#========== Programme principal =============

# les variables suivantes seront utilisées de manière globale :
x1, y1 = 10, 10 # coordonnées initiales
dx, dy = 15, 0 # 'pas' du déplacement
flag =0 # commutateur

# Création du widget principal ("parent") :
fen1 = Tk()
fen1.title("Exercice d'animation avec tkinter")
# création des widgets "enfants" :
can1 = Canvas(fen1,bg='dark grey',height=250, width=250)
can1.pack(side=LEFT, padx =5, pady =5)
oval1 = can1.create_oval(x1, y1, x1+30, y1+30, width=2, fill='red')
bou1 = Button(fen1,text='Quitter', width =8, command=fen1.destroy)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Démarrer', width =8, command=start_it)
bou2.pack()
bou3 = Button(fen1, text='Arrêter', width =8, command=stop_it)
bou3.pack()
# démarrage du réceptionnaire d'événements (boucle principale) :
fen1.mainloop()

# ex_XXI50b_Bouton_dans_canvas.py
# Référence : https://openclassrooms.com/forum/sujet/un-bouton-dans-un-canva-sur-tkinter
# Montre comment placer un bouton dans un canvas
#
# Le canvas d'adapte à la taille de la fenêtre.
# Les boutons restent toujours en bas à droite du canvas

from tkinter import *

def Canvas_resise(event):
#========================
    # Est appelé à chaque modification de la taille du canvas.
    # Repositionne le texte en fonction de la taille du canvas.
    large, hauteur = event.width, event.height # Largeur et hauteur du canvas    
    can.coords(bt_quit_w, large - 50, hauteur-20) # repositionne le bouton quit
    can.coords(bt_blue_w, large - 126, hauteur-20) # repositionne le bouton blue
    can.coords(bt_green_w, large - 200, hauteur-20) # repositionne le bouton green

fen = Tk()

can = Canvas(fen, width=400, height=300, bg="white")
can.pack(side=LEFT, fill="both", expand=True) # insertion du canvas dans la fenêtre.

can.bind("<Configure", Canvas_resise) # Appel de la fonction au redimentionnement du canvas

# Création d'un bouton et placement du bouton dans le canvas.
bt_blue = Button(fen, text="Blue", command=lambda: can.config(bg="blue"))
bt_blue_w = can.create_window(40, 20, window=bt_blue)

# Création d'un bouton et placement du bouton dans le canvas.
bt_green = Button(fen, text="Green", command=lambda: can.config(bg="green"))
bt_green_w = can.create_window(40, 60, window=bt_green)

# Création d'un bouton et placement du bouton dans le canvas.
bt_quit = Button(fen, text='Quitter', command=fen.destroy)
bt_quit_w = can.create_window(40, 280, window=bt_quit)

# Les trois boutons seront repositionnés dans la fonction "Canvas_resise"

fen.mainloop()

# ex_XXX01a_Classe_vertebres.py
'''
Le but de ce programme est d'illustrer la programmation objet sur la classe des vertébrés
et quelques classes descendantes plus particulières.
Structure des classes :
- classe des vertébrés.
	- classe des mammifères
		- classe des chiens
		- classe des chats
'''

# Il est usuel en Python que la première lettre du nom de la classe commence par une majuscule.
class Vertebres:
################
    """Classe des vertébrés"""
    # Constructeur de la classe
    def __init__(self, couleur, nom):
    #================================
        # Définition et initialisation des propriétés de cette classe
        self.couleur = couleur
        self.nom = nom
        self.maClass = "Vertébré"

    def AfficheInfo(self):
    #=====================    
        """Méthode qui affiche des informations sur ce vertébré."""    
        print("Class = ", self.maClass)
        print("Couleur = ", self.couleur)
        print("Nom = ", self.nom)

    def ChangeNom(self, nomNouveau):
    #===============================    
        """Méthode qui permet de changer de nom."""
        # Il serait aussi possible de changer le nom sans utiliser de méthode.
        self.nom = nomNouveau

def Fonction_qui_ne_connait_que_les_vertebre(monVertebre):
#=========================================================
    """Cette fonction peut avoir écrite juste après avoir défini la classe des Vertebres,
       sans avoir aucune connaissances des classes descendantes.
       Pourtant, elle accèdera à des méthodes des classes descendantes.
       C'est la force du polymorphisme."""
    monVertebre.AfficheInfo()

class Mammiferes(Vertebres):
############################
    """Classe des mamiferes"""
    # Constructeur de la classe
    def __init__(self, couleur, nom):
    #================================
        # Définition et initialisation des propriétés de cette classe
        Vertebres.__init__(self, couleur, nom) # appelle le constructeur parent
        self.maClass = "Mamifère"
        self.caracteristiques = "A des poiles et donne du lait" # Une propriété a été ajoutée.

    def AfficheInfo(self):
    #=====================    
        """Méthode qui affiche des informations sur ce vertébré."""    
        Vertebres.AfficheInfo(self) # Appelle la méthode partente
        print("Caractéristiques = ", self.caracteristiques) # ajoute une fonctionnalité

class Chiens(Mammiferes):
#########################
    """Classe des chiens"""
    # Constructeur de la classe
    def __init__(self, couleur, nom, ageMax):
    #========================================
        # Définition et initialisation des propriétés de cette classe
        Mammiferes.__init__(self, couleur, nom) # appelle le constructeur parent
        self.maClass = "Chien"
        self.ageMax = ageMax  # Une propriété a été ajoutée, fournie en paramètre au constructeur.
        self.son = "aboient"

    def AfficheInfo(self):
    #=====================    
        """Méthode qui affiche des informations sur ce vertébré."""    
        Mammiferes.AfficheInfo(self) # Appelle la méthode partente
        print("Vie au maximum", self.ageMax, "années") # ajoute une fonctionnalité
        print("Les", self.maClass, self.son, ".")

class Chats(Mammiferes):
########################
    """Classe des chats"""
    # Constructeur de la classe
    def __init__(self, couleur, nom, poils_longueur):
    #================================================
        # Définition et initialisation des propriétés de cette classe
        Mammiferes.__init__(self, couleur, nom) # appelle le constructeur parent
        self.maClass = "Chat"
        self.poils_longueur = poils_longueur  # Une propriété a été ajoutée, fournie en paramètre au constructeur.
        self.son = "miaulent"

    def AfficheInfo(self):
    #=====================    
        """Méthode qui affiche des informations sur ce vertébré."""    
        Mammiferes.AfficheInfo(self) # Appelle la méthode partente
        print(self.poils_longueur) # ajoute une fonctionnalité
        print("Les", self.maClass, self.son, ".");

##################################################################################        
# Création d'un objet particulier, qui est un vertébré en particulier.
# Mais rien ne dit de quel type de vertébré il s'agit.
unVertebre = Vertebres("brun", "mon Vertébré")

# demande d'afficher des informations sur ce vertébré.
unVertebre.AfficheInfo()
unVertebre.ChangeNom("Change le nom du vertébré")
unVertebre.AfficheInfo()
unVertebre.nom = "troisième changement de nom"  # Manière plus simple et plus directe de changer le nom
unVertebre.AfficheInfo()
print("--------------------------")
      
unMammifere = Mammiferes("blanc", "mon Mamifère")
unMammifere.AfficheInfo()
print("--------------------------")

unChien = Chiens("blanc clair", "mon Chien", 15)
unChien.AfficheInfo()
print("--------------------------")

unChat = Chats("gris", "mon Chat", "Poils longs.")
unChat.AfficheInfo()

print("@######################################")

# Ce qui suit montre la force du POLYMORPHISME.
# La fonction suivante a été écrite avant la définition des descendants de la class des Vertebres,
# pourtant, elle appelle les méthodes des enfants de la classe Vertebres.
Fonction_qui_ne_connait_que_les_vertebre(unVertebre)
print("--------------------------")
Fonction_qui_ne_connait_que_les_vertebre(unMammifere)
print("--------------------------")
Fonction_qui_ne_connait_que_les_vertebre(unChien)
print("--------------------------")
Fonction_qui_ne_connait_que_les_vertebre(unChat)

# ex_XXX02a_Classe_figures.py
'''
Teste de l'héritage et du polymorphisme de Classes 
sur la classe des figures géométriques
  Le but de ce programme est d'illustrer la programmation objet sur la classe des figures géométriques

  et quelques classes descendantes plus particulières.

  Structure des classes :

  - classe des Figures.

   - classe des quadrilatères

    - classe des rectangles

'''

class Figure(object):
    """ Représente une Figure géométrique quelconque"""
    
    strNom = "Figure"  # Propriété de class

    def __init__(self, centreX=0.0, centreY=0.0):
        "Définit le nom de la figure et son centre"
        self.centreX = centreX  # Propriété d'instance de classe = Propriété d'objet
        self.centreY = centreY  # Propriété d'objet

    def printNom(self):
        print("Nom = ", self.strNom)  # Affiche la propriété de la classe

    def printCentre(self):
        print("X = ", self.centreX, " ; Y = ", self.centreY)

    def getNombreCotes(self):
        # Cette méthode sera redéfinie dans les classes enfants
        return 0

    def getSurface(self):
        # Cette méthode sera redéfinie dans les classes enfants
        return 0

    def printNombreCotes(self):
        print("Nombre de côtés =", self.getNombreCotes())
        # La méthode (=fonction)  self.getNombreCotes()  sera différente pour chaque classe

    def printSurface(self):
        print("Surface =", self.getSurface())
        # La méthode (=fonction)  self.getSurface()  sera différente pour chaque classe

class Quadrilatere(Figure):
    strNom = "Quadrilatère"  # Propriété de class

    def __init__(self, centreX=0.0, centreY=0.0):
        Figure.__init__(self, centreX, centreY)

    def getNombreCotes(self):
        return 4

class Rectangle(Quadrilatere):
    strNom = "Rectangle"  # Propriété de class

    def __init__(self, centreX=0.0, centreY=0.0, vLongueur=7.0, vLargeur=4.0):
        Quadrilatere.__init__(self, centreX, centreY)
        self.vLongueur = vLongueur
        self.vLargeur = vLargeur
    
    def getSurface(self):
        return self.vLongueur * self.vLargeur

class Carre(Rectangle):
    strNom = "Carre"  # Propriété de class

    def __init__(self, centreX=0.0, centreY=0.0, vCote=4.0):
        Rectangle.__init__(self, centreX, centreY, vCote, vCote)

# On peut ajouter à  Figure  les méthodes :
# translation(vx, vY) ; rotation(vAngle) ; homothetie(vX, vY=0.0) # Si vY == 0, alors vY = vX

# On peut ajouter les Classes :
# Trapeze(Quadrilatere) ; Parallelogramme(Trapeze) ; Losange(Parallelogramme)
# Rectangle devrait être un descendant de Parallelogramme.

# On peut encore ajouter les Classes :
# Triangle(Figure) ; TriangleIsocele(Triangle) ; TriangleEquilateral(TriangleIsocele)
# TriangleRectangle(Triangle)

# On peut encore ajouter les Classes :
# Ellipse(Figure) ; Cercle(Ellipse)

def Imprime_nom(une_figure):
#===========================    
    '''Imprime le nom de la figure qui est donnée en paramètre'''
    une_figure.printNom()
    print("Surface =", une_figure.getSurface())

fig1 = Figure()
fig1.printNom()
fig1.printCentre()
fig1.printNombreCotes()
fig1.printSurface()

print("---")
figQ = Quadrilatere()
figQ.printNom()
figQ.printCentre()
figQ.printNombreCotes()
figQ.printSurface()

print("---")
figRect1 = Rectangle()
figRect1.printNom()
figRect1.printCentre()
figRect1.printNombreCotes()
figRect1.printSurface()

print("---")
figRect2 = Rectangle(vLongueur=9.0, vLargeur=5.0)
figRect2.printNom()
figRect2.printCentre()
figRect2.printNombreCotes()
figRect2.printSurface()

print("---")
figCarre1 = Carre(vCote=6.0)
figCarre1.printNom()
figCarre1.printCentre()
figCarre1.printNombreCotes()
figCarre1.printSurface()

print("---")
Rectangle.strNom = "rectangle changé"  # Changle la propriété de la classe Rectangle
figRect1.printNom()
figRect2.printNom()
fig1.printNom()
figCarre1.printNom()
# Il faut éviter d'avoir un nom de propriété de classe identique
# au nom de propriété d'instance de cette classe.
# print(self.strNom)  cherchera en premier à savoir si  strNom  est une propriété d'objet.
# Si ce n'est pas le cas, il cherchera si  strNom  est une propriété de classe.
# Si ce n'est pas le cas, il affiche une erreur

print("---------")
# Cette fonction peut avoir été écrite avant les classes Quadrilatere, Rectangle et Carre,
# elle appellera quand-même leur méthode si l'argument leur correspond.
Imprime_nom(fig1)
Imprime_nom(figRect1)
Imprime_nom(figCarre1)

'''
Le 15.3.2018
L'objectif est d'afficher du texte en couleur dans le "Shell" de IDLE.  Réf :
https://stackoverflow.com/questions/42472958/how-do-i-print-colored-text-in-idles-terminal

Après avoir cherché des heures sur le Web comment afficher du texte en couleur
dans le "Shell" de "IDLE3" de Python, voici tout ce que j'ai trouvé.
Je suis persuadé qu'il y a d'autres couleurs possibles,
mais je ne sais pas comment y accéder.

Sion lance Python dans un Terminal sous Linux,
les "Escape code" donne beaucoup de possibilités.
Suivant le type de terminal émulé, on peut
° afficher de de différentes couleurs
° déplacer le curseur d'impression
° détercter la souris

Pour les escape code dans un Terminal :
https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences

Inutile, utile que pour un Terminal : sudo pip3 install colorama
'''

import sys
# c.f. https://docs.python.org/3/library/sys.html

color = sys.stdout.shell

print("On est sous :", sys.platform) # 'linux' ou 'win32' ou 'cygwin' ou 'darwin'

color.write(" 1) en Noir  : stdin\n","stdin")
color.write(" 2) en Brun  : console\n","console")
color.write(" 3) en Bleu  : stdout\n","stdout")
color.write(" 4) en Mauve : BUILTIN\n","BUILTIN")
color.write(" 5) en Vert  : STRING\n","STRING")
color.write(" 6) en Rouge : stderr\n","stderr")
color.write(" 7) en Jaune : KEYWORD\n","KEYWORD")
color.write("11) en Fond noir : hit\n","hit")
color.write("12) en Fond rose ERROR: \n","ERROR")
color.write("en Fond gris : sel \n","sel")
print()
print("Supplément :")
color.write("en Noir  : SYNC\n","SYNC")
color.write("en Noir : TODO\n","TODO")
color.write("en Bleu : DEFINITION\n","DEFINITION")
color.write("en Rouge : COMMENT\n","COMMENT")
print()
print("il doit être possible d'écrire avec un fond jaund, mais comment ?")
print("C.f. breakpoint des Option > Configure IDLE > Highligthing")

print()
'''
color.write("Test de couleur\n","BREAK")
color.write("Test de couleur\n","BREAKP")
color.write("Test de couleur\n","BREAKPO")
color.write("Test de couleur\n","BREAKPOI")
color.write("Test de couleur\n","BREAKPOIN")
color.write("Test de couleur\n","BREAKPOINT")
color.write("Test de couleur\n","Breakpoint")
color.write("Test de couleur\n","Breakpoin")
color.write("Test de couleur\n","Breakpoi")
color.write("Test de couleur\n","Breakpo")
color.write("Test de couleur\n","Breakp")
color.write("Test de couleur\n","Break")
color.write("Test de couleur\n","break")
color.write("Test de couleur\n","brea")
color.write("Test de couleur\n","bre")
color.write("Test de couleur\n","br")
color.write("Test de couleur\n","bp")
color.write("Test de couleur\n","BP")
color.write("Test de couleur\n","EDITOR")
color.write("Test de couleur\n","editor")
color.write("Test de couleur\n","editorbreak")
color.write("Test de couleur\n","editorbreakpoint")
color.write("Test de couleur\n","bp")
color.write("Test de couleur\n","bp")

color.write("Test de couleur\n","rgb(56,99,99)")
color.write("Test de couleur\n","#FFFF44")
'''

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Exemple de couleurs lorsqu'on exécute ce script python dans
un Terminal sous linux.

À faire une fois, pour le rendre exécutable
chmod a+x color_test_escape_code.py 

Pour l'exécuter depuis un terminal
./color_test_escape_code.py

Pour changer la version par défaut de Python (la version (3.5) peut changer avec le temps) :
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.5 1
sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 2
update-alternatives --list python
update-alternatives --config python

Autre ??? :
python --version
alias python="/usr/bin/python3.5"
python --version

Il y a énormément de possibilités, cherchez "Escape code"

c.f. 
https://en.wikipedia.org/wiki/ANSI_escape_code
https://www.xfree86.org/4.8.0/ctlseqs.html   BIEN, parle de "mouse traacking"
https://gist.github.com/justinmk/a5102f9a0c1810437885a04a07ef0a91  Bien à étudier plus...
https://www.systutorials.com/docs/linux/man/4-console_codes/   chercher "Mouse"
https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences
'''
# Essai de couleurs :
print("\033[1;41m" + "   ." +"\033[1;46m" + "   ." + "\033[1;42m  .")
print("\033[0;37;40m 0;37;40m : Normal text")
print("\033[1;37;40m 1;37;40m : Bright Colour")
print("\033[2;37;40m 2;37;40m : faint Colour")
print("\033[1;37;40m", end='') # Pour revenir aux couleur blanc sur fond noir
print("\033[3;37;40m 3;37;40m : standout Colour")
print("\033[4;37;40m 4;37;40m : Underlined text")
print("\033[24;7;37;40m 7;37;40m : Negative Colour \n")
 
print("\033[1;37;40m \033[2;37;40m TextColour BlackBackground          TextColour GreyBackground                WhiteText ColouredBackground\033[0;37;40m\n")
print("\033[1;30;40m Dark Gray      \033[0m 1;30;40m            \033[1;30;47m Black      \033[0m 0;30;47m               \033[0;30;41m Black      \033[0m 0;37;41m")
print("\033[1;31;40m Bright Red     \033[0m 1;31;40m            \033[0;31;47m Red        \033[0m 0;31;47m               \033[0;30;42m Black      \033[0m 0;37;42m")
print("\033[1;32;40m Bright Green   \033[0m 1;32;40m            \033[0;32;47m Green      \033[0m 0;32;47m               \033[0;30;43m Black      \033[0m 0;37;43m")
print("\033[1;33;40m Yellow         \033[0m 1;33;40m            \033[0;33;47m Brown      \033[0m 0;33;47m               \033[0;30;44m Black      \033[0m 0;37;44m")
print("\033[1;34;40m Bright Blue    \033[0m 1;34;40m            \033[0;34;47m Blue       \033[0m 0;34;47m               \033[0;30;45m Black      \033[0m 0;37;45m")
print("\033[1;35;40m Bright Magenta \033[0m 1;35;40m            \033[0;35;47m Magenta    \033[0m 0;35;47m               \033[0;30;46m Black      \033[0m 0;37;46m")
print("\033[1;36;40m Bright Cyan    \033[0m 1;36;40m            \033[0;36;47m Cyan       \033[0m 0;36;47m               \033[0;30;47m Black      \033[0m 0;37;47m")
print("\033[1;37;40m White          \033[0m 1;37;40m            \033[0;37;40m Light Grey \033[0m 0;37;40m               \033[0;30;48m Black      \033[0m 0;37;48m")

print("\033[s", end='') # Mémorise la position du curseur
print("\033[5;50f \033[1;37;41mTexte en ligne 3 colonne 50")
print("\033[1;37;40m") # Pour revenir aux couleur blanc sur fond noir
print("\033[u", end='') # Retourne à la position mémorisée du curseur
print()


'''

ESC doit être remplacé par  \e  ou par  \E  ou par  \033
Exemples :
echo -e "\e[3A"  monte le curseur de 3 lignes.
echo -e "\e[3B"  descent le curseur de 3 lignes.
echo -e "\e[3;4f"  met le curseur en position ligne 3, colonne 4
echo -e "\e[32m"   le texte est affiché en vert

ANSI Escape Sequences

Wherever you see '#', that should be replaced by the appropriate number.

        ESC code sequence Function
       ------------------- ---------------------------
Cursor Controls:
         ESC[#;#H or ESC[#;#f Moves cusor to line #, column #
         ESC[#A Moves cursor up # lines
         ESC[#B Moves cursor down # lines
         ESC[#C Moves cursor forward # spaces
         ESC[#D Moves cursor back # spaces
         ESC[#;#R Reports current cursor line & column
         ESC[s Saves cursor position for recall later
         ESC[u Return to saved cursor position

Erase Functions:
         ESC[2J Clear screen and home cursor
         ESC[K Clear to end of line

Set Graphics Rendition:
         ESC[#;#;....;#m Set display attributes where # is
                                       00 for normal display (or just 0)
                                       01 for bold on (or just 1)
                                       02 faint (or just 2)
                                       03 standout (or just 3)
                                       04 underline (or just 4)
                                       05 blink on (or just 5)
                                       07 reverse video on (or just 7)
                                       08 nondisplayed (invisible) (or just 8)
                                       22 normal
                                       23 no-standout
                                       24 no-underline
                                       25 no-blink
                                       27 no-reverse
                                       30 black foreground
                                       31 red foreground
                                       32 green foreground
                                       33 yellow foreground
                                       34 blue foreground
                                       35 magenta foreground
                                       36 cyan foreground
                                       37 white foreground
                                       39 default foreground
                                       40 black background
                                       41 red background
                                       42 green background
                                       43 yellow background
                                       44 blue background
                                       45 magenta background
                                       46 cyan background
                                       47 white background
                                       49 default background

         ESC[=#;7h or Put screen in indicated mode where # is
         ESC[=h or 0 for 40 x 25 black & white
         ESC[=0h or 1 for 40 x 25 color
         ESC[?7h    2 for 80 x 25 b&w
                    3 for 80 x 25 color
                    4 for 320 x 200 color graphics
                    5 for 320 x 200 b & w graphics
                    6 for 640 x 200 b & w graphics
                    7 to wrap at end of line

         ESC[=#;7l or ESC[=l or Resets mode # set with above command
         ESC[=0l or ESC[?7l

Keyboard Reassignments:

         ESC[#;#;...p Keyboard reassignment. The first ASCII
         or ESC["string"p code defines which code is to be
         or ESC[#;"string";#; changed. The remaining codes define
            #;"string";#p what it is to be changed to.

   E.g. Reassign the Q and q keys to the A and a keys (and vice versa).

         ESC [65;81p A becomes Q
         ESC [97;113p a becomes q
         ESC [81;65p Q becomes A
         ESC [113;97p q becomes a

         E.g. Reassign the F10 key to a DIR command.

         ESC [0;68;"dir";13p The 0;68 is the extended ASCII code
                                   for the F10 key and 13 is the ASCII
                                   code for a carriage return.

         Other function key codes F1=59,F2=60,F3=61,F4=62,F5=63
                                        F6=64,F7=65,F8=66,F9=67,F10=68

'''

Plan du Site : Home     Python     python_code.html ( = http://www.juggling.ch/gisin/python/python_code.html )

Page mise à jour le 25 mars 2019 par Bernard Gisin     ( Envoyer un e-mail )
Hébergement par : www.infomaniak.ch