Déroulement réel des cours

La « pensée » du samedi 20 avril 2019, 02h28m06s :
Windows est aux systèmes d'exploitation ce que le gruyère est au fromage... La saveur en moins...
1 : semaine du lendi 19 janbier 2009
 Cours n°1 (Cumul=2h) : [Voir le CM n°1]
2 : semaine du lendi 26 janbier 2009
 TD n°1 (Cumul=2h) : [Voir le TD n°1]
 Cours n°2 (Cumul=4h) : [Voir le CM n°2]
3 : semaine du lendi 2 fébrier 2009
 TD n°2 (Cumul=4h) : [Voir le TD n°2]
 Cours n°3 (Cumul=6h) :
  • Regrouper les exercices précédents pour écrire un programme qui crée une grille remplie aléatoirement de marques, affiche la grille à l'écran en matérialisant les marques, déplace le curseur avec les touches et permet de modifier l'état d'une cellule (marquée ou non) en appuyant sur une touche.
    Tout doit être paramétré : la taille de la grille, les dimensions des cellules, la touche sur laquelle appuyer pour marquer/démarquer une cellule, le caractère représentant une marque à l'écran, etc.
    demineur001.py [sans numéros de lignes]
    1. # -*- coding: utf-8 -*-
    2. ############################################
    3. ############################################
    4. ##                                        ##
    5. ##    P R E M I È R E    V E R S I O N    ##
    6. ##                                        ##
    7. ##          D U     P R O J E T           ##
    8. ##                                        ##
    9. ##            D É M I N E U R             ##
    10. ##                                        ##
    11. ############################################
    12. ############################################
    13. import random,curses
    14. ############################################
    15. #  I N I T I A L I S A T I O N S
    16. ############################################
    17. ecran=curses.initscr()  # création de l'écran "graphique"
    18. ecran.keypad(True)      # codage des touches de fonctions en 1 octet
    19. curses.curs_set(False)  # pas d'affichage du curseur
    20.  
    21. ############################################
    22. #  P A R A M È T R E S
    23. ############################################
    24. maxl=10                 # nombre de lignes dans la grille
    25. maxc=10                 # nombre de colonnes dans la grille
    26. ecarth=4                # écart entre deux lignes horizontales
    27. ecartv=3                # écart entre deux lignes verticales
    28. changemarque=ord(" ")   # touche pour marquer/démarquer une cellule
    29. terrain=[]              # création du tableau vide
    30. curseur="+++"           # dessin du curseur
    31. marque="XXX"            # dessin de la marque
    32. curseurmarque="***"     # le curseur + la marque
    33. probamarques=0.2        # probabilité d'apparition des marques
    34. horizontal="-"          # pour dessiner les lignes horizontales
    35. vertical="|"            # pour dessiner les lignes verticales
    36. intersection="+"        # pour dessiner les intersections
    37.  
    38. ############################################
    39. #  F O N C T I O N S
    40. ############################################
    41. # == affichage de la grille ==
    42. def affichagegrille() :
    43.     # création des lignes horizontales
    44.     l=0                                                 # position de la première ligne
    45.     while l<=maxl :                                     # pour chaque ligne
    46.         ecran.addstr(l*ecartv,0,horizontal*ecarth*maxc) # afficher une ligne horizontale
    47.         l+=1                                            # ligne suivante
    48.     # création des lignes verticales
    49.     c=0                                              # position de la première ligne
    50.     while c<=maxc :                                  # pour chaque ligne
    51.         l=1                                          # position de la première case
    52.         while l <= ecartv*maxl :                     # pour chaque case
    53.             if l % ecartv == 0 :                     # tous les "ecarth" lignes
    54.                 ecran.addch(l,c*ecarth,intersection) # afficher une intersection
    55.             else :                                   # sinon...
    56.                 ecran.addch(l,c*ecarth,vertical)     # afficher un trait vertical
    57.             l+=1                                     # ligne suivante
    58.         c+=1                                         # colonne suivante
    59.  
    60. # == créer les marques ==
    61. def poserlesmarques() :
    62.     global terrain
    63.     for l in range (0,maxl) :                   # boucle sur chaque ligne
    64.         terrain.append([])                      # ajouter une ligne au tableau
    65.         for c in range (0,maxc) :               # boucle sur chaque colonne
    66.             if random.random() < probamarques : # si nb aléatoire < proba apparition des marques
    67.                 terrain[l].append(True)         # cocher la case
    68.             else :                              # sinon
    69.                 terrain[l].append(False)        # ne pas cocher
    70.  
    71. # ==  afficher les marques ==
    72. def affichemarques() :
    73.     for l in range(0,maxl) :                                # boucle sur chaque ligne
    74.         for c in range(0,maxc) :                            # boucle sur chaque colonne
    75.             if terrain[l][c] :                              # si la case est "cochée"
    76.                 ecran.addstr(l*ecartv+1,c*ecarth+1,marque)  # afficher (sinon rien)
    77.    
    78. ############################################
    79. #  C O R P S     D U    P R O G R A M M E
    80. ############################################
    81. poserlesmarques()            # créer les marques
    82. ligne=1                      # position verticale initiale du curseur
    83. colonne=1                    # position horizontale initiale du curseur
    84. unetouche=0                  # pour pouvoir entrer dans la boucle
    85. while unetouche!=ord("q") :  # tant qu'on n'a pas appuyé sur la touche Q
    86.     # analyse de la frappe clavier
    87.     if (unetouche==curses.KEY_RIGHT) and (colonne<maxc-1) : # à droite
    88.         colonne += 1
    89.     elif (unetouche==curses.KEY_LEFT) and (colonne>0) :     # à gauche
    90.         colonne -= 1
    91.     elif (unetouche==curses.KEY_UP) and (ligne>0) :         # en haut
    92.         ligne -= 1
    93.     elif (unetouche==curses.KEY_DOWN) and (ligne<maxl-1) :  # en bas
    94.         ligne += 1
    95.     elif unetouche==changemarque :                          # marquer/démarquer
    96.         terrain[ligne][colonne] = not terrain[ligne][colonne]
    97.     # (ré-)affichage du terrain
    98.     ecran.clear()                                                    # effacer l'écran
    99.     affichagegrille()                                                # affichage de la grille
    100.     affichemarques()                                                 # afficher les marques
    101.     if terrain[ligne][colonne] :                                     # si il y a une mine
    102.         ecran.addstr(1+ligne*ecartv,1+colonne*ecarth,curseurmarque)  # positionner le curseur + marque
    103.     else :                                                           # sinon
    104.         ecran.addstr(1+ligne*ecartv,1+colonne*ecarth,curseur)        # positionner le curseur
    105.     # attente...
    106.     unetouche=ecran.getch()                                          # attente d'une frappe clavier
    107.  
    108. ############################################
    109. #  F I N
    110. ############################################
    111. curses.endwin()  # revenir à la console
  • Les caractères spéciaux.
    Pour construire la grille on va utiliser des caractères spéciaux de curses. Ainsi pour afficher le coin de la grille à la deuxième colonne de la deuxième ligne on écrira ecran.addch(1,1,curses.ACS_ULCORNER) .
    Le tableau ci-dessous montre les différents codes et les caractèrs produits (cliquer pour agrandir) :
    caractères spéciaux de curses
  • On va utiliser aussi les couleurs
    Pour pouvoir utiliser les couleurs il faut exécuter d'abord la commande curses.start_color() . Les noms des couleurs possibles sont :
    • COLOR_BLACK,
    • COLOR_RED,
    • COLOR_GREEN,
    • COLOR_YELLOW,
    • COLOR_BLUE,
    • COLOR_MAGENTA,
    • COLOR_CYAN,
    • COLOR_WHITE.
    Curses permet de manipuler les couleurs, en les accordant par paires. Pour pouvoir être utilisée, une paire doit être initialisée : on définit les couleurs qui la composent. Une paire de couleurs correspond à une couleur de texte associée à une couleur de fond.
    On peut utiliser 64 paires, numérotées de 0 à 63, en sachant que la paire n°0 ne peut pas être modifiée, elle est cablée sur blanc et noir.
    Exemple :
    couleurs.py [sans numéros de lignes]
    1. import curses
    2. ecran = curses.initscr()
    3. curses.start_color()
    4. curses.init_pair(3,curses.COLOR_GREEN,curses.COLOR_BLUE)
    5. ecran.addstr(5,5," Essai de couleur ",curses.color_pair(3))
    6. ecran.getch()
    7. curses.endwin()
    Ce programme initialise la paire n°3 avec du bleu en couleur de fond et du vert en couleur de texte, puis écrit en (5,5) un texte en utilisant cette paire de couleurs.
  • La gestion du temps
    Notre programme devra afficher le temps passé pendant que la partie se déroule. Pour cela il faut utiliser la bibliothéque time. Nous utiliserons la fonction time.clock() qui renvoie le temps écoulé depuis le début de l'exécution du programme.
    Exemple :
    temps.py [sans numéros de lignes]
    1. import time,curses
    2. ecran = curses.initscr()
    3. ecran.nodelay(1)                         # getch() non bloquant
    4. curses.curs_set(False)                   # pas d'affichage du curseur
    5. touche=0                                 # pour entrer dans la boucle
    6. while touche!=ord('q'):                  # tant qu'on n'appuie pas sur la touche "q"
    7.     ecran.addstr(5,5,str(time.clock()))  # afficher le temps ecoule
    8.     touche=ecran.getch()                 # recuperer au vol une frappe clavier
    9. curses.endwin()
Dernière modification : 25/8/2016
4 : semaine du lendi 9 fébrier 2009
 TD n°3 (Cumul=6h) : [Voir le TD n°3]
 Cours n°4 (Cumul=8h) : [Voir le CM n°4]
5 : semaine du lendi 16 fébrier 2009
 TD n°4 (Cumul=8h) : [Voir le TD n°4]
6 : semaine du lendi 2 môrs 2009
 TD n°5 (Cumul=10h) : [Voir le TD n°5]
7 : semaine du lendi 9 môrs 2009
 TD n°6 (Cumul=12h) : [Voir le TD n°6]
8 : semaine du lendi 16 môrs 2009
 TD n°7 (Cumul=15h) : [Voir le TD n°7]
9 : semaine du lendi 23 môrs 2009
 TD n°8 (Cumul=18h) : [Voir le TD n°8]
Dernière modification : 25/8/2016