as3:~/ngokevin-site# nano content/blog/20140114_test-chinese.mkd
as3:~/ngokevin-site# wok
Traceback (most recent call last):
File "/usr/local/bin/wok", line 4, in
Engine()
File "/usr/local/lib/python2.7/site-packages/wok/engine.py", line 104, in init
self.load_pages()
File "/usr/local/lib/python2.7/site-packages/wok/engine.py", line 238, in load_pages
p = Page.from_file(os.path.join(root, f), self.options, self, renderer)
File "/usr/local/lib/python2.7/site-packages/wok/page.py", line 111, in from_file
page.meta['content'] = page.renderer.render(page.original)
File "/usr/local/lib/python2.7/site-packages/wok/renderers.py", line 46, in render
return markdown(plain, Markdown.plugins)
File "/usr/local/lib/python2.7/site-packages/markdown/init.py", line 419, in markdown
return md.convert(text)
File "/usr/local/lib/python2.7/site-packages/markdown/init.py", line 281, in convert
source = unicode(source)
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe8 in position 1: ordinal not in range(128). -- Note: Markdown only accepts unicode input!

Como corrigi-lo?

Em alguns outros aplicativos de blog estáticos baseados em python, a postagem em chinês pode ser publicada com sucesso. Como este aplicativo: http://github.com/vrypan/bucket3 . No meu site http://bc3.brite.biz/ , o post em chinês pode ser publicado com sucesso.

tl; dr / correção rápida

• Não decodifique / codifique willy nilly
• Não assuma que suas strings são codificadas em UTF-8
• Tente converter cadeias de caracteres para cadeias de caracteres Unicode o mais rápido possível no seu código
• Corrija seu código do idioma: Como resolver o UnicodeDecodeError no Python 3.6?
• Não fique tentado a usar reloadhacks rápidos

Zen Unicode no Python 2.x - a versão longa

Sem ver a fonte, é difícil conhecer a causa raiz, então terei que falar em geral.

UnicodeDecodeError: 'ascii' codec can't decode bytegeralmente acontece quando você tenta converter um Python 2.x strque contém não-ASCII em uma cadeia de caracteres Unicode sem especificar a codificação da cadeia de caracteres original.

Em resumo, as cadeias Unicode são um tipo totalmente separado de cadeia Python que não contém nenhuma codificação. Eles contêm apenas códigos de ponto Unicode e, portanto, podem conter qualquer ponto Unicode de todo o espectro. As strings contêm texto codificado, como UTF-8, UTF-16, ISO-8895-1, GBK, Big5 etc. As strings são decodificadas para Unicode e Unicodes são codificadas para strings . Arquivos e dados de texto são sempre transferidos em cadeias codificadas.

Os autores do módulo Markdown provavelmente usam unicode()(onde a exceção é lançada) como uma porta de qualidade para o restante do código - ele converterá ASCII ou reorganizará as cadeias Unicodes existentes em uma nova cadeia Unicode. Os autores do Markdown não sabem a codificação da sequência de entrada, portanto, você decodificará as seqüências de caracteres em strings Unicode antes de passar para o Markdown.

As strings Unicode podem ser declaradas no seu código usando o uprefixo das strings. Por exemplo

>>> my_u = u'my ünicôdé strįng'
>>> type(my_u)
<type 'unicode'>

As strings Unicode também podem vir de arquivos, bancos de dados e módulos de rede. Quando isso acontece, você não precisa se preocupar com a codificação.

Pegadinhas

A conversão de strpara Unicode pode ocorrer mesmo quando você não chama explicitamente unicode().

Os seguintes cenários causam UnicodeDecodeErrorexceções:

# Explicit conversion without encoding
unicode('€')

# New style format string into Unicode string
# Python will try to convert value string to Unicode first
u"The currency is: {}".format('€')

# Old style format string into Unicode string
# Python will try to convert value string to Unicode first
u'The currency is: %s' % '€'

# Append string to Unicode
# Python will try to convert string to Unicode first
u'The currency is: ' + '€'         

Exemplos

No diagrama a seguir, você pode ver como a palavra caféfoi codificada na codificação "UTF-8" ou "Cp1252", dependendo do tipo de terminal. Nos dois exemplos, cafsão apenas ascii regulares. Em UTF-8, éé codificado usando dois bytes. Em "Cp1252", é 0xE9 (que também é o valor do ponto Unicode (não é coincidência)). O correto decode()é chamado e a conversão para um Python Unicode é bem-sucedida:

Neste diagrama, decode()é chamado com ascii(que é o mesmo que chamar unicode()sem uma codificação fornecida). Como o ASCII não pode conter bytes maiores que 0x7F, isso gerará uma UnicodeDecodeErrorexceção:

O sanduíche Unicode

É uma boa prática formar um sanduíche Unicode no seu código, onde você decodifica todos os dados recebidos em cadeias Unicode, trabalha com Unicodes e depois codifica para strs na saída. Isso evita que você se preocupe com a codificação de strings no meio do seu código.

Entrada / decodificação

Código fonte

Se você precisar inserir não-ASCII em seu código-fonte, basta criar cadeias Unicode prefixando-as com a u. Por exemplo

u'Zürich'

Para permitir que o Python decodifique seu código-fonte, você precisará adicionar um cabeçalho de codificação para corresponder à codificação real do seu arquivo. Por exemplo, se seu arquivo foi codificado como 'UTF-8', você usaria:

# encoding: utf-8

Isso é necessário apenas quando você possui código não ASCII .

arquivos

Normalmente, dados não ASCII são recebidos de um arquivo. O iomódulo fornece um TextWrapper que decodifica seu arquivo rapidamente, usando um dado encoding. Você deve usar a codificação correta para o arquivo - ele não pode ser facilmente adivinhado. Por exemplo, para um arquivo UTF-8:

import io
with io.open("my_utf8_file.txt", "r", encoding="utf-8") as my_file:
     my_unicode_string = my_file.read() 

my_unicode_stringseria adequado para passar para Markdown. Se for UnicodeDecodeErrorda read()linha, você provavelmente já usou o valor de codificação errado.

Arquivos CSV

O módulo CSV do Python 2.7 não suporta caracteres não ASCII 😩. A ajuda está disponível, no entanto, com https://pypi.python.org/pypi/backports.csv .

Use-o como acima, mas passe o arquivo aberto para ele:

from backports import csv
import io
with io.open("my_utf8_file.txt", "r", encoding="utf-8") as my_file:
    for row in csv.reader(my_file):
        yield row

Bases de dados

A maioria dos drivers de banco de dados Python pode retornar dados em Unicode, mas geralmente requer um pouco de configuração. Sempre use seqüências de caracteres Unicode para consultas SQL.

Na cadeia de conexão, adicione:

charset='utf8',
use_unicode=True

Por exemplo

>>> db = MySQLdb.connect(host="localhost", user='root', passwd='passwd', db='sandbox', use_unicode=True, charset="utf8")

Adicionar:

psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)

HTTP

As páginas da Web podem ser codificadas em praticamente qualquer codificação. O Content-typecabeçalho deve conter um charsetcampo para sugerir a codificação. O conteúdo pode ser decodificado manualmente contra esse valor. Como alternativa, Python-Requests retorna Unicodes em response.text.

Manualmente

Se você precisar decodificar cadeias manualmente, pode simplesmente fazer my_string.decode(encoding), onde encodingestá a codificação apropriada. Os codecs suportados pelo Python 2.x são fornecidos aqui: Codificações padrão . Novamente, se você receber UnicodeDecodeError, provavelmente terá a codificação errada.

A carne do sanduíche

Trabalhe com Unicodes como faria com strs normais.

Resultado

stdout / impressão

printescreve através do fluxo stdout. O Python tenta configurar um codificador no stdout para que os Unicodes sejam codificados na codificação do console. Por exemplo, se um shell do Linux localefor en_GB.UTF-8, a saída será codificada para UTF-8. No Windows, você estará limitado a uma página de código de 8 bits.

Um console configurado incorretamente, como código de idioma corrompido, pode levar a erros de impressão inesperados. PYTHONIOENCODINGA variável de ambiente pode forçar a codificação para stdout.

arquivos

Assim como a entrada, io.openpode ser usado para converter transparentemente Unicodes em seqüências de bytes codificadas.

Base de dados

A mesma configuração para leitura permitirá que Unicodes sejam gravados diretamente.

Python 3

O Python 3 não é mais capaz de Unicode do que o Python 2.x, no entanto, é um pouco menos confuso sobre o assunto. Por exemplo, o regular stragora é uma string Unicode e o antigo stragora bytes.

A codificação padrão é UTF-8, portanto, se você for .decode()uma sequência de bytes sem fornecer uma codificação, o Python 3 usará a codificação UTF-8. Isso provavelmente corrige 50% dos problemas de Unicode das pessoas.

Além disso, open()opera no modo de texto por padrão, então retorna decodificado str(Unicode). A codificação é derivada do código de idioma, que tende a ser UTF-8 em sistemas Un * x ou uma página de código de 8 bits, como windows-1251, nas caixas do Windows.

Por que você não deve usar sys.setdefaultencoding('utf8')

É um hack desagradável (há uma razão para você usar reload) que apenas mascara problemas e dificulta sua migração para o Python 3.x. Entenda o problema, corrija a causa raiz e aproveite o Unicode zen. Consulte Por que NÃO devemos usar sys.setdefaultencoding ("utf-8") em um script py? para mais detalhes

Finalmente eu entendi:

as3:/usr/local/lib/python2.7/site-packages# cat sitecustomize.py
# encoding=utf8  
import sys  

reload(sys)  
sys.setdefaultencoding('utf8')

Deixe-me ver:

as3:~/ngokevin-site# python
Python 2.7.6 (default, Dec  6 2013, 14:49:02)
[GCC 4.4.5] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> reload(sys)
<module 'sys' (built-in)>
>>> sys.getdefaultencoding()
'utf8'
>>>

A descrição acima mostra que a codificação padrão do python é utf8. Então o erro não existe mais.

Este é o clássico "problema unicode". Acredito que explicar isso está além do escopo de uma resposta StackOverflow para explicar completamente o que está acontecendo.

Está bem explicado aqui .

Em um resumo muito breve, você passou algo que está sendo interpretado como uma sequência de bytes para algo que precisa decodificá-lo em caracteres Unicode, mas o codec padrão (ascii) está falhando.

A apresentação que eu apontei para você fornece conselhos para evitar isso. Faça do seu código um "sanduíche unicode". No Python 2, o uso de from __future__ import unicode_literalsajuda.

Atualização: como o código pode ser corrigido:

OK - na sua variável "fonte" você tem alguns bytes. Não está claro em sua pergunta como eles chegaram lá - talvez você os leia em um formulário da Web? De qualquer forma, eles não são codificados com ascii, mas o python está tentando convertê-los em unicode, assumindo que eles são. Você precisa dizer explicitamente qual é a codificação. Isso significa que você precisa saber qual é a codificação! Isso nem sempre é fácil e depende inteiramente de onde essa string veio. Você pode experimentar algumas codificações comuns - por exemplo, UTF-8. Você diz a unicode () a codificação como um segundo parâmetro:

source = unicode(source, 'utf-8')

Em alguns casos, quando você verifica sua codificação padrão ( print sys.getdefaultencoding()), retorna que você está usando ASCII. Se você mudar para UTF-8, não funcionará, dependendo do conteúdo da sua variável. Eu encontrei outra maneira:

import sys
reload(sys)  
sys.setdefaultencoding('Cp1252')

Eu estava procurando resolver a seguinte mensagem de erro:

unicodedecodeerror: o codec 'ascii' não pode decodificar o byte 0xe2 na posição 5454: ordinal fora do intervalo (128)

Finalmente consertei isso especificando 'codificação':

f = open('../glove/glove.6B.100d.txt', encoding="utf-8")

Gostaria que pudesse ajudá-lo também.

"UnicodeDecodeError: 'ascii' codec can't decode byte"

Causa deste erro: input_string deve ser unicode, mas str foi fornecido

"TypeError: Decoding Unicode is not supported"

Causa deste erro: tentando converter unicode input_string em unicode

Portanto, verifique primeiro se seu input_string é stre converta para unicode, se necessário:

if isinstance(input_string, str):
   input_string = unicode(input_string, 'utf-8')

Em segundo lugar, o texto acima apenas altera o tipo, mas não remove caracteres não ascii. Se você deseja remover caracteres não-ascii:

if isinstance(input_string, str):
   input_string = input_string.decode('ascii', 'ignore').encode('ascii') #note: this removes the character and encodes back to string.

elif isinstance(input_string, unicode):
   input_string = input_string.encode('ascii', 'ignore')

Acho que o melhor é sempre converter para unicode - mas isso é difícil de conseguir, porque na prática você teria que verificar e converter todos os argumentos em todas as funções e métodos que você escreve, incluindo alguma forma de processamento de string.

Então, eu vim com a seguinte abordagem para garantir cadeias unicodes ou bytes, de qualquer entrada. Em resumo, inclua e use as seguintes lambdas:

# guarantee unicode string
_u = lambda t: t.decode('UTF-8', 'replace') if isinstance(t, str) else t
_uu = lambda *tt: tuple(_u(t) for t in tt) 
# guarantee byte string in UTF8 encoding
_u8 = lambda t: t.encode('UTF-8', 'replace') if isinstance(t, unicode) else t
_uu8 = lambda *tt: tuple(_u8(t) for t in tt)

Exemplos:

text='Some string with codes > 127, like Zürich'
utext=u'Some string with codes > 127, like Zürich'
print "==> with _u, _uu"
print _u(text), type(_u(text))
print _u(utext), type(_u(utext))
print _uu(text, utext), type(_uu(text, utext))
print "==> with u8, uu8"
print _u8(text), type(_u8(text))
print _u8(utext), type(_u8(utext))
print _uu8(text, utext), type(_uu8(text, utext))
# with % formatting, always use _u() and _uu()
print "Some unknown input %s" % _u(text)
print "Multiple inputs %s, %s" % _uu(text, text)
# but with string.format be sure to always work with unicode strings
print u"Also works with formats: {}".format(_u(text))
print u"Also works with formats: {},{}".format(*_uu(text, text))
# ... or use _u8 and _uu8, because string.format expects byte strings
print "Also works with formats: {}".format(_u8(text))
print "Also works with formats: {},{}".format(*_uu8(text, text))

Aqui está mais um raciocínio sobre isso .

Para resolver isso no nível do sistema operacional em uma instalação do Ubuntu, verifique o seguinte:

$ locale charmap

Se você pegar

locale: Cannot set LC_CTYPE to default locale: No such file or directory

ao invés de

UTF-8

então defina LC_CTYPEe LC_ALLassim:

$ export LC_ALL="en_US.UTF-8"
$ export LC_CTYPE="en_US.UTF-8"

Codificar converte um objeto unicode em um objeto de sequência. Eu acho que você está tentando codificar um objeto string. primeiro converta seu resultado em objeto unicode e depois codifique esse objeto unicode em 'utf-8'. por exemplo

    result = yourFunction()
    result.decode().encode('utf-8')

Eu tive o mesmo problema, mas não funcionou no Python 3. Segui isso e resolvi o meu problema:

enc = sys.getdefaultencoding()
file = open(menu, "r", encoding = enc)

Você precisa definir a codificação quando estiver lendo / gravando o arquivo.

Recebi o mesmo erro e isso resolveu o meu erro. Obrigado! python 2 e python 3 diferentes no manuseio unicode estão tornando os arquivos em pickup bastante incompatíveis para carregar. Portanto, use o argumento de codificação python pickle. O link abaixo me ajudou a resolver o problema semelhante quando estava tentando abrir dados em conserva do meu python 3.7, enquanto meu arquivo foi salvo originalmente na versão do python 2.x. https://blog.modest-destiny.com/posts/python-2-and-3-compatible-pickle-save-and-load/ Copio a função load_pickle no meu script e chamei load_pickle (pickle_file) durante o carregamento do meu input_data assim:

input_data = load_pickle("my_dataset.pkl")

A função load_pickle está aqui:

def load_pickle(pickle_file):
    try:
        with open(pickle_file, 'rb') as f:
            pickle_data = pickle.load(f)
    except UnicodeDecodeError as e:
        with open(pickle_file, 'rb') as f:
            pickle_data = pickle.load(f, encoding='latin1')
    except Exception as e:
        print('Unable to load data ', pickle_file, ':', e)
        raise
    return pickle_data

Isso funcionou para mim:

    file = open('docs/my_messy_doc.pdf', 'rb')

Em resumo, para garantir o manuseio unicode adequado no Python 2:

• use io.openpara ler / gravar arquivos
• usar from __future__ import unicode_literals
• configurar outras entradas / saídas de dados (por exemplo, bancos de dados, rede) para usar unicode
• se você não pode configurar saídas para utf-8, converta sua saída para elas print(text.encode('ascii', 'replace').decode())

Para explicações, consulte a resposta detalhada de @Alastair McCormack .

Eu tive o mesmo erro, com URLs contendo caracteres não-ascii (bytes com valores> 128), minha solução:

url = url.decode('utf8').encode('utf-8')

Nota: utf-8, utf8 são simplesmente aliases. Usar apenas 'utf8' ou 'utf-8' deve funcionar da mesma maneira

No meu caso, trabalhei para mim, no Python 2.7, suponho que essa atribuição tenha alterado 'algo' na strrepresentação interna - ou seja, força a decodificação correta da sequência de bytes de backup urle, finalmente, coloca a string em um utf-8 str com toda a magia no lugar certo. Unicode em Python é magia negra para mim. Espero que seja útil

Eu tive o mesmo problema com a string "Pastelería Mallorca" e resolvi com:

unicode("Pastelería Mallorca", 'latin-1')

Em um projeto Django (1.9.10) / Python 2.7.5, tenho UnicodeDecodeErrorexceções frequentes ; principalmente quando tento alimentar cadeias unicode no log. Eu criei uma função auxiliar para objetos arbitrários basicamente para formatar cadeias ASCII de 8 bits e substituir qualquer caractere que não esteja na tabela para '?'. Eu acho que não é a melhor solução, mas como a codificação padrão é ascii (e eu não quero alterá-la), ela fará:

def encode_for_logging (c, codificação = 'ascii'):
    se isinstance (c, base):
        retornar c.encode (codificação, 'substituir')
    elif isinstance (c, Iterable):
        c_ = []
        para v em c:
            c_.append (encode_for_logging (v, codificação))
        retornar c_
    outro:
        retornar encode_for_logging (unicode (c))

Este erro ocorre quando há alguns caracteres não ASCII em nossa string e estamos executando quaisquer operações nessa string sem decodificação adequada. Isso me ajudou a resolver meu problema. Estou lendo um arquivo CSV com ID de colunas, caracteres de texto e decodificação, como abaixo:

train_df = pd.read_csv("Example.csv")
train_data = train_df.values
for i in train_data:
    print("ID :" + i[0])
    text = i[1].decode("utf-8",errors="ignore").strip().lower()
    print("Text: " + text)

Aqui está a minha solução, basta adicionar a codificação. with open(file, encoding='utf8') as f

E como a leitura do arquivo de luva levará muito tempo, recomendo que ele seja um arquivo numpy. Quando o tempo de netx você lê os pesos de incorporação, ele economiza seu tempo.

import numpy as np
from tqdm import tqdm


def load_glove(file):
    """Loads GloVe vectors in numpy array.
    Args:
        file (str): a path to a glove file.
    Return:
        dict: a dict of numpy arrays.
    """
    embeddings_index = {}
    with open(file, encoding='utf8') as f:
        for i, line in tqdm(enumerate(f)):
            values = line.split()
            word = ''.join(values[:-300])
            coefs = np.asarray(values[-300:], dtype='float32')
            embeddings_index[word] = coefs

    return embeddings_index

# EMBEDDING_PATH = '../embedding_weights/glove.840B.300d.txt'
EMBEDDING_PATH = 'glove.840B.300d.txt'
embeddings = load_glove(EMBEDDING_PATH)

np.save('glove_embeddings.npy', embeddings) 

Gist link: https://gist.github.com/BrambleXu/634a844cdd3cd04bb2e3ba3c83aef227

Especifique: # encoding = utf-8 na parte superior do seu arquivo Python, deve corrigir o problema