On décide ici de coder l'écriture hexadécimale d'un entier par la liste de ses chiffres (chiffre de type str).
Par exemple, l'entier c7aseize sera codé par la liste ['c', '7', 'a'].
Écrire une fonction python qui :
def hexToDec(n) :
f=len(n)-1
s=0
for k in n :
if k=='a' : k=10
elif k=='b' : k=11
elif k=='c' : k=12
elif k=='d' : k=13
elif k=='e' : k=14
elif k=='f' : k=15
else : k=int(k)
s+=k*pow(16,f)
f-=1
return s
print( hexToDec(['c', '8', 'f']) )
print( hexToDec(['a']) )
print( hexToDec(['1','0']) )
Si le programme est correct, l'affichage obtenu doit être le même que l'affichage obtenu pour le code suivant :
print(0xc8f)
print(0xa)
print(0x10)
def hexToDec(n) :
s=0 # contiendra b_0 puis b_0+16*b_1 puis b_0+16*b_1+16^2*b_2 ...
p=1 # contient les puissances successives de 16
for k in reversed(n) :
if k=='a' : k=10
elif k=='b' : k=11
elif k=='c' : k=12
elif k=='d' : k=13
elif k=='e' : k=14
elif k=='f' : k=15
else : k=int(k)
s+=k*p
p*=16
return s
print( hexToDec(['c', '8', 'f']) )
print( hexToDec(['a']) )
print( hexToDec(['1','0']) )
Dans cette troisième version, on utilise la fonction python ord()
qui renvoie un entier correspondant au code unicode du caractère passé en argument.
On consultera le cours de G. Swinnen pour en savoir plus sur le code unicode, la fonction ord() et sa fonction 'inverse' chr().
def hexToDec(n) :
s=0 # contiendra b_0 puis b_0+16*b_1 puis b_0+16*b_1+16^2*b_2 ...
p=1 # contient les puissances successives de 16
for k in reversed(n) :
if ord(k) in range(ord('a'), ord('f')+1) : k=ord(k)-ord('a')+10
else : k=int(k)
s+=k*p
p*=16
return s
print( hexToDec(['c', '8', 'f']) )
print( hexToDec(['a']) )
print( hexToDec(['1','0']) )
Programmer l'algorithme des divisions en cascade pour obtenir l'écriture hexadécimale d'un entier n donné en entrée (la donnée n sera sous sa forme décimale).
L'écriture hexadécimale obtenue en sortie sera codée sous la même forme qu'à l'exercice précédent.
Par exemple, l'entier c7aseize sera codé par la liste ['c', '7', 'a'].
On prévoira aussi un affichage 'normal' de cette écriture hexadécimale.
def cascade(n) :
listchiffres=[]
while n!=0 :
r=n%16
if r==10 : r='a'
elif r==11 : r='b'
elif r==12 : r='c'
elif r==13 : r='d'
elif r==14 : r='e'
elif r==15 : r='f'
listchiffres.append(r)
n//=16
listchiffres.reverse()
return listchiffres
def affichehexa(n) :
L=cascade(n)
for x in L :
print(x,end='')
print()
a,b,c,d=357,15,16,17
affichehexa(a)
affichehexa(b)
affichehexa(c)
affichehexa(d)
Si le programme est correct, on obtiendra les mêmes affichages (sans le préfixe 0x) que le code suivant :
a,b,c,d=357,15,16,17
print(hex(a),hex(b),hex(c),hex(d))
Les lignes de code correspondant au if peuvent être abrégées en utilisant ord() et chr() :
def cascade(n) :
listchiffres=[]
while n!=0 :
r=n%16
if 10<= r<= 15 : r=chr(ord('a')+r-10)
listchiffres.append(r)
n//=16
listchiffres.reverse()
return listchiffres
def affichehexa(n) :
L=cascade(n)
for x in L :
print(x,end='')
print()
a,b,c,d=357,15,16,17
affichehexa(a)
affichehexa(b)
affichehexa(c)
affichehexa(d)
On suppose ici qu'une écriture hexadécimale est une chaîne de caractères. Par exemple l'entier c7aseize sera codé par la chaîne 'c7a'.
Une écriture binaire sera également codée sous forme d'un string. Par exemple, l'entier 11deux sera codé par la chaîne '11'.
Écrire une fonction :
(On s'interdira de passer par la base 10... Revoir le cours si nécessaire.)
On définit d'abord une fonction hb qui traduit un chiffre hexadécimal en binaire sur quatre rangs. Il suffit ensuite de faire appel à cette fonction hb pour chacun des chiffres hexadécimaux de l'écriture donnée en entrée et de concaténer les chaînes binaires correspondantes.
def hb(x) :
if x=='0': return '0000'
if x=='1': return '0001'
if x=='2': return '0010'
if x=='3': return '0011'
if x=='4': return '0100'
if x=='5': return '0101'
if x=='6': return '0110'
if x=='7': return '0111'
if x=='8': return '1000'
if x=='9': return '1001'
if x=='a': return '1010'
if x=='b': return '1011'
if x=='c': return '1100'
if x=='d': return '1101'
if x=='e': return '1110'
if x=='f': return '1111'
def hexToBin(n) :
""" n est une écriture hexa d'un entier.
La fonction retourne l'écriture binaire associée."""
b='' # chaîne vide qui contiendra l'écriture binaire de n
for x in n :
b+=hb(x)
return b
print(hexToBin('ef21a'))
print(bin(0xef21a)[2:]) # pour vérif
Dans cette seconde version, on a remplacé la fonction hb par un dictionnaire python.
On pourra consulter le cours de G.Swinnen pour en savoir plus sur ces dictionnaires.
def hexToBin(n) :
""" n est une écriture hexa d'un entier.
La fonction retourne l'écriture binaire associée."""
# dictionnaire traduisant les chiffres hexa en binaire :
hb={'0':'0000', '1':'0001', '2':'0010', '3':'0011', '4':'0100', '5':'0101',\
'6':'0110', '7':'0111', '8':'1000', '9':'1001', 'a':'1010', 'b':'1011',\
'c':'1100', 'd':'1101', 'e':'1110', 'f':'1111' }
b='' # chaîne vide qui contiendra l'écriture binaire de n
for x in n :
b+=hb[x]
return b
print(hexToBin('ef21a'))
print(bin(0xef21a)[2:]) # pour vérif