This repository has been archived by the owner on Apr 28, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 0
/
06_working_with_strings.Rmd
415 lines (240 loc) · 19.7 KB
/
06_working_with_strings.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
# Working with Strings
### Strings review
Strings were introduced in an earlier lesson; however, to review briefly here:
> A string is a sequence of characters, letters, numbers or symbols.
So within R, you could create a string using this syntax. Note that the string begins and ends with quotation marks:
```r
stringA <- "This sentence is a string."
```
Multiple strings can be stored within vectors. So, if you have multiple vectors that you want to store in a single object, you could do so by using c() around the strings you want to store and commas to separate each individual string:
```r
objectA <- c( "This sentence is a string.", "Short String", "Third string" )
```
### stringr
[stringr](http://stringr.tidyverse.org/) is a package within the [tidyverse](https://www.tidyverse.org/) specifically designed to work well with strings. All functions within this package start with `str_`, as you'll see below. There are *many* helpful functions within the stringr package. We'll only review the basics here, but if you're looking to accomplish something with a string and aren't sure how to approach it, the stringr package is a good first place to look. To install and load the stringr package, you'll use the following:
```r
# If not already installed, you'll need to install the package
install.packages("stringr")
# load package into R
library(stringr)
```
The best way to work through this lesson is to copy and paste every line of code into your RStudio window and see if the output makes sense to you. Working with strings and regular expressions is best learned by practice.
#### Available functions
As we'll only cover a few of the functions within stringr in this lesson, it's important to remember that if you start typing "str_" within RStudio, a list of the many options will show up.
### String basics
When working with strings, some of the most frequent tasks you'll need to complete are to:
* determine the length of a string
* combine strings together
* subset strings
#### String length
Returning to our object with three strings from earlier in the lesson, we can determine the length of each string in the vector.
```r
objectA <- c( "This sentence is a string.", "Short String", "Third string" )
str_length(objectA)
```
Here we see that the first string has a length of 26. If you were to go back and count the characters in the first string, you would see that this 26 includes each letter, space, and period in that string. The length of a string does not just could the letters in its length. The length includes every character. The second and third strings each have length 12.
#### Combining strings: `str_c()`
If you were interested in combining strings, you'd want to use `str_c`.
```r
str_c( "Good", "Morning")
```
However, the output from this doesn't look quite right. You may want a space between these two words when you combine the two strings. That can be controlled with the `sep` argument.
```r
str_c( "Good", "Morning", sep=" ")
```
#### Subsetting strings: `str_sub()`
Often, it's important to get part of a string out. To do this, you'll want to subset the string using the `str_sub()` function. For example, if you wanted only the first three characters in the string below, you would specify that within `str_sub()`.
```r
object <- c( "Good", "Morning")
str_sub(object, 1, 3)
```
You can also use negative numbers to count from the end of the string. For example, below we see code that returns the last three positions in the string.
```r
object <- c( "Good", "Morning")
str_sub(object, -3, -1)
```
#### String sorting: `str_sort()`
Finally, if you wanted to sort a string alphabetically, `str_sort()` can help you accomplish that.
```r
names <- c("Keisha", "Mohammed", "Jane")
str_sort(names)
```
### Regular expressions
Above we discuss the basics of working with strings within `stringr`. However, working with strings becomes infinitely easier with an understanding of regular expressions. Regular expressions (regexps) are used to **describe patterns within strings**. They can take a little while to get the hang of but become very helpful once you do. With regexps, instead of specifying that you want to extract the first three letters of a string (as we did above), you could more generally specify that you wanted to extract all strings that start with a specific letter or that contain a specific word somewhere in the string using regexps. We'll explore the basics of regexps here.
The use them in `stringr`, the general format is `function(string , pattern = regexp)`, which you'll see used in practice below. The set of functions from `stringr` we'll cover are listed below
We'll cover a number of helpful `stringr` functions:
* **str_view()** - View the first occurrence in a string that matches the regex
* **str_view_all()** - View all occurrences in a string that match the regex
* **str_count()** - count the number of times a regex matches within a string
* **str_detect()** - determine if regex is found within string
* **str_subset()** - return subset of strings that match the regex
* **str_extract()** - return portion of each string that matches the regex
* **str_replace()** - replace portion of string that matches the regex with something else
#### Anchors
If interested in finding a pattern at the beginning (`^`) or end (`$`) of a string, you can specify that using a regexp. For example, if you wanted to only look at names that started with the letter "M", you would specify that using a regexp. The pattern you would include would be `"^M"` to identify all strings that start with the letter M. To specify those strings that end with a capital M, you would specify the pattern `"$M"`.
#### Show matches: str_view()
To get comfortable with using regexps with strings, `str_view()` can be very helpful. The output from `str_view()` highlights what portion of your string match the pattern specified in your regexp with a gray box. For example, to we'll start using anchors and `str_view()` below:
```r
names <- c("Keisha", "Mohammed", "Jane", "Mathieu")
## identify strings that start with "M"
str_view(names, "^M")
```
In this first example we see in the Viewer Panel that str_view has identified the names that start with the letter M.
However, if you try to match strings that end with the letter "M", no match is found.
```r
## identify strings that end with "M"
str_view(names, "M$")
```
To identify names by that end with the letter "a", you would use the following.
```r
## identify strings that end with "a"
str_view(names, "a$")
```
Note, however, that regexps are case sensitive. To match patterns, you have to consider that "A" and "a" are different characters.
```r
## identify strings that end with "A"
str_view(names, "A$")
```
#### Count matches: `str_count()`
To count the number of matches within your strings, you would use `str_count()`. Below, using the names vector we've been using, we see that `str_count()` produces a 1 for those names that start with "M" and a 0 otherwise.
```r
## identify strings that start with "M"
## return count of the number of times string matches pattern
str_count(names, "^M")
```
However, if we instead wanted a count of the numbers of lowercase "m"s, we could still use `str_count()` to accomplish that. Notice below we've removed the specification to just look at the beginning of the string. Here, we're looking for lowercase m's anywhere in the string and counting them:
```r
## identify strings that have a lowercase "m"
## return count of the number of times string matches pattern
str_count(names, "m")
```
#### Detect matches: `str_detect()`
Instead of returning a count, at times you're just interested in knowing which strings match the pattern you're searching for. In these cases you'll want to use `str_detect()`. This function simply returns a TRUE if the string matches the pattern specified and FALSE otherwise.
```r
## identify strings that start with "M"
## return TRUE if they do; FALSE otherwise
str_detect(names, "^M")
```
#### Subset matches: `str_subset()`
To return the actual string that matches the specified pattern, rather than a TRUE/FALSE, you'll look to `str_subset()`. This function pulls out those strings that match the specified pattern. For example, to obtain the subset of names whose values start with the capital letter "M", you would use the following:
```r
## identify strings that start with "M"
## return whole string
str_subset(names, "^M")
```
#### Extract matches: `str_extract()`
To extract only the portions of the string that match the specified pattern, you would use `str_extract()`. This function returns the pattern specified for strings where it is found and NA otherwise. For example, by searching for names that start with M, below, we see that the second and fourth strings in our vector return the pattern specified ("M") and that the first and third strings in the vector return NA, as they do not start with a capital "M".
```r
## return "M" from strings with "M" in it
## otherwise, return NA
str_extract(names, "^M")
```
#### Replace matches: `str_replace()`
The final basic function from `stringr` that we'll discuss is `str_replace()`. This function identifies a regex and replaces each occurrence with whatever replacement the user specifies. For example, below we search for strings that start with the capital letter "M" and replace each of them with a question mark. All strings that do *not* match the regex are returned unchanged.
```r
## replace capital M with a question mark
str_replace(names, "^M", "?")
```
#### Common regular expressions
Above we discuss two common patterns searched for using regular expressions: starts with (`^`) and ends with (`$`). However, there are a number of additional common ways to match patterns. They are listed here, and we'll discuss each one in slightly more detail below.
##### Searching for characters
To search for a set of characters, you place these characters within brackets. Below, this will identify anywhere in the strings where you have a lowercase vowel. Note, that we're now using `str_view_all()` to identify all occurrences of these characters, rather than `str_view()`, which only identifies the first occurrence in each string.
```r
## identify all lowercase vowels
str_view_all(names, "[aeiou]")
```
##### Searching for anything *other* than a set of characters
By adding a caret (`^`) before the vowels within the brackets, this regular expressions specifies that you are searching for any character that is not a lowercase vowel within your strings.
```r
## identify anything that's NOT a lowercase vowel
str_view_all(names, "[^aeiou]")
```
##### Search for digits
To search for digits (numeric variable between 0 and 9) in a string you use "\d"; however, backslashes are protected characters in R. This means that you have to escape this character first with an additional backslash (`\`), to let R know that you want to search for the regular expression "\d".
```r
addresses <- c("1234 Main Street", "1600 Pennsylvania Ave", "Brick Building")
## identify anything that's a digit
str_view_all(addresses, "\\d")
```
##### Search for whitespace
Identifying whitespace in R identifies any spaces, tabs or newlines. Note that again we have to escape the "\s" with a backslash for R to recognize the regular expression.
```r
## identify any whitespace
str_view_all(addresses, "\\s")
```
##### Identify any character (except newline)
To identify any character except for a newline you'll use `"."`. Notice in our addresses example that there are no newlines, so this pattern will match with the entire string.
```r
## identify any character
str_view_all(addresses, ".")
```
#### Repetition within regular expressions
Searches for regular expressions allow you to specify how many times a pattern should be found within the string. To do so, you use the following:
* ? : 0 or 1
* + : 1 or more
* \\* : 0 or more
* {n} : exactly n times
* {n,} : n or more times
* {n,m} : between n and m times
##### Examples of repetition within regular expressions
Using the definitions above, we can see that the following code will identify patterns within the addresses vector where n shows up one more more times in a string.
```r
## identify any time n shows up one or more times
str_view_all(addresses, "n+")
```
While the difference is slight in the output here, we're identifying portions of the string where n shows up exactly once. So, instead of the 'nn' in Pennsylvania matching together, the code here splits these up, due to the fact that we're specifying the pattern match 'n' exactly one time:
```r
## identify any time n shows up
str_view_all(addresses, "n{1}")
```
If you only wanted to match strings where n showed up twice in a row, you could specify that in this way:
```r
## identify any time n shows up exactly two times in a row
str_view_all(addresses, "n{2}")
```
This could similarly be achieved by specifying to search for the pattern 'nn' one or more times (`+`):
```r
## identify any time 'nn' shows up one or more times
str_view_all(addresses, "nn+")
```
You can also specify a range of the number of times to search for a pattern within your string. Below, we see that if we specify n be searched for at least two and at most 3 times, the pattern matches within our string. However, if we increase that to between three and four times, no pattern matching occurs, as there are never three or four n's in a row in our strings.
```r
## identify any time n shows up two or three times
str_view_all(addresses, "n{2,3}")
## identify any time n shows up three or four times
str_view_all(addresses, "n{3,4}")
```
### Conclusion
This lesson set out to introduce you to how to work with strings within RStudio, using the stringr package and to introduce you to regular expressions. We've covered a number of functions and concepts in this lesson. Feel free to review the material and practice as much as you need before completing this quiz!
### Additional Resources
* [r4ds : Chapter 14 - Strings](http://r4ds.had.co.nz/strings.html) by [Hadley Wickham](http://hadley.nz/)
* [stringr documentation](http://stringr.tidyverse.org/articles/regular-expressions.html), part of the [tidyverse](https://www.tidyverse.org/)
### Slides and Video
[Automated Video](https://youtu.be/F1YuVyHGwEQ)
* [Slides](https://docs.google.com/presentation/d/1-6k6usRR06dp-YK-M3HUOUgQZKXXqKnAD5RC4TISGhw/edit?usp=sharing)