Transformation d'un entier en binaire

Bonjour,

pour transformer un entier en binaire, j'ai effectué le programme suivant qui a l'air de fonctionner.
Je ne sais pas si j'ai adopté les bons réflexes de programmeur, toutes vos critiques seront les bienvenues.
Merci d'avance pour vos conseils :

Code:

---

1 2 3 4 5 6 7 8 9 10

def bin(a): nbr_bin = '' while a > 0: q = a//2 reste = a%2 reste_str = str(reste) nbr_bin = nbr_bin + reste_str a = q return nbr_bin

---

Salut,

Le bon réflexe côté "programmeur" sera d'éviter de coder une fonction qui existe déjà.

Difficile de critiquer le code d'un débutant qui fait avec le Python qu'il connaît.
Le seul intérêt de l'exercice n'est pas le résultat (le truc qui marche) mais tout ce que vous avez appris en réfléchissant à comment coder çà, le mettre au point,...

Et si on peut faire "mieux" (sans utiliser la fonction bin builtins), çà pourrait être:

Code:

---

1 2 3 4 5 6

def bin(n): v = [] while n > 0: n, r = divmod(n, 2) v.append(r) return ''.join(str(z) for z in v)

---

mais çà utilise des structures de données (listes) et des fonctions (divmod) que vous ne connaissez pas encore.

- W

Bonjour,

Comme la fonction "bin" existe déjà dans Python, il vaut mieux donner un autre nom. Par exemple: "ent2bin".

Voilà une petite amélioration du code:

Code:

---

1 2 3 4 5 6 7

def ent2bin(a): nbr_bin = '' while a != 0: q, r = divmod(a, 2) nbr_bin = str(r) + nbr_bin a = q return nbr_bin

---

Ce qui donne, par exemple:

Code:

---

1 2 3 4

print(ent2bin(75)) 1001011 print(bin(75)) 0b1001011

---

Il est souvent intéressant de donner le nombre de digit demandé, par exemple 8:

Code:

---

1 2 3 4 5 6 7

def ent2bin(a, nbd=0): nbr_bin = '' while a != 0: q, r = divmod(a, 2) nbr_bin = str(r) + nbr_bin a = q return nbr_bin.zfill(nbd)

---

Et là:

Code:

---

1 2	print(ent2bin(75, 8)) 01001011

---

Salut,

Il fonctionne à l'envers ton code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

>>> def bin_(a): ... nb = "" ... while a > 0: ... q, r = divmod(a, 2) ... nb += str(r) ... a = q ... print(nb) ... >>> bin_(16) 00001 >>> bin_(8) 0001 >>> bin_(4) 001 >>> bin_(2) 01 >>> bin_(255) 11111111 >>> bin_(127) 1111111

---

Je te laisse réfléchir au pourquoi.

Bonjour

Citation:

---

Envoyé par sam01

Je ne sais pas si j'ai adopté les bons réflexes de programmeur, toutes vos critiques seront les bienvenues.

---

Ta plus grosse erreur est de n'avoir pas testé ton code sinon tu aurais vu que d'une part il retourne le nombre inversé comme le dit VinsS et d'autre part qu'il ne fonctionne pas pour 0 (comme ceux de wiztricks ou de tyrtamos d'ailleurs :mouarf: :chin:). Sinon pour le reste oui, tu as codé un algo fonctionnel (à cette nuance près facilement réparable). Quelques variables inutiles qui montrent quelques hésitations qui disparaitront assez vite.

Mais un réflexe que tu aurais pu aussi avoir aurait été de tenter aussi l'approche récursive pour exercer ton cerveau à ce genre de travail qui pourra être nécessaire sur des choses plus complexes...

Code:

---

1 2 3

def e2bin(a): if a <= 1: return str(a) return e2bin(a//2) + str(a%2)

---

Merci à tous. j'ai compris mon erreur. Une erreur d'inattention en fait.
Je l'ai corrigé :

Code:

---

1 2 3 4 5 6 7 8 9 10

def bin(a): nbr_bin = '' while a > 0: q = a//2 reste = a%2 reste_str = str(reste) nbr_bin = reste_str + nbr_bin a = q return nbr_bin

---

je sais que mon code n'est pas élégant, mais je suis obligé de faire comme ça pour comprendre.

@sve@r, ton code est impressionant et tellement court, mais je t'avoue que je n'ai as tout compris, et qu'est-ce l'approche récursive ?

Citation:

---

Envoyé par sam01

@sve@r, ton code est impressionant et tellement court, mais je t'avoue que je n'ai as tout compris, et qu'est-ce l'approche récursive ?

---

C'est la traduction informatique du "diviser pour régner" quand un traitement sur un truc complexe peut se décomposer en plusieurs traitements identiques mais sur des trucs plus simples.

Elle s'appuie sur le fait qu'une fonction qui en appelle une autre, met alors son code en "suspens" tant que l'autre ne termine pas son travail. Donc si une fonction s'appelle elle-même, l'instance de premier niveau attendra le retour de l'instance de second niveau. Et si l'instance de second niveau a besoin d'un sous-sous calcul plus simple, elle s'appellera de nouveau elle-même puis attendra alors le retour de l'instance de 3° niveau.
L'exemple le plus classique est la factorielle où le résultat de facto(n) c'est n * facto(n-1).

A partir de là, généralement, quand on veut programmer une fonction récursive, on commence par prévoir le cas où l'instance de plus bas niveau donne la valeur finale. C'est impératif sinon la récursion n'a aucune possibilité de s'arrêter. Pour la factorielle, ce sera quand n vaut 0 et où le résultat vaut alors 1.
Une fois ce cas écrit, ne reste qu'à écrire le corps de la récursion correspondant.
Pour la factorielle, ce sera alors

Code:

---

1 2 3

def facto(n): if n == 0: return 1 return n * facto(n-1)

---

Ce n'est pas la seule façon d'écrire une fonction récursive (def facto(n): return n * facto(n-1) if n else 1), mais c'est généralement celle qui permet de ne pas se tromper.

Pour ton cas, afficher (par exemple) 10 en binaire, c'est afficher d'abord 5 (sa moitié) en binaire auquel on rajoute ensuite le reste de la division de 10 par 2. Et pour afficher 5 en binaire, c'est d'abord afficher 2 (sa moitié arrondie) auquel on rajoute le reste de la division de 5 par 2. Et pour afficher 2 en binaire c'est ...

Attention, la récursivité c'est peut-être une simplification de code qui semble attrayante mais ça se traduit en retour par une charge terrible pour le processeur (à chaque sous-appel, il doit mémoriser le contexte de l'appel courant pour pouvoir le récupérer au retour). Donc généralement on ne l'emploie que si on ne peut pas faire autrement.

Merci pour l'explication mais c'est costaud quand même. En tout cas pour moi...