Hoe stopwoorden te verwijderen met nltk of python

Dus ik heb een dataset waarvan ik stopwoorden wil verwijderen uit het gebruik van

stopwords.words('english')

Ik heb moeite om dit in mijn code te gebruiken om deze woorden gewoon te verwijderen. Ik heb al een lijst met de woorden uit deze dataset, het deel waar ik mee worstel is het vergelijken met deze lijst en het verwijderen van de stopwoorden.
Alle hulp wordt op prijs gesteld.

Antwoord 1, autoriteit 100%

from nltk.corpus import stopwords
# ...
filtered_words = [word for word in word_list if word not in stopwords.words('english')]

Antwoord 2, autoriteit 9%

Je zou ook een set diff kunnen doen, bijvoorbeeld:

list(set(nltk.regexp_tokenize(sentence, pattern, gaps=True)) - set(nltk.corpus.stopwords.words('english')))

Antwoord 3, autoriteit 8%

Om alle soorten stopwoorden, inclusief nltk stopwoorden, uit te sluiten, kunt u zoiets als dit doen:

from stop_words import get_stop_words
from nltk.corpus import stopwords
stop_words = list(get_stop_words('en'))         #About 900 stopwords
nltk_words = list(stopwords.words('english')) #About 150 stopwords
stop_words.extend(nltk_words)
output = [w for w in word_list if not w in stop_words]

Antwoord 4, autoriteit 6%

Ik neem aan dat je een lijst met woorden (word_list) hebt waaruit je stopwoorden wilt verwijderen. Je zou zoiets als dit kunnen doen:

filtered_word_list = word_list[:] #make a copy of the word_list
for word in word_list: # iterate over word_list
  if word in stopwords.words('english'): 
    filtered_word_list.remove(word) # remove word from filtered_word_list if it is a stopword

Antwoord 5, autoriteit 4%

Er is een heel eenvoudig lichtgewicht python-pakket stop-wordsspeciaal voor dit doel.

Installeer eerst het pakket met:
pip install stop-words

Dan kunt u uw woorden in één regel verwijderen met behulp van lijstbegrip:

from stop_words import get_stop_words
filtered_words = [word for word in dataset if word not in get_stop_words('english')]

Dit pakket is erg licht om te downloaden (in tegenstelling tot nltk), werkt voor zowel Python 2als Python 3en heeft stopwoorden voor veel andere talen, zoals :

   Arabic
    Bulgarian
    Catalan
    Czech
    Danish
    Dutch
    English
    Finnish
    French
    German
    Hungarian
    Indonesian
    Italian
    Norwegian
    Polish
    Portuguese
    Romanian
    Russian
    Spanish
    Swedish
    Turkish
    Ukrainian

Antwoord 6, autoriteit 2%

Gebruik de bibliotheek textcleanerom stopwoorden uit uw gegevens te verwijderen.

Volg deze link:https://yugantm.github.io/textcleaner/documentation. html#remove_stpwrds

Volg deze stappen om dit met deze bibliotheek te doen.

pip install textcleaner

Na installatie:

import textcleaner as tc
data = tc.document(<file_name>) 
#you can also pass list of sentences to the document class constructor.
data.remove_stpwrds() #inplace is set to False by default

Gebruik bovenstaande code om de stopwoorden te verwijderen.

Antwoord 7, autoriteit 2%

Hier is mijn mening hierover, voor het geval je het antwoord meteen in een string wilt krijgen (in plaats van een lijst met gefilterde woorden):

STOPWORDS = set(stopwords.words('english'))
text =  ' '.join([word for word in text.split() if word not in STOPWORDS]) # delete stopwords from text

Antwoord 8

u kunt deze functie gebruiken, u zou moeten opmerken dat u alle woorden moet verlagen

from nltk.corpus import stopwords
def remove_stopwords(word_list):
        processed_word_list = []
        for word in word_list:
            word = word.lower() # in case they arenet all lower cased
            if word not in stopwords.words("english"):
                processed_word_list.append(word)
        return processed_word_list

Antwoord 9

met behulp van filter:

from nltk.corpus import stopwords
# ...  
filtered_words = list(filter(lambda word: word not in stopwords.words('english'), word_list))

Antwoord 10

Hoewel de vraag een beetje oud is, is hier een nieuwe bibliotheek, die het vermelden waard is, die extra taken kan uitvoeren.

In sommige gevallen wilt u niet alleen stopwoorden verwijderen. U wilt liever de stopwoorden in de tekstgegevens zoeken en deze in een lijst opslaan zodat u de ruis in de gegevens kunt vinden en deze interactiever kunt maken.

De bibliotheek wordt 'textfeatures'. U kunt het als volgt gebruiken:

! pip install textfeatures
import textfeatures as tf
import pandas as pd

Stel bijvoorbeeld dat u de volgende reeks strings hebt:

texts = [
    "blue car and blue window",
    "black crow in the window",
    "i see my reflection in the window"]
df = pd.DataFrame(texts) # Convert to a dataframe
df.columns = ['text'] # give a name to the column
df

Bel nu de functie Stopwoorden () en geef de gewenste parameters door:

tf.stopwords(df,"text","stopwords") # extract stop words
df[["text","stopwords"]].head() # give names to columns

Het resultaat wordt:

   text                                 stopwords
0   blue car and blue window             [and]
1   black crow in the window             [in, the]
2   i see my reflection in the window    [i, my, in, the]

Zoals u kunt zien, heeft de laatste kolom de stopwoorden die in die docute (record) zijn opgenomen.

Antwoord 11

Als uw gegevens worden opgeslagen als een Pandas DataFrame, kunt u remove_stopwordsuit Textero gebruiken die de NLTK-stopwoordenlijst met standaard .

import pandas as pd
import texthero as hero
df['text_without_stopwords'] = hero.remove_stopwords(df['text'])

Antwoord 12

from nltk.corpus import stopwords 
from nltk.tokenize import word_tokenize 
example_sent = "This is a sample sentence, showing off the stop words filtration."
stop_words = set(stopwords.words('english')) 
word_tokens = word_tokenize(example_sent) 
filtered_sentence = [w for w in word_tokens if not w in stop_words] 
filtered_sentence = [] 
for w in word_tokens: 
    if w not in stop_words: 
        filtered_sentence.append(w) 
print(word_tokens) 
print(filtered_sentence) 

Antwoord 13

Ik zal je een voorbeeld laten zien
Eerst extraheer ik de tekstgegevens uit het dataframe (twitter_df) om verder te verwerken als volgt

    from nltk.tokenize import word_tokenize
     tweetText = twitter_df['text']

Vervolgens gebruik ik de volgende methode om te tokeniseren

    from nltk.tokenize import word_tokenize
     tweetText = tweetText.apply(word_tokenize)

Vervolgens, om stopwoorden te verwijderen,

    from nltk.corpus import stopwords
     nltk.download('stopwords')
     stop_words = set(stopwords.words('english'))
     tweetText = tweetText.apply(lambda x:[word for word in x if word not in stop_words])
     tweetText.head()

Ik denk dat dit je zal helpen

Antwoord 14

  import sys
print ("enter the string from which you want to remove list of stop words")
userstring = input().split(" ")
list =["a","an","the","in"]
another_list = []
for x in userstring:
    if x not in list:           # comparing from the list and removing it
        another_list.append(x)  # it is also possible to use .remove
for x in another_list:
     print(x,end=' ')
   # 2) if you want to use .remove more preferred code
    import sys
    print ("enter the string from which you want to remove list of stop words")
    userstring = input().split(" ")
    list =["a","an","the","in"]
    another_list = []
    for x in userstring:
        if x in list:           
            userstring.remove(x)  
    for x in userstring:           
        print(x,end = ' ') 
    #the code will be like this