TP3 PEP8

Pour le bonheur de mes yeux et de pylint

S2/TP3/bataille_navale.py

@@ -16,7 +16,8 @@ http://fr.wikipedia.org/wiki/Bataille_navale_%28jeu%29
 """
 
 __author__ = 'BEAUSSART Jean-loup & PREUD\'HOMME Geoffrey'
-__date_creation__ = 'Tue, 10 Feb 2015 11:26:19 +0100' # TODO Metre à jour avant envoi
+# TODO Metre à jour avant envoi
+__date_creation__ = 'Tue, 10 Feb 2015 11:26:19 +0100'
 
 
 ###############################################
@@ -27,7 +28,7 @@ __date_creation__ = 'Tue, 10 Feb 2015 11:26:19 +0100' # TODO Metre à jour avant
 from random import randint
 
 # Pour le fichier des scores
-from datetime import datetime 
+from datetime import datetime
 
 ###############################################
 # Constantes nommées utilisées
@@ -37,7 +38,7 @@ from datetime import datetime
 #  sur le plateau :
 # - H : horizontale
 # - V : verticale
-DISPOSITIONS="HV"
+DISPOSITIONS = "HV"
 
 
 # codes réponses d'analyse de tirs
@@ -52,11 +53,12 @@ FICHIER_RESULT = 'bataille_navale_scores.txt'
 # Procédure principale du jeu
 ###############################################
 
-def jouer (nom,descr):
+
+def jouer(nom, descr):
     """
     str, str -> ()
     procédure de jeu complet de bataille navale,
-    le nom du joueur est donné par le paramètre nom, 
+    le nom du joueur est donné par le paramètre nom,
     et le jeu est décrit dans le fichier descr.
 
     CU : le fichier jeu doit exister et être conforme
@@ -66,32 +68,33 @@ def jouer (nom,descr):
     decrire_le_jeu(jeu)
     nbre_tirs = 0
     while not tous_coules(jeu):
-        tir = lire_un_tir (nom)
+        tir = lire_un_tir(nom)
         nbre_tirs += 1
-        nav,res = analyse_un_tir (jeu,tir)
+        nav, res = analyse_un_tir(jeu, tir)
         if res == RATE:
-            print ("raté.")
+            print("raté.")
         elif res == TOUCHE:
-            print (nav + " touché.")
+            print(nav + " touché.")
         else:
-            print (nav + " coulé.")
+            print(nav + " coulé.")
-    sauver_result (nom,descr,nbre_tirs)
+    sauver_result(nom, descr, nbre_tirs)
-    print ("Terminé en {0} tirs".format(nbre_tirs))
+    print("Terminé en {0} tirs".format(nbre_tirs))
 
 ###############################################
 # Opérations sur les fichiers
 ###############################################
 
+
 def lire_donnees(num_descr):
     """
     str -> tuple
-    renvoie un triplet dont les deux premières composantes sont 
+    renvoie un triplet dont les deux premières composantes sont
     et la troisième une liste de couples (nature, taille) où
     nature est une chaîne de caractères décrivant la nature du navire
     et taille un entier désignant le nombre de cases occupées par ce navire.
     Toutes ces données sont lues dans un fichier nommé 'jeu'+num_descr+'.txt'.
 
-    CU : le fichier 'jeu'+num_descr+'.txt' doit exister et être au bon format, 
+    CU : le fichier 'jeu'+num_descr+'.txt' doit exister et être au bon format,
     ie un  fichier texte contenant :
     larg : haut
     nature1 : taille1
@@ -103,72 +106,73 @@ def lire_donnees(num_descr):
     contenu = fichier.readlines()
     fichier.close()
 
-    #On lit la largeur
+    # On lit la largeur
 
-    i=0
+    i = 0
-    tmp=''
+    tmp = ''
-    while(contenu[0][i] != ':'):
+    while contenu[0][i] != ':':
         tmp += contenu[0][i]
-        i+=1
+        i += 1
 
-    largeur=int(tmp)
+    largeur = int(tmp)
 
-    #On lit la hauteur
+    # On lit la hauteur
 
-    i+=1
+    i += 1
-    tmp=''
+    tmp = ''
-    while(contenu[0][i] != '\n'):
+    while contenu[0][i] != '\n':
         tmp += contenu[0][i]
-        i+=1
+        i += 1
 
-    hauteur=int(tmp)
+    hauteur = int(tmp)
 
     res = (largeur, hauteur, list())
 
-    #On va maintenant traiter tous les bateaux un par un
+    # On va maintenant traiter tous les bateaux un par un
 
     for i in range(1, len(contenu)):
-        nom=''
+        nom = ''
-        tailleStr=''
+        tailleStr = ''
-        j=0
+        j = 0
-        while(contenu[i][j] != ':'):
+        while contenu[i][j] != ':':
             nom += contenu[i][j]
-            j+=1
+            j += 1
-        nom = nom[:-1] #on supprime l'espace
+        nom = nom[:-1]  # on supprime l'espace
 
-        j+=1
+        j += 1
-        while(contenu[i][j] != '\n'):
+        while contenu[i][j] != '\n':
             tailleStr += contenu[i][j]
-            j +=1
+            j += 1
 
         res[2].append((nom, int(tailleStr)))
 
     return res
 
-#test OK
+# test OK
-#print(lire_donnees('2'))
+# print(lire_donnees('2'))
-#print(lire_donnees('1'))
+# print(lire_donnees('1'))
-#  
+#
 
-#Fichier personnalisé 
+# Fichier personnalisé
-#print(lire_donnees('3'))
+# print(lire_donnees('3'))
 #
 
 # Sauvegarde du bilan
-#q1
+# q1
 
-#print(datetime.today())
+# print(datetime.today())
-#2015-02-10 11:25:48.324981
+# 2015-02-10 11:25:48.324981
-#On obtient la date et l'heure au format AAAA-MM-JJ HH:MM:S
+# On obtient la date et l'heure au format AAAA-MM-JJ HH:MM:S
 
-#str(datetime.today())
+# str(datetime.today())
-#on convertie en chaîne de caractères la date et l'heure
+# on convertie en chaîne de caractères la date et l'heure
 
-def sauver_result (nom, jeu, nbre):
+
+def sauver_result(nom, jeu, nbre):
     """
     str, str, int -> NoneType
     ajoute une ligne dans le fichier FICHIER_RESULT
-    contenant le nom, le numéro du jeu joué et le nombre de tirs effectués 
+    contenant le nom, le numéro du jeu joué et le nombre de tirs effectués
     dans la partie.
 
     CU : aucune
@@ -178,7 +182,7 @@ def sauver_result (nom, jeu, nbre):
 
     fichierScores = open(FICHIER_RESULT, 'a')
 
-    fichierScores.write('%s:%s:%s:%s\n' %(nom, jeu, nbre, date))
+    fichierScores.write('%s:%s:%s:%s\n' % (nom, jeu, nbre, date))
 
     fichierScores.close()
 
@@ -190,11 +194,12 @@ def sauver_result (nom, jeu, nbre):
 ###############################################
 # Procédures de construction du jeu
 ###############################################
-    
+
-def cree_jeu (descr):
+
+def cree_jeu(descr):
     """
     str -> dict
-    renvoie un nouveau jeu de bataille navale construit à partir des données 
+    renvoie un nouveau jeu de bataille navale construit à partir des données
     lues dans le fichier descr.
 
 
@@ -203,9 +208,9 @@ def cree_jeu (descr):
     - 'nb_cases_occupees' dont la valeur associée est le nombre de cases du plateau
                           occupées par les navires
     - 'touches' dictionnaire contenant deux champs :
-                * l'un nomme 'nb_touches' contenant un entier 
+                * l'un nomme 'nb_touches' contenant un entier
                 * l'autre nomme 'etats_navires' qui contient un dictionnaire
-                  donnant pour chaque navire le nombre de tirs 
+                  donnant pour chaque navire le nombre de tirs
                   qu'ils peuvent encore recevoir avant d'être coulés
     - 'coups_joues' ensemble des coups joués depuis le début de la partie.
 
@@ -213,30 +218,31 @@ def cree_jeu (descr):
     """
 
 
-def cree_plateau (l, h, l_nav):
+def cree_plateau(l, h, l_nav):
     """
     int, int, list -> dict
-    renvoie un plateau de largeur l et de hauteur h occupé par les navires 
+    renvoie un plateau de largeur l et de hauteur h occupé par les navires
     de l_nav.
     La disposition est aléatoire.
 
     CU : les dimensions doivent permettre le placement de tous les navires
     """
 
-def est_placable (esp, nav, pos, disp):
+
+def est_placable(esp, nav, pos, disp):
     """
     dict, tuple, tuple, str -> bool
-    
+
     CU : disp = 'H' ou 'V'
     """
 
-    assert(disp == 'H' or disp == 'V')
+    assert(disp == 'H' or disp == 'V'), 'disp = \'H\' ou \'V\''
 
     if pos[0] > esp['larg'] or pos[0] < 0 or pos[1] < 0 or pos[1] > esp['haut']:
         return False
 
 
-def placer (esp, nav):
+def placer(esp, nav):
     """
     dict, tuple -> NoneType
     place le navire nav dans l'espace maritime esp.
@@ -249,25 +255,28 @@ def placer (esp, nav):
 ###############################################
 # Procédures de déroulement du jeu
 ###############################################
-    
+
-def decrire_le_jeu (jeu):
+def decrire_le_jeu(jeu):
     """
     dict -> ()
     imprime une description du jeu.
-    
+
     CU : aucune
     """
     print('Dimensions du plateau de jeu :')
     print('- largeur : %d' % jeu['plateau']['larg'])
     print('- hauteur : %d' % jeu['plateau']['haut'])
-    
+
     print('Navires :')
     etats = jeu['touches']['etats_navires']
     for navire in etats:
-        print('- %s : %d case%s' % (navire, etats[navire], 's' * (etats[navire] >= 2)))
+        print('- %s : %d case%s' %
-    print('À vous de jouer en répondant à l\'invite ?- par deux nombres séparés par une virgule.')
+              (navire, etats[navire], 's' * (etats[navire] >= 2)))
+    print(
+        'À vous de jouer en répondant à l\'invite ?- par deux nombres séparés par une virgule.')
 
-def lire_un_tir (nom):
+
+def lire_un_tir(nom):
     """
     str -> tuple
     renvoie un couple d'entiers lus sur l'entrée standard
@@ -277,34 +286,32 @@ def lire_un_tir (nom):
     """
     while True:
         try:
-            entree = input() # TODO Texte
+            entree = input()  # TODO Texte
             dec = entree.split(',')
             x, y = int(dec[0]), int(dec[1])
             if type(x) == type(y) == int and x >= 0 and y >= 0:
                 return (x, y)
             else:
                 raise ValueError
-        except: # TODO Tester erreurs possibles
+        except:  # TODO Tester erreurs possibles
             print('Merci de saisir une valeur correcte.')
 
 
-
+def analyse_un_tir(jeu, tir):
-
-def analyse_un_tir (jeu,tir):
     """
     dict, tuple -> str,int
-    renvoie 
+    renvoie
       - ("",RATE) si tir raté
       - (nav,TOUCHE) si nav touché
       - (nav,COULE) si nav coulé
     et modifie l'état du jeu en conséquence.
 
-    CU : aucune 
+    CU : aucune
     """
     jeu["coups_joues"].add(tir)
     if tir in jeu['coups_joues']:
         print('DEBUG Vous avez déjà joué à cet endroit.')
-        return ('', RATE)      
+        return ('', RATE)
     elif tir in jeu['plateau']:
         nav = jeu['plateau'][tir]
         jeu['touches']['nb_touches'] += 1
@@ -317,7 +324,7 @@ def analyse_un_tir (jeu,tir):
         return ('', RATE)
 
 
-def tous_coules (jeu):
+def tous_coules(jeu):
     """
     dict -> bool
     renvoie True si tous les navires du plateau de jeu ont été coulés
@@ -329,10 +336,9 @@ def tous_coules (jeu):
     return jeu['touches']['nb_touches'] >= jeu['nb_cases_occupees']
 
 
-    
 ###############################################
 # Pour une utilisation du module depuis un terminal
-###############################################    
+###############################################
 
 # if __name__ == '__main__':
 #     import sys
@@ -341,6 +347,3 @@ def tous_coules (jeu):
 #         jouer ('Jean Bart','1')
 #     else:
 #         jouer (sys.argv[1],sys.argv[2])
-
-
-