TP - Adressage IP, réseaux, masques

---

Ce TP dans Capytale

L’objectif est d’écrire une fonction meme_sous_reseau(ip_a, ip_b, masque) qui renvoie un booléen indiquant si les machines A et B font partie du même sous-réseau.

On rappelle quelques instructions qui pourront s’avérer utiles :

bin(45)

'0b101101'

chaine = "bonjour à tous !"
chaine.split(' ')  # on sépare la chaîne selon le caractère espace

['bonjour', 'à', 'tous', '!']

def et_logique(bit1, bit2):
    """
    Renvoie le résultat de l'opération logique bit1 ET bit2.
    
    Entrées : deux string d'1 caractère ('0' ou '1')
    Sortie : string 
    """
    # à vous de jouer !
    pass

assert et_logique('0', '0') == '0'
assert et_logique('0', '1') == '0'
assert et_logique('1', '0') == '0'
assert et_logique('1', '1') == '1'
print("Tests réussis !")

Traceback (most recent call last):
  File "<input>", line 18, in <module>
  File "<input>", line 12, in test_et_logique
AssertionError

Error: 

def entier_en_mot_binaire(entier, longueur_mot_binaire):
    """
    Renvoie un mot binaire correspondant à l'entier.
    
    Entrées :
        entier : int
        longueur_mot_binaire : int de longueur supérieure ou égale au nombre de bits nécessaires
    pour convertir entier en base 2
    
    Sortie : string de longueur longueur_mot_binaire            
    """
    # à vous de jouer !
    pass


assert entier_en_mot_binaire(1, 8) == '00000001'
assert entier_en_mot_binaire(192, 8) == '11000000'
assert entier_en_mot_binaire(168, 8) == '10101000'
print("Tests réussis !")

def masque_en_mot_binaire(masque):
    """
    Renvoie la conversion du masque en un mot binaire.
    
    Entrée : masque (int)
    Sortie : string de 32 caractères
    """
    # à vous de jouer !
    pass


assert masque_en_mot_binaire(24) == '11111111111111111111111100000000'
print("Tests réussis !")

def ip_en_liste(ip):
    """
    Renvoie une liste dont les éléments sont les 4 octets de l'adresse ip.
    
    Entrée : ip (string) 
    Sortie : liste d'entiers
    """
    # à vous de jouer !
    pass


assert ip_en_liste('192.168.0.1') == [192, 168, 0, 1]
print("Tests réussis !")

def ip_en_mot_binaire(ip):
    """
    Renvoie la conversion d'une ip en un mot binaire.
    
    Entrée : string contenant une IP (ex "192.168.0.1")
    Sortie : string de 32 caractères
    """
    # à vous de jouer !
    pass
    

assert ip_en_mot_binaire("192.168.0.1") == '11000000101010000000000000000001'
print("Tests réussis !")

def adresse_reseau_ip(ip, masque):
    """
    Renvoie l'adresse réseau de l'adresse ip avec le masque masque.
    
    Entrées :
        ip : string contenant une IP (ex "192.168.0.1")
        masque : entier du masque en notation CIDR (ex : 24)
    Sortie : string de 32 caractères    
    """
    # à vous de jouer !
    pass

       

assert adresse_reseau_ip("192.168.0.1", 24) == '11000000101010000000000000000000'
assert adresse_reseau_ip("192.168.1.3", 24) == '11000000101010000000000100000000'
assert adresse_reseau_ip("192.168.0.1", 20) == '11000000101010000000000000000000'
assert adresse_reseau_ip("192.168.1.3", 20) == '11000000101010000000000000000000'
print("Tests réussis !")

def meme_sous_reseau(ip_a, ip_b, masque):
    """
    Renvoie un booléen indiquant si ip_a et ip_b sont dans un même réseau de masque masque.
    
    Entrées :
    ip_a:  string contenant une IP (ex "192.168.0.1")
    ip_b : string contenant une IP
    masque : entier du masque en notation CIDR (ex : 24)
    """
    # à vous de jouer !
    pass


assert meme_sous_reseau("192.168.0.1", "192.168.1.3", 24) == False
assert meme_sous_reseau("192.168.0.1", "192.168.1.3", 20) == True
assert meme_sous_reseau("192.168.0.1", "192.168.0.3", 30) == True
print("Tests réussis !")