Eliminar caracteres no imprimibles de una cadena en Python

Yo solía correr

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

en Perl para deshacerse de los caracteres no imprimibles.

En Python no hay clases de expresiones regulares POSIX, y no puedo escribir [: print:] si significa lo que quiero. No conozco ninguna forma en Python de detectar si un personaje es imprimible o no.

¿Qué harías?

EDITAR: También debe admitir caracteres Unicode. La forma string.printable felizmente los eliminará de la salida. curses.ascii.isprint devolverá falso para cualquier carácter Unicode.

Desafortunadamente, la iteración sobre cadenas es bastante lenta en Python. Las expresiones regulares son más rápidas en un orden de magnitud para este tipo de cosas. Solo tienes que construir la clase de personaje tú mismo. El módulo unicodedata es bastante útil para esto, especialmente la función unicodedata.category () . Consulte Base de datos de caracteres Unicode para obtener descripciones de las categorías.

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)

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

Para algunos casos de uso, pueden ser preferibles categorías adicionales (por ejemplo, todos los del grupo de control , aunque esto podría ralentizar el tiempo de procesamiento y aumentar el uso de la memoria de manera significativa. Número de caracteres por categoría:

• Cc (control): 65
• Cf (formato): 161
• Cs (sustituto): 2048
• Co (uso privado): 137468
• Cn (no asignado): 836601

Editar Agregar sugerencias de los comentarios.

Hasta donde yo sé, el método más pitónico / eficiente sería:

import string

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

Puede intentar configurar un filtro usando la unicodedata.category()función:

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

Consulte la Tabla 4-9 en la página 175 en las propiedades de caracteres de la base de datos Unicode para conocer las categorías disponibles.

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

Vea esta publicación de StackOverflow sobre cómo eliminar la puntuación para ver cómo se compara .translate () con regex & .replace ()

Los rangos se pueden generar mediante el nonprintable = (ord(c) for c in (chr(i) for i in range(sys.maxunicode)) if unicodedata.category(c)=='Cc')uso de las categorías de la base de datos de caracteres Unicode como lo muestra @Ants Aasma.

Lo siguiente funcionará con la entrada Unicode y es bastante rápido ...

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('') == ''

Mis propias pruebas sugieren que este enfoque es más rápido que las funciones que iteran sobre la cadena y devuelven un resultado usando str.join.

Esta función usa listas por comprensión y str.join, por lo que se ejecuta en tiempo lineal en lugar de O (n ^ 2):

from curses.ascii import isprint

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

Otra opción más en Python 3:

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

Lo mejor que se me ocurrió ahora es (gracias a los python-izers anteriores)

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

Esta es la única forma en que he descubierto que funciona con caracteres / cadenas Unicode

¿Alguna mejor opción?

El de abajo funciona más rápido que los de arriba. Echar un vistazo

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

En Python no hay clases de expresiones regulares POSIX

Hay cuando se usa la regexbiblioteca: https://pypi.org/project/regex/

Está bien mantenido y es compatible con expresiones regulares Unicode, expresiones regulares Posix y muchos más. El uso (firmas de métodos) es muy similar al de Python re.

De la documentación:

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

Se admiten las clases de caracteres POSIX. Normalmente se tratan como una forma alternativa de \p{...}.

(No estoy afiliado, solo un usuario).

Según la respuesta de @ Ber, sugiero eliminar solo los caracteres de control como se define en las categorías de la base de datos de caracteres Unicode :

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

Para eliminar los 'espacios en blanco',

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

Adaptado de las respuestas de Ants Aasma y 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)

probado en Python 3.7.7