Zählen Sie die Anzahl aller Wörter in einer Zeichenfolge

Gibt es eine Funktion zum Zählen der Anzahl von Wörtern in einer Zeichenfolge? Zum Beispiel:

str1 <- "How many words are in this sentence"

um ein Ergebnis von 7 zurückzugeben.

Sie können strsplitund sapplyFunktionen verwenden

sapply(strsplit(str1, " "), length)

Verwenden Sie das Symbol \\Wfür reguläre Ausdrücke , um Nicht-Wort-Zeichen abzugleichen +, und geben Sie ein oder mehrere Zeichen in einer Reihe an gregexpr, um alle Übereinstimmungen in einer Zeichenfolge zu finden. Wörter sind die Anzahl der Worttrennzeichen plus 1.

lengths(gregexpr("\\W+", str1)) + 1

Dies wird mit leeren Saiten am Anfang oder Ende des Zeichenvektor scheitern, wenn ein „Wort“ nicht erfüllt \\W‚s Begriff des Nicht-Wortes (man könnte mit anderen regulären Ausdrücken arbeiten, \\S+, [[:alpha:]]etc., aber es wird immer Dies sind wahrscheinlich effizientere strsplitLösungen als Lösungen, bei denen jedem Wort Speicher zugewiesen wird. Reguläre Ausdrücke sind in beschrieben ?regex.

Aktualisieren Wie in den Kommentaren und in einer anderen Antwort von @Andri erwähnt, schlägt der Ansatz mit (Null-) und Ein-Wort-Zeichenfolgen sowie mit nachgestellten Satzzeichen fehl

str1 = c("", "x", "x y", "x y!" , "x y! z")
lengths(gregexpr("[A-z]\\W+", str1)) + 1L
# [1] 2 2 2 3 3

Viele der anderen Antworten schlagen auch in diesen oder ähnlichen Fällen (z. B. mehreren Leerzeichen) fehl. Ich denke, die Einschränkung meiner Antwort bezüglich der Vorstellung eines Wortes in der ursprünglichen Antwort deckt Probleme mit der Interpunktion ab (Lösung: Wählen Sie einen anderen regulären Ausdruck, z. B. [[:space:]]+), aber die Fälle mit null und einem Wort sind ein Problem. @ Andris Lösung unterscheidet nicht zwischen null und einem Wort. Ein "positiver" Ansatz, um Wörter zu finden, könnte man also

sapply(gregexpr("[[:alpha:]]+", str1), function(x) sum(x > 0))

Führen zu

sapply(gregexpr("[[:alpha:]]+", str1), function(x) sum(x > 0))
# [1] 0 1 2 2 3

Wieder könnte der reguläre Ausdruck für verschiedene Begriffe von "Wort" verfeinert werden.

Ich mag die Verwendung von, gregexpr()weil es speichereffizient ist. Eine alternative Verwendung strsplit()(wie @ user813966, jedoch mit einem regulären Ausdruck zum Abgrenzen von Wörtern) und Verwenden des ursprünglichen Begriffs der Abgrenzung von Wörtern ist

lengths(strsplit(str1, "\\W+"))
# [1] 0 1 2 2 3

Dies muss für jedes erstellte Wort und für die Zwischenliste der Wörter einen neuen Speicher zuweisen. Dies kann relativ teuer sein, wenn die Daten "groß" sind, aber wahrscheinlich ist es für die meisten Zwecke effektiv und verständlich.

Der einfachste Weg wäre:

require(stringr)
str_count("one,   two three 4,,,, 5 6", "\\S+")

... alle Sequenzen auf Nicht-Leerzeichen zählen ( \\S+).

Aber was ist mit einer kleinen Funktion, mit der wir auch entscheiden können, welche Art von Wörtern wir zählen möchten und welche auch für ganze Vektoren funktioniert ?

require(stringr)
nwords <- function(string, pseudo=F){
  ifelse( pseudo, 
          pattern <- "\\S+", 
          pattern <- "[[:alpha:]]+" 
        )
  str_count(string, pattern)
}

nwords("one,   two three 4,,,, 5 6")
# 3

nwords("one,   two three 4,,,, 5 6", pseudo=T)
# 6

Ich benutze die str_countFunktion aus der stringrBibliothek mit der Escape-Sequenz \w, die darstellt:

Beliebiges 'Wort'-Zeichen (Buchstabe, Ziffer oder Unterstrich im aktuellen Gebietsschema: Im UTF-8-Modus werden nur ASCII-Buchstaben und -Ziffern berücksichtigt).

Beispiel:

> str_count("How many words are in this sentence", '\\w+')
[1] 7

Von allen anderen 9 Antworten, die ich testen konnte, arbeiteten nur zwei (von Vincent Zoonekynd und von Petermeissner) für alle hier vorgestellten Eingaben, aber sie erfordern auch stringr.

Aber nur diese Lösung funktioniert mit allen bisher präsentierten Eingaben sowie Eingaben wie "foo+bar+baz~spam+eggs"oder "Combien de mots sont dans cette phrase ?".

Benchmark:

library(stringr)

questions <-
  c(
    "", "x", "x y", "x y!", "x y! z",
    "foo+bar+baz~spam+eggs",
    "one,   two three 4,,,, 5 6",
    "How many words are in this sentence",
    "How  many words    are in this   sentence",
    "Combien de mots sont dans cette phrase ?",
    "
    Day after day, day after day,
    We stuck, nor breath nor motion;
    "
  )

answers <- c(0, 1, 2, 2, 3, 5, 6, 7, 7, 7, 12)

score <- function(f) sum(unlist(lapply(questions, f)) == answers)

funs <-
  c(
    function(s) sapply(gregexpr("\\W+", s), length) + 1,
    function(s) sapply(gregexpr("[[:alpha:]]+", s), function(x) sum(x > 0)),
    function(s) vapply(strsplit(s, "\\W+"), length, integer(1)),
    function(s) length(strsplit(gsub(' {2,}', ' ', s), ' ')[[1]]),
    function(s) length(str_match_all(s, "\\S+")[[1]]),
    function(s) str_count(s, "\\S+"),
    function(s) sapply(gregexpr("\\W+", s), function(x) sum(x > 0)) + 1,
    function(s) length(unlist(strsplit(s," "))),
    function(s) sapply(strsplit(s, " "), length),
    function(s) str_count(s, '\\w+')
  )

unlist(lapply(funs, score))

Ausgabe:

6 10 10  8  9  9  7  6  6 11

str2 <- gsub(' {2,}',' ',str1)
length(strsplit(str2,' ')[[1]])

Die gsub(' {2,}',' ',str1)stellt sicher , dass alle Worte nur durch ein Leerzeichen getrennt, durch alle Vorkommen von zwei Ersatz oder mehr Räumen mit einem Raum.

Das strsplit(str,' ')teilt den Satz an jeder Stelle auf und gibt das Ergebnis in einer Liste zurück. Der [[1]]greift nach dem Wortvektor aus dieser Liste. Das lengthzählt wie viele Wörter.

> str1 <- "How many words are in this     sentence"
> str2 <- gsub(' {2,}',' ',str1)
> str2
[1] "How many words are in this sentence"
> strsplit(str2,' ')
[[1]]
[1] "How"      "many"     "words"    "are"      "in"       "this"     "sentence"
> strsplit(str2,' ')[[1]]
[1] "How"      "many"     "words"    "are"      "in"       "this"     "sentence"
> length(strsplit(str2,' ')[[1]])
[1] 7

Sie können str_match_alleinen regulären Ausdruck verwenden, der Ihre Wörter identifiziert. Das Folgende funktioniert mit anfänglichen, endgültigen und duplizierten Leerzeichen.

library(stringr)
s <-  "
  Day after day, day after day,
  We stuck, nor breath nor motion;
"
m <- str_match_all( s, "\\S+" )  # Sequences of non-spaces
length(m[[1]])

Versuchen Sie diese Funktion aus dem stringiPaket

   require(stringi)
   > s <- c("Lorem ipsum dolor sit amet, consectetur adipisicing elit.",
    +        "nibh augue, suscipit a, scelerisque sed, lacinia in, mi.",
    +        "Cras vel lorem. Etiam pellentesque aliquet tellus.",
    +        "")
    > stri_stats_latex(s)
        CharsWord CharsCmdEnvir    CharsWhite         Words          Cmds        Envirs 
              133             0            30            24             0             0 

Sie können die wc- Funktion in der Bibliothek qdap verwenden :

> str1 <- "How many words are in this sentence"
> wc(str1)
[1] 7

Sie können doppelte Leerzeichen entfernen und die Anzahl " "der Zeichen in der Zeichenfolge zählen, um die Anzahl der Wörter zu ermitteln. Verwenden Sie stringr und rm_white{ qdapRegex }

str_count(rm_white(s), " ") +1

Versuche dies

length(unlist(strsplit(str1," ")))

Ebenfalls ab stringiPaket die unkomplizierte Funktionstri_count_words

stringi::stri_count_words(str1)
#[1] 7

Die Lösung 7 liefert nicht das richtige Ergebnis, wenn nur ein Wort vorhanden ist. Sie sollten nicht nur die Elemente im Ergebnis von gregexpr zählen (was -1 ist, wenn es keine Übereinstimmungen gibt), sondern auch die Elemente> 0 zählen.

Ergo:

sapply(gregexpr("\\W+", str1), function(x) sum(x>0) ) + 1 

require(stringr)
str_count(x,"\\w+")

wird gut mit doppelten / dreifachen Leerzeichen zwischen Wörtern

Alle anderen Antworten haben Probleme mit mehr als einem Leerzeichen zwischen den Wörtern.

erfordern (stringr)

Definieren Sie eine sehr einfache Funktion

str_words <- function(sentence) {

  str_count(sentence, " ") + 1

}

Prüfen

str_words(This is a sentence with six words)

Verwenden nchar

wenn ein Vektor von Strings aufgerufen wird x

(nchar(x) - nchar(gsub(' ','',x))) + 1

Finden Sie die Anzahl der Leerzeichen heraus und fügen Sie eines hinzu

Ich habe die folgende Funktion und den folgenden regulären Ausdruck für die Anzahl der Wörter nützlich gefunden, insbesondere bei einfachen oder doppelten Bindestrichen, bei denen erstere im Allgemeinen nicht als Wortumbruch gelten sollten, z. B. bekannte HiFi-Dateien. wohingegen ein doppelter Bindestrich ein Interpunktionsbegrenzer ist, der nicht durch Leerzeichen begrenzt ist - beispielsweise für Bemerkungen in Klammern.

txt <- "Don't you think e-mail is one word--and not two!" #10 words
words <- function(txt) { 
length(attributes(gregexpr("(\\w|\\w\\-\\w|\\w\\'\\w)+",txt)[[1]])$match.length) 
}

words(txt) #10 words

Stringi ist ein nützliches Paket. In diesem Beispiel werden jedoch Wörter aufgrund von Bindestrichen überzählt.

stringi::stri_count_words(txt) #11 words

Mit dem stringr- Paket kann man auch ein einfaches Skript schreiben, das einen Vektor von Strings beispielsweise durch eine for-Schleife durchlaufen kann.

Sagen wir

df $ text

enthält einen Vektor von Zeichenfolgen, die wir analysieren möchten. Zunächst fügen wir dem vorhandenen Datenrahmen df wie folgt zusätzliche Spalten hinzu:

df$strings    = as.integer(NA)
df$characters = as.integer(NA)

Dann führen wir eine for-Schleife über den Vektor der Zeichenfolgen wie folgt aus:

for (i in 1:nrow(df)) 
{
   df$strings[i]    = str_count(df$text[i], '\\S+') # counts the strings
   df$characters[i] = str_count(df$text[i])         # counts the characters & spaces
}

Die resultierenden Spalten: Zeichenfolgen und Zeichen enthalten die Anzahl der Wörter und Zeichen. Dies wird in einem Durchgang für einen Vektor von Zeichenfolgen erreicht.