Remplacez les caractères non ASCII par un seul espace

Je dois remplacer tous les caractères non ASCII (\ x00- \ x7F) par un espace. Je suis surpris que ce ne soit pas facile à faire en Python, sauf si je manque quelque chose. La fonction suivante supprime simplement tous les caractères non ASCII:

def remove_non_ascii_1(text):

    return ''.join(i for i in text if ord(i)<128)

Et celui-ci remplace les caractères non ASCII par la quantité d'espaces selon la quantité d'octets dans le point de code de caractère (c'est-à-dire que le –caractère est remplacé par 3 espaces):

def remove_non_ascii_2(text):

    return re.sub(r'[^\x00-\x7F]',' ', text)

Comment remplacer tous les caractères non ASCII par un seul espace?

Parmi la myriade de questions SO similaires , aucune ne concerne le remplacement de caractère par opposition à la suppression , et traite également tous les caractères non-ascii et non un caractère spécifique.

Votre ''.join()expression filtre , supprimant tout ce qui n'est pas ASCII; vous pouvez utiliser une expression conditionnelle à la place:

return ''.join([i if ord(i) < 128 else ' ' for i in text])

Cela gère les caractères un par un et utilise toujours un espace par caractère remplacé.

Votre expression régulière doit simplement remplacer les caractères non ASCII consécutifs par un espace:

re.sub(r'[^\x00-\x7F]+',' ', text)

Notez le +là.

Pour vous obtenir la représentation la plus similaire de votre chaîne d'origine, je recommande le module unidecode :

from unidecode import unidecode
def remove_non_ascii(text):
    return unidecode(unicode(text, encoding = "utf-8"))

Ensuite, vous pouvez l'utiliser dans une chaîne:

remove_non_ascii("Ceñía")
Cenia

Pour le traitement des caractères , utilisez des chaînes Unicode:

PythonWin 3.3.0 (v3.3.0:bd8afb90ebf2, Sep 29 2012, 10:57:17) [MSC v.1600 64 bit (AMD64)] on win32.
>>> s='ABC马克def'
>>> import re
>>> re.sub(r'[^\x00-\x7f]',r' ',s)   # Each char is a Unicode codepoint.
'ABC  def'
>>> b = s.encode('utf8')
>>> re.sub(rb'[^\x00-\x7f]',rb' ',b) # Each char is a 3-byte UTF-8 sequence.
b'ABC      def'

Mais notez que vous aurez toujours un problème si votre chaîne contient des caractères Unicode décomposés (caractère séparé et combinaison de marques d'accentuation, par exemple):

>>> s = 'mañana'
>>> len(s)
6
>>> import unicodedata as ud
>>> n=ud.normalize('NFD',s)
>>> n
'mañana'
>>> len(n)
7
>>> re.sub(r'[^\x00-\x7f]',r' ',s) # single codepoint
'ma ana'
>>> re.sub(r'[^\x00-\x7f]',r' ',n) # only combining mark replaced
'man ana'

Si le caractère de remplacement peut être «?» au lieu d'un espace, alors je suggère result = text.encode('ascii', 'replace').decode():

"""Test the performance of different non-ASCII replacement methods."""


import re
from timeit import timeit


# 10_000 is typical in the project that I'm working on and most of the text
# is going to be non-ASCII.
text = 'Æ' * 10_000


print(timeit(
    """
result = ''.join([c if ord(c) < 128 else '?' for c in text])
    """,
    number=1000,
    globals=globals(),
))

print(timeit(
    """
result = text.encode('ascii', 'replace').decode()
    """,
    number=1000,
    globals=globals(),
))

Résultats:

0.7208260721400134
0.009975979187503592

Et celui-ci?

def replace_trash(unicode_string):
     for i in range(0, len(unicode_string)):
         try:
             unicode_string[i].encode("ascii")
         except:
              #means it's non-ASCII
              unicode_string=unicode_string[i].replace(" ") #replacing it with a single space
     return unicode_string

En tant qu'approche native et efficace, vous n'avez pas besoin d'utiliser ordou de boucle sur les personnages. Il suffit d'encoder asciiet d'ignorer les erreurs.

Ce qui suit supprimera simplement les caractères non ascii:

new_string = old_string.encode('ascii',errors='ignore')

Maintenant, si vous souhaitez remplacer les caractères supprimés, procédez comme suit:

final_string = new_string + b' ' * (len(old_string) - len(new_string))

Potentiellement pour une question différente, mais je fournis ma version de la réponse de @ Alvero (en utilisant unidecode). Je veux faire une bande "régulière" sur mes chaînes, c'est-à-dire le début et la fin de ma chaîne pour les caractères d'espacement, puis remplacer uniquement les autres caractères d'espacement par un espace "régulier", c'est-à-dire

"Ceñíaㅤmañanaㅤㅤㅤㅤ"

à

"Ceñía mañana"

,

def safely_stripped(s: str):
    return ' '.join(
        stripped for stripped in
        (bit.strip() for bit in
         ''.join((c if unidecode(c) else ' ') for c in s).strip().split())
        if stripped)

Nous remplaçons d'abord tous les espaces non-unicode par un espace régulier (et le rejoignons à nouveau),

''.join((c if unidecode(c) else ' ') for c in s)

Et puis nous avons divisé à nouveau, avec la division normale de python, et dépouiller chaque "bit",

(bit.strip() for bit in s.split())

Enfin, rejoignez-les à nouveau, mais uniquement si la chaîne réussit un iftest,

' '.join(stripped for stripped in s if stripped)

Et avec cela, safely_stripped('ㅤㅤㅤㅤCeñíaㅤmañanaㅤㅤㅤㅤ')revient correctement 'Ceñía mañana'.