Étapes d'utilisation du concept d'une affectation

1. Déterminer l’expression pour calculer la valeur à affecter ;
2. Déterminer l’identifiant de la variable à modifier ;
3. Écrire l’expression Python avec les bons opérateurs ;
4. Vérifier que les types des opérandes soient bien compatibles avec les opérateurs ;
5. Vérifier si la valeur de l’expression est du type attendu

Étapes d'utilisation du concept d'une instruction conditionnelle

1. Définir tous les cas mutuellement exclusifs nécessaires ;
2. Les ordonner pour faciliter la lisibilité des conditions ;
3. Écrire if, la première condition, « : » et les instructions du cas True indentées ensuite ;
4. S’il y a plus de deux cas, faire de même pour chacune avec elif ;
5. Finir si nécessaire par else, « : » et les instructions correspondantes.

Étapes d'utilisation du concept d'une boucle while

Boucle while

1. Définir et initialiser les variables ;
2. Déterminez la condition d’arrêt (ou de continuation)
3. Écrire le corps de la boucle (mettre à jour la variable de contrôle jusqu’à la condition d’arrêt si nécessaire).

Étapes d'utilisation du concept de boucle for et parcourir une séquence

1. Déterminer la séquence à parcourir :

   1. Soit un intervalle avec un pas

      for i in range(a, b, pas) :
         # Corps de la boucle
      

   2. Soit itérer sur les indices ;

      for index in range(len(l)) :
         # Corps de la boucle
      

   3. Soit itérer sur les éléments

      for element in l :
         # Corps de la boucle
      

   4. Et initialiser les variables de parcours en fonction ;

2. Exprimer la condition de traitement si nécessaire (ou de sortie de boucle si la liste ne doit pas être parcourue en entier)

3. Écrire le corps de la boucle

4. Vérifier les cas particuliers (liste vide, bornes de début et fin de parcours, etc).

Étapes d'utilisation du concept d'écriture d'une fonction

1. Écrire l'en-tête de la fonction
   1. Choisir l'identifiant de la fonction pour qu'il traduise l'intention (snake_case)
   2. Choisir le nombre de paramètres et les identifiants pour qu'ils traduisent leur rôle
2. Rédiger les spécifications de la fonction
   1. Donner les préconditions sur les paramètres de la fonction et leur type
   2. Donner les postconditions décrivant l'effet, la valeur et le type de retour de la fonction
3. Écrire le corps de la fonction en respectant les spécifications
   1. Déterminer la logique du programme (affectation, condition, boucle, etc)
   2. Déclarer les variables locales nécessaires
   3. Écrire les instructions du programme
4. Terminer par un return en fonction des spécifications
   1. Il faut un return pour chaque chemin d’exécution dans la fonction
   2. Pas de return est équivalent à retourner None

Étapes d'utilisation du concept de lecture d'un fichier

1. Ouverture du fichier
   1. Identifier le nom et le chemin du fichier (typiquement dans filename)
   2. Choisir le mode "r" pour la lecture
   3. Ouvrir le fichier avec : with open(filename , mode) as f : ou f = open(filename , mode)
2. Traitement du fichier en fonction du format
   1. Parcours des lignes : ligne par ligne avec f.readline() en itérant sur les lignes avec for line in f: ou for line in f.readlines())
   2. Traitement des lignes
      1. Retrait des blancs en début et fin de ligne (line.strip())
      2. Séparer les éléments en fonction du format (line.split())
      3. Convertir les éléments en fonction du type attendu
   3. Traiter les erreurs de formatage du fichier (ignorer ligne, raise ValueError) * Trouver l’expression pour écrire une ligne en fonction du format par concaténation
3. Fermeture du fichier
   1. Avec un with, il n’y a rien à faire
   2. Sinon, avec un f.close()
4. Gérer les exceptions susceptibles de se produire durant le traitement du fichier (typiquement IOError)
   1. Mettre le code dans un try : … except :
   2. Traiter les exceptions par le suite avec des except error_type: …

Étapes d'utilisation du concept de l'écriture d'un fichier

1. Ouverture du fichier
   1. Identifier le nom et le chemin du fichier (typiquement dans filename)
   2. Choisir le mode "r" pour la lecture ou le mode "w" pour l'écriture
   3. Ouvrir le fichier avec : with open(filename , mode) as f : ou f = open(filename , mode)
2. Traitement du fichier en fonction du format
   1. Trouver l’expression pour écrire une ligne en fonction du format par concaténation
   2. Parcourir la structure de données et écrire les lignes au fur et à mesure
      1. Avec f.write()
      2. Prendre en compte les retours à la ligne
3. Fermeture du fichier
   1. Avec un with, il n’y a rien à faire
   2. Sinon, avec un f.close()
4. Gérer les exceptions susceptibles de se produire durant le traitement du fichier (typiquement IOError)
   1. Mettre le code dans un try : … except :
   2. Traiter les exceptions par le suite avec des except error_type: …

Étapes d'utilisation du concept de création et mise à jour d'un dictionnaire

1. Déterminer le type des clés et des valeurs du dictionnaire, éventuellement à l’aide d’un dessin ;
2. Créer un dictionnaire vide (d={}) s’il n’existe pas encore ;
3. Pour chaque clé à modifier dans le dictionnaire, vérifier si la clé existe dans le dictionnaire
   1. Établir l’expression qui donnera la valeur à mettre dans le dictionnaire
   2. Si non, ajouter la clé au dictionnaire avec une valeur par défaut en fonction du type des valeurs (d[key] = default_val) ou directement la bonne valeur
   3. Si oui, mettre à jour la valeur correspondante à la clé (nouvelle valeur ou valeur modifiée en fonction, par exemple d[key] = new_val ou d[key].append(new_elem))

Étapes d'utilisation du concept de l'écriture d'une classe

1. Bien nommer la classe
   1. Utiliser un substantif qui décrit le type d'objet
   2. Utiliser du CamelCase si le nom est composé de plusieurs mots
2. Déterminer les attributs et méthodes en fonction de ce que représente cette classe
   1. Déterminer le nombre et les types des attributs
   2. Déterminer le nombre et les objectifs des méthodes
3. Créer la méthode d’initialisation __init__
   1. Entête :
      1. Ajouter self comme premier paramètre
      2. Déterminer les types et les identifiants des paramètres pour qu’ils traduisent leur rôle
   2. Pour chaque attribut nécessaire :
      1. Choisir un identifiant qui traduise son rôle (le même que le paramètre associé sipossible)
      2. Trouver l’expression pour l’initialiser en utilisant (ou non) les paramètres (self.attr = expression)
4. Pour chaque autre méthode d’instance
   1. Ecrire l'entête :
      1. Donner un identifiant en snake_case à la méthode qui traduise son rôle
      2. Ajouter self comme premier paramètre
      3. Déterminer les types et les identifiants des paramètres pour qu’ils traduisent leur rôle
   2. Ajouter au moins un test pour cette méthode
   3. Dans le corps de la méthode :
      1. Utiliser self.attribut pour accéder à la valeur d’un attribut
      2. Pour appeler une autre méthode de la même classe écrivez self.autre_méthode()
      3. Si la méthode doit retourner un résultat ne pas oublier return et bien réfléchir à l’expression et au type de la valeur retournée
5. Créer la méthode __str__
   1. Entête :
      1. Écrire l’entête def __str__(self)
   2. Déterminer l’expression pour représenter l’objet au format désiré en utilisant les bons attributs
      1. Concaténer les attributs via + self.nom_de_variable +
      2. Attention à bien convertir des valeurs qui ne seraient pas des strings avec l’instruction str(otherType)
6. Créer la méthode __eq__
   1. Entête :
      1. Écrire l’entête def__eq__(self,autre)
   2. Vérifier que le paramètre autre est bien une instance de cette classe avec type() ou isinstance(autre, ClassName)
   3. Comparer individuellement l’égalité des valeurs des attributs désirés
7. Tester la classe en exécutant les tests que vous avez ajouté pour ses différentes méthodes.

Étapes d'utilisation du concept de l'ajout d'un noeud dans une liste chainée

1. Créer un nouveau nœud (new_node) composé de la valeur à ajouter dans la liste.
2. Parcourir la structure pour identifier le nœud précédant l’emplacement où insérer new_node
3. Pour ne pas perdre la référence vers le nœud suivant, faire pointer new_node.next vers le nœud qui suit le nœud courant
4. Insérer new_node (cas général, attention aux cas particuliers), en faisant pointer le nœud courant vers new_node
5. Mettre à jour les attributs de la classe le cas échéant (taille, tête de liste, etc.)

Étapes d'utilisation du concept du retrait d'un noeud dans une liste chainée

1. Identifier la valeur associée au nœud à retirer
2. Parcourir la structure pour identifier le nœud précédant l’emplacement du nœud à supprimer
3. Retirer le nœud correspondant (cas général) en faisant pointer le nœud courant vers le nœud suivant le nœud à supprimer
4. Mettre à jour les attributs de la classe le cas échéant (taille, tête de liste, etc.)