Лучший способ убрать знаки препинания из строки

Не обязательно проще, но по-другому, если вы больше знакомы с семьей re.

import re, string
s = "string. With. Punctuation?" # Sample string 
out = re.sub('[%s]' % re.escape(string.punctuation), '', s)

Обычно я использую что-то вроде этого:

>>> s = "string. With. Punctuation?" # Sample string
>>> import string
>>> for c in string.punctuation:
...     s= s.replace(c,"")
...
>>> s
'string With Punctuation'

С точки зрения эффективности вы не победите

s.translate(None, string.punctuation)

Для более высоких версий Python используйте следующий код:

s.translate(str.maketrans('', '', string.punctuation))

Он выполняет операции с необработанными строками на C с помощью таблицы поиска - мало что может превзойти это, кроме написания собственного кода C.

Если скорость не вызывает беспокойства, есть еще один вариант:

exclude = set(string.punctuation)
s = ''.join(ch for ch in s if ch not in exclude)

Это быстрее, чем s.replace с каждым символом, но не будет работать так же хорошо, как подходы, не являющиеся чистыми python, такие как регулярные выражения или string.translate, как вы можете видеть из приведенных ниже значений времени. Для этого типа проблемы окупается выполнение ее на как можно более низком уровне.

Код времени:

import re, string, timeit

s = "string. With. Punctuation"
exclude = set(string.punctuation)
table = string.maketrans("","")
regex = re.compile('[%s]' % re.escape(string.punctuation))

def test_set(s):
    return ''.join(ch for ch in s if ch not in exclude)

def test_re(s):  # From Vinko's solution, with fix.
    return regex.sub('', s)

def test_trans(s):
    return s.translate(table, string.punctuation)

def test_repl(s):  # From S.Lott's solution
    for c in string.punctuation:
        s=s.replace(c,"")
    return s

print "sets      :",timeit.Timer('f(s)', 'from __main__ import s,test_set as f').timeit(1000000)
print "regex     :",timeit.Timer('f(s)', 'from __main__ import s,test_re as f').timeit(1000000)
print "translate :",timeit.Timer('f(s)', 'from __main__ import s,test_trans as f').timeit(1000000)
print "replace   :",timeit.Timer('f(s)', 'from __main__ import s,test_repl as f').timeit(1000000)

Это дает следующие результаты:

sets      : 19.8566138744
regex     : 6.86155414581
translate : 2.12455511093
replace   : 28.4436721802

myString.translate(None, string.punctuation)

Возможно, это не лучшее решение, но я сделал это так.

import string
f = lambda x: ''.join([i for i in x if i not in string.punctuation])

string.punctuation - это ASCII Только! Более правильный (но и гораздо более медленный) способ - использовать модуль unicodedata:

# -*- coding: utf-8 -*-
from unicodedata import category
s = u'String — with -  «punctation »...'
s = ''.join(ch for ch in s if category(ch)[0] != 'P')
print 'stripped', s

Вы также можете обобщить и исключить другие типы символов:

''.join(ch for ch in s if category(ch)[0] not in 'SP')

Он также удалит такие символы, как ~*+§$, которые могут быть или не быть «пунктуацией» в зависимости от точки зрения.

Мне нравится использовать такую ​​функцию:

def scrub(abc):
    while abc[-1] is in list(string.punctuation):
        abc=abc[:-1]
    while abc[0] is in list(string.punctuation):
        abc=abc[1:]
    return abc

Регулярные выражения достаточно просты, если вы их знаете.

import re
s = "string. With. Punctuation?"
s = re.sub(r'[^\w\s]','',s)

Для значений Python 3 str или Python 2 unicodestr.translate() принимает только словарь; кодовые точки (целые числа) ищутся в этом сопоставлении, и все, что сопоставлено с None, удаляется.

Чтобы удалить (некоторые?) Знаки препинания, используйте:

import string

remove_punct_map = dict.fromkeys(map(ord, string.punctuation))
s.translate(remove_punct_map)

dict.fromkeys() метод класса упрощает создание сопоставления, устанавливая все значения на None на основе последовательности ключей.

Чтобы удалить знаки препинания все, а не только знаки препинания ASCII, ваша таблица должна быть немного больше; см. Ответ Дж. Ф. Себастьяна (версия Python 3):

import unicodedata
import sys

remove_punct_map = dict.fromkeys(i for i in range(sys.maxunicode)
                                 if unicodedata.category(chr(i)).startswith('P'))

Вот функция, которую я написал. Это не очень эффективно, но это просто, и вы можете добавлять или удалять любые знаки препинания, которые захотите:

def stripPunc(wordList):
    """Strips punctuation from list of words"""
    puncList = [".",";",":","!","?","/","\\",",","#","@","$","&",")","(","\""]
    for punc in puncList:
        for word in wordList:
            wordList=[word.replace(punc,'') for word in wordList]
    return wordList

Однострочник может быть полезен в не очень строгих случаях:

''.join([c for c in s if c.isalnum() or c.isspace()])

Вот однострочный текст для Python 3.5:

import string
"l*ots! o(f. p@u)n[c}t]u[a'ti\"on#$^?/".translate(str.maketrans({a:None for a in string.punctuation}))

Для удобства использования я резюмирую примечание о разделении знаков препинания в строке как в Python 2, так и в Python 3. Подробное описание см. В других ответах.

Python 2

import string

s = "string. With. Punctuation?"
table = string.maketrans("","")
new_s = s.translate(table, string.punctuation)      # Output: string without punctuation

Python 3

import string

s = "string. With. Punctuation?"
table = str.maketrans(dict.fromkeys(string.punctuation))  # OR {key: None for key in string.punctuation}
new_s = s.translate(table)                          # Output: string without punctuation

Я еще не видел этого ответа. Просто используйте регулярное выражение; он удаляет все символы, кроме символов слова (\w) и цифровых символов (\d), за которыми следует пробельный символ (\s):

import re
s = "string. With. Punctuation?" # Sample string 
out = re.sub(ur'[^\w\d\s]+', '', s)

>>> s = "string. With. Punctuation?"
>>> s = re.sub(r'[^\w\s]','',s)
>>> re.split(r'\s*', s)


['string', 'With', 'Punctuation']

string.punctuation пропускает множество знаков препинания, которые обычно используются в реальном мире. Как насчет решения, которое работает с пунктуацией, отличной от ASCII?

import regex
s = u"string. With. Some・Really Weird、Non？ASCII。 「（Punctuation）」?"
remove = regex.compile(ur'[\p{C}|\p{M}|\p{P}|\p{S}|\p{Z}]+', regex.UNICODE)
remove.sub(u" ", s).strip()

Лично я считаю, что это лучший способ удалить знаки препинания из строки в Python, потому что:

• Удаляет все знаки препинания Unicode.
• Его легко изменить, например вы можете удалить \{S}, если хотите убрать знаки препинания, но оставить символы вроде $.
• Вы можете четко указать, что вы хотите сохранить и что хотите удалить, например, \{Pd} удалит только тире.
• Это регулярное выражение также нормализует пробелы. Он отображает табуляцию, возврат каретки и другие странности в красивые одиночные пробелы.

При этом используются свойства символов Юникода, которые вы можете узнать больше в Википедии.

Вот решение без регулярного выражения.

import string

input_text = "!where??and!!or$$then:)"
punctuation_replacer = string.maketrans(string.punctuation, ' '*len(string.punctuation))    
print ' '.join(input_text.translate(punctuation_replacer).split()).strip()

Output>> where and or then

• Заменяет знаки препинания пробелами
• Замените несколько пробелов между словами одним пробелом
• Удалите конечные пробелы, если они есть, с помощью полоска()

#FIRST METHOD
#Storing all punctuations in a variable    
punctuation='!?,.:;"\')(_-'
newstring='' #Creating empty string
word=raw_input("Enter string: ")
for i in word:
     if (i not in punctuation):
                  newstring+=i
print "The string without punctuation is",newstring

#SECOND METHOD
word=raw_input("Enter string: ")
punctuation='!?,.:;"\')(_-'
newstring=word.translate(None,punctuation)
print "The string without punctuation is",newstring


#Output for both methods
Enter string: hello! welcome -to_python(programming.language)??,
The string without punctuation is: hello welcome topythonprogramminglanguage

with open('one.txt','r')as myFile:

    str1=myFile.read()

    print(str1)


    punctuation = ['(', ')', '?', ':', ';', ',', '.', '!', '/', '"', "'"] 

for i in punctuation:

        str1 = str1.replace(i," ") 
        myList=[]
        myList.extend(str1.split(" "))
print (str1) 
for i in myList:

    print(i,end='\n')
    print ("____________")

Удалите стоп-слова из текстового файла с помощью Python

print('====THIS IS HOW TO REMOVE STOP WORS====')

with open('one.txt','r')as myFile:

    str1=myFile.read()

    stop_words  = "not", "is", "it", "By","between","This","By","A","when","And","up","Then","was","by","It","If","can","an","he","This","or","And","a","i","it","am","at","on","in","of","to","is","so","too","my","the","and","but","are","very","here","even","from","them","then","than","this","that","though","be","But","these"

    myList=[]

    myList.extend(str1.split(" "))

    for i in myList:

        if i not in stop_words:

            print ("____________")

            print(i,end='\n')

import re
s = "string. With. Punctuation?" # Sample string 
out = re.sub(r'[^a-zA-Z0-9\s]', '', s)

В качестве обновления я переписал пример @Brian в Python 3 и внес в него изменения, чтобы переместить этап компиляции регулярного выражения внутри функции. Моя мысль здесь заключалась в том, чтобы рассчитать каждый шаг, необходимый для работы функции. Возможно, вы используете распределенные вычисления и не можете разделять объект регулярного выражения между вашими рабочими, и вам нужно иметь шаг re.compile для каждого рабочего. Кроме того, мне было любопытно примерить две разные реализации maketrans для Python 3.

table = str.maketrans({key: None for key in string.punctuation})

против

table = str.maketrans('', '', string.punctuation)

Кроме того, я добавил еще один метод использования set, в котором я использую функцию пересечения, чтобы уменьшить количество итераций.

Это полный код:

import re, string, timeit

s = "string. With. Punctuation"


def test_set(s):
    exclude = set(string.punctuation)
    return ''.join(ch for ch in s if ch not in exclude)


def test_set2(s):
    _punctuation = set(string.punctuation)
    for punct in set(s).intersection(_punctuation):
        s = s.replace(punct, ' ')
    return ' '.join(s.split())


def test_re(s):  # From Vinko's solution, with fix.
    regex = re.compile('[%s]' % re.escape(string.punctuation))
    return regex.sub('', s)


def test_trans(s):
    table = str.maketrans({key: None for key in string.punctuation})
    return s.translate(table)


def test_trans2(s):
    table = str.maketrans('', '', string.punctuation)
    return(s.translate(table))


def test_repl(s):  # From S.Lott's solution
    for c in string.punctuation:
        s=s.replace(c,"")
    return s


print("sets      :",timeit.Timer('f(s)', 'from __main__ import s,test_set as f').timeit(1000000))
print("sets2      :",timeit.Timer('f(s)', 'from __main__ import s,test_set2 as f').timeit(1000000))
print("regex     :",timeit.Timer('f(s)', 'from __main__ import s,test_re as f').timeit(1000000))
print("translate :",timeit.Timer('f(s)', 'from __main__ import s,test_trans as f').timeit(1000000))
print("translate2 :",timeit.Timer('f(s)', 'from __main__ import s,test_trans2 as f').timeit(1000000))
print("replace   :",timeit.Timer('f(s)', 'from __main__ import s,test_repl as f').timeit(1000000))

Это мои результаты:

sets      : 3.1830138750374317
sets2      : 2.189873124472797
regex     : 7.142953420989215
translate : 4.243278483860195
translate2 : 2.427158243022859
replace   : 4.579746678471565

Почему никто из вас этим не пользуется?

 ''.join(filter(str.isalnum, s)) 

Слишком медленно?

Учитывая юникод. Код проверен в python3.

from unicodedata import category
text = 'hi, how are you?'
text_without_punc = ''.join(ch for ch in text if not category(ch).startswith('P'))

Вот еще один простой способ сделать это с помощью RegEx

import re

punct = re.compile(r'(\w+)')

sentence = 'This ! is : a # sample $ sentence.' # Text with punctuation
tokenized = [m.group() for m in punct.finditer(sentence)]
sentence = ' '.join(tokenized)
print(sentence) 
'This is a sample sentence'

Попробуйте это :)

regex.sub(r'\p{P}','', s)

Я искал действительно простое решение. вот что у меня получилось:

import re 

s = "string. With. Punctuation?" 
s = re.sub(r'[\W\s]', ' ', s)

print(s)
'string  With  Punctuation '