Come cercare su Twitter con rtweet e R.

Twitter è un'ottima fonte di notizie su R, specialmente durante conferenze come useR! e RStudio Conference. E grazie a R e al pacchetto rtweet, puoi creare il tuo strumento per scaricare i tweet per una facile ricerca, ordinamento e filtraggio. Diamo uno sguardo, passo dopo passo.

Per prima cosa vuoi installare uno qualsiasi dei pacchetti del progetto rtweet che non hai già: rtweet, Reactable, glue, stringr, httpuv e dplyr. Quindi, per iniziare, carica rtweet e dplyr.

# Se è necessario installare uno di questi:

# install.packages ("rtweet")

# install.packages ("Reactable")

# install.packages ("colla")

# install.packages ("stringr")

# install.packages ("httpuv")

# install.packages ("dplyr")

# install.packages ("purrr")

libreria (rtweet)

libreria (dplyr)

Autorizza l'API di Twitter

Per utilizzare rtweet, è necessario un account Twitter in modo da poter autorizzare rtweet a utilizzare le credenziali dell'account specifico. Questo perché esiste un limite al numero di tweet che puoi scaricare in un periodo di 15 minuti.

Michael Kearney, che ha scritto rtweet, offre agli utenti di rtweet due scelte. Il modo più semplice è semplicemente richiedere alcuni tweet. Se non ci sono credenziali memorizzate sul tuo sistema, dovrebbe aprirsi una finestra del browser che ti chiede di autorizzare la richiesta. Dopodiché, un token di autorizzazione verrà memorizzato nel tuo file .Renviron in modo che tu non debba autorizzare nuovamente in futuro.

Puoi andare su rtweet.info per vedere l'altro metodo, che prevede la creazione di un account sviluppatore Twitter e un nuovo progetto per generare credenziali di autorizzazione. Se hai intenzione di usare molto rtweet, probabilmente vorrai farlo. Ma per iniziare, il modo più semplice è, beh, più facile.

Importa i tweet

Per cercare tweet con un hashtag specifico (o una frase che non è un hashtag), si utilizza la earch_tweets()funzione denominata intuitivamente s . Richiede diversi argomenti, inclusa la query, come #rstudioconf o #rstats; se desideri includere retweet; e il numero di tweet da restituire. Il numero predefinito è 100.

Sebbene sia possibile ricevere fino a 18.000 tweet in 15 minuti, esiste un'importante restrizione quando si utilizza l'API di Twitter per cercare una parola o una frase: i risultati della ricerca risalgono solo da sei a nove giorni a meno che non si paghi un account API Twitter premium. A differenza del sito Web di Twitter, non è possibile utilizzare rtweet per cercare i tweet di una conferenza dell'anno scorso. Non sarai in grado di cercare due settimane dopo una conferenza per ottenere quei tweet. Quindi ti consigliamo di assicurarti di salvare i tweet che tiri ora che potresti desiderare in futuro.

Ci sono più argomenti che puoi usare per personalizzare la tua ricerca, ma iniziamo con una ricerca di base: 200 tweet con l'hashtag #rstudioconf, senza retweet.

tweet_df <- search_tweets ("# rstudioconf", n = 200,

include_rts = FALSE)

Se esegui quel codice e non hai mai usato rtweet prima, ti verrà chiesto di autorizzare un'app Twitter.

Nota che anche se chiedi 200 tweet, potresti ricevere meno. Uno dei motivi è che potrebbero non esserci 200 tweet per la tua query negli ultimi sei-nove giorni. Un altro è che Twitter potrebbe aver estratto inizialmente 200 tweet, ma dopo aver filtrato i retweet, ne sono rimasti meno.

Il data frame tweet_df torna con 90 colonne di dati per ogni tweet:

Sharon Machlis,

Le colonne che di solito mi interessano di più sono status_id, created_at, screen_name, text, favourite_count, retweet_count e urls_expanded_url. Potresti volere altre colonne per la tua analisi; ma per questo tutorial selezionerò solo quelle colonne. 

Cerca, filtra e analizza i tuoi tweet

Ci sono molte visualizzazioni e analisi interessanti che puoi fare con i dati di Twitter e R. Alcune di esse sono integrate direttamente in rtweet. Ma sto scrivendo questo tutorial indossando il mio cappello da giornalista tecnologico. Voglio un modo semplice per vedere cose nuove e interessanti che potrei non sapere.

I tweet più apprezzati da una conferenza potrebbero aiutare in questo. E se utilizzo rtweet e l'API di Twitter, non devo fare affidamento sull'algoritmo "popolare" di Twitter. Posso fare le mie ricerche e impostare i miei criteri per "popolare". Potrei voler cercare i tweet migliori solo del giorno corrente mentre una conferenza è in corso, o filtrare per un argomento specifico che mi interessa - come "brillante" o "purrr" - ordinato in base alla maggior parte dei Mi piace o alla maggior parte dei retweet.

Uno dei modi più semplici per eseguire questi tipi di ricerche e ordinamenti è con una tabella ordinabile. DT è un pacchetto popolare per questo. Ma ultimamente ne sto sperimentando un altro: reattivo. 

L'impostazione predefinita reactable()è una specie di blah. Per esempio: 

tweet_table_data <- seleziona (tweets, -user_id, -status_id)

libreria (reattiva)

reattivo (tweet_table_data)

Questo codice produce una tabella simile a questa:

Sharon Machlis,

Ma possiamo aggiungere alcune personalizzazioni, come:

reagibile (tweet_table_data,

filtrabile = VERO, ricercabile = VERO, con bordi = VERO,

strisce = VERO, evidenziare = VERO,

defaultPageSize = 25, showPageSizeOptions = TRUE,

showSortable = TRUE, pageSizeOptions = c (25, 50, 75, 100, 200), defaultSortOrder = "desc",

colonne = elenco (

created_at = colDef (defaultSortOrder = "asc"),

screen_name = colDef (defaultSortOrder = "asc"),

text = colDef (html = TRUE, minWidth = 190, ridimensionabile = TRUE),

favour_count = colDef (filtrabile = FALSE),

retweet_count = colDef (filtrabile = FALSE),

urls_expanded_url = colDef (html = TRUE)

)

)

Il risultato è una tabella simile a questa:

Sharon Machlis,

Configura la tua tabella dati reattiva 

Nel blocco di codice sopra, l' filterable = TRUEargomento ha aggiunto filtri di ricerca sotto ogni intestazione di colonna e ha searchableaggiunto la casella di ricerca della tabella generale in alto a destra. Accensione bordered, stripede highlightfa quello che ci si potrebbe aspettare: Aggiunge un bordo tavolo, aggiunge colore alternato-fila “strisce”, e mette in evidenza una fila se si mette un cursore su di esso.

I set my defaultPageSize to 25. The showPageSizeOptions argument lets me change the page length interactively, and then I define page size options that will show up in a drop-down menu below the table (not visible in the screen shot). The showSortable argument adds little arrow icons next to column names so users know they can click to sort. And I set each column’s defaultSortOrder to descending instead of ascending. So if I click on the column of number of retweets or likes, I will see that as most to least, not least to most.

Finally, there is the columns argument. That’s a list containing a column definition for each column. Look at the reactable help files for more details on other available options. In this example, I set the created_at and screen_name columns to have a default sort order of ascending. For the text column, I set it to display HTML as HTML so I can add clickable links. I also set a minimum column width of 190 pixels and made the column resizable — so users can click and drag to make it wider or narrower.

I also turned off the filter boxes for favorite_count and reply_count. That’s because, unfortunately, reactable filters don’t understand when columns are numbers and will filter them as character strings. While reactable sorts number columns properly, the filter boxes are problematic. That’s the major drawback to reactable vs. the DT package: DT understands column types and filters accordingly. But sorting numerically is enough for me for this purpose. 

You can check out the video at the top of this article to see what it looks like when you sort a column or make the tweet text column wider and narrower.

Make your data table more useful

A couple of things will make this table more useful. This code doesn’t display images or videos included in tweets. That’s fine, because my purpose here is to scan text, not re-create a Twitter application. But that means it will sometimes be helpful to see the original tweet in order to view photos, videos, or comments.

I think it’s convenient to add a small clickable something at the end of each tweet’s text that you can click to see the actual tweet on Twitter. I decided on >> although it could be any character or characters.

To construct a URL, I need to know the format of a tweet, which if you look at any tweet on the Twitter website, you can see is //twitter.com/username/status/tweetID. 

Using the glue package, that would be rendered like this: 

glue::glue("//twitter.com/{screen_name}/status/{status_id}")

If you haven’t used glue before, it’s a great package for pasting together text and variable values. In the above code, any variable name between braces is evaluated.

My full code to create a column with a clickable link to the tweet after the tweet text:

Tweet = glue::glue("{text} >> ") 

And the code to create a data frame for an interactive table:

tweet_table_data %

select(user_id, status_id, created_at, screen_name, text, favorite_count, retweet_count, urls_expanded_url) %>%

mutate(

Tweet = glue::glue("{text} >> ")

)%>%

select(DateTime = created_at, User = screen_name, Tweet, Likes = favorite_count, RTs = retweet_count, URLs = urls_expanded_url)

I'd also like to make clickable links from the URL column, which is now just text. This is a bit complicated, because the URL column is a list column because some tweets include more than one URL.

I’m sure there is a more elegant way to create clickable links from a list column of plain-text URLs, but the code below works. First I create a function to generate the HTML if there are no URLs, one URL, or two or more:

make_url_html <- function(url) {

if(length(url) < 2) {

if(!is.na(url)) {

as.character(glue("{url}") )

} else {

""

}

} else {

paste0(purrr::map_chr(url, ~ paste0("", .x, "", collapse = ", ")), collapse = ", ")

}

}

I run purrr::map_chr() on the URL value if there are two or more URLs so that each URL gets its own HTML; then I paste them together and collapse them into a single character string to appear in the table.

Once my function works, I use purrr::map_chr() again to iterate over each item in the column:

tweet_table_data$URLs <- purrr::map_chr(tweet_table_data$URLs, make_url_html)

Don’t worry if you don’t understand this part, since it’s really more about purrr and list columns than rtweet and reactable. And it’s not necessary to search and sort the tweets; you can always click to the original tweet and see clickable links there.

Finally, I can run my customized reactable() code on the new tweet table data: 

reactable(tweet_table_data,

filterable = TRUE, searchable = TRUE, bordered = TRUE, striped = TRUE, highlight = TRUE,

showSortable = TRUE, defaultSortOrder = "desc", defaultPageSize = 25, showPageSizeOptions = TRUE, pageSizeOptions = c(25, 50, 75, 100, 200),

columns = list(

DateTime = colDef(defaultSortOrder = "asc"),

User = colDef(defaultSortOrder = "asc"),

Tweet = colDef(html = TRUE, minWidth = 190, resizable = TRUE),

Likes = colDef(filterable = FALSE, format = colFormat(separators = TRUE)),

RTs = colDef(filterable = FALSE, format = colFormat(separators = TRUE)),

URLs = colDef(html = TRUE)

)

)

If you’ve been following along, you should have your own interactive table that can search, sort, and filter conference or topic tweets.

Tips for tweet collectors

One thing to remember: If you’re following a conference hashtag during a conference, you will want to pull enough tweets to get the whole conference. So check the earliest date in your tweet data frame. If that date is after the conference started, request more tweets. If your conference hashtag has more than 18,000 tweets (as happened when I was tracking CES) you’ll need to come up with some strategies to get the whole set. Check out the retryonratelimit argument for search_tweets() if you want to collect a whole 18,000+ set of conference hashtag tweets going back 6 days or less 

Finally, make sure to save your data to a local file when the conference ends! A week later, you’ll no longer have access to those tweets via search_tweets() and the Twitter API.

E guarda l'episodio bonus "Fai di più con R" per vedere come trasformare questa app di monitoraggio di Twitter in un'app Shiny interattiva.

Per ulteriori suggerimenti R, vai alla pagina Fai di più con R su //bit.ly/domorewithR o la playlist Fai di più con R sul canale YouTube di TECHtalk.