Jak wyszukiwać na Twitterze za pomocą rtweet i R

Twitter to świetne źródło wiadomości o R - zwłaszcza podczas konferencji typu useR! i RStudio Conference. Dzięki R i pakietowi rtweet możesz zbudować własne narzędzie do pobierania tweetów w celu łatwego wyszukiwania, sortowania i filtrowania. Przyjrzyjmy się krok po kroku.

Najpierw chcesz zainstalować dowolny pakiet projektu rtweet, którego jeszcze nie masz: rtweet, reactable, glue, stringr, httpuv i dplyr. Następnie, aby rozpocząć, załaduj rtweet i dplyr.

# Jeśli musisz zainstalować którykolwiek z poniższych:

# install.packages („rtweet”)

# install.packages („reaktywny”)

# install.packages („klej”)

# install.packages ("stringr")

# install.packages („httpuv”)

# install.packages („dplyr”)

# install.packages ("mruczenie")

biblioteka (rtweet)

biblioteka (dplyr)

Autoryzuj API Twittera

Aby korzystać z rtweet, potrzebujesz konta na Twitterze, aby móc autoryzować rtweet do korzystania z określonych poświadczeń konta. Dzieje się tak, ponieważ istnieje ograniczenie liczby tweetów, które można pobrać w ciągu 15 minut.

Michael Kearney, który napisał rtweet, daje użytkownikom rtweeta dwie możliwości. Najłatwiej jest po prostu poprosić o kilka tweetów. Jeśli w systemie nie ma żadnych danych logowania, powinno otworzyć się okno przeglądarki z prośbą o autoryzację żądania. Następnie token autoryzacyjny zostanie zapisany w Twoim pliku .Renviron, więc nie będziesz musiał ponownie autoryzować w przyszłości.

Możesz przejść do rtweet.info, aby zobaczyć inną metodę, która obejmuje utworzenie konta programisty na Twitterze i nowy projekt do generowania danych uwierzytelniających. Jeśli zamierzasz często używać rtweeta, prawdopodobnie będziesz chciał to zrobić. Ale na początek łatwiejszy sposób jest, no cóż, łatwiejszy.

Importuj tweety

Aby wyszukać tweety z określonym hashtagiem (lub frazą, która nie jest hashtagiem), użyj intuicyjnie nazwanej earch_tweets()funkcji s . Wymaga kilku argumentów, w tym zapytania, takich jak #rstudioconf lub #rstats; czy chcesz dołączyć retweety; i liczbę tweetów do zwrócenia. Liczba domyślnie wynosi 100.

Chociaż możesz otrzymać do 18 000 tweetów w ciągu 15 minut, istnieje ważne ograniczenie podczas korzystania z interfejsu API Twittera do wyszukiwania słowa lub frazy: wyniki wyszukiwania są cofane tylko od sześciu do dziewięciu dni, chyba że zapłacisz za konto premium Twitter API. W przeciwieństwie do serwisu Twitter, nie możesz używać rtweeta do wyszukiwania tweetów z zeszłorocznej konferencji. Po dwóch tygodniach od konferencji nie będziesz mieć możliwości wyszukiwania tych tweetów. Dlatego zechcesz zapisać tweety, które pobierasz teraz, które możesz chcieć w przyszłości.

Istnieje więcej argumentów, których możesz użyć, aby dostosować wyszukiwanie, ale zacznijmy od podstawowego wyszukiwania: 200 tweetów z hashtagiem #rstudioconf, bez retweetów.

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

include_rts = FALSE)

Jeśli uruchomisz ten kod i nigdy wcześniej nie korzystałeś z rtweeta, zostaniesz poproszony o autoryzację aplikacji na Twitterze.

Pamiętaj, że nawet jeśli poprosisz o 200 tweetów, możesz odzyskać mniej. Jednym z powodów jest to, że w ciągu ostatnich sześciu do dziewięciu dni w zapytaniu może nie być 200 tweetów. Innym jest to, że Twitter rzeczywiście mógł początkowo wyodrębnić 200 tweetów, ale po odfiltrowaniu retweetów pozostało mniej.

Ramka danych tweet_df zawiera 90 kolumn danych dla każdego tweeta:

Sharon Machlis,

Kolumny, które zwykle mnie najbardziej interesują, to status_id, created_at, screen_name, text, Favorite_count , retweet_count i urls_expanded_url. Możesz potrzebować innych kolumn do analizy; ale w tym samouczku wybiorę tylko te kolumny. 

Wyszukuj, filtruj i analizuj swoje tweety

Istnieje wiele interesujących wizualizacji i analiz, które możesz wykonać z danymi z Twittera i R. Niektóre z nich są wbudowane bezpośrednio w rtweet. Ale piszę ten samouczek w kapeluszu dziennikarza technicznego. Chcę w łatwy sposób zobaczyć nowe i fajne rzeczy, o których mogę nie wiedzieć.

Mogą w tym pomóc najbardziej lubiane tweety z konferencji. A jeśli używam rtweeta i Twittera API, nie muszę polegać na „popularnym” algorytmie Twittera. Mogę samodzielnie wyszukiwać i ustawiać własne kryteria dla „popularnych”. Mogę chcieć wyszukać najlepsze tweety z bieżącego dnia, gdy konferencja jest w toku, lub przefiltrować pod kątem konkretnego tematu, który mnie interesuje - np. „Błyszczące” lub „mruczenie” - posortowane według większości polubień lub większości retweetów.

Jednym z najłatwiejszych sposobów przeprowadzania tego rodzaju wyszukiwania i sortowania jest sortowanie w tabeli. DT jest jednym z popularnych pakietów do tego. Ale ostatnio eksperymentowałem z innym: reagującym. 

Wartość domyślna reactable()to rodzaj bla. Na przykład: 

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

biblioteka (reaktywna)

reaktywny (tweet_table_data)

Ten kod tworzy tabelę, która wygląda następująco:

Sharon Machlis,

Ale możemy dodać kilka dostosowań, takich jak:

reaktywny (tweet_table_data,

filtrowalny = PRAWDA, przeszukiwany = PRAWDA, obramowany = PRAWDA,

stripes = TRUE, highlight = TRUE,

defaultPageSize = 25, showPageSizeOptions = TRUE,

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

kolumny = lista (

created_at = colDef (defaultSortOrder = "asc"),

screen_name = colDef (defaultSortOrder = "asc"),

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

ulubione_count = colDef (filterable = FALSE),

retweet_count = colDef (filterable = FALSE),

urls_expanded_url = colDef (html = TRUE)

)

)

Rezultatem jest tabela, która wygląda mniej więcej tak:

Sharon Machlis,

Skonfiguruj tabelę danych, które można reagować 

W powyższym fragmencie kodu filterable = TRUEargument dodał filtry wyszukiwania poniżej każdego nagłówka kolumny i searchabledodał ogólne pole wyszukiwania tabeli w prawym górnym rogu. Włączanie bordered, stripedi highlightrobi to, co można się spodziewać: Dodaje obramowanie tabeli, dodaje koloru przemiennego rzędzie „paski” i podkreśla rzędu Jeśli umieścisz kursor na nim.

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.

Obejrzyj też odcinek bonusowy „Zrób więcej z R”, aby zobaczyć, jak zmienić tę aplikację śledzącą na Twitterze w interaktywną aplikację Shiny.

Aby uzyskać więcej wskazówek dotyczących języka R, przejdź na stronę Zrób więcej z R pod adresem //bit.ly/domorewithR lub listę odtwarzania Zrób więcej z R na kanale TECHtalk YouTube.