Como fazer o interpretador Python lidar corretamente com caracteres não ASCII em operações de string?

Eu tenho uma string assim:

6 918 417 712

A maneira clara de cortar essa string (pelo que eu entendo Python) é simplesmente dizer que a string está em uma variável chamada s, obtemos:

s.replace('Â ', '')

Isso deve funcionar. Mas é claro que ele reclama que o caractere não ASCII '\xc2'no arquivo blabla.py não está codificado.

Nunca consegui entender como alternar entre as diferentes codificações.

Aqui está o código, ele realmente é igual ao anterior, mas agora está no contexto. O arquivo é salvo como UTF-8 no bloco de notas e possui o seguinte cabeçalho:

#!/usr/bin/python2.4
# -*- coding: utf-8 -*-

O código:

f = urllib.urlopen(url)

soup = BeautifulSoup(f)

s = soup.find('div', {'id':'main_count'})

#making a print 's' here goes well. it shows 6Â 918Â 417Â 712

s.replace('Â ','')

save_main_count(s)

Não vai além de s.replace...

Python 2 usa asciicomo a codificação padrão para arquivos de origem, o que significa que você deve especificar outra codificação no topo do arquivo para usar caracteres Unicode não ASCII em literais. Python 3 usa utf-8como codificação padrão para arquivos de origem, portanto, isso não é um problema.

Consulte: http://docs.python.org/tutorial/interpreter.html#source-code-encoding

Para habilitar a codificação de origem utf-8, isso ficaria em uma das duas linhas principais:

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

O texto acima está nos documentos, mas também funciona:

# coding: utf-8

Considerações adicionais:

• O arquivo de origem também deve ser salvo usando a codificação correta em seu editor de texto.

• No Python 2, o literal unicode deve ter um uantes dele, como em s.replace(u"Â ", u"")Mas no Python 3, apenas use aspas. No Python 2, você pode from __future__ import unicode_literalsobter o comportamento do Python 3, mas esteja ciente de que isso afeta todo o módulo atual.

• s.replace(u"Â ", u"")também falhará se snão for uma string Unicode.

• string.replace retorna uma nova string e não edita no local, então certifique-se de usar o valor de retorno também

def removeNonAscii(s): return "".join(filter(lambda x: ord(x)<128, s))

editar: meu primeiro impulso é sempre usar um filtro, mas a expressão do gerador é mais eficiente em termos de memória (e mais curta) ...

def removeNonAscii(s): return "".join(i for i in s if ord(i)<128)

Lembre-se de que isso funcionará com a codificação UTF-8 (porque todos os bytes em caracteres multibyte têm o bit mais alto definido como 1).

>>> unicode_string = u"hello aåbäcö"
>>> unicode_string.encode("ascii", "ignore")
'hello abc'

O código a seguir substituirá todos os caracteres não ASCII por pontos de interrogação.

"".join([x if ord(x) < 128 else '?' for x in s])

Usando Regex:

import re

strip_unicode = re.compile("([^-_a-zA-Z0-9!@#%&=,/'\";:~`\$\^\*\(\)\+\[\]\.\{\}\|\?\<\>\\]+|[^\s]+)")
print strip_unicode.sub('', u'6Â 918Â 417Â 712')

Tarde demais para uma resposta, mas a string original estava em UTF-8 e '\ xc2 \ xa0' é UTF-8 para NO-BREAK SPACE. Simplesmente decodifique a string original como s.decode('utf-8')(\ xa0 é exibido como um espaço quando decodificado incorretamente como Windows-1252 ou latin-1:

Exemplo (Python 3)

s = b'6\xc2\xa0918\xc2\xa0417\xc2\xa0712'
print(s.decode('latin-1')) # incorrectly decoded
u = s.decode('utf8') # correctly decoded
print(u)
print(u.replace('\N{NO-BREAK SPACE}','_'))
print(u.replace('\xa0','-')) # \xa0 is Unicode for NO-BREAK SPACE

Resultado

6 918 417 712
6 918 417 712
6_918_417_712
6-918-417-712

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

s = u"6Â 918Â 417Â 712"
s = s.replace(u"Â", "") 
print s

Isso vai imprimir 6 918 417 712

Eu sei que é um tópico antigo, mas me senti obrigado a mencionar o método translate, que é sempre uma boa maneira de substituir todos os códigos de caracteres acima de 128 (ou outro, se necessário).

Uso : str. traduzir ( tabela [, deletechars] )

>>> trans_table = ''.join( [chr(i) for i in range(128)] + [' '] * 128 )

>>> 'Résultat'.translate(trans_table)
'R sultat'
>>> '6Â 918Â 417Â 712'.translate(trans_table)
'6  918  417  712'

A partir do Python 2.6 , você também pode definir a tabela como Nenhum e usar deletechars para excluir os caracteres que você não deseja, como nos exemplos mostrados nos documentos padrão em http://docs.python.org/library/stdtypes. html .

Com strings Unicode, a tabela de tradução não é uma string de 256 caracteres, mas um dict com ord () de caracteres relevantes como chaves. Mas, de qualquer forma, obter uma string ascii adequada de uma string Unicode é bastante simples, usando o método mencionado por truppo acima, a saber: unicode_string.encode ("ascii", "ignore")

Como resumo, se por algum motivo você absolutamente precisar obter uma string ascii (por exemplo, quando você levanta uma exceção padrão com raise Exception, ascii_message), você pode usar a seguinte função:

trans_table = ''.join( [chr(i) for i in range(128)] + ['?'] * 128 )
def ascii(s):
    if isinstance(s, unicode):
        return s.encode('ascii', 'replace')
    else:
        return s.translate(trans_table)

A coisa boa com traduzir é que você pode realmente converter caracteres acentuados em caracteres ascii não acentuados relevantes em vez de simplesmente excluí-los ou substituí-los por '?' Isso geralmente é útil, por exemplo, para fins de indexação.

s.replace(u'Â ', '')              # u before string is important

e tornar seu .pyarquivo Unicode.

Este é um hack sujo, mas pode funcionar.

s2 = ""
for i in s:
    if ord(i) < 128:
        s2 += i

Pelo que valeu a pena, meu conjunto de caracteres era utf-8e eu incluí a clássica # -*- coding: utf-8 -*-linha " ".

No entanto, descobri que não tinha Newlines Universal ao ler esses dados de uma página da web.

Meu texto tinha duas palavras, separadas por " \r\n". Eu estava apenas dividindo no \ne substituindo o "\n".

Assim que fiz um loop e vi o conjunto de caracteres em questão, percebi o erro.

Portanto, ele também pode estar dentro do conjunto de caracteres ASCII , mas um caractere que você não esperava.