Remoção de caracteres não imprimíveis de uma string em python

Eu costumava correr

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

em Perl para se livrar de caracteres não imprimíveis.

Em Python não há classes regex POSIX e não posso escrever [: print:] porque significa o que eu quero. Não conheço nenhuma maneira em Python de detectar se um caractere pode ser impresso ou não.

O que você faria?

EDIT: Ele também deve oferecer suporte a caracteres Unicode. A forma string.printable irá facilmente eliminá-los da saída. curses.ascii.isprint retornará false para qualquer caractere Unicode.

A iteração em strings é, infelizmente, bastante lenta em Python. As expressões regulares são mais do que uma ordem de magnitude mais rápidas para esse tipo de coisa. Você apenas tem que construir a classe de personagem sozinho. O módulo unicodedata é bastante útil para isso, especialmente a função unicodedata.category () . Consulte o banco de dados de caracteres Unicode para obter as descrições das categorias.

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 alguns casos de uso, categorias adicionais (por exemplo, todas do grupo de controle podem ser preferíveis, embora isso possa diminuir o tempo de processamento e aumentar o uso de memória significativamente. Número de caracteres por categoria:

• Cc (controle): 65
• Cf (formato): 161
• Cs (substituto): 2048
• Co (uso privado): 137468
• Cn (não atribuído): 836601

Editar Adicionando sugestões dos comentários.

Pelo que eu sei, o método mais pitônico / eficiente seria:

import string

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

Você pode tentar configurar um filtro usando a unicodedata.category()função:

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

Consulte a Tabela 4-9 na página 175 nas propriedades de caracteres do banco de dados Unicode para as categorias disponíveis

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

Veja esta postagem StackOverflow sobre como remover pontuação para saber como .translate () se compara a regex e .replace ()

Os intervalos podem ser gerados nonprintable = (ord(c) for c in (chr(i) for i in range(sys.maxunicode)) if unicodedata.category(c)=='Cc')usando as categorias do banco de dados de caracteres Unicode, conforme mostrado por @Ants Aasma.

O seguinte funcionará com entrada Unicode e é 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('') == ''

Meus próprios testes sugerem que essa abordagem é mais rápida do que funções que iteram na string e retornam um resultado usando str.join.

Esta função usa compreensões de lista e str.join, por isso é executado em tempo linear em vez de O (n ^ 2):

from curses.ascii import isprint

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

Mais uma opção em python 3:

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

O melhor que descobri agora é (graças aos python-izers acima)

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

Esta é a única maneira que descobri que funciona com caracteres / strings Unicode

Alguma opção melhor?

O que está abaixo tem um desempenho mais rápido do que os outros acima. Dê uma olhada

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

Em Python não há classes POSIX regex

Existem ao usar a regexbiblioteca: https://pypi.org/project/regex/

É bem mantido e oferece suporte a Unicode regex, Posix regex e muitos mais. O uso (assinaturas de método) é muito semelhante ao do Python re.

Da documentação:

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

Classes de caracteres POSIX são suportadas. Estes são normalmente tratados como uma forma alternativa de\p{...} .

(Não sou afiliado, apenas um usuário.)

Com base na resposta de @Ber, sugiro remover apenas os caracteres de controle, conforme definido nas categorias do banco de dados 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 remover 'espaços em branco',

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 das respostas de Ants Aasma e 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)

testado em Python 3.7.7