Qual è il modo migliore per rimuovere gli accenti in una stringa Unicode Python?

Ho una stringa Unicode in Python e vorrei rimuovere tutti gli accenti (segni diacritici).

Ho trovato sul Web un modo elegante per farlo in Java:

1. converti la stringa Unicode nella sua forma lunga normalizzata (con un carattere separato per lettere e segni diacritici)
2. rimuove tutti i caratteri il cui tipo Unicode è "diacritico".

Devo installare una libreria come pyICU o è possibile solo con la libreria standard di Python? E che dire di Python 3?

Nota importante: vorrei evitare il codice con una mappatura esplicita dai caratteri accentati alla loro controparte non accentata.

Unidecode è la risposta corretta per questo. Traslittera qualsiasi stringa unicode nella rappresentazione più vicina possibile nel testo ASCII.

Esempio:

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'

Cosa ne pensi di questo:

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

Funziona anche con lettere greche:

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

La categoria di caratteri "Mn" rappresenta Nonspacing_Mark, che è simile a unicodedata.combining nella risposta di MiniQuark (non ho pensato al unicodedata.combining, ma è probabilmente la soluzione migliore, perché è più esplicita).

E tieni presente che queste manipolazioni possono alterare in modo significativo il significato del testo. Accenti, Umlaut ecc. Non sono "decorazioni".

Ho appena trovato questa risposta sul 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

Funziona bene (per il francese, per esempio), ma penso che il secondo passo (rimuovere gli accenti) potrebbe essere gestito meglio che eliminare i caratteri non ASCII, perché questo fallirà per alcune lingue (greco, per esempio). La soluzione migliore sarebbe probabilmente quella di rimuovere esplicitamente i caratteri unicode che sono etichettati come segni diacritici.

Modifica : questo fa il trucco:

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)tornerà vero se il personaggio cpuò essere combinato con il carattere precedente, questo è principalmente se è un carattere diacritico.

Modifica 2 : si remove_accentsaspetta una stringa unicode , non una stringa di byte. Se hai una stringa di byte, devi decodificarla in una stringa unicode come questa:

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)

Attualmente lavoro su progetti compatibili con Python 2.6, 2.7 e 3.4 e devo creare ID da voci utente gratuite.

Grazie a te, ho creato questa funzione che fa miracoli.

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

risultato:

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

Questo gestisce non solo gli accenti, ma anche i "tratti" (come in ø ecc.):

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

Questo è il modo più elegante che mi viene in mente (ed è stato menzionato da Alexis in un commento in questa pagina), anche se non penso che sia davvero molto elegante. In effetti, è più un trucco, come sottolineato nei commenti, poiché i nomi Unicode sono - in realtà solo nomi, non danno alcuna garanzia di essere coerenti o altro.

Ci sono ancora lettere speciali che non sono gestite da questo, come lettere girate e invertite, poiché il loro nome unicode non contiene 'WITH'. Dipende da cosa vuoi fare comunque. A volte avevo bisogno di eliminare l'accento per ottenere l'ordinamento del dizionario.

MODIFICA NOTA:

Suggerimenti incorporati nei commenti (gestione degli errori di ricerca, codice Python-3).

In risposta alla risposta di @ MiniQuark:

Stavo cercando di leggere in un file CSV mezzo francese (contenente accenti) e anche alcune stringhe che alla fine sarebbero diventate numeri interi e float. Come test, ho creato un test.txtfile simile al seguente:

Montréal, über, 12.89, Mère, Françoise, noël, 889

Ho dovuto includere linee 2e 3farlo funzionare (che ho trovato in un ticket Python), oltre a incorporare il commento di @ 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)

Il risultato:

Montreal
uber
12.89
Mere
Francoise
noel
889

(Nota: sono su Mac OS X 10.8.4 e utilizzo Python 2.7.3)

gensim.utils.deaccent (testo) di Gensim - modellazione di argomenti per l'uomo :

'Sef chomutovskych komunistu dostal postou bily prasek'

Un'altra soluzione è unidecode .

Si noti che la soluzione suggerita con unicodedata in genere rimuove gli accenti solo in alcuni caratteri (ad esempio si trasforma 'ł'in '', piuttosto che in 'l').

Alcune lingue hanno combinato segni diacritici come lettere linguistiche e segni diacritici di accento per specificare l'accento.

Penso che sia più sicuro specificare esplicitamente quali segni diatrici vuoi eliminare:

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))