UnicodeEncodeError: le codec 'ascii' ne peut pas coder le caractère u '\ xa0' en position 20: l'ordinal n'est pas dans la plage (128)

J'ai des problèmes avec les caractères unicode du texte récupéré à partir de différentes pages Web (sur différents sites). J'utilise BeautifulSoup.

Le problème est que l'erreur n'est pas toujours reproductible; il fonctionne parfois avec certaines pages, et parfois, il abat en lançant a UnicodeEncodeError. J'ai essayé à peu près tout ce à quoi je peux penser, et pourtant je n'ai rien trouvé qui fonctionne de manière cohérente sans lancer une sorte d'erreur liée à Unicode.

L'une des sections de code qui pose problème est illustrée ci-dessous:

agent_telno = agent.find('div', 'agent_contact_number')
agent_telno = '' if agent_telno is None else agent_telno.contents[0]
p.agent_info = str(agent_contact + ' ' + agent_telno).strip()

Voici une trace de pile produite sur CERTAINES chaînes lorsque l'extrait ci-dessus est exécuté:

Traceback (most recent call last):
  File "foobar.py", line 792, in <module>
    p.agent_info = str(agent_contact + ' ' + agent_telno).strip()
UnicodeEncodeError: 'ascii' codec can't encode character u'\xa0' in position 20: ordinal not in range(128)

Je soupçonne que cela est dû au fait que certaines pages (ou plus précisément, les pages de certains sites) peuvent être codées, tandis que d'autres peuvent ne pas l'être. Tous les sites sont basés au Royaume-Uni et fournissent des données destinées à la consommation au Royaume-Uni - il n'y a donc aucun problème lié à l'internalisation ou au traitement de texte écrit en autre chose qu'en anglais.

Quelqu'un at-il des idées sur la façon de résoudre ce problème afin que je puisse résoudre ce problème de manière cohérente?

Vous devez lire le HOWTO Python Unicode . Cette erreur est le tout premier exemple .

Fondamentalement, arrêtez d'utiliser strpour convertir unicode en texte / octets codés.

À la place, utilisez correctement .encode()pour encoder la chaîne:

p.agent_info = u' '.join((agent_contact, agent_telno)).encode('utf-8').strip()

ou travailler entièrement en unicode.

C'est un point de douleur unicode classique en python! Considérer ce qui suit:

a = u'bats\u00E0'
print a
 => batsà

Tout va bien jusqu'à présent, mais si nous appelons str (a), voyons ce qui se passe:

str(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode character u'\xe0' in position 4: ordinal not in range(128)

Oh trempette, ça ne fera de bien à personne! Pour corriger l'erreur, codez les octets explicitement avec .encode et dites à python quel codec utiliser:

a.encode('utf-8')
 => 'bats\xc3\xa0'
print a.encode('utf-8')
 => batsà

Voil \ u00E0!

Le problème est que lorsque vous appelez str (), python utilise le codage de caractères par défaut pour essayer de coder les octets que vous lui avez donnés, qui dans votre cas sont parfois des représentations de caractères unicode. Pour résoudre le problème, vous devez dire à python comment gérer la chaîne que vous lui donnez en utilisant .encode ('any_unicode'). La plupart du temps, vous devriez bien utiliser utf-8.

Pour une excellente exposition sur ce sujet, voir le discours PyCon de Ned Batchelder ici: http://nedbatchelder.com/text/unipain.html

J'ai trouvé un travail élégant pour supprimer les symboles et continuer à garder la chaîne en tant que chaîne comme suit:

yourstring = yourstring.encode('ascii', 'ignore').decode('ascii')

Il est important de noter que l'utilisation de l'option ignorer est dangereuse car elle supprime silencieusement toute prise en charge unicode (et internationalisation) du code qui l'utilise, comme on le voit ici (convertir unicode):

>>> u'City: Malmö'.encode('ascii', 'ignore').decode('ascii')
'City: Malm'

eh bien j'ai tout essayé mais cela n'a pas aidé, après avoir fait des recherches sur Google, j'ai compris ce qui suit et cela a aidé. python 2.7 est en cours d'utilisation.

# encoding=utf8
import sys
reload(sys)
sys.setdefaultencoding('utf8')

Un problème subtil entraînant l'échec de l'impression est que vos variables d'environnement sont incorrectes, par exemple. ici LC_ALL mis à "C". Dans Debian, ils découragent de le configurer: Debian wiki sur Locale

$ echo $LANG
en_US.utf8
$ echo $LC_ALL 
C
$ python -c "print (u'voil\u00e0')"
Traceback (most recent call last):
  File "<string>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode character u'\xe0' in position 4: ordinal not in range(128)
$ export LC_ALL='en_US.utf8'
$ python -c "print (u'voil\u00e0')"
voilà
$ unset LC_ALL
$ python -c "print (u'voil\u00e0')"
voilà

Pour moi, ce qui a fonctionné était:

BeautifulSoup(html_text,from_encoding="utf-8")

J'espère que cela aide quelqu'un.

J'ai en fait constaté que dans la plupart de mes cas, le simple fait de supprimer ces caractères est beaucoup plus simple:

s = mystring.decode('ascii', 'ignore')

Le problème est que vous essayez d'imprimer un caractère unicode, mais votre terminal ne le prend pas en charge.

Vous pouvez essayer d'installer le language-pack-enpackage pour résoudre ce problème:

sudo apt-get install language-pack-en

qui fournit des mises à jour des données de traduction en anglais pour tous les packages pris en charge (y compris Python). Installez un package de langue différent si nécessaire (selon les caractères que vous essayez d'imprimer).

Sur certaines distributions Linux, il est nécessaire pour s'assurer que les paramètres régionaux anglais par défaut sont correctement configurés (afin que les caractères unicode puissent être gérés par shell / terminal). Parfois, il est plus facile de l'installer que de le configurer manuellement.

Ensuite, lors de l'écriture du code, assurez-vous d'utiliser le bon encodage dans votre code.

Par exemple:

open(foo, encoding='utf-8')

Si vous avez toujours un problème, revérifiez la configuration de votre système, telle que:

• Votre fichier de paramètres régionaux ( /etc/default/locale), qui devrait avoir par exemple

  LANG="en_US.UTF-8"
  LC_ALL="en_US.UTF-8"

  ou:

  LC_ALL=C.UTF-8
  LANG=C.UTF-8

• Valeur de LANG / LC_CTYPEin shell.

• Vérifiez les paramètres régionaux pris en charge par votre shell:

  locale -a | grep "UTF-8"

Démonstration du problème et de la solution dans une nouvelle machine virtuelle.

1. Initialiser et provisionner la VM (par exemple en utilisant vagrant):

   vagrant init ubuntu/trusty64; vagrant up; vagrant ssh

   ^{Voir: boîtes Ubuntu disponibles .} .

2. Impression de caractères unicode (comme le signe de marque comme ™):

   $ python -c 'print(u"\u2122");'
   Traceback (most recent call last):
     File "<string>", line 1, in <module>
   UnicodeEncodeError: 'ascii' codec can't encode character u'\u2122' in position 0: ordinal not in range(128)

3. Installation en cours language-pack-en:

   $ sudo apt-get -y install language-pack-en
   The following extra packages will be installed:
     language-pack-en-base
   Generating locales...
     en_GB.UTF-8... /usr/sbin/locale-gen: done
   Generation complete.

4. Maintenant, le problème devrait être résolu:

   $ python -c 'print(u"\u2122");'
   ™

5. Sinon, essayez la commande suivante:

   $ LC_ALL=C.UTF-8 python -c 'print(u"\u2122");'
   ™

En coquille:

1. Recherchez les paramètres régionaux UTF-8 pris en charge à l'aide de la commande suivante:

   locale -a | grep "UTF-8"

2. Exportez-le avant d'exécuter le script, par exemple:

   export LC_ALL=$(locale -a | grep UTF-8)

   ou manuellement comme:

   export LC_ALL=C.UTF-8

3. Testez-le en imprimant des caractères spéciaux, par exemple ™:

   python -c 'print(u"\u2122");'

Ci-dessus testé dans Ubuntu.

Ajoutez la ligne ci-dessous au début de votre script (ou comme deuxième ligne):

# -*- coding: utf-8 -*-

C'est la définition de l'encodage du code source python. Plus d'informations dans PEP 263 .

Voici un remaniement de quelques autres réponses soi-disant "flic out". Il y a des situations dans lesquelles le simple fait de jeter les caractères / chaînes gênants est une bonne solution, malgré les protestations exprimées ici.

def safeStr(obj):
    try: return str(obj)
    except UnicodeEncodeError:
        return obj.encode('ascii', 'ignore').decode('ascii')
    except: return ""

Le tester:

if __name__ == '__main__': 
    print safeStr( 1 ) 
    print safeStr( "test" ) 
    print u'98\xb0'
    print safeStr( u'98\xb0' )

Résultats:

1
test
98°
98

Suggestion: vous pourriez vouloir nommer cette fonction à la toAsciiplace? C'est une question de préférence.

Cela a été écrit pour Python 2. Pour Python 3, je pense que vous voudrez utiliser bytes(obj,"ascii")plutôt que str(obj). Je n'ai pas encore testé cela, mais je vais à un moment donné et réviser la réponse.

Je mets toujours le code ci-dessous dans les deux premières lignes des fichiers python:

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

Fonctions d'assistance simples trouvées ici .

def safe_unicode(obj, *args):
    """ return the unicode representation of obj """
    try:
        return unicode(obj, *args)
    except UnicodeDecodeError:
        # obj is byte string
        ascii_text = str(obj).encode('string_escape')
        return unicode(ascii_text)

def safe_str(obj):
    """ return the byte string representation of obj """
    try:
        return str(obj)
    except UnicodeEncodeError:
        # obj is unicode
        return unicode(obj).encode('unicode_escape')

Ajoutez simplement à un encodage variable ('utf-8')

agent_contact.encode('utf-8')

Veuillez ouvrir le terminal et lancer la commande ci-dessous:

export LC_ALL="en_US.UTF-8"

Je viens d'utiliser les éléments suivants:

import unicodedata
message = unicodedata.normalize("NFKD", message)

Vérifiez ce que la documentation en dit:

unicodedata.normalize (form, unistr) Retourne le formulaire de formulaire normal pour la chaîne Unicode unistr. Les valeurs valides pour le formulaire sont «NFC», «NFKC», «NFD» et «NFKD».

La norme Unicode définit diverses formes de normalisation d'une chaîne Unicode, basées sur la définition de l'équivalence canonique et de l'équivalence de compatibilité. En Unicode, plusieurs caractères peuvent être exprimés de différentes manières. Par exemple, le caractère U + 00C7 (LETTRE MAJUSCULE LATINE C AVEC CEDILLE) peut également être exprimé sous la forme de la séquence U + 0043 (LETTRE MAJUSCULE LATINE C) U + 0327 (COMBINAISON CEDILLE).

Pour chaque caractère, il existe deux formes normales: la forme normale C et la forme normale D. La forme normale D (NFD) est également connue sous le nom de décomposition canonique et traduit chaque caractère en sa forme décomposée. La forme normale C (NFC) applique d'abord une décomposition canonique, puis compose à nouveau les caractères pré-combinés.

En plus de ces deux formes, il existe deux formes normales supplémentaires basées sur l'équivalence de compatibilité. Dans Unicode, certains caractères sont pris en charge qui normalement seraient unifiés avec d'autres caractères. Par exemple, U + 2160 (ROMAN NUMERAL ONE) est vraiment la même chose que U + 0049 (LETTRE MAJUSCULE LATINE I). Cependant, il est pris en charge dans Unicode pour la compatibilité avec les jeux de caractères existants (par exemple gb2312).

La forme normale KD (NFKD) appliquera la décomposition de compatibilité, c'est-à-dire remplacer tous les caractères de compatibilité par leurs équivalents. La forme normale KC (NFKC) applique d'abord la décomposition de compatibilité, suivie de la composition canonique.

Même si deux chaînes Unicode sont normalisées et ont la même apparence pour un lecteur humain, si l'une a la combinaison de caractères et l'autre pas, elles peuvent ne pas être égales.

Le résout pour moi. Simple et facile.

La solution ci-dessous a fonctionné pour moi, vient d'être ajoutée

u "String"

(représentant la chaîne en unicode) avant ma chaîne.

result_html = result.to_html(col_space=1, index=False, justify={'right'})

text = u"""
<html>
<body>
<p>
Hello all, <br>
<br>
Here's weekly summary report.  Let me know if you have any questions. <br>
<br>
Data Summary <br>
<br>
<br>
{0}
</p>
<p>Thanks,</p>
<p>Data Team</p>
</body></html>
""".format(result_html)

Hélas, cela fonctionne en Python 3 au moins ...

Python 3

Parfois, l'erreur se trouve dans les variables de l'environnement et se rencontre donc

import os
import locale
os.environ["PYTHONIOENCODING"] = "utf-8"
myLocale=locale.setlocale(category=locale.LC_ALL, locale="en_GB.UTF-8")
... 
print(myText.encode('utf-8', errors='ignore'))

où les erreurs sont ignorées dans le codage.

Je viens d'avoir ce problème, et Google m'a conduit ici, alors juste pour ajouter aux solutions générales ici, c'est ce qui a fonctionné pour moi:

# 'value' contains the problematic data
unic = u''
unic += value
value = unic

J'ai eu cette idée après avoir lu la présentation de Ned .

Je ne prétends pas comprendre pleinement pourquoi cela fonctionne, cependant. Donc, si quelqu'un peut modifier cette réponse ou mettre un commentaire pour l'expliquer, je l'apprécierai.

Nous avons rencontré cette erreur lors de l'exécution manage.py migrate dans Django avec des appareils localisés.

Notre source contenait la # -*- coding: utf-8 -*-déclaration, MySQL était correctement configuré pour utf8 et Ubuntu avait le pack de langue et les valeurs appropriés dans/etc/default/locale .

Le problème était simplement que le conteneur Django (nous utilisons docker) manquait le LANG var env.

Réglage LANGde en_US.UTF-8et redémarrer le conteneur avant migrations réexécution résolu le problème.

De nombreuses réponses ici (@agf et @Andbdrew par exemple) ont déjà abordé les aspects les plus immédiats de la question OP.

Cependant, je pense qu'il y a un aspect subtil mais important qui a été largement ignoré et qui compte beaucoup pour tous ceux qui comme moi se sont retrouvés ici tout en essayant de donner un sens aux encodages en Python: Python 2 vs Python 3, la gestion de la représentation des personnages est très différente . Je me sens comme un gros morceau de confusion a à voir avec les gens qui lisent sur les encodages en Python sans être au courant de la version.

Je suggère à toute personne intéressée à comprendre la cause première du problème OP de commencer par lire l' introduction de Spolsky aux représentations de caractères et Unicode, puis de passer à Batchelder sur Unicode en Python 2 et Python 3.

Essayez d'éviter la conversion de variable en str (variable). Parfois, cela peut provoquer le problème.

Astuce simple à éviter:

try: 
    data=str(data)
except:
    data = data #Don't convert to String

L'exemple ci-dessus résoudra également l'erreur Encode.

Si vous avez quelque chose comme packet_data = "This is data"ça, faites-le sur la ligne suivante, juste après l'initialisation packet_data:

unic = u''
packet_data = unic

Mise à jour pour python 3.0 et versions ultérieures. Essayez ce qui suit dans l'éditeur python:

locale-gen en_US.UTF-8
export LANG=en_US.UTF-8 LANGUAGE=en_US.en
LC_ALL=en_US.UTF-8

Cela définit l'encodage des paramètres régionaux par défaut du système au format UTF-8.

Plus d'informations peuvent être lues ici sur PEP 538 - Contrainte des paramètres régionaux C hérités à des paramètres régionaux basés sur UTF-8 .

J'ai eu ce problème en essayant de sortir des caractères Unicode stdout, mais avecsys.stdout.write , plutôt que d'imprimer (afin que je puisse également prendre en charge la sortie vers un fichier différent).

À partir de la propre documentation de BeautifulSoup , j'ai résolu cela avec la bibliothèque de codecs:

import sys
import codecs

def main(fIn, fOut):
    soup = BeautifulSoup(fIn)
    # Do processing, with data including non-ASCII characters
    fOut.write(unicode(soup))

if __name__ == '__main__':
    with (sys.stdin) as fIn: # Don't think we need codecs.getreader here
        with codecs.getwriter('utf-8')(sys.stdout) as fOut:
            main(fIn, fOut)

Ce problème se produit souvent lorsqu'un projet django se déploie à l'aide d'Apache. Parce qu'Apache définit la variable d'environnement LANG = C dans / etc / sysconfig / httpd. Ouvrez simplement le fichier et commentez (ou modifiez votre version) ce paramètre. Ou utilisez l'option lang de la commande WSGIDaemonProcess, dans ce cas, vous pourrez définir différentes variables d'environnement LANG sur différents hôtes virtuels.

La solution recommandée n'a pas fonctionné pour moi, et je pouvais vivre avec le dumping de tous les caractères non ascii, donc

s = s.encode('ascii',errors='ignore')

ce qui m'a laissé quelque chose de dépouillé qui ne jette pas d'erreurs.

Cela fonctionnera:

 >>>print(unicodedata.normalize('NFD', re.sub("[\(\[].*?[\)\]]", "", "bats\xc3\xa0")).encode('ascii', 'ignore'))

Production:

>>>bats

Dans le cas général de l'écriture de cette chaîne de codage non prise en charge (disons ) dans un fichier (par exemple ), cela fonctionnedata_that_causes_this_errorresults.txt

f = open("results.txt", "w")
  f.write(data_that_causes_this_error.encode('utf-8'))
  f.close()