Untitled

1 Chương 1

##Lý do chọn chủ đề

2 Chương 2

Ở chương này chúng em sẽ đi sau vào cách làm việc phân tích của chuỗi khi dùng stringr và phần tích đi sau vào cách làm việc của hàm trong Stringr để xử lí cách chuỗi

Trước tiên chúng em sẽ giới thiệt về chuỗi là gì?

2.1 Giới thiệu chuỗi

Chuỗi ký tự có thể xuất hiện trong tất cả các giai đoạn của dự án khoa học dữ liệu. Người dùng có thể phải xóa đầu vào chuỗi lộn xộn trước khi phân tích, trích xuất dữ liệu được nhúng trong văn bản hoặc tự động biến các kết quả dạng số thành một câu để đưa vào báo cáo. Có lẽ bản thân các chuỗi là dữ liệu quan tâm và bạn cần phát hiện và khớp các mẫu bên trong chúng Chúng em sẽ bắt đầu với một số điều cơ bản: cách nhập chuỗi trong R, cách kiểm soát cách số được chuyển đổi thành chuỗi và cuối cùng là cách kết hợp các chuỗi với nhau để tạo đầu ra kết hợp văn bản và số được định dạng độc đáo.

2.2 Thao tác chuỗi cơ bản

Chúng em sẽ bắt đầu bằng cách tìm hiểu về một số hàm stringr rất giống với một số hàm R cơ sở, sau đó là cách phát hiện các mẫu cụ thể trong chuỗi, cách tách các chuỗi thành nhiều phần cũng như cách tìm và thay thế các phần của chuỗi.

Các chức năng của Stringr đều bắt đầu bằng str_ điều này tạo điều kiện thuận lợi cho việc tìm lệnh thích hợp: Chúng ta chỉ cần nhập str_ và chức năng tự động đề xuất của Rstudio sẽ hiện thị những phần còn lại.

Đầu tiên chúng em sẽ cái đặt và gọi cói Stringr

library(stringr)

2.2.1 Quản lí độ dài chuỗi

1. Độ dài của một chuỗi

str_length(): Trả về một độ dài của một chuỗi bao gồm cả khoảng trắng và cả dấu chấm câu. Trong đó string là một vecto đầu vào hoặc là một vecto kí tự.

Các hàm cơ sở R có nhiều hàm để thao tác với các chuỗi, nhưng nên tránh những hàm này vì chúng khó nhớ, có một bộ nhớ tốt cho các hàm này trong gói stringr

Lấy một vectơ chuỗi làm đầu vào và trả về số lượng ký tự trong mỗi chuỗi.

str_length(c("a", "R cho khoa hoc du lieu", NA))

## [1]  1 22 NA

Chúng em sẽ gọi gói “babyname” và “dplyr” để hổ trợ cho việc phân tích chuỗi và các hàm

library(babynames)

## Warning: package 'babynames' was built under R version 4.3.1

library(dplyr)

## Warning: package 'dplyr' was built under R version 4.3.1

## 
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
## 
##     filter, lag

## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

Trước tiên,chúng em sẽ sử dụng gói “babynames” để gọi xử lý dữ liệu về các tên trẻ em phổ biến theo năm và giới tính

Trích xuất vector tên con trai và tên con gái trong năm 2014.

Chọn những hàng có giá trị trong cột “sex” là “M” (nam giới),cột “sex” là “F” (nữ giới) và sau đó chỉ lấy các giá trị trong cột “name”

babynames_2014 <- filter(babynames, year == 2014)
boy_names <- filter(babynames_2014, sex == "M")$name
girl_names <- filter(babynames_2014, sex == "F")$name

Danh sách năm tên phổ biến đầu tiên của nam giới trong năm 2014.

head(boy_names)

## [1] "Noah"    "Liam"    "Mason"   "Jacob"   "William" "Ethan"

Tìm độ dài của tất cả các tên boy_names

boy_length <- str_length(boy_names)
head(boy_length)

## [1] 4 4 5 5 7 5

Điểm khác biệt về chiều dài trung bình của boy_names và girls_name

girl_length <- str_length(girl_names)
mean(girl_length) - mean(boy_length)

## [1] 0.3374758

sử dụng hàm str_length() để kiểm tra độ dài a các phần tử trong vector boy_names

head(str_length(factor(boy_names)))

## [1] 4 4 5 5 7 5

Kết luận: Độ dài trung bình của tên con gái vào năm 2014 dài hơn một ký tự khoảng một phần ba. Đây là con số trung bình ngây thơ trong đó mỗi cái tên được tính một lần, không phải theo số lượng em bé đã nhận được tên. Một phép so sánh tốt hơn có thể là trọng số trung bình của cột n trong babynames

2. Đệm chuỗi sử dụng str_pad()

Đệm chuỗi liên quan đến việc thêm các ký tự vào một chuỗi để làm cho nó có độ dài nhất định. Hàm str_pad() trong gói Stringr có thể được sử dụng để đệm chuỗi. Hàm str_pad () trả về một vectơ ký tự chứa (các) chuỗi được đệm. Dưới đây là một số tham số bạn có thể sử dụng với hàm str_pad():

Cú pháp: str_pad(string,width, side = c(“left”,“right”,“both”),pad = ““).

Trong đó:

• String: chuỗi đầu vào mà chúng ta muốn đệm

• width: Độ rộng mong muốn của chuỗi kết quả sau khi đệm

• Side: Chỉ định đệm các chuỗi ở bên trái, bên phải hay cả hai bên

• Pad: Ký tự dùng để đệm. Giá trị mặc định là khoảng trắng(” “)

Ví dụ: Thêm khoảng trắng vào một chuỗi (đối với một ký tự)

str_pad("boy_names",11,side = "both") #11:cho biet do dai sau khi them la 11

## [1] " boy_names "

Tham số pad có thể chỉ định các ký tự cần điền

str_pad("boy_names",11,side = "both",pad = "*")

## [1] "*boy_names*"

Em sẽ kết hợp với gói Purrr, lập trình chức năng có thể được vector hóa, để loại bỏ khoảng trắng và thêm khoảng trắng

x <- c("boy_names","girl_names")
library(purrr)

## Warning: package 'purrr' was built under R version 4.3.1

map_chr(x,str_pad,11,side = "left")

## [1] "  boy_names" " girl_names"

str_c(x[seq_len(3) - 1],collapse = ",")

## [1] "boy_names,girl_names"

3. Cắt xén chuỗi sử dụng bằng str_trim( )

Cắt xén chuỗi liên quan đến việc loại bỏ các ký tự khoảng trắng ở đầu và/hoặc cuối chuỗi. Hàm str_trim() trong gói Stringr có thể được sử dụng để cắt chuỗi. Hàm str_trim() trả về một vectơ ký tự chứa (các) chuỗi đã cắt. Dưới đây là các tham số bạn có thể sử dụng với hàm str_trim():

Cú pháp:str_trim(string,side = c(“left”,“right”,“both”)).

Trong đó

• string: Tham số này đại diện cho chuỗi ký tự hoặc vectơ của chuỗi sẽ được cắt bớt.

• side: Tham số này chỉ định (các) bên của (các) chuỗi cần cắt. Các giá trị có thể là “cả hai”, “trái” hoặc “phải”. Giá trị mặc định là “cả hai”.

• whitespace: Tham số này chỉ định các ký tự khoảng trắng cần xóa. Giá trị mặc định là “[:space:]”, khớp với bất kỳ ký tự khoảng trắng nào.

• pattern: Tham số này cho phép bạn chỉ định một mẫu biểu thức chính quy để khớp các ký tự cần xóa khỏi (các) chuỗi. Giá trị mặc định là NULL, có nghĩa là tham số khoảng trắng được sử dụng để khớp với các ký tự cần loại bỏ.

• fixed: Tham số này chỉ định xem tham số mẫu là một chuỗi cố định (TRUE) hay một biểu thức chính quy (FALSE). Giá trị mặc định là FALSE.

Loaị bỏ các khoảng trắng dư thừa ở đầu và cuối của một chuỗi ký tự

str_trim(" boy_names ")

## [1] "boy_names"

Chúng cũng có thể chỉ định phần cuối của khoảng trống cần xóa. VÍ dụ loại bỏ các khoảng trắng dư thừa ở phía bên trái của một chuỗi ký tự:

str_trim(" boynames ",side = "left")

## [1] "boynames "

2.2.2 Chuỗi con

1. Trích xuất chuỗi con bằng cách sử dụng str_sub()

Trích xuất chuỗi con liên quan đến việc trích xuất một phần của chuỗi. Hàm str_sub() trong gói Stringr có thể được sử dụng để trích xuất các chuỗi con. Dưới đây là một số tham số bạn có thể sử dụng với hàm str_sub():

Cú pháp: str_sub(string, start = 1L, end = -1L.

Trong đó:

• string: là vecto đầu vào hoặc là một vecto kí tự

• start: chỉ định vị trí ký tự đầu tiên trong chuỗi con sẽ được trích xuất

• end: Chỉ định vị trí của ký tự cuối cùng trong các chuỗi con sẽ được trích xuất

Ví dụ: str_sub(x, 1, 3) yêu cầu chuỗi con bắt đầu từ ký tự đầu tiên, cho đến ký tự thứ ba hoặc nói cách khác là bốn ký tự đầu tiên.

x <- c("boy_names","girl_names")
str_sub(x,1,3)

## [1] "boy" "gir"

Cả bắt đầu và kết thúc đều có thể là số nguyên âm, trong trường hợp đó, chúng được tính từ cuối chuỗi. Ví dụ: str_sub(x, -3, -1), yêu cầu chuỗi con bắt đầu từ ký tự thứ tư tính từ cuối cho đến ký tự đầu tiên tính từ cuối, tức là ba ký tự cuối cùng. Một lần nữa, hãy thử với ví dụ trên:

str_sub(x,-3,-1)

## [1] "mes" "mes"

Trích xuất chữ cái đầu tiền trong boy_names và sau đó lặp bảng

boy_first_letter <- str_sub(boy_names, 1, 1)
table(boy_first_letter)

## boy_first_letter
##    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O    P 
## 1454  651  770  998  549  185  334  403  235 1390 1291  537  914  424  207  230 
##    Q    R    S    T    U    V    W    X    Y    Z 
##   56  778  806  771   43  160  174   56  252  379

Trích xuất chữ cái cuối cùng trong boy_names và sau đó lặp bảng

boy_last_letter <- str_sub(boy_names, -1, -1)
table(boy_last_letter)

## boy_last_letter
##    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o    p 
##  421  104   92  436 1148   66   82  583  705   57  349  945  389 4672  730   32 
##    q    r    s    t    u    v    w    x    y    z 
##   19 1011  826  292   81   71   34   86  697  119

Trích xuất chữ cái đầu tiền trong girl_names và sau đó lặp bảng

girl_first_letter <- str_sub(girl_names, 1, 1)
table(girl_first_letter)

## girl_first_letter
##    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O    P 
## 3101  699  946  810  933  209  345  469  373 1430 1694 1122 1746  752  143  303 
##    Q    R    S    T    U    V    W    X    Y    Z 
##   38  831 1369  683   28  214   85   62  294  502

Trích xUất chữ cái cuối cùng trong girl_names và sau đó lặp bảng

girl_last_letter <- str_sub(girl_names, -1, -1)
table(girl_last_letter)

## girl_last_letter
##    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o    p 
## 6632   20   13   81 3114    8   21 1942 1581   12   31  450  115 2608  105    3 
##    q    r    s    t    u    v    w    x    y    z 
##    2  291  326  208   59    6   17   50 1435   51

Kết luận: “A” là chữ cái đầu tiên phổ biến nhất cho cả bé trai và bé gái, và là chữ cái cuối cùng phổ biến nhất cho bé gái.

Tuy nhiên, chữ cái cuối cùng phổ biến nhất cho tên con trai là “n”. CHúng có thể đã thấy substr() một hàm R cơ sở tương tự như str_sub()

Ưu điểm lớn của str_sub() là khả năng sử dụng các chỉ mục âm để đếm từ cuối chuỗi.

2. str_subset(): chức năng trả về các chuỗi chứa mẫu khớp

Vì việc phát hiện các chuỗi có mẫu và sau đó sắp xếp lại các chuỗi đó là một hoạt động phổ biến, stringr cung cấp một hàm str_subset() thực hiện điều đó trong một bước. Ví dụ: hãy lặp lại tìm kiếm boy_names có chứa”zz” bằng cách sử dụng str_subset():

str_subset(boy_names, pattern = fixed("zz"))

##  [1] "Uzziah"    "Ozzie"     "Ozzy"      "Jazz"      "Uzziel"    "Chazz"    
##  [7] "Izzy"      "Azzam"     "Izzac"     "Izzak"     "Fabrizzio" "Jazziel"  
## [13] "Azzan"     "Izzaiah"   "Muizz"     "Yazziel"

Chúng ta nhận được một vectơ chuỗi mới, nhưng nó chỉ chứa các chuỗi ban đầu chứa mẫu.

str_subset() có thể dễ bị nhầm lẫn với str_extract(). str_extract() trả về một vectơ có cùng độ dài với vectơ đầu vào, nhưng chỉ với các phần của chuỗi khớp với mẫu. Tìm girl_name có chứa “U” và “z”

starts_U <- str_subset(girl_names, pattern = fixed("U"))
starts_U

##  [1] "Unique"  "Uma"     "Unknown" "Una"     "Uriah"   "Ursula"  "Unity"  
##  [8] "Umaiza"  "Urvi"    "Ulyana"  "Ula"     "Udy"     "Urwa"    "Ulani"  
## [15] "Umaima"  "Umme"    "Ugochi"  "Ulyssa"  "Umika"   "Uriyah"  "Ubah"   
## [22] "Umaira"  "Umi"     "Ume"     "Urenna"  "Uriel"   "Urijah"  "Uyen"

str_subset(starts_U, pattern = "z")

## [1] "Umaiza"

Kết luận: “Umamiza” là có gái có tên duy nhất bắt đầu bắt chữ “U” và chứa chữ “z”

3. Hàm str_extract() trả về một vectơ ký tự chứa (các) chuỗi con được trích xuất

Hàm này được sử dụng để trích xuất lần xuất hiện đầu tiên của một mẫu trong chuỗi ký tự hoặc vectơ của chuỗi. Hàm str_extract() trả về một vectơ ký tự chứa (các) chuỗi con được trích xuất. Dưới đây là một số tham số bạn có thể sử dụng với hàm str_extract():

Cú pháp: str_extract(string, pattern, simplify, ignore_case, opts_regex).

Trong đó:

• string: Tham số này đại diện cho chuỗi ký tự hoặc vectơ của chuỗi sẽ được tách.

• pattern: Tham số này chỉ định dấu phân cách hoặc mẫu biểu thức chính quy sẽ được sử dụng để tách (các) chuỗi đầu vào.

• simplify: Tham số này chỉ định có đơn giản hóa kết quả thành ma trận ký tự hoặc vectơ hay không. Giá trị mặc định là FALSE.

• ignore_case: Tham số này chỉ định số lần phân tách tối đa được thực hiện. Giá trị mặc định là ‘Inf’.

• opts_regex: Tham số này chỉ định có nên loại bỏ các chuỗi trống trong đầu ra hay không. Giá trị mặc định là true.

Dưới đây là hai bộ dữ liệu đã được cài đặt sẳn trong gói Stringr, bao gồm fruit cho chúng ta biết 79 loại trái cây và dữ liệu sentences bao gồm 720 dòng. Chúng em sẽ dùng lệnh head() để xem 6 dòng đầu của 2 bộ dữ liệu:

fruit = stringr::fruit
head(fruit)

## [1] "apple"       "apricot"     "avocado"     "banana"      "bell pepper"
## [6] "bilberry"

head(sentences)

## [1] "The birch canoe slid on the smooth planks." 
## [2] "Glue the sheet to the dark blue background."
## [3] "It's easy to tell the depth of a well."     
## [4] "These days a chicken leg is a rare dish."   
## [5] "Rice is often served in round bowls."       
## [6] "The juice of lemons makes fine punch."

Ví dụ: chúng em sẽ trích xuất chuỗi chưa tất cả các từ có trái cây trong vector “fruit” và dùng “|” để nối các chuỗi với nhau

fruit_match <- str_c(fruit, collapse = "|")
fruit_match

## [1] "apple|apricot|avocado|banana|bell pepper|bilberry|blackberry|blackcurrant|blood orange|blueberry|boysenberry|breadfruit|canary melon|cantaloupe|cherimoya|cherry|chili pepper|clementine|cloudberry|coconut|cranberry|cucumber|currant|damson|date|dragonfruit|durian|eggplant|elderberry|feijoa|fig|goji berry|gooseberry|grape|grapefruit|guava|honeydew|huckleberry|jackfruit|jambul|jujube|kiwi fruit|kumquat|lemon|lime|loquat|lychee|mandarine|mango|mulberry|nectarine|nut|olive|orange|pamelo|papaya|passionfruit|peach|pear|persimmon|physalis|pineapple|plum|pomegranate|pomelo|purple mangosteen|quince|raisin|rambutan|raspberry|redcurrant|rock melon|salal berry|satsuma|star fruit|strawberry|tamarillo|tangerine|ugli fruit|watermelon"

TÌm kiếm trích xuất các từ chứa trái cây từ trong một tập hợp các câu (sentences)

has_fruit <- str_subset(sentences, fruit_match)
matches <- str_extract(has_fruit, fruit_match)
head(matches)

## [1] "lemon" "fig"   "pear"  "peach" "fig"   "fig"

str_extract() chỉ trích xuất kết quả khớp đầu tiên, nên em sẽ sử dụng str_extract_all() để trích xuất tất cả các kết quả khớp, kết quả được hiển thị trong danh sách

str_extract_all(has_fruit,fruit_match) %>% head()

## [[1]]
## [1] "lemon"
## 
## [[2]]
## [1] "fig"
## 
## [[3]]
## [1] "pear"
## 
## [[4]]
## [1] "peach"
## 
## [[5]]
## [1] "fig"
## 
## [[6]]
## [1] "fig"   "apple"

Tiếp theo chúng em sẽ Đơn giản hóa = TRUE trả về một ma trận

str_extract_all(has_fruit,fruit_match,simplify = T) %>% head()

##      [,1]    [,2]   
## [1,] "lemon" ""     
## [2,] "fig"   ""     
## [3,] "pear"  ""     
## [4,] "peach" ""     
## [5,] "fig"   ""     
## [6,] "fig"   "apple"

4. str_match(x, pattern): trích xuất các phần của trận đấu được xác định bởi dấu ngoặc đơn

Bây giờ chúng em sẽ lấy ví dụ trong bộ dữ liệu sentences để giải thích về hàm str_match

Lấy tất cả các danh từ trong câu có “a” hoặc “the” để làm từ định lượng

danhtu <- "(a|the) ([^ ]+)"

has_danhtu <- sentences %>%
  str_subset(danhtu) %>%
  head(10)
has_danhtu %>% 
  str_extract(danhtu)

##  [1] "the smooth" "the sheet"  "the depth"  "a chicken"  "the parked"
##  [6] "the sun"    "the huge"   "the ball"   "the woman"  "a helps"

str_match() khác với str_extract(), chủ yếu là vì str_match() sẽ trả về mọi nội dung đã chụp

Trích xuất phần khớp với mẫu trong mỗi danh từ

danhtu <- "(a|the) ([^ ]+)"
has_danhtu <- sentences %>%
  str_subset(danhtu) %>%
  head(10)
has_danhtu %>% 
  str_match(danhtu)

##       [,1]         [,2]  [,3]     
##  [1,] "the smooth" "the" "smooth" 
##  [2,] "the sheet"  "the" "sheet"  
##  [3,] "the depth"  "the" "depth"  
##  [4,] "a chicken"  "a"   "chicken"
##  [5,] "the parked" "the" "parked" 
##  [6,] "the sun"    "the" "sun"    
##  [7,] "the huge"   "the" "huge"   
##  [8,] "the ball"   "the" "ball"   
##  [9,] "the woman"  "the" "woman"  
## [10,] "a helps"    "a"   "helps"

2.3 Phát hiện kết quả trùng khớp

2.3.1 TÌm kiếm và trích suất thông tin chuỗi

1. Khớp mẫu sử dụng str_detect( )

Khớp mẫu liên quan đến việc tìm một chuỗi con khớp với một mẫu cụ thể. Hàm str_detect() trong gói Stringr có thể được sử dụng để phát hiện các mẫu trong chuỗi. Dưới đây là một số tham số bạn có thể sử dụng với hàm str_detect() :

Cú pháp: str_detect(string, pattern, negate ): Có chức năng kiểm tra xem một chuỗi có chứa một mẫu hay không và kết quả trả về là “TRUE” hoặc “FALSE”

• string: Đại diện cho chuỗi ký tự hoặc vecto của chuỗi muốn phát hiện trong mẫu đó

• pattern: Tham số này chỉ định mẫu hoặc biểu thức chính quy sẽ được phát hiện trong chuỗi đầu vào

• negate: Tham số này chỉ định có trả về phần bù logic của kết quả phát hiện hay không

Chúng em sẽ lấy ví dụ kiểm tra xem một vectơ ký tự có khớp với một mẫu hay không, trả về một vectơ logic

x <- c("boy_names","girl_names")
str_detect(x,"o")

## [1]  TRUE FALSE

Ngoài ra có thể sử dụng vec-to logic thu được để thu được các phần tử con phù hợp

x[str_detect(x,"e")]

## [1] "boy_names"  "girl_names"

Kiểm tra xem mỗi phần tử trong vector boy_names có chứa chuỗi “zz” hay không?

contains_zz <- str_detect(boy_names, pattern = "zz")
str(contains_zz)

##  logi [1:14047] FALSE FALSE FALSE FALSE FALSE FALSE ...

Có bao nhiêu tên chứa “zz”?

sum(contains_zz)

## [1] 16

Tên nào có chứa “zz”

boy_names[contains_zz]

##  [1] "Uzziah"    "Ozzie"     "Ozzy"      "Jazz"      "Uzziel"    "Chazz"    
##  [7] "Izzy"      "Azzam"     "Izzac"     "Izzak"     "Fabrizzio" "Jazziel"  
## [13] "Azzan"     "Izzaiah"   "Muizz"     "Yazziel"

Hàng nào trong boy_df có tên chứa “zz” ?

boy_df <- filter(babynames_2014, sex == "M")
boy_df[contains_zz,]

## # A tibble: 16 × 5
##     year sex   name          n       prop
##    <dbl> <chr> <chr>     <int>      <dbl>
##  1  2014 M     Uzziah       67 0.0000328 
##  2  2014 M     Ozzie        62 0.0000303 
##  3  2014 M     Ozzy         57 0.0000279 
##  4  2014 M     Jazz         21 0.0000103 
##  5  2014 M     Uzziel       21 0.0000103 
##  6  2014 M     Chazz        17 0.00000832
##  7  2014 M     Izzy         16 0.00000783
##  8  2014 M     Azzam        14 0.00000685
##  9  2014 M     Izzac        13 0.00000636
## 10  2014 M     Izzak         8 0.00000391
## 11  2014 M     Fabrizzio     7 0.00000342
## 12  2014 M     Jazziel       6 0.00000293
## 13  2014 M     Azzan         5 0.00000245
## 14  2014 M     Izzaiah       5 0.00000245
## 15  2014 M     Muizz         5 0.00000245
## 16  2014 M     Yazziel       5 0.00000245

Ví dụ cuối cùng đó là một cách sử dụng phổ biến khác của str_detect() đặt khung dữ liệu thành các hàng trong đó các giá trị trong cột chứa mẫu quan tâm.

Kết luận: Trong ví dụ này, nó cho chúng ta thấy rằng những tên có chứa zz này khá hiếm. Ngay cả cậu bé nổi tiếng nhất, Uzziah, cũng chỉ chiếm 0,003% trong số các cậu bé sinh năm 2014.

2. Chức năng định vị kí tự bằng hàm str_locate()

str_locate() Trả về vị trí đầu tiên và cuối cùng của đối tượng phù hợp, thường được sử dụng cùng với hàm str_sub

x <- c("boy_names","girl_names")
str_locate_all(x,'a')

## [[1]]
##      start end
## [1,]     6   6
## 
## [[2]]
##      start end
## [1,]     7   7

2.3.2 Đếm và tính toán trong chuỗi bằng hàm str_count()

Gói stringr cung cấp phương thức str_count() được sử dụng để đếm số lần xuất hiện của một mẫu nhất định được chỉ định làm đối số cho hàm. Mẫu có thể là một ký tự đơn hoặc một nhóm ký tự. Bất kỳ trường hợp nào khớp với biểu thức đều dẫn đến sự gia tăng của số đếm. Phương thức này cũng có thể được gọi trên một vectơ chuỗi và một vectơ đếm riêng lẻ được trả về có chứa các số lượng riêng lẻ của số lượng mẫu phù hợp được tìm thấy.

Cú pháp:str_count(str, pattern = ““) Trong đó:

• str: Chuỗi để đếm số lần xuất hiện của
• pattern: mẫu phù hợp với

str_count() hàm này sẽ trả về số lượng kết quả khớp trong mỗi chuỗi

Ví dụ: đến số lần xuất hiện của “a” trong mỗi phần tử của “x”

x <- c("boy_names","girl_names")
str_count(x, "a")

## [1] 1 1

Đếm số lần xuất hiện của “a” và “A” trong girl_names và tạo biểu đồ số của cả 2

number_as <- str_count(girl_names, pattern = fixed("a"))
number_As <- str_count(girl_names, pattern = fixed("A"))
hist(number_as)

hist(number_As)

Tìm tổng của “a” và “A”

total_as <- number_As + number_as
girl_names[total_as > 4]

## [1] "Aaradhana"

2.4 Chia và tách chuỗi

1. Nối chuỗi sử dụng str_c( )

Nối chuỗi là quá trình nối hai hoặc nhiều chuỗi lại với nhau. Hàm str_c() trong gói Stringr có thể được sử dụng để nối chuỗi. Hàm str_c() rất dễ sử dụng và cung cấp nhiều tham số khác nhau để tùy chỉnh quy trình nối. Dưới đây là một số tham số bạn có thể sử dụng với hàm str_c():

c là viết tắt của concatenate, một hàm hoạt động giống như paste() Nó lấy các vectơ của chuỗi làm đầu vào cùng với các đối số sep và collapse.

Cú pháp :str_c(…, sep, collapse, ignore_na, trim)

Trong đó:

• . . .: Tham số này đại diện cho các chuỗi cần được nối. Bạn có thể chỉ định bất kỳ số lượng đối số nào được phân tách bằng dấu phẩy.

• sep: Tham số này chỉ định dấu phân cách được sử dụng giữa các chuỗi được nối. Dấu phân cách mặc định là một chuỗi rỗng.

• collapse: Tham số này được sử dụng để thu gọn đầu ra của str_c() thành một chuỗi. Giá trị mặc định là FALSE.

• ignore_na – Tham số này được sử dụng để bỏ qua mọi giá trị bị thiếu trong chuỗi đầu vào. Giá trị mặc định là FALSE.

• trim – Tham số này được sử dụng để cắt bất kỳ ký tự khoảng trắng nào từ đầu hoặc cuối mỗi chuỗi trước khi nối chúng. Giá trị mặc định là FALSE.

Hợp nhất nhiều chuỗi thành một chuỗi

str_c("x","y","z")

## [1] "xyz"

Chỉ định tham số sep để xác định dấu phân cách

str_c("x","y",sep = ", ")

## [1] "x, y"

Chỉ định collapse để kết hợp các đối số vectơ thành một chuỗi lớn

str_c(head(letters),collapse = ",")

## [1] "a,b,c,d,e,f"

 str_c(c('a','a1'),c('b','b1'),collapse='-')

## [1] "ab-a1b1"

str_c() là một hàm được vector hóa để tái chế các vectơ ký tự có độ dài ngắn

str_c("prefix-",c('a','b','c'),"-suffix")

## [1] "prefix-a-suffix" "prefix-b-suffix" "prefix-c-suffix"

Kết hợp một vectơ ký tự thành một chuỗi, sử dụng đối số thu gọn

str_c(c("x","y","z"),collapse = ",")

## [1] "x,y,z"

Điều chứng minh được hàm str_c giúp chúng ta tìm hiểu nhanh chóng khi chúng ta có thể thiếu các giá trị, thay vì phát hiện ra các “NA” kỳ lạ sau đó bên trong chuỗi của mình.

2. Tách chuỗi bằng cách sử dụng str_split()

Sử dụng str_split() để phân tách chuỗi thành nhiều phần và trả về một danh sách. Bạn cũng có thể chỉ định Simple = TRUE để trả về một ma trận

Ví dụ: phân tách chuỗi của bộ dữ liệu sentences

sentences %>%
  head(5) %>% 
  str_split(" ")

## [[1]]
## [1] "The"     "birch"   "canoe"   "slid"    "on"      "the"     "smooth" 
## [8] "planks."
## 
## [[2]]
## [1] "Glue"        "the"         "sheet"       "to"          "the"        
## [6] "dark"        "blue"        "background."
## 
## [[3]]
## [1] "It's"  "easy"  "to"    "tell"  "the"   "depth" "of"    "a"     "well."
## 
## [[4]]
## [1] "These"   "days"    "a"       "chicken" "leg"     "is"      "a"      
## [8] "rare"    "dish."  
## 
## [[5]]
## [1] "Rice"   "is"     "often"  "served" "in"     "round"  "bowls."

Tập dữ liệu “sentences” đã tách mỗi câu thành các từ riêng lẻ, tạo thành một danh sách với mỗi phần tử là một vector chứa các từ của từng câu.

Chúng em sẽ tách both_names thành first_names và last_names

both_names <- c("Box, George", "Cox, David")
both_names_split <- str_split(both_names, pattern = fixed(", "), simplify = TRUE)
first_names <- both_names_split[, 2]
last_names <- both_names_split[, 1]
both_names_split

##      [,1]  [,2]    
## [1,] "Box" "George"
## [2,] "Cox" "David"

Ngoài ra có thể sử dụng đối số đơn giản hóa = TRUE khi chúng ta muốn chia mỗi chuỗi thành các phần bằng nhau.

_ Đơn giản hóa =True

Việc chỉ định đơn giản hóa = TRUE sẽ cung cấp cho chúng ta đầu ra dễ làm việc hơn, nhưng chúng ta sẽ luôn nhận được n phần (ngay cả khi một số phần trống, ““).

Đôi khi, chúng ta muốn biết một chuỗi có thể được chia thành bao nhiêu phần hoặc muốn làm gì đó với mỗi phần trước khi chuyển sang cấu trúc đơn giản hơn. Đây là tình huống mà chúng ta không muốn đơn giản hóa và sẽ phải xử lý đầu ra bằng thứ gì đó như lapply().

Để thực hiện các phép tính này, chúng ta cần chia các dòng thành các từ. Một cách để chia câu thành các từ là chia trên khoảng trống ” “. Điều này hơi khó khăn vì, ví dụ, nó sẽ không nhận các từ được phân tách bằng một chuỗi thoát dòng mới như trong”hai“, nhưng vì tình huống này không xảy ra trong các dòng của bạn, nên nó sẽ làm

Sau đây chúng em sẽ lấy dữ liệu sentences để thực hiện một số thống kê văn bản đơn giản trên các dòng của mình. Mục tiêu của chúng em là tính xem có bao nhiêu từ trong mỗi dòng và độ dài trung bình của các từ trong mỗi dòng.

Số từ trong mỗi dòng

lines <- head(sentences)
words <- str_split(lines, pattern = fixed(" "))
lapply(words, length)

## [[1]]
## [1] 8
## 
## [[2]]
## [1] 8
## 
## [[3]]
## [1] 9
## 
## [[4]]
## [1] 9
## 
## [[5]]
## [1] 7
## 
## [[6]]
## [1] 7

Độ dài trung bình trên mỗi dòng

word_lengths <- lapply(words, str_length)
lapply(word_lengths, mean)

## [[1]]
## [1] 4.375
## 
## [[2]]
## [1] 4.5
## 
## [[3]]
## [1] 3.333333
## 
## [[4]]
## [1] 3.555556
## 
## [[5]]
## [1] 4.285714
## 
## [[6]]
## [1] 4.428571

Kết luận: Độ dài từ không hoàn toàn đúng vì nó đã bao gồm một số ký hiệu dấu chấm câu. Để giải quyết vấn đề đó chúng ta thay thế chúng trước bằng hàm str_replace() sẽ được chúng em giới thiệu phần sau.

2.5 Biến đổi chuỗi

2.5.1 Thay thế và chuyển đổi chuỗi

Đôi khi, việc thay thế các phần chúng ta không muốn bằng một chuỗi rỗng ” ” sẽ dễ dàng hơn. Đây cũng là một phương pháp phổ biến để dọn dẹp chuỗi, chẳng hạn như để xóa dấu chấm câu hoặc khoảng trắng không mong muốn.

str_replace() và str_replace_all() cho phép chúng ta thay thế các kết quả khớp để tạo chuỗi mới

str_replace(string, pattern = ’‘, replacement =’’): Thay thế ký tự liên quan đến viêc thay thế một chuỗi con trong một chuỗi bằng một chuỗi con khác. Trong đó:

• string: Tham số này đại diện cho chuỗi ký tự hoặc một vecto chuỗi muốn thay thế các mẫu

• pattern: Tham số này chỉ định mẫu hoặc biểu thức chính quy sẽ được thay thế cho các chuỗi đầu vào.

• replacement: Tham số này chỉ định các chuỗi thay thế sẽ được thay thế cho các mẫu trong các chuỗi đầu vào

Đầu tiên chúng em sẽ thực hiện thay thế các nguyên âm (a, e, i, o, u) trong các chuỗi “apple”, “pear” và “banana” bằng dấu gạch ngang “-”

x <- c("apple", "pear", "banana")
str_replace(x, "[aeiou]", "-")

## [1] "-pple"  "p-ar"   "b-nana"

Thay tế tất cả các ký tự trong chuỗi bằng str_replace_all

str_replace_all(x, "[aeiou]", "-")

## [1] "-ppl-"  "p--r"   "b-n-n-"

Với str_replace_all() chúng em cũng có thể cung cấp một vectơ có tên cho nhiều lần thay thế

x <- c("1 house", "2 cars", "3 people")
str_replace_all(x, c("1" = "one", "2" = "two", "3" = "three"))

## [1] "one house"    "two cars"     "three people"

Trong quá trình thay thế, chúng ta cũng có thể được kết hợp

sentences %>% 
  str_replace("([^ ]+) ([^ ]+) ([^ ]+)", "\\1 \\3 \\2") %>% 
  head(5)

## [1] "The canoe birch slid on the smooth planks." 
## [2] "Glue sheet the to the dark blue background."
## [3] "It's to easy tell the depth of a well."     
## [4] "These a days chicken leg is a rare dish."   
## [5] "Rice often is served in round bowls."

Đây chính là mẫu biểu thức chính quy để tìm các đoạn câu trong danh sách sentences có ba từ, đổi chỗ vị trí giữa từ thứ hai và thứ ba trong mỗi đoạn câu.Chúng em sẽ giải thích rõ ở phần sau biểu thức chính quy

2.5.2 Chuyển đổi chuỗi

Trong một số trường hợp chúng ta muốn biểu thị text ở dạng viết hoa hoặc viết thường, chúng ta có thể dùng hàm như sau:

Ví dụ: lấy dữ liệu về trái cây

fruit <- c("apple", "pear", "banana")

str_to_lower(): chuyển đổi tất cả các chữ cái trong chuỗi thành chữ thường

str_to_lower(fruit)

## [1] "apple"  "pear"   "banana"

str_to_upper(): chuyển đổi tất cả các chữ cái trong chuỗi đầu vào thành chữ hoa

str_to_upper(fruit)

## [1] "APPLE"  "PEAR"   "BANANA"

str_to_title(): Chuyển đổi các ký tự đầu tiên của mỗi từ trong một chuỗi thành chữ hoa (in hoa), trong khi giữ lại các ký tự còn lại ở dạng chữ thường (in thường).

str_to_title(fruit)

## [1] "Apple"  "Pear"   "Banana"

2.6 Biểu thức thính quy trong R

Giới thiệu Regular Expression

Regular Expression( tạm dịch là biểu thức chính quy) có thể hiểu là một chuỗi các ký tự khớp với một mẫu trong một đoạn văn bản hoặc một tệp văn bản. Nó được sử dụng trong khai thác văn bản trong rất nhiều ngôn ngữ lập trình. Các ký tự của biểu thức chính quy khá giống nhau trong tất cả các ngôn ngữ. Nhưng các chức năng trích lọc, định vị, phát hiện và thay thế có thể khác nhau ở các ngôn ngữ khác nhau.

Trong phần này, chúng em sẽ tìm hiểu về biểu thức chính quy, một ngôn ngữ để mô tả các mẫu trong chuỗi. Bằng cách kết hợp các biểu thức chính quy với các hàm stringr, giúp sẽ tăng đáng kể khả năng thao tác các chuỗi của mình.

2.6.1 Khớp mẫu đầu và mẫu cuối của chuỗ

Rebus cung cấp các phím tắt START và END để chỉ định các biểu thức chính quy khớp với phần đầu và phần cuối của chuỗi. Chúng còn được gọi là neo. Bạn có thể dùng thử chỉ bằng cách gõ

• str_view() và str_view_all(): Hai hàm này dùng để học biểu thức chính quy

KHớp các chữ bằng chữ “an”

library(rebus)

## Warning: package 'rebus' was built under R version 4.3.1

## 
## Attaching package: 'rebus'

## The following object is masked from 'package:stringr':
## 
##     regex

x <- c("apple", "banana", "pear") 
str_view(x,"an")

## [2] │ b<an><an>a

” . ” Có thể đại diện cho bất kỳ ký tự nào, ngoại trừ dòng mới

str_view(x,".a.")

## [2] │ <ban>ana
## [3] │ p<ear>

Nếu chúng ta muốn khớp với ký tự “.”, cần thoát ký tự đó (bảo R chỉ khớp với ” .” và loại bỏ tính năng khớp của “.”)

str_view(c("abc","a.c","bef"),"a\\.c")

## [2] │ <a.c>

Nếu chúng ta muốn khớp , cần sử dụng \\ để khớp

str_view(c("a\\c","abc"),"\\\\")

## [1] │ a<\>c

Ký tự đặc biệt

^ khớp với phần đầu của ký tự $ khớp với cuối ký tự

x <- c("apple","banana")
str_view(x,"^a")

## [1] │ <a>pple

str_view(x,"a$")  

## [2] │ banan<a>

Để khớp một ký tự hoàn chỉnh, hãy sử dụng cả ^ và $

x <- c("apple pie", "apple", "apple cake")
str_view(x,"^apple$")

## [2] │ <apple>

Giống như các biểu thức chính quy trong các ngôn ngữ khác, sự khác biệt trong cách sử dụng là chúng cần sử dụng hai dấu gạch chéo

x <- c("1","a1w")
str_view(x,"^\\d$")

## [1] │ <1>

-Tương tự như biểu thức chính quy khác R cũng có Số lần lập lại Nhóm và phản hồi(chú ý đến việc sử dụng phản hồi gạch chéo kép)

x <- c("abab","abba")
str_view(x,"(..)\\1")

## [1] │ <abab>

Trên đây là phần cơ bản về biểu thức chính quy trong R, sau này chúng ta sẽ tìm hiểu cách sử dụng chúng để giải quyết các bài toán thực tế, các hàm do gói stringr triển khai như sau:

Xác định cái nào phù hợp với mẫu Tìm nơi mẫu phù hợp

Trích xuất nội dung phù hợp

Thay thế phần phù hợp

Tách một chuỗi dựa trên một trận đấu

Chúng em sẽ chứng mình những điều đó vào phần sau

2.6.2 Các biểu thửc chính Quy khác

Trong các biểu thức chính quy, một lớp ký tự là một cách chỉ định “khớp một (và chỉ một) trong số các ký tự sau”.

.

2.6.3 Ứng dụng của biểu thức chính quy

.

2.6.3.1 Săn tìm số điện thoạ

. Giả sử: chúng em sẽ trích xuất thông tin về các số điện thoại gồm 10 chữ số của Hoa Kỳ từ một tệp văn bản.

a1 <- "Home: 507-645-5489"
a2 <- "Cell: 219.917.9871"
a3 <- "My work phone is 507-202-2332"
a4 <- "I don't have a phone"
info <- c(a1, a2, a3, a4)
info

## [1] "Home: 507-645-5489"            "Cell: 219.917.9871"           
## [3] "My work phone is 507-202-2332" "I don't have a phone"

Bây giờ chúng em sẽ trích xuất các số điện thoại từ chuỗi này.

Mã vùng phải bắt đầu bằng số 2 trở lên, vì vậy chúng em sử dụng lại dấu ngoặc để biểu thị phạm vi: [2-9]. Hai chữ số tiếp theo có thể nằm trong khoảng từ 0 đến 9, vì vậy chúng tôi viết [0-9]{2}. Đối với dấu phân cách, chúng tôi sử dụng [-.] để biểu thị dấu gạch ngang hoặc dấu chấm.

Biểu thức chính quy hoàn chỉnh được đưa ra dưới đây:

phone <- "([2-9][0-9]{2})[-.]([0-9]{3})[-.]([0-9]{4})"
out <- str_detect(info, phone)
out

## [1]  TRUE  TRUE  TRUE FALSE

Một lần nữa, str_detectchỉ cho biết sự hiện diện hay vắng mặt của mẫu được đề cập.

str_extract(info, phone)

## [1] "507-645-5489" "219.917.9871" "507-202-2332" NA

Bây giờ chúng em ẩn danh các số điện thoại

str_replace(info, phone, "XXX-XXX-XXXX")

## [1] "Home: XXX-XXX-XXXX"            "Cell: XXX-XXX-XXXX"           
## [3] "My work phone is XXX-XXX-XXXX" "I don't have a phone"

Kết Luận: Như chúng em đã lưu ý ở trên, một số ký tự được bảo lưu. Nếu chúng ta thực sự muốn tham chiếu chúng trong một biểu thức chính quy, hãy đặt chúng trong dấu ngoặc vuông hoặc sử dụng dấu gạch chéo kép về phía trước.

2.6.3.2 Trích các địa chỉ mail

Việc trích các địa chỉ email thường phức tạp hơn so với số điện thoại. Bởi vì một địa chỉ email có thể chứa chữ hoa, chữ thường, chữ số, ký tự đặc biệt, mọi thứ. Chúng em sẽ thực hành trích địa chỉ email từ văn bản emails sau:

emails <- c("RashNErel@gmail.com",
          "rash.nerel@regen04.net",
          "rash_48@uni.edu",
          "rash_48_nerel@STB.org")

Một email với hai kí tự đặc biệt ngăn cách là ‘@’ và ‘.’ sẽ phân địa chỉ thành ba phần: phần trước kí tự ‘@’, phần sau dấu ‘@’ và trước kí tự ‘.’ và cuối cùng là phần còn lại. Ở đây, chỉ xét kí tự đặc biệt ‘@’ và ‘.’ xuất hiện đầu tiên trong chuỗi theo thứ tự từ trái qua phải.

• Phần đầu tiên bao gồm các kí tự viết thường, [a-z], viết hoa, [A-Z], các kí tự số, [0–9] và một số kí tự đặc biệt như ‘.’ và ‘_’. Do vậy, biểu thức chính quy có thể được viết là “[a-zA-Z0–9-.]+”. Ở đây, dấu ‘+’ cho biết các kí tự trên có thể xuất hiện nhiều hơn 1 lần (quy tắc 17). Bởi vì chúng ta không biết các kí tự xuất hiện bao nhiêu lần nên không thể sử dụng quy tắc 19.

• Phần thứ hai cũng tương tự phần đầu nên có thể được phát hiện qua biểu thức: “[a-zA-Z0–9-.]+”

• Phần thứ ba là phần còn lại. Bởi vì tôi đã thêm dấu ‘+’ sau phần thứ hai nên nó có thể nhận bất kì kí tự nào xuất hiện sau đó.

Tổng hợp lại, để trích các địa chỉ email từ văn bản emails trên, chúng em xây dựng một biểu thức chính quy như sau:

p <- "[a-zA-Z0-9-.]+@[a-zA_Z0-9]+"
str_extract_all(emails, p)

## [[1]]
## [1] "RashNErel@gmail"
## 
## [[2]]
## [1] "rash.nerel@regen04"
## 
## [[3]]
## [1] "48@uni"
## 
## [[4]]
## character(0)

Kết quả vẫn tốt khi chúng không đề cập đến các từ ‘com’, ‘net’, ‘edu’, ‘org’ như trong ví dụ. Tuy nhiên, vì mục đích mở rộng sau này, em nhận diện và trích xuất bằng cách sử dụng quy tắc 14 (hoặc) kết hợp quy tắc 15 (gom nhóm): “(com|edu|net|org”) như sau:

p <- "[a-zA-Z0-9-.]+@[a-zA_Z0-9]+\\.(com|edu|net|org)"
str_extract_all(emails, p)

## [[1]]
## [1] "RashNErel@gmail.com"
## 
## [[2]]
## [1] "rash.nerel@regen04.net"
## 
## [[3]]
## [1] "48@uni.edu"
## 
## [[4]]
## character(0)

2.6.3.3 Trích các URL

Việc trích các URL cũng tương tự như với số điện thoại, mặc dù có đôi chút bất tiện do các địa chỉ có thể bắt đầu với chuẩn http hay https, có hoặc không có www.. Chúng em sẽ thực hành trích các URL từ văn bản urls sau:

urls <- c("https://regenerativetoday.com",
         "http://setf.ml",
         "https://www.yahoo.com",
         "http://studio_base.net"
         )

Một URL sẽ bao gồm 3 phần:

• Phần đầu bao gồm các tiền tố http hay https, có hoặc không có www. Nó có thể được ghi nhận bằng cách sử dụng quy tắc 15, 18 như sau:

‘https?’: có hoặc không kí tự ‘s’ “(www.)?”: có hoặc không từ ‘www.’

• Phần thứ hai là tên miền có thể là bất kì kí tự thông thường nào được lặp lại nhiều hơn một lần –> sử dụng: “+”

• Phần thứ ba là sau tên miền: có thể có một hoặc nhiều hơn một dấu chấm “.” và theo sau là các kí tự thông thường khác –> sử dụng: “.+”

Tổng hợp lại, em sẽ viết biểu thức chính quy để trích các URL từ văn bản urls như sau:

p <- "https?://(www\\.)?\\w+\\.\\w+"
str_extract_all(urls, p)

## [[1]]
## [1] "https://regenerativetoday.com"
## 
## [[2]]
## [1] "http://setf.ml"
## 
## [[3]]
## [1] "https://www.yahoo.com"
## 
## [[4]]
## [1] "http://studio_base.net"

Trong trường hợp chỉ muốn lấy các tên miền ‘.com’ hoặc ‘.net’ thì bổ sung thêm nhóm (com|net) vào biểu thức chính quy trên như sau:

p <- "https?://(www\\.)?(\\w+)(\\.)+(com|net)"
str_extract_all(urls, p)

## [[1]]
## [1] "https://regenerativetoday.com"
## 
## [[2]]
## character(0)
## 
## [[3]]
## [1] "https://www.yahoo.com"
## 
## [[4]]
## [1] "http://studio_base.net"

2.6.3.4 Xuất danh bạ

Cuối cùng là ví dụ kết hợp các quy tắc để xuất các danh bạ từ một văn bản name sau:

name <- c("Mr. Jon",
         "Mrs. Jon",
         "Mr Ron",
         "Ms. Reene",
         "Ms Julie")

Một danh bạ bao gồm bí danh Mr, Mrs, Ms (–> sử dụng: “M(r|s|rs)”) có thể có hoặc không dấu ‘.’ đi kèm (–> sử dụng: “.?”), theo sau là một khoảng trắng (–> sử dụng: “”).

Sau đó là tên, với kí tự đầu tiên viết hoa (–> sử dụng: “[A-Z]”), theo sau là các kí tự thông thường (–> sử dụng: “”). Sử dụng dấu ’’ có nghĩa các kí tự trước đó có thể không xuất hiện hoặc xuất hiện nhiều lần. Kết hợp lại, biểu thức chính quy sau sẽ trích các danh bạ từ văn bản name như sau

p <- "M(r|s|rs)\\.?[A-Z\\s]\\w*"
str_extract_all(name, p)

## [[1]]
## [1] "Mr. Jon"
## 
## [[2]]
## [1] "Mrs. Jon"
## 
## [[3]]
## [1] "Mr Ron"
## 
## [[4]]
## [1] "Ms. Reene"
## 
## [[5]]
## [1] "Ms Julie"

2.6.4 Kết hợp các quy tắc và thao tác nâng cao trong chuỗi, biểu thức chính quy

3 Chương 4

3.1 Kết luận liên quan đến chủ đề

3.1.1 Ưm điểm

·        Cú pháp dễ đọc và sử dụng: Stringr cung cấp một tập hợp các hàm dễ đọc và dễ sử dụng cho các tác vụ xử lý chuỗi phổ biến. Cú pháp rõ ràng giúp người dùng nắm bắt nhanh chóng cách sử dụng các hàm.

·        Tích hợp tốt với dplyr và tidyr: Stringr được phát triển bởi cùng tác giả của gói dplyr và tidyr, nên nó tích hợp tốt với những gói này để thực hiện xử lý dữ liệu toàn diện, từ làm sạch dữ liệu đến biến đổi dữ liệu.

·        Cung cấp các hàm linh hoạt cho xử lý chuỗi: Gói Stringr cung cấp các hàm cho việc cắt chuỗi, thay thế, tách chuỗi thành các phần, chuẩn hóa khoảng trắng, và nhiều thao tác khác để xử lý chuỗi dễ dàng và hiệu quả.

·        Hỗ trợ biểu thức chính quy dễ hiểu: Stringr cung cấp cách thức sử dụng biểu thức chính quy một cách dễ hiểu và trực quan hơn. Điều này giúp người dùng không quen thuộc với biểu thức chính quy cũng có thể thực hiện các phép toán phức tạp trên chuỗi.

·        Tương thích với dữ liệu dạng tibble: Stringr cung cấp hàm str_detect() và str_subset() có thể dễ dàng tích hợp vào dữ liệu dạng tibble mà không cần chuyển đổi qua dạng ma trận.

·       Hiệu quả của bộ nhớ: Các chuỗi thường được lưu trữ trong một khối bộ nhớ liền kề, giúp phân bổ và giải phóng chúng hiệu quả. Điều này có nghĩa là chúng có thể được sử dụng để biểu diễn một lượng lớn dữ liệu mà không chiếm quá nhiều bộ nhớ.

Kết luận: gói Stringr là một công cụ mạnh mẽ và tiện ích cho việc làm việc với chuỗi trong R, đặc biệt là khi bạn làm việc với dữ liệu cấu trúc hoặc cần thực hiện các xử lý chuỗi phức tạp.

3.1.2 Nhược điểm

·        Khả năng sử dụng thấp cho xử lý dữ liệu lớn: stringr có thể trở nên chậm khi chúng áp dụng nó cho các tập dữ liệu lớn. Nếu cần xử lý chuỗi trong các tập dữ liệu có kích thước lớn, có thể cần phải tìm hiểu các phương pháp khác hiệu quả hơn để xử lý chuỗi.

·        Phụ thuộc vào gói dplyr và tidyr: stringr thường được sử dụng cùng với các gói khác như dplyr và tidyr để thực hiện xử lý dữ liệu toàn diện. Điều này có thể đôi khi tạo ra sự phức tạp và đòi hỏi người dùng phải hiểu rõ về cả các gói khác.

·        Yêu cầu kiến thức về biểu thức chính quy (regular expressions): Một số hàm trong stringr yêu cầu người dùng biết về biểu thức chính quy để thực hiện các phép toán phức tạp. Điều này có thể đặt khó khăn cho người mới học hoặc không quen thuộc với biểu thức chính quy.

·        Không hoàn toàn thay thế được các hàm chuỗi cơ bản trong R: Mặc dù stringr cung cấp nhiều tính năng tiện ích hơn cho việc làm việc với chuỗi so với các hàm chuỗi cơ bản trong R, nhưng vẫn có những tình huống mà chúng ta có thể cần phải sử dụng các hàm cơ bản này.

·        Khả năng đụng độ với các gói khác: Khi chúng ta sử dụng nhiều gói trong R cùng một lúc, có thể xảy ra xung đột tên hàm hoặc biến. Điều này có thể xảy ra khi stringr sử dụng các tên hàm tương tự như các gói khác.

·        Yêu cầu cài đặt gói phụ thuộc: Để sử dụng stringr, chúng cần phải cài đặt các gói phụ thuộc như dplyr và tidyr. Điều này có thể đòi hỏi thời gian và tài nguyên để cài đặt và duy trì các gói này.

·        Chi phí hoạt động: Các thao tác chuỗi có thể chậm hơn so với các thao tác trên các loại dữ liệu khác, đặc biệt là khi làm việc với các chuỗi lớn hoặc phức tạp. Điều này là do các thao tác chuỗi thường liên quan đến việc sao chép và phân bổ lại bộ nhớ, điều này có thể tốn nhiều thời gian.

Kết luận: mặc dù Stringr có nhiều ưu điểm trong việc làm việc với chuỗi trong R, nhưng cũng cần cân nhắc các hạn chế và điểm yếu của nó khi lựa chọn sử dụng gói này.

3.2 Kết Luận cho quá trình làm chủ đề

Trong quá trình chúng em làm tiểu luận, chúng em cảm thấy Stringr rất hữu ích. Vì nó hiển thị một tập hợp tối thiểu các hàm, đã được chọn cẩn thận để xử lý các hàm thao tác chuỗi phổ biến nhất. Stringr được thiết kế toàn diện, nó chứa hầu hết mọi chức năng mà chúng em cần để xử lý chuỗi có 59 của stringr.

Ngoài ra gói Stringr đã giúp chúng em học tập, thực hành và phát triển kỹ năng xử lý chuỗi trong R phù hợp với thời đại 4.0. Việc sử dụng gói Stringr trong bài tiểu luận không chỉ giúp chúng em nắm vững và áp dụng kiến thức về xử lý chuỗi trong R mà còn phát triển kỹ năng phù hợp với thời đại 4.0 như kỹ năng xử lý dữ liệu, giải quyết vấn đề cụ thể, phân tích và trình bày kết quả một cách cẩn thận và nâng cao kỹ năng lập trình trong quá trình học tập,công việc trong tương lai.