TP3 - La spécification

La spécification est une partie essentielle en programmation, elle correspond à un ensemble d'exigences à satisfaire dans le cadre de la mise au point de programme. On va retrouver un ensemble d'exigences :

Le nommage

L'une des premières exigences concerne le nommage des variables et fonctions. Il faut choisir des noms adéquats permettant à un lecteur de comprendre l'utilité de la variable, ou ce qu'est censé faire la fonction.

Exemple :

def r(l,n):
    b = False
    i = 0
    while i < len(l) and b == False:
        if l[i] == n :
            b = True
        else :
            i+=1
    return b

À première vue, cela peut-être complexe, ou nécessiter du temps pour lire et comprendre ce programme.
En suivant des règles de nommage, on pourrait avoir :

def recherche(liste, nombre):
    nombre_trouve = False
    indice = 0
    while indice < len(liste) and nombre_trouve == False:
        if liste[indice] == nombre :
            nombre_trouve = True
        else:
            indice+=1
    return nombre_trouve

Le programme devient un peu plus clair et explicite quant à son fonctionnement. Chaque variable utilisée dans ce programme a un nom qui détermine son usage dans ce programme.

À vous de jouer

On donne le programme suivant :

def ind(n,l):
    t = []
    for i in range(len(l)):
        if l[i] == n :
            t.append(i)
    return t

Déterminer ce que fait la fonction, puis modifier son nom ainsi que le nom des variables pour savoir ce qu'elles font dans le programme.

Documentation

C'est l'étape permettant d'expliciter ce qu'est censée faire la fonction que l'on écrit, en indiquant ses paramètres et types, et résultat.
En algorithmique, cela correspond à l'écriture de l'entête : la description de la fonction (ce qu'elle fait), ses potentiels paramètres et résultats.
Dans l'entête de la fonction, il faut également préciser le type des paramètres, et le type de ce que peut renvoyer la fonction.

Sur python, cela s'écrit avec un commentaire multilignes :

def uneFonction(parametre1 : unType) -> untypeDeRetour :
    '''
    Les 3 ' sur deux lignes définissent un commentaire multilignes
    En sautant une ligne, je continue mon commentaire.
    Ici, on décrit ce que la fonction doit faire.
    @param parametre1 : (unType) le type du paramètre
    @return : (unTypeDeRetour) préciser le type retourné
    '''

Sur un exemple concret :

def affichage(liste : list) -> string :
    '''
    Transforme une liste d'entiers en une chaîne de caractères possédant ces entiers
    @param liste : (list) liste d'entiers
    @return : (string) la chaîne de caractères comportant les entiers
    '''
    chaine = ''
    for element in liste :
        chaine += str(element)
    return chaine

Le travail de documentation est crucial. Il y a plusieurs intérêts de le faire :

• Écrire : documenter votre code avant de le rédiger vous permet d'avoir un objectif clair de ce que vous voulez faire ;
• Lire : certains programmes peuvent vous faire arracher les cheveux de par la difficulté de lecture. Avoir une documentation vous permet de comprendre ce qui a été fait ;
• Collaborer : quand on fait des projets de groupe, on perd un temps phénoménal à lire les fonctions des autres, si celles-ci ne sont pas documentées. À plusieurs, c'est donc indispensable.

Lire la documentation

Dans la console python, la commande help(fonction) permet d'afficher la documentation associée à la fonction précisée.

Exercices

Pour chaque exercice

Pour chaque question, vous allez devoir :

• tester les fonctions ;
• Faire la documentation ;
• Calculer la complexité et donner l'ordre de grandeur.

1. Fonction pair_impair(liste) prenant une liste d'entiers en paramètre, et retourne 2 listes comportant dans l'une les entiers pairs de la liste en paramètre, dans l'autre les entiers impairs.
2. Fonction nb_zero(nombre) prenant un entier en paramètre, et compte le nombre de 0 présents dans cet entier. On pourra convertir en chaine de caractères.

Sur le réseau social TocToc, les utilisateurs peuvent "liker" les vidéos d'autres utilisateurs. Ainsi, chaque utilisateur possède un nombre de "like". On représente les utilisateurs et leurs likes avec un dictionnaire, dont les clés sont les utilisateurs, et les valeurs leur nombre de likes.

3. Écrire une fonction premier_TocToc(liste) prenant un dictionnaire en paramètre, cherche l'utilisateur de ce dictionnaire ayant le plus de likes, et retourne un tuple comprenant en premier élément l'utilisateur, et en second élément son nombre de likes.

On va s'intéresser ici à la codification des couleurs en hexadécimal. Plus précisément, nous allons convertir un code hexadécimal ("F03B5D" par exemple) en un tuple (rouge, vert, bleu) :

4. 1. Écrire une fonction lettre_en_chiffre(lettre) qui prend une lettre hexadécimale en paramètre, et la convertie en sa valeur décimale ("0" = 0, "1" = 1, ... "A" = 10, ... "F" = 15). On utilisera un dictionnaire dans la fonction. La fonction retournera la valeur décimale.
   2. Écrire une fonction hexa_dec(lettre1,lettre2) qui prend 2 lettres hexadécimales en paramètre, et calcule la valeur décimale suivant la formule de conversion (pour rappel : F5 = 15 ∗ 16¹ + 5 ∗ 16⁰). La fonction retournera la valeur décimale. On utilisera la fonction écrite précédemment.
   3. Écrire une fonction hexa_vers_rvb(chaine) prenant une chaîne de caractères comprenant 6 caractères maximum, et retournant un tuple de 3 valeurs. Chacune des valeurs du tuple sera la conversion de 2 caractères de la chaîne, convertis grâce à la fonction précédente.