Entfernen nicht druckbarer Zeichen aus einer Zeichenfolge in Python

Ich laufe

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

auf Perl, um nicht druckbare Zeichen loszuwerden.

In Python gibt es keine POSIX-Regex-Klassen, und ich kann nicht schreiben [:print:] es bedeutet, was ich will. Ich kenne in Python keine Möglichkeit zu erkennen, ob ein Zeichen druckbar ist oder nicht.

Was würdest du tun?

EDIT: Es muss auch Unicode-Zeichen unterstützen. Der string.printable-Weg entfernt sie gerne aus der Ausgabe. curses.ascii.isprint gibt für jedes Unicode-Zeichen false zurück.

Das Iterieren über Strings ist in Python leider ziemlich langsam. Reguläre Ausdrücke sind für solche Dinge über eine Größenordnung schneller. Sie müssen nur die Charakterklasse selbst erstellen. Der Unicodedaten Modul ist dabei sehr hilfreich, besonders das unicodedata.category() Funktion. Sehen Unicode-Zeichendatenbank für Beschreibungen der Kategorien.

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)

Für 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)

Für einige Anwendungsfälle können zusätzliche Kategorien (z. B. alle aus der Kontrolle Gruppe ist möglicherweise vorzuziehen, obwohl dies die Verarbeitungszeit verlangsamen und die Speichernutzung erheblich erhöhen kann. Anzahl Zeichen pro Kategorie:

• Cc (Kontrolle): 65
• Cf (Format): 161
• Cs (Ersatz): 2048
• Co (private Nutzung): 137468
• Cn (nicht zugeordnet): 836601

Bearbeiten Hinzufügen von Vorschlägen aus den Kommentaren.

Soweit ich weiß, wäre die pythonischste/effizienteste Methode:

import string

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

Sie könnten versuchen, einen Filter mit dem einzurichten unicodedata.category() Funktion:

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

Siehe Tabelle 4-9 auf Seite 175 im Zeicheneigenschaften der Unicode-Datenbank für die verfügbaren Kategorien

Das Folgende funktioniert mit Unicode-Eingabe und ist ziemlich schnell …

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('x00x11Hello') == 'Hello'
assert make_printable('') == ''

Meine eigenen Tests deuten darauf hin, dass dieser Ansatz schneller ist als Funktionen, die die Zeichenfolge durchlaufen und ein Ergebnis mit zurückgeben str.join.

In Python3,

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

In diesem StackOverflow-Beitrag zum Entfernen von Satzzeichen erfahren Sie, wie .translate() mit Regex & .replace() verglichen wird.

Die Bereiche können über generiert werden nonprintable = (ord(c) for c in (chr(i) for i in range(sys.maxunicode)) if unicodedata.category(c)=='Cc') Verwendung der Datenbankkategorien für Unicode-Zeichen wie von @Ants Aasma gezeigt.

Noch eine weitere Option in Python 3:

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

Diese Funktion verwendet Listenverständnisse und str.join, sodass sie in linearer Zeit statt in O(n^2) ausgeführt wird:

from curses.ascii import isprint

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