Définition du codage correct lors de la canalisation de la sortie standard en Python

Lors de la transmission de la sortie d'un programme Python, l'interpréteur Python est confus au sujet de l'encodage et le définit sur Aucun. Cela signifie un programme comme celui-ci:

# -*- coding: utf-8 -*-
print u"åäö"

fonctionnera correctement lorsqu'il est exécuté normalement, mais échouera avec:

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

lorsqu'il est utilisé dans une séquence de tuyaux.

Quelle est la meilleure façon de faire fonctionner cela lors de la tuyauterie? Puis-je simplement lui dire d'utiliser l'encodage du shell / système de fichiers / tout ce qui est utilisé?

La suggestion que j'ai vue jusqu'à présent est de modifier directement votre site.py, ou de coder en dur le codage par défaut en utilisant ce hack:

# -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
print u"åäö"

Existe-t-il une meilleure façon de faire fonctionner la tuyauterie?

Votre code fonctionne lorsqu'il est exécuté dans un script car Python code la sortie dans le codage utilisé par votre application de terminal. Si vous canalisez, vous devez le coder vous-même.

Une règle d'or est la suivante: utilisez toujours Unicode en interne. Décodez ce que vous recevez et encodez ce que vous envoyez.

# -*- coding: utf-8 -*-
print u"åäö".encode('utf-8')

Un autre exemple didactique est un programme Python pour convertir entre ISO-8859-1 et UTF-8, mettant tout en majuscule entre les deux.

import sys
for line in sys.stdin:
    # Decode what you receive:
    line = line.decode('iso8859-1')

    # Work with Unicode internally:
    line = line.upper()

    # Encode what you send:
    line = line.encode('utf-8')
    sys.stdout.write(line)

La définition du codage par défaut du système est une mauvaise idée, car certains modules et bibliothèques que vous utilisez peuvent s'appuyer sur le fait qu'il est ASCII. Ne le fais pas.

Tout d'abord, concernant cette solution:

# -*- coding: utf-8 -*-
print u"åäö".encode('utf-8')

Il n'est pas pratique d'imprimer explicitement avec un encodage donné à chaque fois. Ce serait répétitif et sujet aux erreurs.

Une meilleure solution consiste à changer sys.stdoutau début de votre programme, à encoder avec un encodage sélectionné. Voici une solution que j'ai trouvée sur Python: Comment est choisi sys.stdout.encoding? , en particulier un commentaire de "toka":

import sys
import codecs
sys.stdout = codecs.getwriter('utf8')(sys.stdout)

Vous pouvez essayer de changer la variable d'environnement "PYTHONIOENCODING" en "utf_8". J'ai écrit une page sur mon calvaire avec ce problème .

Tl; dr de l'article de blog:

import sys, locale, os
print(sys.stdout.encoding)
print(sys.stdout.isatty())
print(locale.getpreferredencoding())
print(sys.getfilesystemencoding())
print(os.environ["PYTHONIOENCODING"])
print(chr(246), chr(9786), chr(9787))

vous donne

utf_8
False
ANSI_X3.4-1968
ascii
utf_8
ö ☺ ☻

export PYTHONIOENCODING=utf-8

faire le travail, mais ne peut pas le définir sur python lui-même ...

ce que nous pouvons faire, c'est vérifier si le paramètre n'est pas défini et dire à l'utilisateur de le définir avant d'appeler le script avec:

if __name__ == '__main__':
    if (sys.stdout.encoding is None):
        print >> sys.stderr, "please set python env PYTHONIOENCODING=UTF-8, example: export PYTHONIOENCODING=UTF-8, when write to stdout."
        exit(1)

Mise à jour pour répondre au commentaire: le problème existe juste lors du canalisation vers stdout. J'ai testé dans Fedora 25 Python 2.7.13

python --version
Python 2.7.13

chat b.py

#!/usr/bin/env python
#-*- coding: utf-8 -*-
import sys

print sys.stdout.encoding

en cours d'exécution ./b.py

UTF-8

en cours d'exécution ./b.py | Moins

None

J'ai eu un problème similaire la semaine dernière . C'était facile à corriger dans mon IDE (PyCharm).

Voici ma solution:

À partir de la barre de menus de PyCharm: Fichier -> Paramètres ... -> Éditeur -> Encodages de fichiers, puis définissez: "Encodage IDE", "Encodage de projet" et "Encodage par défaut pour les fichiers de propriétés" TOUS en UTF-8 et elle travaille maintenant comme un charme.

J'espère que cela t'aides!

Une version aseptisée discutable de la réponse de Craig McQueen.

import sys, codecs
class EncodedOut:
    def __init__(self, enc):
        self.enc = enc
        self.stdout = sys.stdout
    def __enter__(self):
        if sys.stdout.encoding is None:
            w = codecs.getwriter(self.enc)
            sys.stdout = w(sys.stdout)
    def __exit__(self, exc_ty, exc_val, tb):
        sys.stdout = self.stdout

Usage:

with EncodedOut('utf-8'):
    print u'ÅÄÖåäö'

Je pourrais "l'automatiser" avec un appel à:

def __fix_io_encoding(last_resort_default='UTF-8'):
  import sys
  if [x for x in (sys.stdin,sys.stdout,sys.stderr) if x.encoding is None] :
      import os
      defEnc = None
      if defEnc is None :
        try:
          import locale
          defEnc = locale.getpreferredencoding()
        except: pass
      if defEnc is None :
        try: defEnc = sys.getfilesystemencoding()
        except: pass
      if defEnc is None :
        try: defEnc = sys.stdin.encoding
        except: pass
      if defEnc is None :
        defEnc = last_resort_default
      os.environ['PYTHONIOENCODING'] = os.environ.get("PYTHONIOENCODING",defEnc)
      os.execvpe(sys.argv[0],sys.argv,os.environ)
__fix_io_encoding() ; del __fix_io_encoding

Oui, il est possible d'obtenir une boucle infinie ici si ce "setenv" échoue.

Je pensais juste que je mentionnerais quelque chose ici que j'ai dû consacrer longtemps à expérimenter avant de finalement réaliser ce qui se passait. Cela peut être si évident pour tout le monde ici qu'ils n'ont pas pris la peine de le mentionner. Mais cela m'aurait aidé s'ils l'avaient fait, donc selon ce principe ...!

NB: J'utilise spécifiquement Jython , v 2.7, donc il est possible que cela ne s'applique pas à CPython ...

NB2: les deux premières lignes de mon fichier .py sont:

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

Le mécanisme de construction de chaîne "%" (AKA "opérateur d'interpolation") provoque également des problèmes ADDITIONNELS ... Si le codage par défaut de "l'environnement" est ASCII et que vous essayez de faire quelque chose comme

print( "bonjour, %s" % "fréd" )  # Call this "print A"

Vous n'aurez aucune difficulté à exécuter dans Eclipse ... Dans une CLI Windows (fenêtre DOS), vous constaterez que l'encodage est la page de codes 850 (mon système d'exploitation Windows 7) ou quelque chose de similaire, qui peut gérer au moins les caractères accentués européens, donc il va travailler.

print( u"bonjour, %s" % "fréd" ) # Call this "print B"

fonctionnera également.

Si, OTOH, vous dirigez vers un fichier à partir de la CLI, l'encodage stdout sera None, qui sera par défaut ASCII (sur mon système d'exploitation de toute façon), qui ne pourra gérer aucune des impressions ci-dessus ... (encodage redouté Erreur).

Alors vous pourriez penser à rediriger votre stdout en utilisant

sys.stdout = codecs.getwriter('utf8')(sys.stdout)

et essayez d'exécuter dans la tuyauterie CLI vers un fichier ... Très bizarrement, l'impression A ci-dessus fonctionnera ... Mais l'impression B ci-dessus générera l'erreur de codage! Cependant, les éléments suivants fonctionneront correctement:

print( u"bonjour, " + "fréd" ) # Call this "print C"

La conclusion à laquelle je suis parvenu (provisoirement) est que si une chaîne qui est spécifiée pour être une chaîne Unicode utilisant le préfixe "u" est soumise au mécanisme de gestion%, elle semble impliquer l'utilisation du codage d'environnement par défaut, indépendamment de si vous avez défini stdout pour rediriger!

La façon dont les gens gèrent cela est une question de choix. Je souhaiterais la bienvenue à un expert Unicode pour dire pourquoi cela se produit, si je me trompe d'une manière ou d'une autre, quelle est la solution préférée à cela, si cela s'applique également à CPython , si cela se produit en Python 3, etc., etc.

J'ai rencontré ce problème dans une application héritée, et il était difficile d'identifier où ce qui était imprimé. Je me suis aidé avec ce hack:

# encoding_utf8.py
import codecs
import builtins


def print_utf8(text, **kwargs):
    print(str(text).encode('utf-8'), **kwargs)


def print_utf8(fn):
    def print_fn(*args, **kwargs):
        return fn(str(*args).encode('utf-8'), **kwargs)
    return print_fn


builtins.print = print_utf8(print)

En plus de mon script, test.py:

import encoding_utf8
string = 'Axwell Λ Ingrosso'
print(string)

Notez que cela modifie TOUS les appels à imprimer pour utiliser un encodage, donc votre console imprimera ceci:

$ python test.py
b'Axwell \xce\x9b Ingrosso'

Sous Windows, j'ai eu ce problème très souvent lors de l'exécution d'un code Python à partir d'un éditeur (comme Sublime Text), mais pas si vous l'exécutiez à partir de la ligne de commande.

Dans ce cas, vérifiez les paramètres de votre éditeur. Dans le cas de SublimeText, cela l'a Python.sublime-buildrésolu:

{
  "cmd": ["python", "-u", "$file"],
  "file_regex": "^[ ]*File \"(...*?)\", line ([0-9]*)",
  "selector": "source.python",
  "encoding": "utf8",
  "env": {"PYTHONIOENCODING": "utf-8", "LANG": "en_US.UTF-8"}
}