Discussion :

[P.G]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

Salut !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Sve@r]

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

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))

[Invité]

Et un truc du genre peut-être ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[Sve@r]

Et un truc du genre peut-être ?

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

C'est de la bidouille...

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

[Invité]

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

Hein ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tmp=x+tmp

On dirait un débutant !

Allez pour changer un générateur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Sve@r]

Hein ?

Je comprends pourquoi ça "marchote" chez-toi : 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 ).
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

[wiztricks]

Salut,

mais comment faire ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Sve@r]

ç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.

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

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...