Conversion bytes vers string

Version imprimable

19/09/2022, 21h07
P.G

Conversion bytes vers string

Bonjour,

Je reçois après un traitement un message sous la forme d'une liste de bytes

Code:

maListe = [b'a', b'b', b'c', b'd', b'\xc3', b'\xa9']

Je bute sur le problème suivant je souhaite la convertir en chaine de caractères
et donc retrouver le résultat ci-contre 'abcdé'

mais comment faire ?

Merci par avance pour tout coup de main.

Cordialement.

P.G
19/09/2022, 21h24
Invité
Salut !
Code:

1 2 3 >>> a = maListe[4]+maListe[5] >>> a.decode('utf8') 'é'
Va falloir travailler sur la liste pour savoir quand tu dois additionner ou non les éléments successifs si tu veux automatiser le truc.

Bonjour
Pas évident.
Le souci c'est que l'utf-8 encode ses éléments de façon variable. Si l'élément est ascii, il prendra un octet (tu le retrouves donc dans b'a', b'b', etc) mais si l'élément n'entre pas dans l'ascii, alors il en prend deux (ou 3 ou 4 si besoin). Ainsi "é" qui se code b'\xc3\xa9' fait deux octets.
Sauf que toi, tu le reçois sous forme séparée b'\xc3', b'\xa9'. Comment ensuite recoller les deux ? Ou plutôt comment déterminer que telle valeur \xYY est unique ou bien doit être combinée avec la suivante \xZZ ? Il me semblait avoir lu dans la doc de l'utf que si le premier bit était à 1, alors cela signifiait que l'octet remonte sur le précédent mais ça ne marche pas. En effet, 0xa9 vaut 10101001 ce qui correspond donc on rajoute 0xc3 mais 0xc3 vaut 11000011 donc on devrait y rajouter ensuite le précédent 'd' mais lui il ne doit pas se rajouter.

J'ai essayé s="".join(x.decode("latin-1") for x in maListe) mais commeje m'en doutais, il a pris les caractères un à un, convertissant b'\xc3' puis b'\xa9'

[edit]C'est finalement Le Narvalo qui m'a donné l'idée (mais il ne le sait pas).
Suffit de coder un truc essai/echec. Tant que ça rate on rajoute le caractère suivant (enfin plus exactement le précédent)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 def toStr(l): s="" tmp=b"" for x in reversed(l): tmp=x+tmp try: s+=tmp.decode("utf-8") tmp=b"" except UnicodeError: pass # if # for return "".join(reversed(s)) # toStr() maListe=[b'a', b'b', b'c', b'd', b'\xc3', b'\xa9'] print(toStr(maListe))

Et un truc du genre peut-être ?

Code:

1
2
3
4
5
6
7
8
9
10
11
def toto():
    letter = b""
    for x in maListe:
        letter+=x
        try:
            print(letter.decode('utf8'))
            letter = b""
        except UnicodeDecodeError:
            pass
    if letter:
        print(letter.decode('utf8'))

C'est de la bidouille...

19/09/2022, 21h55
Sve@r

Citation:

Envoyé par LeNarvalo

Et un truc du genre peut-être ?

Trop tard :P
En plus avec letter+=x tu crées la chaine à l'envers...

Citation:

Envoyé par LeNarvalo

C'est de la bidouille...

Pas tout à fait. Ca correspond à l'esprit Python expliqué au chapitre XIX/8 de mon tutoriel 8-) => on tente et tant que ça marche pas on retente (devise shadock: plus on essaye plus on a de chances que ça marche)...

Citation:

En plus avec letter+=x tu crées la chaine à l'envers...

Hein ?

Code:

1
2
3
4
5
6
>>> toto()
a
b
c
d
é

Code:

tmp=x+tmp

~~On dirait un débutant ! :mouarf::P~~

Allez pour changer un générateur :

Code:

1
2
3
4
5
6
7
8
9
10
11
def toto():
    letter = b""
    for x in maListe:
        letter+=x
        try:
            yield (letter.decode('utf8'))
            letter = b""
        except UnicodeDecodeError:
            pass
    if letter:
        yield letter.decode('utf8')

Code:

1
2
>>> print("".join(toto()))
abcdé

19/09/2022, 22h16
Sve@r

Citation:

Envoyé par LeNarvalo

Hein ?

Je comprends pourquoi ça "marchote" chez-toi :aie: : je suis parti du principe réfléchi que si b'\xa9' ne fonctionne pas, il faut lui rajouter alors b'\xc3'. Donc je traite la chaine à l'envers (d'où le reversed en début de boucle) et fatalement je rajoute les caractère qui viennent ensuite devant les caractères déjà lus, d'où le tmp=x+tmp qui n'est pas la même chose que tmp+=x (parce que pour les chaines, l'addition n'est pas commutative :P).
Toi tu lis la chaine au naturel, comme ça te vient. Il se trouve que par chance b'\xc3' ne fonctionne pas donc tu lui rajoutes (en te gaudriolant comme un bon paysan) le suivant b'\xa9' et tu retombes par chance sur tes pattes.
Mais (et là c'est plus sérieux) l'utf-8 ça se lit de la fin vers le début. Tu peux très bien tomber sur un truc style b'a' + b'\xa9' or b'a' reste traductible 8-)
19/09/2022, 22h27
Invité

Citation:

Envoyé par Sve@r

le tmp=x+tmp qui n'est pas la même chose que tmp+=x (parce que pour les chaines, l'addition n'est pas commutative :P).

Effecftivement ! :oops: :oops: :oops:
J'ai cru pouvoir me moquer du maître... :(

Citation:

Toi tu lis la chaine au naturel, comme ça te vient. Il se trouve que par chance b'\xc3' ne fonctionne pas donc tu lui rajoutes (en te gaudriolant comme un bon paysan) le suivant b'\xa9' et tu retombes par chance sur tes pattes.
Mais (et là c'est plus sérieux) l'utf-8 ça se lit de la fin vers le début. Tu peux très bien tomber sur un truc style b'a' + b'\xa9' or b'a' reste traductible 8-)

Vu que b'a' va marcher je ne vais pas tenter b'a' + b'\xa9', ce qui m'inquiétait avec ma proposition c'était de savoir s'il y avait des codes '\xc3\xa9\xf0' par exemple car dans ce cas il va me sortir "é" (\xc3\xa9) alors que je voulais "þ", mais apparemment non, ça à l'air bien fichu cette table.

Est-ce que je me trompe ?
https://www.utf8-chartable.de/unicod...codeinhtml=hex
19/09/2022, 22h47
P.G

Merci à tous

Problème est résolu.

:applo:
20/09/2022, 06h39
MPython Alaplancha

Bonjour,

Citation:

Envoyé par Sve@r

(en te gaudriolant comme un bon paysan)

Je ne saisis pas... à quoi penses-tu?

Salut,

Citation:

Envoyé par P.G

mais comment faire ?
Code:

1 2 3 4 >>> L = [b'a', b'b', b'c', b'd', b'\xc3', b'\xa9'] >>> b''.join(L).decode('utf-8') 'abcdé' >>>
- W

20/09/2022, 11h53
Sve@r
Citation:

Envoyé par LeNarvalo

ça à l'air bien fichu cette table.

Ben quand-même, un truc destiné à remplacer et à unifier tout l'encodage mondial en englobant le grec, le cyrillique, l'arabe et l'asiatique, faut que ce soit un minimum réfléchi.
Tel que je l'ai compris, les caractères "simples" sont encodés en ascii sur 7 bits (afin d'assurer la compatibilité avec l'ascii) et ensuite quand ça se complexifie, le dernier bit passe à 1 indiquant que l'encodage continue sur le caractère d'avant, et etc jusqu'à je crois 4 octets possibles.
Citation:
Envoyé par wiztricks

Code:

1 2 3 >>> b''.join(L).decode('utf-8') 'abcdé' >>>
Voilà. Je savais qu'il arriverait et nous éclaterait tous avec un truc en une ligne aussi simple qu'évident...8-)