Suppression des caractères non imprimables d'une chaîne en python

J'ai l'habitude de courir

$s =~ s/[^[:print:]]//g;

sur Perl pour se débarrasser des caractères non imprimables.

En Python, il n'y a pas de classes regex POSIX, et je ne peux pas écrire [: print:] pour que cela signifie ce que je veux. Je ne connais aucun moyen en Python de détecter si un caractère est imprimable ou non.

Qu'est-ce que tu ferais?

EDIT: Il doit également prendre en charge les caractères Unicode. La méthode string.printable les supprimera volontiers de la sortie. curses.ascii.isprint retournera false pour tout caractère Unicode.

L'itération sur des chaînes est malheureusement assez lente en Python. Les expressions régulières sont plus rapides d'un ordre de grandeur pour ce genre de chose. Il vous suffit de créer vous-même la classe de personnage. Le module unicodedata est très utile pour cela, en particulier la fonction unicodedata.category () . Voir Base de données de caractères Unicode pour une description des catégories.

import unicodedata, re, itertools, sys

all_chars = (chr(i) for i in range(sys.maxunicode))
categories = {'Cc'}
control_chars = ''.join(c for c in all_chars if unicodedata.category(c) in categories)
# or equivalently and much more efficiently
control_chars = ''.join(map(chr, itertools.chain(range(0x00,0x20), range(0x7f,0xa0))))

control_char_re = re.compile('[%s]' % re.escape(control_chars))

def remove_control_chars(s):
    return control_char_re.sub('', s)

Pour Python2

import unicodedata, re, sys

all_chars = (unichr(i) for i in xrange(sys.maxunicode))
categories = {'Cc'}
control_chars = ''.join(c for c in all_chars if unicodedata.category(c) in categories)
# or equivalently and much more efficiently
control_chars = ''.join(map(unichr, range(0x00,0x20) + range(0x7f,0xa0)))

control_char_re = re.compile('[%s]' % re.escape(control_chars))

def remove_control_chars(s):
    return control_char_re.sub('', s)

Pour certains cas d'utilisation, des catégories supplémentaires (par exemple, toutes du groupe témoin peuvent être préférables, bien que cela puisse ralentir le temps de traitement et augmenter considérablement l'utilisation de la mémoire. Nombre de caractères par catégorie:

• Cc (contrôle): 65
• Cf (format): 161
• Cs (substitut): 2048
• Co (à usage privé): 137468
• Cn (non attribué): 836601

Modifier Ajout de suggestions à partir des commentaires.

Autant que je sache, la méthode la plus pythonique / efficace serait:

import string

filtered_string = filter(lambda x: x in string.printable, myStr)

Vous pouvez essayer de configurer un filtre en utilisant la unicodedata.category()fonction:

import unicodedata
printable = {'Lu', 'Ll'}
def filter_non_printable(str):
  return ''.join(c for c in str if unicodedata.category(c) in printable)

Reportez-vous au Tableau 4-9 à la page 175 dans les propriétés des caractères de la base de données Unicode pour les catégories disponibles

Dans Python 3,

def filter_nonprintable(text):
    import itertools
    # Use characters of control category
    nonprintable = itertools.chain(range(0x00,0x20),range(0x7f,0xa0))
    # Use translate to remove all non-printable characters
    return text.translate({character:None for character in nonprintable})

Voir cet article de StackOverflow sur la suppression de la ponctuation pour savoir comment .translate () se compare à regex et .replace ()

Les plages peuvent être générées en nonprintable = (ord(c) for c in (chr(i) for i in range(sys.maxunicode)) if unicodedata.category(c)=='Cc')utilisant les catégories de base de données de caractères Unicode comme indiqué par @Ants Aasma.

Ce qui suit fonctionnera avec l'entrée Unicode et est plutôt rapide ...

import sys

# build a table mapping all non-printable characters to None
NOPRINT_TRANS_TABLE = {
    i: None for i in range(0, sys.maxunicode + 1) if not chr(i).isprintable()
}

def make_printable(s):
    """Replace non-printable characters in a string."""

    # the translate method on str removes characters
    # that map to None from the string
    return s.translate(NOPRINT_TRANS_TABLE)


assert make_printable('Café') == 'Café'
assert make_printable('\x00\x11Hello') == 'Hello'
assert make_printable('') == ''

Mes propres tests suggèrent que cette approche est plus rapide que les fonctions qui itèrent sur la chaîne et retournent un résultat en utilisant str.join.

Cette fonction utilise des compréhensions de liste et str.join, donc elle s'exécute en temps linéaire au lieu de O (n ^ 2):

from curses.ascii import isprint

def printable(input):
    return ''.join(char for char in input if isprint(char))

Encore une autre option dans python 3:

re.sub(f'[^{re.escape(string.printable)}]', '', my_string)

Le meilleur que j'ai trouvé maintenant est (grâce aux python-izers ci-dessus)

def filter_non_printable(str):
  return ''.join([c for c in str if ord(c) > 31 or ord(c) == 9])

C'est le seul moyen que j'ai découvert qui fonctionne avec les caractères / chaînes Unicode

Y a-t-il de meilleures options?

Celui ci-dessous fonctionne plus rapidement que les autres ci-dessus. Regarde

''.join([x if x in string.printable else '' for x in Str])

En Python, il n'y a pas de classes regex POSIX

Il y en a lors de l'utilisation de la regexbibliothèque: https://pypi.org/project/regex/

Il est bien entretenu et prend en charge les expressions régulières Unicode, Posix regex et bien d'autres. L'utilisation (signatures de méthode) est très similaire à celle de Python re.

De la documentation:

[[:alpha:]]; [[:^alpha:]]

Les classes de caractères POSIX sont prises en charge. Ceux-ci sont normalement traités comme une forme alternative de \p{...}.

(Je ne suis pas affilié, juste un utilisateur.)

Sur la base de la réponse de @ Ber, je suggère de supprimer uniquement les caractères de contrôle tels que définis dans les catégories de la base de données de caractères Unicode :

import unicodedata
def filter_non_printable(s):
    return ''.join(c for c in s if not unicodedata.category(c).startswith('C'))

Pour supprimer les «espaces»,

import re
t = """
\n\t<p>&nbsp;</p>\n\t<p>&nbsp;</p>\n\t<p>&nbsp;</p>\n\t<p>&nbsp;</p>\n\t<p>
"""
pat = re.compile(r'[\t\n]')
print(pat.sub("", t))

Adapté des réponses d' Ants Aasma et shawnrad :

nonprintable = set(map(chr, list(range(0,32)) + list(range(127,160))))
ord_dict = {ord(character):None for character in nonprintable}
def filter_nonprintable(text):
    return text.translate(ord_dict)

#use
str = "this is my string"
str = filter_nonprintable(str)
print(str)

testé sur Python 3.7.7