Représentation des entiers relatifs.¶

Activité I¶

  L'objectif de notre premier programme, va être de donner la représentation sur un octet (8 bits) d'un nombre positif compris entre 0 et 127.
  Nous allons récupérer notre fonction de conversion d'un nombre donné en base 10 et converti en base 2.
In [ ]:
###section des fonctions

def converti_10_2(nombre_base_10):
    
    """Cette fonction converti un nombre donné en base 10 en sa traduction en base 2"""
    
    NB_10=int(nombre_base_10)                         # Conversion de la chaine de caractères en entier
    liste=[]                                          # Liste qui contiendra les restes des divisions par 2
    while NB_10!=0:                                   # Tourne tant que le reste n'est pas nul.
        liste.append(NB_10%2)                         # Donne le reste de la division par 2
        NB_10=NB_10//2                                # Donne le quotient qu'il va falloir à nouveau diviser.
    liste.reverse()                                   # Renverse la liste
    NB_2=""                                           # Initialise la chaine de caractère à vide.
    for i in range(len(liste)):                       # Passe tous les éléments de la liste 1 par 1
        NB_2=NB_2+str(liste[i])                       # Concatenne les éléments de la liste
    return NB_2                                       # Retourne le nombre en base 2.
       

### Section main

question=input("De quel nombre compris entre 0 et 127 voulez-vous l'écriture sur 1 octet?  ")
NB_2=converti_10_2(question)
longueur=len(NB_2)
octet=''
for i in range(8-longueur):
    octet=octet+'0'
octet=octet+NB_2
print(octet)

Activité 2¶

Transformez votre programme en fonction.
In [ ]:
###section des fonctions

def converti_10_2(nombre_base_10):
    
    """Cette fonction converti un nombre donné en base 10 en sa traduction en base 2"""
    
    NB_10=int(nombre_base_10)                         # Conversion de la chaine de caractères en entier
    liste=[]                                          # Liste qui contiendra les restes des divisions par 2
    while NB_10!=0:                                   # Tourne tant que le reste n'est pas nul.
        liste.append(NB_10%2)                         # Donne le reste de la division par 2
        NB_10=NB_10//2                                # Donne le quotient qu'il va falloir à nouveau diviser.
    liste.reverse()                                   # Renverse la liste
    NB_2=""                                           # Initialise la chaine de caractère à vide.
    for i in range(len(liste)):                       # Passe tous les éléments de la liste 1 par 1
        NB_2=NB_2+str(liste[i])                       # Concatenne les éléments de la liste
    return NB_2                                       # Retourne le nombre en base 2.
       
def repre_1_octet_positif(NB_2):
    
    """Cette fonction prend un entier en base 2 et donne son écriture sur 1 octet."""
    
    longueur=len(NB_2)
    octet=''
    for i in range(8-longueur):                       # On commence par écrire le nombre de 0 nécessaires.
        octet=octet+'0'
    octet=octet+NB_2
    print(octet)

### Section main

question=input("De quel entier compris entre 0 et 127 voulez-vous l'écriture sur 1 octet?  ")
NB_2=converti_10_2(question)
repre_1_octet_positif(NB_2)

Activité 2¶

Votre objectif est désormais de donner l'écriture sur 1 octet d'un entier compris entre 0 et 127, puis l'écriture de son opposé.
Pour cela, vous allez commencer par aller chercher le complément de l'écriture sur 8 bits.
In [ ]:
###section des fonctions

def converti_10_2(nombre_base_10):
    
    """Cette fonction converti un nombre donné en base 10 en sa traduction en base 2"""
    
    NB_10=int(nombre_base_10)                         # Conversion de la chaine de caractères en entier
    liste=[]                                          # Liste qui contiendra les restes des divisions par 2
    while NB_10!=0:                                   # Tourne tant que le reste n'est pas nul.
        liste.append(NB_10%2)                         # Donne le reste de la division par 2
        NB_10=NB_10//2                                # Donne le quotient qu'il va falloir à nouveau diviser.
    liste.reverse()                                   # Renverse la liste
    NB_2=""                                           # Initialise la chaine de caractère à vide.
    for i in range(len(liste)):                       # Passe tous les éléments de la liste 1 par 1
        NB_2=NB_2+str(liste[i])                       # Concatenne les éléments de la liste
    return NB_2                                       # Retourne le nombre en base 2.
       
def repre_1_octet_positif(NB_2):
    
    """Cette fonction prend un entier en base 2 et donne son écriture sur 1 octet."""
    
    longueur=len(NB_2)
    octet=''
    for i in range(8-longueur):                       # On commence par écrire le nombre de 0 nécessaires.
        octet=octet+'0'
    octet=octet+NB_2
    return octet

### Section main

question=input("Donnez un nombre entre 0 et 127  ")
NB_2=converti_10_2(question)
octet_p=repre_1_octet_positif(NB_2)
complement=''
for i in octet_p:
    if i=='1':
        complement=complement+'0'
    else:
        complement=complement+'1'
print(octet_p)
print(complement)   

Activité 3¶

Remplacer votre programme par une fonction comp.
In [ ]:
###section des fonctions

def converti_10_2(nombre_base_10):
    
    """Cette fonction converti un nombre donné en base 10 en sa traduction en base 2"""
    
    NB_10=int(nombre_base_10)                         # Conversion de la chaine de caractères en entier
    liste=[]                                          # Liste qui contiendra les restes des divisions par 2
    while NB_10!=0:                                   # Tourne tant que le reste n'est pas nul.
        liste.append(NB_10%2)                         # Donne le reste de la division par 2
        NB_10=NB_10//2                                # Donne le quotient qu'il va falloir à nouveau diviser.
    liste.reverse()                                   # Renverse la liste
    NB_2=""                                           # Initialise la chaine de caractère à vide.
    for i in range(len(liste)):                       # Passe tous les éléments de la liste 1 par 1
        NB_2=NB_2+str(liste[i])                       # Concatenne les éléments de la liste
    return NB_2                                       # Retourne le nombre en base 2.
       
def repre_1_octet_positif(NB_2):
    
    """Cette fonction prend un entier en base 2 et donne son écriture sur 1 octet."""
    
    longueur=len(NB_2)
    octet=''
    for i in range(8-longueur):                       # On commence par écrire le nombre de 0 nécessaires.
        octet=octet+'0'
    octet=octet+NB_2
    return octet

def comp(octet_p):
    
    """Cette fonction donne le complément sur 8 bits d'un nombre donné sur 8 bits."""
    
    complement=''
    for i in octet_p:
        if i=='1':
            complement=complement+'0'
        else:
            complement=complement+'1'
    return complement

### Section main

question=input("Donnez un nombre entre 0 et 127  ")
NB_2=converti_10_2(question)
octet_p=repre_1_octet_positif(NB_2)
print(octet_p)
complement=comp(octet_p)
print(complement) 

Activité 4¶

Il faut désormais additionner le 1. Le nombre à additionner étant dans une variable, vous ne pourrez pas utiliser la technique vue dans la séquence sur l'algèbre de Bool, séquence 4.
Vous allez devoir construire un programme qui additionne bit à bit pour un octet avec le nombre 1.
Pour cela, vous aurez besoin de renverser une chaine de caractère avec : chaine[::-1]
Ce n'est pas une méthode. Il faut donc entrer le résultat dans une variable.
In [ ]:
a=input('Entrez une chaine de 8 bits')
r_a=a[::-1]
retenue=1                           # La retenue est initialiser à 1 car nous additionnons  le nombre 1.
somme=''
for i in r_a:
    s=int(i)+retenue
    if s==2:
        retenue=1
        somme=somme+'0'
    elif s==1:
        retenue=0
        somme=somme+'1'
    else:
        retenue=0
        somme=somme+'0'
add=somme[::-1]
print(add)

Activité 5¶

Transformer votre programme en fonction addition_1().
In [ ]:
def addition_1(chaine):
    
    """Cette fonction additionne un entier naturel écrit avec 8 bits avec le nombre 1 écrit avec 8 bots."""
    
    r_a=chaine[::-1]
    retenue=1                                  # La retenue est initialiser à 1 car nous additionnons  le nombre 1.
    somme=''
    for i in r_a:
        s=int(i)+retenue
        if s==2:
            retenue=1
            somme=somme+'0'
        elif s==1:
            retenue=0
            somme=somme+'1'
        else:
            retenue=0
            somme=somme+'0'
    add=somme[::-1]
    return add
   
chaine=input('Entrez une chaine de 8 bits :  ')
print(addition_1(chaine))

Activité 6¶

Terminer l'objectif en réalisant un programme transformant un nombre entier entre 0 et 127 en son codage sur 8 bits (à afficher). Le programme doit également afficher son opposé sur 8 bits.
In [ ]:
###section des fonctions

def converti_10_2(nombre_base_10):
    
    """Cette fonction converti un nombre donné en base 10 en sa traduction en base 2"""
    
    NB_10=int(nombre_base_10)                         # Conversion de la chaine de caractères en entier
    liste=[]                                          # Liste qui contiendra les restes des divisions par 2
    while NB_10!=0:                                   # Tourne tant que le reste n'est pas nul.
        liste.append(NB_10%2)                         # Donne le reste de la division par 2
        NB_10=NB_10//2                                # Donne le quotient qu'il va falloir à nouveau diviser.
    liste.reverse()                                   # Renverse la liste
    NB_2=""                                           # Initialise la chaine de caractère à vide.
    for i in range(len(liste)):                       # Passe tous les éléments de la liste 1 par 1
        NB_2=NB_2+str(liste[i])                       # Concatenne les éléments de la liste
    return NB_2                                       # Retourne le nombre en base 2.
       
def repre_1_octet_positif(NB_2):
    
    """Cette fonction prend un entier en base 2 et donne son écriture sur 1 octet."""
    
    longueur=len(NB_2)
    octet=''
    for i in range(8-longueur):                       # On commence par écrire le nombre de 0 nécessaires.
        octet=octet+'0'
    octet=octet+NB_2
    return octet

def comp(octet_p):
    
    """Cette fonction donne le complément sur 8 bits d'un nombre donné sur 8 bits."""
    
    complement=''
    for i in octet_p:
        if i=='1':
            complement=complement+'0'
        else:
            complement=complement+'1'
    return complement

def addition_1(chaine):
    
    """Cette fonction additionne un entier naturel écrit avec 8 bits avec le nombre 1 écrit avec 8 bits."""
    
    r_a=chaine[::-1]
    retenue=1                                      # La retenue est initialiser à 1 car nous additionnons  le nombre 1.
    somme=''
    for i in r_a:
        s=int(i)+retenue
        if s==2:
            retenue=1
            somme=somme+'0'
        elif s==1:
            retenue=0
            somme=somme+'1'
        else:
            retenue=0
            somme=somme+'0'
    add=somme[::-1]
    return add

### Section main

question=input("Donnez un nombre entre 0 et 127  ")
NB_2=converti_10_2(question)
octet_p=repre_1_octet_positif(NB_2)
print(octet_p)
complement=comp(octet_p)
print(addition_1(complement)) 
Vérifiez sur 2 ou 3 exemple que la somme des deux nombres obtenus fait bien (1)00000000