###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)
Transformez votre programme en fonction.###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)
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.###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)
Remplacer votre programme par une fonction comp.###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)
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.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)
Transformer votre programme en fonction addition_1().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))
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.###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