Quelle est la meilleure façon de supprimer les accents dans une chaîne unicode Python?

J'ai une chaîne Unicode en Python, et je voudrais supprimer tous les accents (diacritiques).

J'ai trouvé sur le Web une manière élégante de le faire en Java:

1. convertir la chaîne Unicode dans sa longue forme normalisée (avec un caractère séparé pour les lettres et les signes diacritiques)
2. supprimez tous les caractères dont le type Unicode est "diacritique".

Dois-je installer une bibliothèque telle que pyICU ou est-ce possible avec seulement la bibliothèque standard python? Et qu'en est-il de python 3?

Remarque importante: je voudrais éviter le code avec un mappage explicite des caractères accentués à leur homologue non accentué.

Unidecode est la bonne réponse à cela. Il transcrit toute chaîne unicode dans la représentation la plus proche possible dans le texte ascii.

Exemple:

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 dis-tu de ça:

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

Cela fonctionne aussi sur les lettres grecques:

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

La catégorie de caractères "Mn" signifieNonspacing_Mark , qui est similaire à unicodedata.combining dans la réponse de MiniQuark (je n'ai pas pensé à unicodedata.combining, mais c'est probablement la meilleure solution, car elle est plus explicite).

Et gardez à l'esprit que ces manipulations peuvent modifier considérablement la signification du texte. Les accents, trémas, etc. ne sont pas de la "décoration".

Je viens de trouver cette réponse sur le 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

Cela fonctionne bien (pour le français, par exemple), mais je pense que la deuxième étape (supprimer les accents) pourrait être mieux gérée que de supprimer les caractères non ASCII, car cela échouera pour certaines langues (grec, par exemple). La meilleure solution serait probablement de supprimer explicitement les caractères unicode qui sont étiquetés comme étant des signes diacritiques.

Edit : cela fait l'affaire:

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) retournera vrai si le caractère c peut être combiné avec le caractère précédent, c'est principalement s'il s'agit d'un diacritique.

Edit 2 : remove_accentsattend une chaîne unicode , pas une chaîne d'octets. Si vous avez une chaîne d'octets, vous devez la décoder en une chaîne unicode comme celle-ci:

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)

En fait, je travaille sur des projets compatibles python 2.6, 2.7 et 3.4 et je dois créer des identifiants à partir d'entrées utilisateur gratuites.

Grâce à vous, j'ai créé cette fonction qui fait des merveilles.

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

résultat:

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

Cela gère non seulement les accents, mais aussi les "traits" (comme en ø 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

C'est la façon la plus élégante à laquelle je peux penser (et cela a été mentionné par alexis dans un commentaire sur cette page), bien que je ne pense pas que ce soit vraiment très élégant. En fait, c'est plus un hack, comme souligné dans les commentaires, car les noms Unicode sont - vraiment des noms, ils ne garantissent pas la cohérence ou quoi que ce soit.

Il y a encore des lettres spéciales qui ne sont pas gérées par cela, comme les lettres tournées et inversées, car leur nom unicode ne contient pas 'AVEC'. Cela dépend de ce que vous voulez faire de toute façon. J'avais parfois besoin d'un dépouillement d'accent pour obtenir l'ordre de tri du dictionnaire.

NOTE ÉDITÉE:

Intégration des suggestions des commentaires (gestion des erreurs de recherche, code Python-3).

En réponse à la réponse de @ MiniQuark:

J'essayais de lire dans un fichier csv qui était à moitié français (contenant des accents) et aussi quelques chaînes qui finiraient par devenir des entiers et des flottants. À titre de test, j'ai créé un test.txtfichier qui ressemblait à ceci:

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

J'ai dû inclure des lignes 2et 3le faire fonctionner (que j'ai trouvé dans un ticket python), ainsi qu'incorporer le commentaire 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)

Le résultat:

Montreal
uber
12.89
Mere
Francoise
noel
889

(Remarque: je suis sous Mac OS X 10.8.4 et j'utilise Python 2.7.3)

gensim.utils.deaccent (texte) de Gensim - modélisation de sujets pour les humains :

'Sef chomutovskych komunistu dostal postou bily prasek'

Une autre solution est unidecode .

Notez que la solution suggérée avec unicodedata ne supprime généralement les accents que dans certains caractères (par exemple, elle se transforme 'ł'en '', plutôt qu'en 'l').

Certaines langues combinent les signes diacritiques comme lettres de langue et les signes diacritiques accentués pour spécifier l'accent.

Je pense qu'il est plus sûr de spécifier explicitement les diactriques que vous souhaitez supprimer:

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