Строки

Строки

• Строки - один из ключевых объектов в любом языке программирования

• В реальных данных могут встречаться строковые данные
  

• Оперирование именами в подразделах датафрейма - суть, работа со строкой

Итак Строка:
* Строка (string) - элемент вектора типа character
* Большинство функций, оперирующих на строках, векторизированы

s <- c("Терпение и труд все перетрут",
       "Кончил дело - гуляй смело",
       "Без труда не вытащишь и рыбку из пруда",
       "Работа не волк, в лес не убежит")
s

[1] "Терпение и труд все перетрут"          
[2] "Кончил дело - гуляй смело"             
[3] "Без труда не вытащишь и рыбку из пруда"
[4] "Работа не волк, в лес не убежит"       

• Для объявления о начале строки используются знаки " или *‘* - в коде их лучше не мешать, смешивание может пригодится в случае по типу ’Операция “Ы”’. Тогда для корректного выведения нужно экранировать внутренние кавычки бэкслешем

eg <- 'Операция \"Ы\"'
eg

[1] "Операция \"Ы\""

Экранирование помогает отличать открывающие и закрывающие кавычки

Функция paste/paste0

• Выполнябт конкатенацию строковых векторово с учеом правил переписывания
  
• Аргумент sep - разделитель между элементами (для paste по умолчанию пробел, для paste0 - пустая строка)
  
• Аргумент collapse - “схлопывает” вектор в одну строку

Пример 1

paste

function (..., sep = " ", collapse = NULL) 
.Internal(paste(list(...), sep, collapse))
<bytecode: 0x000002148c329e68>
<environment: namespace:base>

paste(c("углексилый", "веселящий"), "газ")

[1] "углексилый газ" "веселящий газ" 

paste0

function (..., collapse = NULL) 
.Internal(paste0(list(...), collapse))
<bytecode: 0x000002148c14e988>
<environment: namespace:base>

paste0(c("углексилый", "веселящий"), "газ")

[1] "углексилыйгаз" "веселящийгаз" 

paste(c("прокариотическая", "эукариотическая"), "клетка")

[1] "прокариотическая клетка"
[2] "эукариотическая клетка" 

paste("зачем", "тебе", "data science?")

[1] "зачем тебе data science?"

paste0("зачем", "тебе", "data science?")

[1] "зачемтебеdata science?"

Пример 2 - аргумент sep

paste(c("веселящий", "углекислый"), "газ", sep = "_")

[1] "веселящий_газ"  "углекислый_газ"

Есть ли разница с paste0, если задать такой же аргумент sep?

paste0(c("веселящий", "углекислый"), "газ", sep = "_")

[1] "веселящийгаз_"  "углекислыйгаз_"

Да, он всопроизвел *_* как часть строки в конце. По итогу, paste0 – это paste с аргументом sep = ""

Функция strsplit - разбиение

• Выполняет разбиение строкового вектора
  
• Результат - список

strsplit

function (x, split, fixed = FALSE, perl = FALSE, useBytes = FALSE) 
.Internal(strsplit(x, as.character(split), fixed, perl, useBytes))
<bytecode: 0x000002148c3780c8>
<environment: namespace:base>

N.B! Обрати внимание, что пробелы, заключенные в кавычки, несут смысловую нагрузку…

strsplit(s," и ", fixed = TRUE)

[[1]]
[1] "Терпение"         
[2] "труд все перетрут"

[[2]]
[1] "Кончил дело - гуляй смело"

[[3]]
[1] "Без труда не вытащишь"
[2] "рыбку из пруда"       

[[4]]
[1] "Работа не волк, в лес не убежит"

…иначе разбиение шло бы еще и внутри слов

strsplit(s,"и", fixed = TRUE)

[[1]]
[1] "Терпен"            
[2] "е "                
[3] " труд все перетрут"

[[2]]
[1] "Конч"                
[2] "л дело - гуляй смело"

[[3]]
[1] "Без труда не вытащ"
[2] "шь "               
[3] " рыбку "           
[4] "з пруда"           

[[4]]
[1] "Работа не волк, в лес не убеж"
[2] "т"                            

Аргумент fixed
Если его не указывать (по умолчанию FALSE), то строка по которой проводится разбиение, будет рассматриваться как регулярное выражение. Про регулярные выражения дальше. Вообще это важный аспект любого языка программироания
Пример
Используем группу, в которой содержатся все знаки препинания. Без агумента fixed, группа воспринимается как регулярное выражение и разбиение происходит по всем знакам препинания.

strsplit(s, "[[:punct:]]")

[[1]]
[1] "Терпение и труд все перетрут"

[[2]]
[1] "Кон"          "ил дело "    
[3] " гуляй смело"

[[3]]
[1] "Без труда не вытащишь и рыбку из пруда"

[[4]]
[1] "Работа не волк"   " в лес не убежит"

Регулярные выражения

• “Метаязык” поиска и манипуляции подстроками, который работает сходным образом во всех языках программирования с некоторыми нюансами
  
• Так сделано, потому что работа со строками сложная часть программирования, которая требовала некооторой достройки, для того, чтобы с ней комфортно рабоать
  
• Образец для поиска может включать обычные символы и т.н. wildcards
  Идея такая - есть строка, в которой нужно заменить выражение. Есть специальные функции низкоуровнего доступа к регулярным выражениям
  **Пример 1 - находим вхождение строк*

grep("труд", s)

[1] 1 3

Пример 2 - находим наличие вхождение по строкам

grepl("труд", s)

[1]  TRUE FALSE  TRUE FALSE

Пример 3 - сложное регулярное выражение

# Аргумент 1 - находим шаблон
# Аругмент 2 - на что заменяем шаблон  
# Аргумент 3 - где ищем и заменяем
gsub("\\b[[:alpha:]][4,5]\\b", "####", s )

[1] "Терпение и труд все перетрут"          
[2] "Кончил дело - гуляй смело"             
[3] "Без труда не вытащишь и рыбку из пруда"
[4] "Работа не волк, в лес не убежит"       

У меня работает не корректно. Возможно проблема с локалью, нужно будет перепроверить на линуксе. На винде не знаю, как поправить

Пакет stringr

Работа со строками с низкоуровневыми функциями не всегда удобна. На помощь, как всегда, приходят пакеты. Удобный пакет для работы со строками - stringr

#install.packages("stringr")
library(stringr)

В пакете множество функций для работы со строками. Функции пакета векторизованы, а также они consistent (последовательны)
В чем же состоит consistency (последовательность)?:
* все функции именуются сходным образом (все начинаются с str)
* похожий порядок аргументов
* возвращают результатым единообразным способом

str_extract(s, "н.")

[1] "ни" "нч" "не" "не"

В таком варианте возвращается только первое вхождение

str_replace(s, "[иа]", "?")

[1] "Терпен?е и труд все перетрут"          
[2] "Конч?л дело - гуляй смело"             
[3] "Без труд? не вытащишь и рыбку из пруда"
[4] "Р?бота не волк, в лес не убежит"       

Почти ко всем функциям пакета можно добавить аргумент *_all*, тогда будут возвращаться все вхождения, а не только первое

str_extract_all(s, "н.")

[[1]]
[1] "ни"

[[2]]
[1] "нч"

[[3]]
[1] "не"

[[4]]
[1] "не" "не"

str_replace_all(s, "[иае]", "?")

[1] "Т?рп?н?? ? труд вс? п?р?трут"          
[2] "Конч?л д?ло - гуляй см?ло"             
[3] "Б?з труд? н? выт?щ?шь ? рыбку ?з пруд?"
[4] "Р?бот? н? волк, в л?с н? уб?ж?т"       

Возвращаемся к базовому R

Функции tolower/touper

Манипулирование регистром в верхний и нижний регистр. Возьмем стандартный массив данных месяцев

month.name

 [1] "January"   "February"  "March"    
 [4] "April"     "May"       "June"     
 [7] "July"      "August"    "September"
[10] "October"   "November"  "December" 

#
month.abb

 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun"
 [7] "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

tolower(month.name)

 [1] "january"   "february"  "march"    
 [4] "april"     "may"       "june"     
 [7] "july"      "august"    "september"
[10] "october"   "november"  "december" 

toupper(month.abb)

 [1] "JAN" "FEB" "MAR" "APR" "MAY" "JUN"
 [7] "JUL" "AUG" "SEP" "OCT" "NOV" "DEC"

Обрати внимание, что если к строке сначала применить toupper, а потом tolower, то результатом не обязательно будет исходная строка

Когда это может пригодится?
Пригодится может в задачах, где ожидаются входные данные от пользователя или сети, т.е. могут прийти на вход данные разного формата, например “ExIT”, “coPy” и как проверить что “ExIT” это “exit”, вот тут помогут tolower или toupper. Ещё может быть что у вас в базе свойство некоторого объекта записано в нижнем регистре, а ответ от сервера с json, где то же поле, но в верхнем регистре, а вам нужно все это дело смаппить

На что еще обратить внимание при работе со строками

Что будет, если мы посмотрим длину следующей строки?

length("Аэрофотосъёмка ландшафта уже выявила земли богачей и процветающих крестьян.")

[1] 1

Тому, кто знаком со структурой R - вывод функции length в данном случае понятен, фактически мы получаем ответ на вопрос, “а сколько здесь строк?”

Чтобы получить длину (т.е. количество символов) строки в базовом R есть функция nchar

nchar("Аэрофотосъёмка ландшафта уже выявила земли богачей и процветающих крестьян.")

[1] 75

При этом, если применить nchar к NA, то получим…

nchar(NA)

[1] NA

В функции из ответа есть логический аргумент keepNA, который сейчас по умолчанию принимает значение TRUE, а раньше (в R <=3.2.0), судя по справке, принимал значение FALSE. И возвращалось 2

Глоссарий

Функции:
* ?paste, ?paste0, ?strsplit
* ?grep, ?grepl, ?gsub
* library(stringr): ?str_extract, ?str_replace, +_all
* ?tolower, ?toupper

Задача

library(stringr)

hamlet <- "To be, or not to be: that is the question:
Whether 'tis nobler in the mind to suffer
The slings and arrows of outrageous fortune,
Or to take arms against a sea of troubles,
And by opposing end them?"

hamlet <- str_replace_all(hamlet, "[:punct:]", "")
hamlet

[1] "To be or not to be that is the question\nWhether tis nobler in the mind to suffer\nThe slings and arrows of outrageous fortune\nOr to take arms against a sea of troubles\nAnd by opposing end them"

hamlet <- tolower(unlist(str_split(hamlet, "[:space:]")))
hamlet

 [1] "to"         "be"         "or"         "not"        "to"         "be"         "that"       "is"        
 [9] "the"        "question"   "whether"    "tis"        "nobler"     "in"         "the"        "mind"      
[17] "to"         "suffer"     "the"        "slings"     "and"        "arrows"     "of"         "outrageous"
[25] "fortune"    "or"         "to"         "take"       "arms"       "against"    "a"          "sea"       
[33] "of"         "troubles"   "and"        "by"         "opposing"   "end"        "them"      

Вопросы?
* Количество слов to

?str_extract
str_count(hamlet, "to")

 [1] 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0

sum(str_count(hamlet, "to"))

[1] 4

или
находим непосредственно номера строк

grep("to", hamlet, fixed = TRUE)

[1]  1  5 17 27

или

hamlet[grep("to", hamlet, fixed = TRUE)]

[1] "to" "to" "to" "to"

• Количество слов, содержаших любую букву из f,q,w

sum(str_count(hamlet, "[fwq]+"))

[1] 7

Насчитал вручную 8, но что-то не так, где-то, кажется, есть повтор * Количество слов, содержащих букву b, после которой - любой другой символ

str_count(hamlet, "[b.]")

 [1] 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0

sum(str_count(hamlet, "[b.]"))

[1] 5

• Количество слов ровно из семи букв

sum(str_count(hamlet, "^[a-z]{7}$"))

[1] 3

Быстро разобраться с регулярными выражениями поможет https://regexone.com/lesson/introduction_abcs

Подробнее можно почитать: “Фридл - Регулярные выражения”