TP bases

Dans cette page, les fonctions présentées sont des versions réécrites et optimisées de celles que nous avons créées ensemble lors d'un TP précédent.Ces fonctions font appel à des connaissances qui n'ont pas nécessairement été abordées en cours, il serait pertinent de prendre le temps de les relire et de mener les recherches nécessaires pour comprendre pourquoi et comment elles ont été réécrites ainsi.

Base 2 vers base 10

Ci-dessous une version optimale de la fonction bindecimal() créée en TP. Quelques différences, au-delà de la docstring :

utilisation de reversed() pour lire la chaîne de caractères de droite à gauche
utilisation de enumerate() qui permet d'obtenir à la fois l'index et la valeur lors d'une itération
utilisation de l'opérateur ** au lieu de la fonction pow() pour une meilleure lisibilité

def bindecimal(nb_binaire):
    """
    Convertit un nombre binaire (sous forme de chaîne ou d'entier) en décimal.

    Paramètres:
    -----------
    nb_binaire : str | int
        Le nombre binaire à convertir (ex: "1010" ou 1010).

    Retourne:
    ---------
    int
        La valeur décimale correspondante.
    """
    # Vérification de l'entrée
    assert isinstance(nb_binaire, (str, int)), "L'entrée doit être une chaîne ou un entier."
    
    # Conversion en chaîne si l'entrée est un entier
    nb_binaire = str(nb_binaire)
    
    # Vérification que l'entrée est bien un nombre binaire valide
    assert all(bit in "01" for bit in nb_binaire), "L'entrée doit contenir uniquement des 0 et des 1."

    # Conversion du binaire en décimal
    nb_decimal = 0
    for i, bit in enumerate(reversed(nb_binaire)):  # Itération de droite à gauche
        nb_decimal += int(bit) * (2 ** i)
        
    return nb_decimal

# Tests rapides
assert bindecimal("1010") == 10
assert bindecimal(1011) == 11
assert bindecimal("0") == 0
assert bindecimal("1") == 1
assert bindecimal("1111") == 15

Base 10 vers base 2

def decibin(nb_decimal):
    """
    Convertit un nombre décimal (entier) en binaire sous forme de chaîne.

    Paramètres:
    -----------
    nb_decimal : int
        Le nombre décimal à convertir (ex: 10).

    Retourne:
    ---------
    str
        La représentation binaire du nombre.
    """
    # Vérification de l'entrée
    if not isinstance(nb_decimal, int) or nb_decimal < 0:
        raise ValueError("L'entrée doit être un entier positif.")

    # Cas particulier : 0 en binaire est "0"
    if nb_decimal == 0:
        return "0"

    # Conversion en binaire avec divisions successives
    nb_binaire = ""
    while nb_decimal > 0:
        nb_binaire = str(nb_decimal % 2) + nb_binaire
        nb_decimal //= 2

    return nb_binaire

# Tests rapides
assert dec_to_bin(10) == "1010"
assert dec_to_bin(13) == "1101"
assert dec_to_bin(0) == "0"
assert dec_to_bin(1) == "1"
assert dec_to_bin(255) == "11111111"
assert dec_to_bin(42) == "101010"

Base 2 vers base 16

def binhex(nb_binaire):
    """
    Convertit un nombre binaire (sous forme de chaîne ou d'entier) en hexadécimal.

    Paramètres:
    -----------
    nb_binaire : str | int
        Le nombre binaire à convertir (ex: "1010" ou 1010).

    Retourne:
    ---------
    str
        La valeur hexadécimale correspondante sous forme de chaîne.
    """
    # Vérification de l'entrée
    if not isinstance(nb_binaire, (str, int)):
        raise ValueError("L'entrée doit être une chaîne ou un entier.")
    
    # Conversion en chaîne si l'entrée est un entier
    nb_binaire = str(nb_binaire)
    
    # Vérification que l'entrée est bien un nombre binaire valide
    if not all(bit in "01" for bit in nb_binaire):
        raise ValueError("L'entrée doit contenir uniquement des 0 et des 1.")
    
    # Ajout de zéros à gauche pour que la longueur soit un multiple de 4
    while len(nb_binaire) % 4 != 0:
        nb_binaire = "0" + nb_binaire

    # Dictionnaire de conversion Binaire → Hexa
    dict_bh = {f"{i:04b}": f"{i:X}" for i in range(16)}

    # Découpage en blocs de 4 bits et conversion
    hex_result = "".join(dict_bh[nb_binaire[i:i+4]] for i in range(0, len(nb_binaire), 4))
    
    return hex_result

# Tests rapides
assert binhex("1010") == "A"
assert binhex(1101) == "D"
assert binhex("1111") == "F"
assert binhex("11111111") == "FF"
assert binhex("0001") == "1"

Base 16 vers base 2

def hex_to_bin(nb_hex):
    """
    Convertit un nombre hexadécimal (sous forme de chaîne) en binaire.

    Paramètres:
    -----------
    nb_hex : str
        Le nombre hexadécimal à convertir (ex: "A" ou "1F").

    Retourne:
    ---------
    str
        La représentation binaire du nombre.
    """
    # Vérification de l'entrée
    if not isinstance(nb_hex, str):
        raise ValueError("L'entrée doit être une chaîne représentant un nombre hexadécimal.")

    # Vérification que la chaîne contient uniquement des caractères hexadécimaux valides
    nb_hex = nb_hex.upper()  # Standardisation en majuscules
    if not all(c in "0123456789ABCDEF" for c in nb_hex):
        raise ValueError("L'entrée doit contenir uniquement des chiffres hexadécimaux (0-9, A-F).")

    # Dictionnaire de conversion Hex → Binaire
    dict_hb = {f"{i:X}": f"{i:04b}" for i in range(16)}

    # Conversion : remplace chaque caractère hexadécimal par son équivalent binaire
    nb_binaire = "".join(dict_hb[c] for c in nb_hex)

    # Suppression des zéros inutiles en tête (sauf si le résultat est "0")
    return nb_binaire.lstrip("0") or "0"

# Tests rapides
assert hex_to_bin("A") == "1010"
assert hex_to_bin("1F") == "11111"
assert hex_to_bin("FF") == "11111111"
assert hex_to_bin("0") == "0"
assert hex_to_bin("C3") == "11000011"
assert hex_to_bin("ABC") == "101010111100"