R для анализа хоккея - Часть 4: Stringr и RegEx

Это четвертая часть серии, в которой я покажу вам несколько способов использования R для анализа хоккейных данных. Если вы не видели первое руководство (установка R / RStudio и основы R), второе руководство (основы функций, конвейер (%>%) и структура ggplot2) или третье руководство ( некоторые важные функции dplyr), я думаю, было бы неплохо их проверить.

Вы можете щелкнуть здесь для Части 1, здесь для Части 2 и здесь для Части 3.

Перво-наперво, давайте установим и / или загрузим библиотеки, которые мы будем использовать. Мы будем использовать tidyvers, который, если вы не знакомы, представляет собой набор полезных пакетов R. stringr - один из таких пакетов.

Если вы не установили tidyverse, вы можете установить его, выполнив эту команду в консоли R Studio (нижний левый квадрант):

install.packages("tidyverse")

А чтобы загрузить tidyverse, мы можем использовать функцию library():

library(tidyverse)

stringr

stringr - это пакет для управления строками в R. Строки могут быть словами, предложениями, числами или чем угодно, заключенными в кавычки («»). Для наглядности напишем несколько строк на R.

Вы можете попробовать запустить их в своей консоли (левый нижний квадрант в R Studio) или в источнике (левый верхний квадрант в R Studio).

"Trevor Zegras is easily 3rd best prospect in the 2019 NHL draft" 
"1975"
"That's the last year the Flyers won the Stanley Cup"
"TRUE"
"."

Это все строки, так как они представляют собой текст в кавычках.

Так для чего stringr полезно? Кажется, что строки довольно просты, так зачем нужен весь пакет?

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

Самое замечательное в пакете stringr состоит в том, что он содержит десятки функций, позволяющих легко манипулировать этими строками.

Начнем с функции, которую я часто использую: str_replace().

str_replace

Цель str_replace() довольно интуитивно понятна; вы хотите заменить какую-то часть своей строки на что-то другое.

Представьте, что у нас есть строка с надписью "I love the New York Islanders". Это все хорошо, но проблема в том, что для большинства людей это неправда. Давайте заменим слово «островитяне» словом «рейнджеры».

Структура str_replace():

str_replace(string, pattern, replacement)

Таким образом, вы предоставляете функции строку, шаблон и замену, чтобы она работала. Помните, что чтобы увидеть, что вам нужно для работы функции, вы можете просмотреть документацию по этой функции, поставив вопросительный знак перед функцией и запустив его в R, чтобы получить страницу справки по этой функции
(например, запустить ?str_replace) .

Итак, строка здесь "I love the New York Islanders”. Мы хотим изменить шаблон, поэтому в данном случае это “Islanders”. Замена - это, в общем, замена. В данном случае замена “Rangers”.

Давай попробуем. Попробуйте запустить это в R Studio:

str_replace("I love the New York Islanders", "Islanders", "Rangers")

Вот что у вас должно получиться:

> str_replace("I love the New York Islanders", "Islanders", "Rangers")
[1] "I love the New York Rangers"

Вау. Ого. Это сработало - или, по крайней мере, должно было быть.

Что, если в строке вместо "I love the New York Islanders" написано "I love the New York Islanders, yes, the New York Islanders!"?

Ничего не изменится, правда? Давайте запустим это с той же настройкой, что и раньше (заменив "Islanders" на "Rangers").

> str_replace("I love the New York Islanders, yes, the New York Islanders!", "Islanders", "Rangers")
[1] "I love the New York Rangers, yes, the New York Islanders!"

Греа, подожди, не сработало. Первое появление "Islanders" было правильно изменено на "Rangers", а второе появление - нет.

Оказывается, когда вы используете str_replace(), вы можете изменить только первое вхождение того паттерна, который пытаетесь обнаружить и изменить. В некоторых случаях это полезно, но зачастую лучше изменить каждое вхождение, а не только первое.

str_replace_all

Давайте попробуем именно то, что мы только что сделали, но вместо использования str_replace() давайте использовать str_replace_all().

> str_replace_all("I love the New York Islanders, yes, the New York Islanders!", "Islanders", "Rangers")
[1] "I love the New York Rangers, yes, the New York Rangers!"

И… это работает.

Поэтому, если у вас может быть несколько экземпляров любого шаблона, который вы хотите изменить, лучше использовать str_replace_all(), а не str_replace().

Пока мы обнаружили и заменили только буквенные строки - "Islanders" и "Rangers" состоят только из буквенных символов. Обнаружение и замена числовых строк - это то же самое, что обнаружение и замена буквенных строк, но все становится немного сложнее, когда мы пытаемся обнаружить строки, содержащие такие символы, как круглые скобки, вопросительные знаки и другие не буквенно-цифровые символы.

RegEx

RegEx означает Reg ular Ex pression, которое используется для обнаружения шаблонов и символов в тексте. Технически вы использовали RegEx при использовании str_replace() и str_replace_all() для поиска экземпляров "Islanders".

RegEx… странно. Не верите мне? Вот строка R RegEx для определения последнего появления левой круглой скобки (() в строке:

"\\((?=[^(]*$)"

Если вы не понимаете, что все это значит, значит, вам повезло. А может, тебе не повезло, о чем, честно говоря, я тоже не имею представления.

Последние мысли

Что ж, надеюсь, вам понравился этот урок. Я вернусь с другим примерно через 19 месяцев.

Я просто шучу

Я немного знаю RegEx и, вероятно, достаточно, чтобы научить вас достаточно, чтобы начать работу.

Вернуться к RegEx

Давайте воспользуемся str_replace_all() для замены экземпляров "?" пробелом " " в строке "Lias?Andersson".

Мы можем использовать ту настройку, которая была у нас ранее. Попробуй это:

str_replace_all("Lias?Andersson", "?", " ")

И запустив это, мы должны получить ni ... боже мой, это страшная ошибка.

> str_replace("Lias?Andersson", "?", " ")
Error in stri_replace_first_regex(string, pattern, fix_replacement(replacement),  : 
  Syntax error in regexp pattern. (U_REGEX_RULE_SYNTAX)

Что случилось? Ну, как правило, не буквенно-цифровые символы (символы, которые не являются ни цифрами, ни буквами) обрабатываются в RegEx по-другому. Они немного… особенные.

Специальные персонажи и побеги

В RegEx некоторые символы, такие как "?", считаются «специальными символами». Чтобы обнаруживать специальные символы с помощью RegEx в R, нам нужно «экранировать» эти специальные символы двумя обратными косыми чертами ("\\") перед специальным символом.

Почему это две обратные косые черты? Честно говоря, понятия не имею.

Давайте попробуем еще раз, но с обратной косой чертой:

str_replace_all("Lias?Andersson", "\\?", " ")

Надеюсь, ваш результат будет выглядеть так:

> str_replace_all("Lias?Andersson", "\\?", " ")
[1] "Lias Andersson"

Потрясающие.

А теперь вот мое практическое правило использования двойных обратных косых черт - я помещаю их перед любыми не буквенно-цифровыми символами в моем шаблоне RegEx. Это означает, что вам нужны символы, включая кавычки, запятые и знаки препинания. Вам не всегда нужны двойные обратные косые черты, но их наличие не повредит вам. Также обратите внимание, что для обнаружения обратной косой черты вам понадобятся 4 обратной косой черты ("\\\\").

Давайте быстро резюмируем то, что мы узнали.

• stringr и его назначение
• str_replace()
• str_replace_all() и насколько он [в целом] полезнее, чем str_replace()
• RegEx и что это такое
• Специальные символы и escape-символы ("\\")

Еще немного RegEx

У RegEx много «кодов». Давайте просто рассмотрим их несколько:

• [A-Z]

Любые буквы в верхнем регистре

• [a-z]

Любые буквы в нижнем регистре

• [A-Za-z]

Любые буквенные символы (независимо от регистра)

Теперь имейте в виду, что квадратные скобки вокруг этих кодов необходимы. Давайте попробуем некоторые из них, заменив каждый узор пробелом (" ").

> str_replace_all("austen Keating is good", "[A-Z]", " ")
[1] "austen  eating is good"
> str_replace_all("PHILIP TOMASINO IS gREAT", "[a-z]", " ")
[1] "PHILIP TOMASINO IS  REAT"
> str_replace_all("I used to wear number 87 before Crosby was a thing", "[A-Za-z]", " ")
[1] "                      87                          "

Имеет ли это смысл? Если нет, сделайте еще один шанс.

Позже мы рассмотрим еще несколько кодов RegEx, но давайте поговорим о нескольких важных stringr функциях.

str_split

Допустим, у вас есть строка Sidney Crosby (Center).

В этой строке есть две части информации, которые могут вам понадобиться: имя (Sidney Crosby) и позиция (Center).

Мы не можем использовать здесь str_replace() или str_replace_all(), поскольку замена шаблонов нам не поможет. Вместо этого нам нужно разделить строку так, чтобы у нас были две отдельные части, которые нужны.

Где мы должны разделить строку? Иногда на этот вопрос сложно ответить. Здесь есть несколько вариантов разделения:

• Разделить на определенную букву ("r", "C", etc.)
• Разделить на заглавную или строчную букву ("[A-Z]" или "[a-z]")
• Разделить слова через пробел (" " или, если хотите, "\\s")
• Разделить в левой скобке ("\\(")

Когда я парсю веб-страницу, я задаю этот вопрос как минимум дюжину раз. Это может быть сложно.

Как правило, вы хотите выбрать уникальный шаблон, чтобы разделение строки всегда было предсказуемым и не происходило в каком-то неожиданном месте в строке. В этом случае похоже, что левая скобка - лучшее место для разделения строки.

Итак, приступим. Вот структура функции str_split():

str_split(string, pattern, n = Inf, simplify = FALSE)

Эта настройка для str_split() немного сложнее, чем для str_replace() и str_replace_all(), но мы уже знакомы с первыми двумя аргументами (string и pattern).

Все, что вам технически нужно для предоставления функции, - это строка (Sidney Crosby (Center)) и шаблон ("\\(") - остальные аргументы необязательны.

str_split("Sidney Crosby (Center)", "\\(")

Вот результат:

> str_split("Sidney Crosby (Center)", "\\(")
[[1]]
[1] "Sidney Crosby " "Center)"

Ух ты, фантастика!

Сейчас там много [] и [[]], но нам не нужно беспокоиться о них прямо сейчас.

Давайте попробуем еще один пример, чтобы проиллюстрировать, насколько важны другие аргументы функции (n и simplify); предположим, что строка, которую мы хотим разделить, находится в обратном порядке, сначала позиция в круглых скобках, а затем имя. Здесь строка будет "(Right Wing) George (Bud) Holloway”, где позиция - "Right Wing", а имя - "George (Bud) Holloway".

Так что же по-другому? Что ж, на этот раз мы разделяем по правой скобке вместо левой, так как мы хотим, чтобы все "Right Wing" отделились. Но нам нужно быть осторожными, так как есть две круглые скобки - одна перед "Right Wing" и одна перед "Bud".

Bud отличный, но мы не хотим разделять "Bud".

Давайте попробуем разделить это так же, как и раньше, только заменив левую скобку ("\\(") на правую скобку ("\\)").

str_split("(Right Wing) George (Bud) Holloway", "\\)")

Вот результат:

> str_split("(Right Wing) George (Bud) Holloway", "\\)")
[[1]]
[1] "(Right Wing"  " George (Bud" " Holloway"

Хорошо, это… не сработало. Я имею в виду, это сработало; он разбивает строку по правой скобке, но разбивает строку по всем экземплярам правой скобки, а не по первому.

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

Итак, вместо трех частей, которые были возвращены автоматически, нам нужны только две.

> str_split("(Right Wing) George (Bud) Holloway", "\\)", n = 2)
[[1]]
[1] "(Right Wing"            " George (Bud) Holloway"

Большой. И аргумент simplify в функции немного сложнее понять, если он вам не нужен, но, если вы укажете simplify = TRUE, функция вернет части в виде матрицы (в основном фрейм данных, но немного другой), а не список векторов символов. Если вы не знаете, что это значит, не беспокойтесь об этом, но я почти всегда указываю simplify = TRUE.

Давайте попробуем еще раз, но с simplify = TRUE:

> str_split("(Right Wing) George (Bud) Holloway", "\\)", n = 2, simplify = TRUE)
     [,1]          [,2]                    
[1,] "(Right Wing" " George (Bud) Holloway"

Почему это полезно? Представим, что у нас есть фрейм данных (в данном случае tibble), где строка, которая у нас есть, "(Right Wing) George (Bud) Holloway", и мы хотим создать 2 новых столбца для name и position.

Если мы хотим выбрать только одну из вновь разделенных частей, мы можем указать, какую часть, используя [,1] или [,2], как показано в выходных данных.

[,] технически означает [rows, columns], поэтому, написав [,1], вы говорите «выберите каждую строку и только столбец 1». Сказать [1,] будет означать «выбрать только строку 1 и каждый столбец».

Давайте поиграемся с этим, чтобы мы были знакомы, поскольку это пригодится через минуту. Попробуйте запустить это:

str_split("(Right Wing) George (Bud) Holloway", "\\)", n = 2, simplify = TRUE)[,1]

Что вы получаете?

> str_split("(Right Wing) George (Bud) Holloway", "\\)", n = 2, simplify = TRUE)[,1]
[1] "(Right Wing"

Итак, когда вы указываете [,1] после функции, вы говорите R выбрать только первую часть разделения. Указание [,2] аналогичным образом выберет вторую часть разделения.

Итак, давайте начнем с создания этого tibble, чтобы иметь хороший фрейм данных с именами и должностями. Для этого мы используем функцию tibble() с столбцом, который мы хотим создать там. Назовем столбец string с единственным значением "(Right Wing) George (Bud) Holloway".

> tibble(string = "(Right Wing) George (Bud) Holloway")
# A tibble: 1 x 1
  string                            
  <chr>                             
1 (Right Wing) George (Bud) Holloway

Большой. Теперь, если вы помните, в двух предыдущих руководствах я говорил о канале (%>%) и о том, как он может упростить написание и чтение кода. По сути, если вы не помните, это способ сказать «а потом сделай это».

Я говорю об этом потому, что нам нужно создать два новых столбца - name и position, используя str_split() в функции из dplyr под названием mutate(). Об этом читайте здесь, если вы забыли про mutate().

В любом случае, это будет базовая структура (с кодом вместо …):

tibble(string = "(Right Wing) George (Bud) Holloway") %>%
  mutate(name = ...) %>%
  mutate(position = ...)

Что такое name в этой ситуации? Что ж, name - это то, что происходит после 1-й правой круглой скобки (конечно, с некоторой очисткой впоследствии). Таким образом, мы получаем name от использования str_split(). Давай попробуем.

Теперь помните, что мы собираемся использовать simplify = TRUE, чтобы преобразовать возвращенные элементы в форму, которой легко манипулировать в mutate(). Мы также собираемся указать n = 2, так как нам нужно вернуть только 2 части: position и name.

Хорошо, вот код для name:

tibble(string = "(Right Wing) George (Bud) Holloway") %>%
  mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2])

И вот результат:

> tibble(string = "(Right Wing) George (Bud) Holloway") %>%
+     mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2])
# A tibble: 1 x 2
  string                             name                    
  <chr>                              <chr>                   
1 (Right Wing) George (Bud) Holloway " George (Bud) Holloway"

Ух ты! Это сработало! Теперь нужно немного подправить name, так как перед словом «Джордж» есть пробелы, но я расскажу об этом позже. Теперь давайте возьмем столбец для position.

Вот код для position в дополнение к предыдущему коду:

tibble(string = "(Right Wing) George (Bud) Holloway") %>%
  mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
  mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1])

Вот результат:

> tibble(string = "(Right Wing) George (Bud) Holloway") %>%
+     mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
+     mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1])
# A tibble: 1 x 3
  string                       name                position  
  <chr>                        <chr>               <chr>     
1 (Right Wing) George (Bud) H~ " George (Bud) Hol~ (Right Wi~

Это немного сложно увидеть здесь (хотя вы, вероятно, сможете лучше увидеть это в собственном сеансе R Studio), поэтому давайте используем select() из dplyr для удаления string и увидим только name и position:

> tibble(string = "(Right Wing) George (Bud) Holloway") %>%
+     mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
+     mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1]) %>%
+     select(name, position)
# A tibble: 1 x 2
  name                     position   
  <chr>                    <chr>      
1 " George (Bud) Holloway" (Right Wing

Большой. Честно говоря, это невероятно. Мы начали с довольно беспорядочной строки (“(Right Wing) George (Bud) Holloway”) и превратили ее в более удобные столбцы.

Но мы еще не закончили.

Обратите внимание на левую скобку в position? Давай избавимся от этого. Мы могли бы разделить строку после этой круглой скобки, как мы только что сделали, и остаться с "Right Wing", но давайте вернемся к str_replace_all(). Мы можем заменить левую скобку пустой строкой "", которая, по сути, удалит левую скобку. И мы могли бы использовать mutate(), как мы использовали старый столбец position для создания нового столбца, также называемого position, с удаленной левой скобкой.

Давайте попробуем это:

tibble(string = "(Right Wing) George (Bud) Holloway") %>%
  mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
  mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1]) %>%
  select(name, position) %>%
  mutate(position = str_replace_all(position, "\\(", ""))

Вот результат:

> tibble(string = "(Right Wing) George (Bud) Holloway") %>%
+     mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
+     mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1]) %>%
+     select(name, position) %>%
+     mutate(position = str_replace_all(position, "\\(", ""))
# A tibble: 1 x 2
  name                     position  
  <chr>                    <chr>     
1 " George (Bud) Holloway" Right Wing

Потрясающие. Это сработало. Еще одно - в name перед словом «Джордж» стоит пробел. Давай уберем это. Это пространство называется «пробелом», и есть несколько способов его удалить. Технически вы можете использовать str_split() для разделения строки после первого экземпляра пробела. Вы также можете использовать str_replace() для замены первого пробела пустой строкой (""). Вместо этого давайте попробуем другую функцию из stringr под названием str_squish().

str_squish

str_squish() делает то, что вы думаете; он сжимает струну.

Если есть начальный пробел (" George") или конечный пробел ("Holloway "), этот пробел будет удален. Эта функция также может заменять несколько пробелов и / или разрывы строк HTML (включая "\n" и "\t") одним пробелом.

Мы можем использовать str_squish(), чтобы «сжать» строку и удалить пробелы в " George".

Мы можем использовать ту же настройку, которую мы использовали, и mutate() наш name столбец с новым name столбцом, который использует str_squish().

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

tibble(string = "(Right Wing) George (Bud) Holloway") %>%
  mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
  mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1]) %>%
  select(name, position) %>%
  mutate(position = str_replace_all(position, "\\(", "")) %>%
  mutate(name = str_squish(name))

Вот результат:

> tibble(string = "(Right Wing) George (Bud) Holloway") %>%
+     mutate(name = str_split(string, "\\)", n = 2, simplify = TRUE)[,2]) %>%
+     mutate(position = str_split(string, "\\)", n = 2, simplify = TRUE)[,1]) %>%
+     select(name, position) %>%
+     mutate(position = str_replace_all(position, "\\(", "")) %>%
+     mutate(name = str_squish(name))
# A tibble: 1 x 2
  name                  position  
  <chr>                 <chr>     
1 George (Bud) Holloway Right Wing

Ух ты! Все это сработало. Теперь у нас есть красивый, аккуратный фрейм данных (в данном случае tibble). Отличная работа, все.

Итак, материала было много. Пожалуйста, сделайте перерыв, если вам нужно. На самом деле, вам, вероятно, стоит сделать перерыв, даже если в этом нет необходимости.

Давайте быстро вернемся к тому, что мы узнали.

• stringr и его назначение
• str_replace() для замены узоров
• str_replace_all() и насколько он [в целом] полезнее, чем str_replace()
• RegEx и что это такое
• Специальные символы и escape-символы ("\\")
• Код RegEx для определения строчных букв "[a-z]"
• Код RegEx для определения заглавных букв "[A-Z]"
• RegEx-код для распознавания букв любого регистра "[A-Za-z]"
• str_split() для разделения строк по некоторому шаблону
• str_split() и его аргументы (включая n и simplify)
• str_squish() для удаления пробелов в строках
• Использование str_split() и других функций в mutate()

Еще немного RegEx

Давайте рассмотрим еще несколько кодов RegEx.

• [0-9]

Любые однозначные числа от 0 до 9

• [0-9]{2,3}

Минимальное и максимальное количество символов для поиска в шаблоне (выделенная жирным шрифтом).

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

Идея состоит в том, что вы помещаете числа в фигурные скобки сразу после шаблона в квадратных скобках ([0-9] в данном случае).

Давайте еще раз посмотрим на этот код:

[0-9]{2,3}

Для чего там двойки и тройки? Ну, 2 указывает минимальное количество шаблонов для обнаружения. Это означает, что шаблон будет обнаружен только при наличии минимум 2 цифр от 0 до 9. Число 3 указывает максимальное количество шаблонов для обнаружения. Это означает, что шаблон будет обнаруживать только при наличии максимум 3 цифр от 0 до 9.

Сложите их вместе, и вы получите код RegEx, который обнаруживает шаблон только при наличии минимум 2 и максимум 3 цифр от 0 до 9 подряд. Другими словами, если есть одна цифра от 0 до 9, она не будет обнаружена. Если в строке 4 цифры, будут обнаружены только первые 3. Если в строке 2 цифры, все они будут обнаружены, а если есть 3 цифры в строке, все они будут обнаружены. Надеюсь, вы поняли идею.

Давайте воспользуемся функцией stringr, чтобы лучше понять, как это работает.

str_match

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

Давай попробуем.

str_match("Connor McMichael", "Mc")

Вот результат:

> str_match("Connor McMichael", "Mc")
     [,1]
[1,] "Mc"

Хорошо, довольно просто. Вот еще несколько, чтобы разобраться в этом:

str_match("Connor McMichael", "[A-Z]")
str_match("The Great 8", "[0-9]")
str_match("#YearOfTheEgor", "\\#")

Вот результат:

> str_match("Connor McMichael", "[A-Z]")
     [,1]
[1,] "C" 
> str_match("The Great 8", "[0-9]")
     [,1]
[1,] "8" 
> str_match("#YearOfTheEgor", "\\#")
     [,1]
[1,] "#"

Вы уловили идею. Функция вернет первое совпадение, найденное в строке. Теперь давайте попробуем, что мы узнали о минимумах и максимумах с {}.

str_match("The Flyers last won the cup in 1975", "[0-9]{1,1}")

Как вы думаете, чего требует шаблон в RegEx, прежде чем запустить его?

Там "[0-9]", значит, это что-то вроде числа, а там "{1,1}", что означает, как минимум, 1 экземпляр цифры и как максимум 1 экземпляр цифры.

Посмотрим на результат:

> str_match("The Flyers last won the cup in 1975", "[0-9]{1,1}")
     [,1]
[1,] "1"

Это хорошо! Это то, что мы ожидали - совпадение совпадало с первым и единственным появлением цифры.

Давайте попробуем еще раз, но давайте изменим максимум 1 на максимум 2.

> str_match("The Flyers last won the cup in 1975", "[0-9]{1,2}")
     [,1]
[1,] "19"

Как и ожидалось, он вернул максимальное количество цифр, 2. Давайте попробуем еще раз, но вместо того, чтобы устанавливать максимум, давайте сделаем максимальное бесконечным. Мы можем сделать это, оставив максимальное поле пустым.

> str_match("The Flyers last won the cup in 1975", "[0-9]{1,}")
     [,1]
[1,] "1975"

Большой. И, чтобы нам было понятно, этот модификатор минимума и / или максимума можно использовать для любого кода RegEx, включая цифры, числа и специальные символы.

Вот пример этого:

> str_match("The Flyers last won the cup in 1975", "[A-Za-z]{4,}")
     [,1]
[1,] "Flyers"

Ладно все, думаю, этого достаточно stringr для одной статьи.

Последние мысли

Давайте совершим еще одно путешествие по переулку памяти и подведем итоги тому, что мы узнали:

• stringr и его назначение
• str_replace() для замены узоров
• str_replace_all() и насколько он [в целом] полезнее, чем str_replace()
• RegEx и что это такое
• Специальные символы и escape-символы ("\\")
• Код RegEx для определения строчных букв "[a-z]"
• Код RegEx для определения заглавных букв "[A-Z]"
• Код RegEx для распознавания букв любого регистра "[A-Za-z]"
• str_split() для разделения строк по некоторому шаблону
• str_split() и его аргументы (включая n и simplify)
• str_squish() для удаления пробелов в строках
• Использование str_split() и других функций в mutate()
• Код RegEx для определения чисел "[0-9]"
• Код RegEx для минимального и максимального количества символов (например, "{1,1}")
• str_match() для сопоставления шаблонов и возврата сопоставленных шаблонов

В любом случае, вот и все! Я буду размещать все свои руководства в Твиттере (@OppenheimerEvan). Если у вас есть какие-либо вопросы, свяжитесь со мной по этому адресу или напишите мне по адресу [email protected].

Вы можете щелкнуть здесь для Части 1, щелкнуть здесь для Части 2 и щелкнуть здесь для Части 3.