Qual é a melhor maneira de remover acentos em uma string unicode Python?

Eu tenho uma string Unicode em Python e gostaria de remover todos os acentos (diacríticos).

Encontrei na Web uma maneira elegante de fazer isso em Java:

1. converta a cadeia Unicode em sua forma normalizada longa (com um caractere separado para letras e diacríticos)
2. remova todos os caracteres cujo tipo Unicode é "diacrítico".

Preciso instalar uma biblioteca como pyICU ou isso é possível apenas com a biblioteca padrão python? E o python 3?

Nota importante: eu gostaria de evitar código com um mapeamento explícito de caracteres acentuados para o seu equivalente não acentuado.

Unidecode é a resposta correta para isso. Ele translitera qualquer string unicode na representação mais próxima possível no texto ascii.

Exemplo:

accented_string = u'Málaga'
# accented_string is of type 'unicode'
import unidecode
unaccented_string = unidecode.unidecode(accented_string)
# unaccented_string contains 'Malaga'and is of type 'str'

Que tal agora:

import unicodedata
def strip_accents(s):
   return ''.join(c for c in unicodedata.normalize('NFD', s)
                  if unicodedata.category(c) != 'Mn')

Isso funciona também com letras gregas:

>>> strip_accents(u"A \u00c0 \u0394 \u038E")
u'A A \u0394 \u03a5'
>>> 

A categoria de personagem "Mn" significa Nonspacing_Mark, que é semelhante a unicodedata.combining na resposta do MiniQuark (eu não pensei em unicodedata.combining, mas provavelmente é a melhor solução, porque é mais explícita).

E lembre-se, essas manipulações podem alterar significativamente o significado do texto. Sotaques, trema etc. não são "decoração".

Acabei de encontrar esta resposta na Web:

import unicodedata

def remove_accents(input_str):
    nfkd_form = unicodedata.normalize('NFKD', input_str)
    only_ascii = nfkd_form.encode('ASCII', 'ignore')
    return only_ascii

Funciona bem (em francês, por exemplo), mas acho que o segundo passo (remover os acentos) poderia ser melhor do que soltar os caracteres não-ASCII, porque isso falhará em alguns idiomas (grego, por exemplo). A melhor solução provavelmente seria remover explicitamente os caracteres unicode marcados como sendo diacríticos.

Edit : isso faz o truque:

import unicodedata

def remove_accents(input_str):
    nfkd_form = unicodedata.normalize('NFKD', input_str)
    return u"".join([c for c in nfkd_form if not unicodedata.combining(c)])

unicodedata.combining(c)retornará true se o caractere cpuder ser combinado com o caractere anterior, ou seja, se for um diacrítico.

Edição 2 : remove_accentsespera uma sequência unicode , não uma sequência de bytes. Se você tiver uma cadeia de bytes, decodifique-a em uma cadeia unicode como esta:

encoding = "utf-8" # or iso-8859-15, or cp1252, or whatever encoding you use
byte_string = b"café"  # or simply "café" before python 3.
unicode_string = byte_string.decode(encoding)

Na verdade, eu trabalho no projeto compatível com python 2.6, 2.7 e 3.4 e tenho que criar IDs a partir de entradas gratuitas do usuário.

Graças a você, eu criei esta função que faz maravilhas.

import re
import unicodedata

def strip_accents(text):
    """
    Strip accents from input String.

    :param text: The input string.
    :type text: String.

    :returns: The processed String.
    :rtype: String.
    """
    try:
        text = unicode(text, 'utf-8')
    except (TypeError, NameError): # unicode is a default on python 3 
        pass
    text = unicodedata.normalize('NFD', text)
    text = text.encode('ascii', 'ignore')
    text = text.decode("utf-8")
    return str(text)

def text_to_id(text):
    """
    Convert input text to id.

    :param text: The input string.
    :type text: String.

    :returns: The processed String.
    :rtype: String.
    """
    text = strip_accents(text.lower())
    text = re.sub('[ ]+', '_', text)
    text = re.sub('[^0-9a-zA-Z_-]', '', text)
    return text

resultado:

text_to_id("Montréal, über, 12.89, Mère, Françoise, noël, 889")
>>> 'montreal_uber_1289_mere_francoise_noel_889'

Isso lida não apenas com detalhes, mas também com "traços" (como em ø etc.):

import unicodedata as ud

def rmdiacritics(char):
    '''
    Return the base character of char, by "removing" any
    diacritics like accents or curls and strokes and the like.
    '''
    desc = ud.name(char)
    cutoff = desc.find(' WITH ')
    if cutoff != -1:
        desc = desc[:cutoff]
        try:
            char = ud.lookup(desc)
        except KeyError:
            pass  # removing "WITH ..." produced an invalid name
    return char

Esta é a maneira mais elegante em que consigo pensar (e foi mencionada por alexis em um comentário nesta página), embora eu não ache que seja muito elegante. De fato, é mais um truque, como apontado nos comentários, já que os nomes Unicode são - na verdade, apenas nomes, eles não dão garantia de consistência nem nada.

Ainda existem letras especiais que não são manipuladas por isso, como letras viradas e invertidas, pois o nome do unicode não contém 'WITH'. Depende do que você deseja fazer de qualquer maneira. Às vezes, eu precisava de remoção de sotaque para obter a ordem de classificação do dicionário.

EDITAR NOTA:

Sugestões incorporadas dos comentários (manipulação de erros de pesquisa, código Python-3).

Em resposta à resposta da @ MiniQuark:

Eu estava tentando ler um arquivo CSV que era meio francês (contendo acentos) e também algumas seqüências que acabariam se tornando números inteiros e flutuantes. Como teste, criei um test.txtarquivo parecido com este:

Montreal, über, 12,89, Senhora, Françoise, noël, 889

Eu tive que incluir linhas 2e 3fazê-lo funcionar (que encontrei em um ticket em python), além de incorporar o comentário de @ Jabba:

import sys 
reload(sys) 
sys.setdefaultencoding("utf-8")
import csv
import unicodedata

def remove_accents(input_str):
    nkfd_form = unicodedata.normalize('NFKD', unicode(input_str))
    return u"".join([c for c in nkfd_form if not unicodedata.combining(c)])

with open('test.txt') as f:
    read = csv.reader(f)
    for row in read:
        for element in row:
            print remove_accents(element)

O resultado:

Montreal
uber
12.89
Mere
Francoise
noel
889

(Nota: estou no Mac OS X 10.8.4 e usando o Python 2.7.3)

gensim.utils.deaccent (texto) de Gensim - modelagem de tópicos para humanos :

'Sef chomutovskych komunistu dostal postou bily prasek'

Outra solução é unidecode .

Observe que a solução sugerida com dados unicoded normalmente remove acentos apenas em alguns caracteres (por exemplo, se transforma 'ł'em '', e não em 'l').

Alguns idiomas combinam diacríticos como letras de idioma e diacríticos de acento para especificar o acento.

Eu acho que é mais seguro especificar explicitamente quais diátricas você deseja remover:

def strip_accents(string, accents=('COMBINING ACUTE ACCENT', 'COMBINING GRAVE ACCENT', 'COMBINING TILDE')):
    accents = set(map(unicodedata.lookup, accents))
    chars = [c for c in unicodedata.normalize('NFD', string) if c not in accents]
    return unicodedata.normalize('NFC', ''.join(chars))