Tiểu Luận Package Stringr
Nguyễn Minh Khang 2121011757 - Phan Đắc Khánh Toàn 2121012730
2023-07-01
1 CHƯƠNG 1: Giới thiệu chung
1.1 Đặt vấn đề
Trong thời đại hiện nay, phân tích dữ liệu đóng vai trò vô cùng quan trọng và mang lại nhiều lợi ích trong nhiều lĩnh vực khác nhau. Các công việc như là xử lý dữ liệu cũng như phân tích văn bản ngày càng phổ biến và đòi hỏi sự tỉ mỉ hơn. Chính vì vậy nên nó làm chúng ta mất nhiều thời gian hơn. Để giải quyết những thách thức này, thì có nhiều cách khác nhau nhưng theo em thấy thì gói Stringr vẫn là tiện dụng nhất. Chúng ta có thể dùng nó để phân tích dữ liệu cũng như trích xuất các ngôn ngữ đặc trưng trong việc nghiên cứu tâm lý, sự tương tác và ngữ nghĩa trong dữ liệu văn bản.Ngoài ra, Stringr còn cung cấp các công cụ để tách từ, tách câu và thực hiện phân tích các ngôn ngữ khác. Điều này giúp chúng ta nghiên cứu phân tích các yếu tố ngôn ngữ dễ dàng hơn.
1.2 Gói Stringr
1.2.1 Nguồn gốc
Gói Stringr là một phần của Tidyverse, một bộ các gói R được phát triển bởi Hadley Wickham và nhóm của ông tại công ty RStudio. Tidyverse được thiết kế để cung cấp một cú pháp dễ đọc, nhất quán và hiệu quả cho việc làm việc với dữ liệu trong R. Gói Stringr được tạo ra để cung cấp các công cụ mạnh mẽ và dễ sử dụng cho xử lý chuỗi ký tự trong R. Hadley Wickham đã nhận thấy rằng việc xử lý và biến đổi chuỗi là một phần quan trọng trong quá trình tiền xử lý dữ liệu và phân tích dữ liệu văn bản. Do đó, ông đã phát triển gói “Stringr” nhằm giúp các nhà phân tích dữ liệu và người sử dụng R thực hiện các tác vụ xử lý chuỗi một cách dễ dàng và hiệu quả hơn. Gói Stringr đã được phát hành lần đầu tiên vào năm 2010 và tiếp tục được phát triển và duy trì trong thời gian kế tiếp. Nó đã trở thành một công cụ phổ biến trong cộng đồng R và được sử dụng rộng rãi trong nhiều lĩnh vực như xử lý ngôn ngữ tự nhiên, phân tích dữ liệu văn bản, khai phá dữ liệu, và nhiều ứng dụng khác liên quan đến chuỗi ký tự. Nguồn gốc của gói Stringr và các gói khác trong Tidyverse xuất phát từ tầm nhìn của Hadley Wickham về cách làm việc hiệu quả và nhất quán với dữ liệu trong R.
1.2.2 Giới thiệu biểu thức chính quy
Biểu thức chính quy được bắt nguồn từ năm 1951, khi nhà toán học Stephen Cole Kleene mô tả cả ngôn ngữ chính quy bằng cách sử dụng ký hiệu toán học của ông được gọi là các sự kiện chính quy. Biểu thức chính quy (Regular Expression hay Regex) được sử dụng phổ biển từ năm 1968 với hai mục đích sử dụng là một chuỗi các ký tự khớp với một mẫu trong soạn thảo văn bản và phân tích từ vựng trong trình biên dịch. Regex được sử dụng trong soạn thảo 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, tìm kiếm và thay thế có thể khác nhau ở các ngôn ngữ khác nhau.
Biểu thức chính quy được tạo ra bằng cách sử dụng các ký tự đặc biệt và ký tự thông thường để mô tả một mẫu ký tự cụ thể. Mỗi ký tự trong một biểu thức chính quy là một siêu ký tự, có ý nghĩa đặc biệt hoặc một ký tự thông thường có nghĩa đen. Khi một biểu thức chính quy được áp dụng cho một chuỗi văn bản, nó sẽ tìm kiếm các điểm trùng khớp với mẫu đã định nghĩa. Cú pháp siêu ký tự được thiết kế đặc biệt để biểu thị các mục tiêu được chỉ định theo cách ngắn gọn và linh hoạt nhằm hướng tự động hóa quá trình xử lý văn bản của nhiều loại dữ liệu đầu vào.
Dưới đây là một số ký tự đặc biệt thường được sử dụng trong biểu thức chính quy:
Ký tự thông thường: Đại diện cho chính nó. Ví dụ: “a” tìm kiếm ký tự “a” trong chuỗi
Dấu chấm (“.”): Đại diện cho bất kỳ ký tự nào, ngoại trừ ký tự xuống dòng.
Ký tự đặc biệt “” (backslash): Thường được sử dụng để làm cho ký tự sau nó không còn là ký tự đặc biệt mà trở thành ký tự thông thường. Ví dụ: “.” tìm kiếm dấu chấm thay vì áp dụng chức năng đặc biệt của dấu chấm.
Ký tự “[]”: Khớp các ký tự hoặc trong dấu ngoặc.
Ký tự “*”: Đại diện cho bất kỳ số lượng xuất hiện của ký tự trước nó (bao gồm cả không xuất hiện).
Ký tự “+”: Đại diện cho ít nhất một hoặc nhiều lần xuất hiện của ký tự trước nó.
Ký tự “?”: Đại diện cho không hoặc một lần xuất hiện của ký tự trước nó.
Ký tự “{}”: Xác định số lượng xuất hiện của ký tự trước nó. Ví dụ: “a{3}” tìm kiếm chuỗi “aaa”.
Ký tự “|”: Đại diện cho phép tìm kiếm một trong các biểu thức được định nghĩa. Ví dụ: “cat|dog” tìm kiếm từ “cat” hoặc “dog”.
Ký tự “^” và “$” : là điểm bắt đầu và điểm kết thúc của dòng
Đối với tất cả các dấu chấm câu, dấu gạch chéo ngược được đặt ở phía trước. Ví dụ “?” là biểu thức chính quy cho dấu chấm hỏi: “?”. Nhưng để viết “?” trong R, chúng ta phải sử dụng hai dấu gạch chéo ngược: “\?”
Đối với bất kỳ chữ số nào, cũng có thể sử dụng cụm từ thông dụng ” or also”[:digit:]“. Đối với các ký tự từ, bạn sử dụng”” hoặc “[:alpha:]” như một biểu thức chính quy.
“[:lower:]” và “[:upper:]”: Tương đương với [a-z]và [A-Z]tương ứng. Dùng để liệt kê các ký tự trong bảng chữ cái dưới dạng chữ thường và chữ in hoa.
“[:alnum:]”: Đại diện cho tất cả các ký tự chữ và số. Chúng giúp liệt kê các ký tự chữ cái bao gồm chữ hoa và chữ thường cùng với các số từ 0 đến 9
“[:punct:]”: So khớp các ký tự dấu chấm câu.
“[:space:]”: So khớp khoảng trắng như dấu cách, tab, dòng mới,…
“[:print:]”: Mọi thứ có thể in được.
1.2.3 Các chức năng của gói Stringr
Để đưa ra định hướng chung về các chức năng, nhóm chúng tôi sẽ trình bày tổng quan ngắn gọn về một số chức năng được sử dụng phổ biến nhất của gói Stringr
1.2.3.1 Quản lý độ dài
str_length(): Hàm str_length() trong gói Stringr trả về một vector chứa độ dài của từng chuỗi ký tự trong một vector chuỗi. Khi được áp dụng cho một vectơ, nó trẻ về một vectơ trong đó mỗi mục biểu thị số lượng ký tự trong một chuỗi tương ứng.
str_pad(): Hàm str_pad() trong gói Stringr có chức năng thêm các ký tự vào bên trái hoặc bên phải của chuỗi (dưới dạng khoảng trắng mặc định). Độ rộng đối số cho biết độ dài của chuỗi sau khi thêm các ký tự bổ sung.
str_trunc(): Hàm str_trunc() trong gói Stringr có chức năng rút ngắn chuỗi thành chiều rộng đối số đã cho. Cạnh mà chuỗi bị cắt được xác định bởi đối số cạnh.
str_trim(): Hàm str_trim() trong gói String có chức năng cắt ngắn các khoảng trắng từ đầu hoặc cuối hoặc cả hai.
1.2.3.2 Chuỗi con
str_sub(): Hàm str_sub() trong gói String có chức năng trả về mội chuỗi con của một chuỗi đã cho. Nó có ba tham số: - Chuỗi (hoặc một vectơ của chuỗi) - Chỉ số bắt đầu của chuỗi con - Chỉ số kết thúc của chuỗi con
str_subset(): Hàm str_subset() có chức năng trả về các chuỗi chứa mẫu khớp. Hàm tìm kiếm tất cả các chuỗi có mẫu đối số trong đó và trả cề tất cả các chuỗi phù hợp dưới dạng một tập hợp chuỗi nhỏ hơn. Nó có hai tham số: vectơ của chuỗi để tìm kiếm và chính mẫu tìm kiếm.
str_extract(): Hàm str_extract() có chức năng trả về kết quả khớp mẫu đầu tiên được tìm thấy trong mỗi chuỗi dưới dạng một vectơ ký tự.
str_match(): Hàm str_match() có chức năng trả về kết quả khớp mẫu đầu tiên được tìm thấy trong mỗi chuỗi, dưới dạng một ma trận với một cột cho mỗi nhóm () trong mẫu.
1.2.3.3 Phát hiện kết quả trùng khớp
str_detect(): Hàm str_detect() có chức năng phát hiện sự hiện diện của một mẫu phù hợp trong một chuỗi. Kết quả đơn giản là nếu mẫu được tìm thấy, hàm sẽ trả về TRUE và nếu không được tìm thấy, nó sẽ trả về FALSE
str_which(): Hàm str_which() có chức năng tìm các chỉ số của các chuỗi chứa mẫu khớp. Đầu ra là một vectơ với các chỉ số này
str_count(): Hàm str_count() có chức năng đếm số lần một mẫu tìm kiếm xấu hiện trong một chuỗi.Nó nhận hai tham số: chuỗi thực hiện tìm kiếm (hoặc một vectơ chuỗi) và mẫu tìm kiếm cũng có thể là một biểu thức chính quy.
str_locate(): Hàm str_locate() có chức năng xác định vị trí của mẫu khớp đầu tiên trong một chuỗi
1.2.3.4 Biến đổi chuỗi
str_replace (và replace_all): Hàm str_replace() có chức năng thay thế của chuỗi Stringr được sử dụng để khớp các mẫu và thay thế chúng bằng các chuỗi mới
str_to_lower(): Hàm str_to_lower() có chức năng để thay đổi văn bản thành chữ thường. Trong đó còn có các hàm:
str_to_title(): Viết hoa chữ cái đầu tiên của mỗi từ trong một chuỗi
str_to_upper(): Viết hoa toàn bộ chuỗi
1.2.3.5 Tham gia và chia tách
str_c(): Hàm str_c() có chức năng để nối nhiều chuỗi thành một chuỗi.
str_split(): Hàm str_split() có chức năng tách một chuỗi hoặc một vectơ của các chuỗi thành một vectơ của các chuỗi con hoặc một danh sách các vectơ của các chuỗi con, tùy thuộc vào định dạng của dữ liệu được truyền vào.
1.3 Lí do chọn chủ đề
R là một ngôn ngữ lập trình và môi trường phân tích dữ liệu phổ biến trong thời đại 4.0. Khi học R nhóm chúng em nhận thấy rằng, việc xử lý dữ liệu trong văn bản rất quan trọng trong việc thực hiện các nghiên cứu và phân tích dữ liệu. Để xử lý tốt một văn bản thì cần có các công cụ mạnh mẽ để tách, chuẩn hóa văn bản và xử lý các kí tự đặc biệt nên nhóm chúng em đã lựa chọn gói Stringr làm chủ đề để thực hiện các nghiên cứu và phân tích dữ liệu.
Ngoài ra, gói Stringr còn cung cấp các công cụ mạnh mẽ để xử lý, tách, chuẩn hóa và trích xuất thông tin từ dữ liệu văn bản. Sử dụng gói này trong bài tiểu luận giúp chúng em có khả năng hiểu và xử lý dữ liệu văn bản hiệu quả phù hợp với xu hướng và yêu cầu của thời đại 4.0. Thêm nữa gói Stringr được thiết kế để đạt hiệu suất cao trong xử lý chuỗi, đặc biệt là trên dữ liệu lớn. Việc sử dụng gói này giúp chúng em tiết kiệm thời gian và tăng tính hiệu quả trong quá trình xử lý dữ liệu chuỗi phức tạp
1.4 Mục tiêu của chủ đề
Mục tiêu chung : Sử dụng gói Stringr một cách tối ưu và hiệu quả trong quá trình làm tiểu luận. Chúng em phải tìm hiểu các chức năng và phương pháp trong package để giảm thiểu thời gian và công sức cần thiết cho xử lý chuỗi, đồng thời tăng tính linh hoạt và khả năng áp dụng vào các tác vụ xử lý chuỗi phức tạp.
Mục tiêu cụ thể:
- Mục tiêu 1: Biết xử lý và chuẩn hóa dữ liệu văn bản gì gói “stringr” cung cấp các hàm để loại bỏ khoảng trắng thừa, ký tự đặc biệt, dấu câu hoặc các ký tự không mong muốn trong văn bản. Điều này giúp tiền xử lý dữ liệu văn bản trước khi tiến hành phân tích, đồng thời chuẩn hóa dữ liệu để làm việc hiệu quả hơn.
- Mục tiêu 2: BIết cách tách từ và trích xuất thông tin, ví dụ có thể tách từ trong văn bản hoặc trích xuất các thông tin quan trọng như tên, số điện thoại, địa chỉ email, v.v. từ chuỗi dữ liệu
- Mục tiêu 3: Biết cách tách, ghép, chuẩn hóa, tìm kiếm hoặc thay thế các chuỗi trong dữ liệu của mình, và sau đó phân tích và báo cáo kết quả một cách chi tiết và rõ ràng.
- Mục tiêu 4: Biết kiểm tra và so sánh chuỗi vì package “stringr” cung cấp các hàm để kiểm tra và so sánh chuỗi, giúp kiểm tra tính hợp lệ của định dạng, tìm kiếm chuỗi con trong chuỗi cha, và thực hiện các phép toán so sánh chuỗi.
- Mục tiêu 5: Sử dụng biểu thức chính quy linh hoạt: Gói “stringr” hỗ trợ sử dụng biểu thức chính quy trong việc tìm kiếm và thay thế các mẫu trong chuỗi. Điều này cho phép bạn thực hiện các tác vụ phức tạp như tìm kiếm theo mẫu, lọc dữ liệu, và thay đổi định dạng chuỗi dễ dàng.
1.5 Lợi ích của chủ đề
Gói Stringr trong Rstudio đã mang lại nhiều lợi ích đáng kể cho việc xử lý dữ liệu nhưng nó cũng có thể được sử dụng để phân tích văn bản, đặc biệt là trong việc xử lý và biến đổi chuổi kí tự. Một số lợi ích chính của gói Stringr:
- Dễ sử dụng: Stringr được thiết kế thân thiện và dễ sử dụng, ngay cả đối với người mới bắt đầu chưa có kinh nghiệm lập trình. Nó cung cấp một loạt các công cụ và chức năng giúp dễ dàng khám phá, làm sạch, trực quan hóa và phân tích dữ liệu.
- Các tính năng mạnh mẽ: Mặc dù đơn giản nhưng Stringr có một loạt các tính năng nâng cao cho phép bạn thực hiện các tác vụ phân tích dữ liệu phức tạp. Chúng bao gồm các thuật toán học máy, kiểm tra thống kê và chức năng chuyển đổi dữ liệu.
- Được sử dụng rộng rãi: Stringr là một gói phổ biến trong R, với cộng đồng người. Điều đó có nghĩa là chúng ta có thể tìm thấy nhiều tài liệu và hỗ trợ trực tuyến nếu bạn có bất kỳ câu hỏi nào hoặc cần trợ giúp về một nhiệm vụ cụ thể.
- Tính linh hoạt: R là một ngôn ngữ lập trình mạnh mẽ cho phép bạn tùy chỉnh quy trình phân tích dữ liệu cho phù hợp với nhu cầu của mình. Với Stringr, chúng ta có thể truy cập đầy đủ các khả năng của R và tích hợp nó với các gói và công cụ khác.
- Tích hợp tốt với các gói khác trong Tidyverse: Gói “Stringr” được phát triển như một phần của “tidyverse”, vì vậy nó tích hợp tốt với các gói khác trong “tidyverse” như “dplyr”, “ggplot2”, và “tidyr”. Điều này cho phép chúng ta kết hợp các công cụ phân tích dữ liệu khác và thực hiện các tác vụ phức tạp trên dữ liệu chuỗi một cách linh hoạt và mạnh mẽ.
Gói Stringr là một lựa chọn tốt để phân tích dữ liệu trong R do dễ sử dụng, các tính năng mạnh mẽ, được áp dụng rộng rãi và linh hoạt, đồng thời kết hợp tốt với các gói trong “Tidyverse”.
2 CHƯƠNG 2: Thao tác với chức năng của Stringr
Trong chương này nhóm chúng tôi sẽ đi sâu vào cách làm việc phân tích các với chuỗi trong R và phân tích đi sâu vào cách làm việc của hàm trong Stringr để xử lí các chuỗi. Trọng tâm của chương này sẽ là biểu thức chính quy, biểu thức chính quy là ngôn ngữ hữu ích đối với gói Stringr vì các chuỗi thường chứa dữ liệu phi cấu trúc hoặc bán cấu trúc và biểu thức chính quy là ngôn ngữ ngắn gọn để mô tả các mẫu trong chuỗi.
2.1 Giới thiệu chuỗi
Chuỗi ký tự có thể xuất hiện trong tất cả các dự án của 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. Bản thân các chuỗi là dữ liệu quan tâm và chúng ta 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ố thao tác 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 Bộ dữ liệu
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. Tôi 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"sentences = stringr::sentences
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."Để thực hiện tốt hơn 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(dplyr)## Warning: package 'dplyr' was built under R version 4.2.3##
## Attaching package: 'dplyr'## The following objects are masked from 'package:stats':
##
## filter, lag## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, unionlibrary(babynames)## Warning: package 'babynames' was built under R version 4.2.3Trướ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
babynames = babynames::babynames
head(babynames)## # A tibble: 6 × 5
## year sex name n prop
## <dbl> <chr> <chr> <int> <dbl>
## 1 1880 F Mary 7065 0.0724
## 2 1880 F Anna 2604 0.0267
## 3 1880 F Emma 2003 0.0205
## 4 1880 F Elizabeth 1939 0.0199
## 5 1880 F Minnie 1746 0.0179
## 6 1880 F Margaret 1578 0.01622.3 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 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 để thực hiện các chức năng liên quan đến chuỗi thì chúng ta cần cài đặt và gọi gói Stringr lên.
library(stringr)2.3.1 Quản lý độ dài chuỗi
1. str_length(string): 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ự.
str_length(sentences[2])## [1] 43=> Kết quả này trả về cho chúng ta biết độ dài của dòng thử 2 của sentences bao gồm 43 kí tự bao gồm cả khoảng trắng.
Ví dụ: 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
head(boy_names)## [1] "Noah" "Liam" "Mason" "Jacob" "William" "Ethan"Bây giờ em sẽ dùng chứng năng str_length để tìm độ dài của tất cả các tên trong boy_names mà đã được liệt kê ở trên, sau đó em dùng lệnh head() để xem kết quả trả về của độ dài các tên đó
boy_length <- str_length(boy_names)
head(boy_length)## [1] 4 4 5 5 7 5Chúng ta cũng có thể dùng hàm chứng năng str_length để so sánh độ dài trung bình giữa tên con gái và con trai và câu lệnh phía dưới chúng em sẽ thực hiện lệnh đó:
girl_length <- str_length(girl_names)
mean(girl_length) - mean(boy_length)## [1] 0.3374758=> Kết quả trả về cho thấy độ dài trung bình của các tên trong girls_name dài hơn boy_name là 0.3374758
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 bằ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 sử dụng để đệm chuỗi và kết quả sẽ trả về một vecto chứa các chuỗi được đệm. Dưới đây là một số tham số trong hàm.
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ụ 1: Em đệm thêm 15 kí tự là khoảng trắng ở phía bên trái cho chuỗi fruit ở dòng 1 là apple
str_pad(fruit[1],width = 15, side = 'left')## [1] " apple"Ví dụ 2: Em đệm thêm 20 khoảng trắng ở cả hai bên bằng dấu ” - “ cho fruit ở dòng 2 là apricot
str_pad(fruit[2],width = 20, side = 'both', pad = '-' )## [1] "------apricot-------"Ví dụ 3: Em đệm thêm 50 khoảng trắng bằng số 0 vào chuỗi sentences ở dòng thứ 2 của chuỗi và kết quả trả về kết quả dưới đây:
str_pad(sentences[2],width = 50, side = 'right', pad = '0')## [1] "Glue the sheet to the dark blue background.0000000"Ví dụ 4: Trong ví dụ này em muốn đệm thêm 100 kí tự là dấu “.” ở bên phải vào chuỗi sentences ở dòng thứ 5. Và câu lệnh trả về kết quả:
str_pad(sentences[5],width = 100, side = 'right', pad = '.')## [1] "Rice is often served in round bowls................................................................."Ví dụ 5: 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") #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*"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)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. Rút ngắn chuỗi bằng str_trunc()
Rút ngắn chuỗi liên quan đến việc rút ngắn các ký tự ở đầu, cuối hoặc ở giữa của chuỗi. Hàm str_trunc() trong gói Stringr có chức năng rút ngắn chuỗi thành chiều rộng đối số đã cho, cạnh mà chuỗi bị cắt được xác định bởi đối số cạnh.
Cú pháp: str_trunc(string,width, side = c(“left”,“right”,“center”):
- string: là chuỗi đầu vào mà chúng ta muốn cắt
- width: chiều rộng tối đa của chuỗi
- side: Vị trí cho biết nội dung đã bị xóa
Ví dụ: Trong ví dụ này chúng em dùng chức năng str_trunc để cắt 17 kí tự ở phía bên phải của chuỗi sentences ở dòng thứ 2 và kết quả trả về là:
str_trunc(sentences[1],width = 17,side = 'right')## [1] "The birch cano..."4. Cắt xén chuỗi bằng str_trim()
Cắt xén chuỗi liên quan đến việc loại bỏ các ký tự trắng ở đầu hoặc cuối chuỗi. Hàm str_trim() trong gói Stringr được sử dụng để cắt chuỗi và kết quả trả về một vecto ký tự chứa các chuỗi đã cắt. Dưới đây là các tham số trong hàm.
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 vecto của chuỗi sẽ được cắt bớt
- side: Tham số này chỉ định cho các bên của chuỗi cần cắt, có thể là phía phải, trái hoặc cả hai bên
Ví dụ:
str_trim(sentences[5],side = 'left')## [1] "Rice is often served in round bowls."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.3.2 Chuỗi con
1. Trích xuất dữ liệu bằng cách sử dụng str_sub()
Trích xuất chuỗi con liên quan đến việc trích một phần của chuỗi. Hàm str_sub() trong gói Stringr được sử dụng để trích xuất hoặc thay thế các chuỗi con. Dưới đây là một số tham số được sử dụng trong hàm str_sub():
Cú pháp: str_sub(string, start = 1L, end = -1L)
- 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à ba ký tự đầu tiên.
bg <- c("boy_names","girl_names")
str_sub(bg,1,3)## [1] "boy" "gir"Ví dụ: chúng ta có thể trích xuất chuỗi con với những kí tự cuối chuỗi bằng số nguyên âm. Trong ví str_sub(bg,-3,-1) yêu cầu chuỗi con bằng 3 kí tự cuối chuỗi.
str_sub(bg,-3,-1)## [1] "mes" "mes"Bên cạnh đó chúng ta có thể trích xuất các chữ cái đâu tiên trong boy_names sau đó chúng ta 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=> Kết quả cho chúng ta biết có 1454 người có tên bắt đầu bằng chữ A, có 651 người bắt đầu bằng chữ B,…
Hoặc là chúng ta có thể 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=> Kết quả trả về cho chúng ta biết có 421 người có tên kết thúc bằng chữ a, 104 người có tên kết thức bằng chữ b,..,
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. Lọc các chuỗi con phù hợp với một mẫu bằng str_subset()
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 đều đó trong một bước. Ví dụ: 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"=> “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 đầu xuất hiện đầu tiên của một mẫu trong chuỗi ký tự hoặc vecto của chuỗi. Hàm str_extract() trả về một vecto chứa ký tự chứa các chuỗi con được trích xuất.
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 vecto 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 vecto 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 muốn trích xuất các từ có trái cây trong “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(string, 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.3 Phát hiện kết quả trùng khớp
2.3.3.1 Tìm kiếm và trích xuấ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.
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
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 FALSEMột ứng dụng phổ biến là sử dụng véc tơ 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 ...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(x,'a')## start end
## [1,] 6 6
## [2,] 7 72.3.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ó thể được gọi trên một vecto chuỗi và một vecto đế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 tim thấy.
Cú pháp:str_count(string, pattern = “”)
Trong đó:
- string: Chuỗi để đếm số lần xuất hiện của
- pattern: mẫu phù hợp
Ví dụ: str_count() hàm này sẽ trả về số lượng kết quả khớp trong mỗi chuỗi
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)
2.3.4 Biến đổi chuỗi
2.3.4.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ặ 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
Cú pháp: 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 trong đó
- 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
Ví dụ: Đầ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
2.3.4.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ụ: Đầu tiên chúng em sẽ lấy dữ liệu từ fruit là 3 loại trái cây và gán lại chúng vào fruit
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.3.4.3 Tham gia và chia tách
1. Nối chuỗi bằ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ố được 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(string, sep, collapse, ignore_na, trim)
Trong đó:
- string: 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.
Ví dụ: Hợp nhất nhiều ký tự 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"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
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á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]Ngoài ra 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
Nói chung, 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] 7Kế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.4 Khai thác chuỗi với biểu thức chính quy
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 trong stringr, giúp tăng đáng kể khả năng thao tác các chuỗi của mình.
2.4.1 Biểu thức chính quy
Biểu thức chính quy hay còn gọi là Regex là một công cụ mạnh mẽ để khớp mẫu và thao tác chuỗi. Là một công cụ rất quan trọng và hữu ích đối với gói Stringr nói riêng mà các gói trong R nói chung. Chúng cho phép chúng ta tìm kiếm, khớp và thao tác văn bản dựa trên các mẫu. Trong Rstudio, các biểu thức chính quy được sử dụng rộng rãi để thực hiện các tác vụ như làm sạch dữ liệu, trích xuất văn bản và xác thực dữ liệu.
2.4.1.1 Thao tác chuỗi với biểu thức chính quy
Dưới đây là 20 quy tắc cơ bản về biểu thức chính quy được áp dụng phổ biến trong khai thác văn bản giúp chúng em thao tác với chuỗi một cách hiệu quả và dễ dàng hơn.
“.” = bất kì kí tự nào
” = 1 kí tự số bất kì từ 0 đến 9
” ” = không phải 1 kí tự số từ 0 đến 9
” ” = một kí tự thông thường (a-z, A-Z, 0-9, _)
” ” = không phải một kí tự thông thường
” ” = một kí tự trắng như: space, tab, newline
” ” = không phải một kí tự trắng
” = khớp nguyên từ (word boundary)
” ” = chỉ lấy một phần của từ
” ^ ” = bắt đầu của một chuỗi
“$” = kết thúc của một chuỗi
[] = khớp các kí tự trong ngoặc
[^ ] = khớp các kí tự không có trong ngoặc
“|” = hoặc
( ) = gom nhóm
“*” = khớp 0 lần hoặc nhiều hơn
“+” = khớp ít nhất 1 lần
“?” = có hoặc không
{x} = xuất hiện đúng x lần
{x, y} = khoảng giá trị cần so khớp (GTLN, GTNN)
- Ở đây chúng tôi có một số chuỗi bao gồm số kí tự số, chữ và kí tự đặc biệt để thao tác chuỗi bằng biểu thức chính quy và gán các chuỗi bằng regex1
regex1 <- c('Nancy Smith',
'is there any solution?',
".[{(^$|?*+",
"coreyms.com",
"321-555-4321",
"123.555.1234",
"123*555*1234")2.4.1.1.1 Trích các kí tự số
Trong gói Stringr có hàm str_extract_all() dùng để trích các kí tự từ một chuỗi thõa mãn các tiêu chí cần trích. Để thực hiện trích các kí tự số chúng em sẽ dùng hàm str_extract_all() trong gói Stringr kết hợp với quy tắc số 2 đã được nêu ở trên là quy tắc **.
str_extract_all(regex1, "\\d")## [[1]]
## character(0)
##
## [[2]]
## character(0)
##
## [[3]]
## character(0)
##
## [[4]]
## character(0)
##
## [[5]]
## [1] "3" "2" "1" "5" "5" "5" "4" "3" "2" "1"
##
## [[6]]
## [1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"
##
## [[7]]
## [1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"Nhận xét: Trong chuỗi regex1 ban đầu, sau khi thực hiện trích các kí tự số kết quả chạy được cho ra bốn chuỗi đầu tiên không có bất kì kí tự nào tức là bốn chuỗi là kết quả rỗng. Ba chuỗi cuối là các số điện thoại và biểu thức chính quy đã lọc những kí tự số này ra từng kí tự số riêng lẻ.
2.4.1.1.2 Loại trừ kí tự số
Để loại trừ các kí tự số em tiếp tục dùng chức năng str_extract_all() kết hợp với quy tắc * để loại bỏ các kí tự là số từ 0 đến 9
str_extract_all(regex1, "\\D")## [[1]]
## [1] "N" "a" "n" "c" "y" " " "S" "m" "i" "t" "h"
##
## [[2]]
## [1] "i" "s" " " "t" "h" "e" "r" "e" " " "a" "n" "y" " " "s" "o" "l" "u" "t" "i"
## [20] "o" "n" "?"
##
## [[3]]
## [1] "." "[" "{" "(" "^" "$" "|" "?" "*" "+"
##
## [[4]]
## [1] "c" "o" "r" "e" "y" "m" "s" "." "c" "o" "m"
##
## [[5]]
## [1] "-" "-"
##
## [[6]]
## [1] "." "."
##
## [[7]]
## [1] "*" "*"Nhận xét: Kết quả trả về cho chúng ta thấy các chuỗi 5,6,7 đã được trích hết các kí tự là số còn lại các kí tự đặc biệt như “-”, “.” hay “*“. Các kí tự ở bốn chuỗi đầu đã được trích hết ra từng kí tự riêng lẻ được đặt trong cặp dấu” “.
2.4.1.1.3 Loại trừ các kí tự đặc biệt
Để loại trừ các kí tự đặc biệt em dùng quy tắc “” kết hợp với chức năng str_extract_all để lọc tất cả các kí tự bao gồm a-z,A-Z,0-9 và kí tự gạch chân “_”
str_extract_all(regex1, "\\w")## [[1]]
## [1] "N" "a" "n" "c" "y" "S" "m" "i" "t" "h"
##
## [[2]]
## [1] "i" "s" "t" "h" "e" "r" "e" "a" "n" "y" "s" "o" "l" "u" "t" "i" "o" "n"
##
## [[3]]
## character(0)
##
## [[4]]
## [1] "c" "o" "r" "e" "y" "m" "s" "c" "o" "m"
##
## [[5]]
## [1] "3" "2" "1" "5" "5" "5" "4" "3" "2" "1"
##
## [[6]]
## [1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"
##
## [[7]]
## [1] "1" "2" "3" "5" "5" "5" "1" "2" "3" "4"2.4.1.1.4 Chỉ lấy các kí tự đặc biệt
Ngược lại với câu lệnh ở trên thì bây giờ chúng tôi chỉ lấy những kí tự đặc biệt, dùng quy tắc “” kết hợp với str_extract_all() để lọc ra các kí tự đặc biệt
str_extract_all(regex1, "\\W")## [[1]]
## [1] " "
##
## [[2]]
## [1] " " " " " " "?"
##
## [[3]]
## [1] "." "[" "{" "(" "^" "$" "|" "?" "*" "+"
##
## [[4]]
## [1] "."
##
## [[5]]
## [1] "-" "-"
##
## [[6]]
## [1] "." "."
##
## [[7]]
## [1] "*" "*"2.4.1.1.5 Bắt đầu và kết thúc chuỗi
Để tìm vị trí bắt đầu và kết thúc trong chuỗi chúng em sử dụng 2 quy tắc trong biểu thức chính quy là “^” và “$” để so khớp kí tự ở vị trí bắt đầu và kết thúc trong một chuỗi
Ví dụ: Để tìm được vị trí kết thức bởi dấu chấm than(!) trong chuỗi regex2 bên dưới:
regex2 <- c("This is me",
"That my house",
"Hello, world!")
str_extract_all(regex2, "!$")## [[1]]
## character(0)
##
## [[2]]
## character(0)
##
## [[3]]
## [1] "!"Để hiện thị chuỗi đã được tìm thấy, chúng tôi sử dụng hàm str_detect() trong gói Stringr.
regex2[str_detect(regex2, "!$")]## [1] "Hello, world!"Tiếp tục chúng tôi sẽ tìm vị trí bắt đầu với từ “this”
regex2[str_detect(regex2, "^This")]## [1] "This is me"2.4.1.1.6 Tìm kí tự hoặc số trong chuỗi
Tiếp tục với các chuỗi đầu đã được gán trong regex1 để thực hiện trích các số trong chuỗi. Ở các chuỗi trong regex1 có thể thấy rằng có 3 chuỗi là dạng chuỗi kí tự dạng số và bây giờ chúng tôi sẽ thử trích tất cả các số trong đoạn từ 2 đến 4 bao gồm cả hai bên và đặt chúng trong dấu ngoặc vuông “[]”
str_extract_all(regex1, "[2-4]")## [[1]]
## character(0)
##
## [[2]]
## character(0)
##
## [[3]]
## character(0)
##
## [[4]]
## character(0)
##
## [[5]]
## [1] "3" "2" "4" "3" "2"
##
## [[6]]
## [1] "2" "3" "2" "3" "4"
##
## [[7]]
## [1] "2" "3" "2" "3" "4"Nhận xét: Kết quả trả về cho chúng tôi thấy có 4 chuỗi đầu là không phải là kí tự số tức là kết quả cho ra chuỗi rỗng
Tiếp theo chúng tôi sẽ trích các kí tự “-” hoặc “.” và đặt chúng trong dấu “[]”
str_extract_all(regex1, "[-.]")## [[1]]
## character(0)
##
## [[2]]
## character(0)
##
## [[3]]
## [1] "."
##
## [[4]]
## [1] "."
##
## [[5]]
## [1] "-" "-"
##
## [[6]]
## [1] "." "."
##
## [[7]]
## character(0)Nhận xét: Kết quả trả về cho chúng ta thấy có 3 chuỗi là cho ra kết quả rỗng tức là không có chuỗi có 2 kí tự đã được trích.
2.4.1.2 Ứng dụng của biểu thức chính quy
2.4.1.2.1 Trích xuất số điện thoại
Đầu tiên 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 FALSEBâ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"2.4.1.2.2 Trích các địa chỉ email
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)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.4.1.2.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.4.1.2.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.4.1.2.5 Tập tin
Ở đây em có 8 tập tin từ năm 1999 đến năm 2011 chưa được xử lý nên dữ liệu bên trong là dữ liệu thô, bây giờ em sẽ dùng chức năng str_subset() để trích xuất các tệp từ năm 2003 trở lên
files <- c("file1999.txt", "file2000.txt", "file2001.txt", "file2002.txt", "file2003.txt",
"file2009.txt", "file2010.txt", "file2011.txt")
str_subset(files, "(200[3-9]{1}|201[0-9]{1})")## [1] "file2003.txt" "file2009.txt" "file2010.txt" "file2011.txt"3 CHƯƠNG 3: Một số ứng dụng của gói Stringr
Trong chương này chúng em sẽ ứng dụng các chức năng đã được thao tác ở chương 2 vào phân tích trên một số bộ dữ liệu giúp người đọc có thể nhận thấy và hiểu rõ hơn về gói Stringr.
3.1 Dữ liệu Babynames
Bộ dữ liệu Babynames trong ngôn ngữ lập trình R là một tập hợp dữ liệu thống kê về tên trẻ sơ sinh theo thời gian và tần suất sử dụng tên đó trong các năm khác nhau từ năm 1880 đến năm 2017. Bộ dữ liệu này bao gồm 1924665 quan sát và có 5 biến. Trong đó:
- year: Năm sinh
- sex: Giới tính
- name: Tên
- n: Số lần tên đó được sử dụng
- prop: Tỷ lệ phần trắm tên cụ thể trong số tất cả các tên cùng giới tính trong cùng một năm
babynames## # A tibble: 1,924,665 × 5
## year sex name n prop
## <dbl> <chr> <chr> <int> <dbl>
## 1 1880 F Mary 7065 0.0724
## 2 1880 F Anna 2604 0.0267
## 3 1880 F Emma 2003 0.0205
## 4 1880 F Elizabeth 1939 0.0199
## 5 1880 F Minnie 1746 0.0179
## 6 1880 F Margaret 1578 0.0162
## 7 1880 F Ida 1472 0.0151
## 8 1880 F Alice 1414 0.0145
## 9 1880 F Bertha 1320 0.0135
## 10 1880 F Sarah 1288 0.0132
## # ℹ 1,924,655 more rowsĐầu tiên, chúng em sử dụng str_detect() đề tìm tất cả các tên bắt đầu bằng ‘sh’. Sau đó để chi tiết hơn chúng em kết hợp gói ggplot để viết một bộ mã dài và phức tạp sẽ trực quan hóa các tên phổ biến bắt đầu bằng ‘sh’ cho phụ nữ sinh năm 1938
babynames %>%
filter(str_detect(name, "Sh") & sex=="F" & year == 1938) %>%
arrange(desc(prop)) %>%
head(20) %>%
ggplot(aes(reorder(name,prop),prop, fill = name)) +
geom_col() +
coord_flip()
Sau khi lọc và sắp xếp, chúng em đã tạo ra một biểu đồ cột thể hiện 20 tên phổ biến nhất trong tập dữ liệu. Biểu đồ này sẽ được vẽ với trục dọc, và mỗi cột sẽ đại diện cho một tên, có chiều cao thể hiện tỷ lệ phổ biến của tên đó trong tập dữ liệu.
Để hiểu rõ hơn về kết quả cụ thể,tiếp theo em sẽ tính tỷ lệ phần trăm cho mỗi năm/mỗi giới tính
Biểu đồ này sẽ giúp chúng ta thấy rõ hơn về tần suất của các tên chứa chuỗi “Sh” và cách chúng phân chia phần trăm phổ biến. Các tên phổ biến hơn sẽ có cột cao hơn, và cột thấp hơn sẽ đại diện cho các tên ít phổ biến hơn.
babynames %>%
filter(str_detect(name, "Sh") & sex=="F" & year == 1938) %>%
arrange(desc(prop)) %>%
head(20) %>%
mutate(percent = (prop * 100)) %>%
ggplot(aes(reorder(name,percent),percent, fill = name)) +
geom_col() +
coord_flip()
Nhận xét: Qua 2 biểu đồ trên có thể thấy người có tên Shirley là có tỷ lệ phần trăm cao trong số những người phụ nữ sinh năm 1938
Tuy nhiên, để có cái nhìn chính xác hơn về kết quả cũng như có thể xác định được kết quả cuối cùng và hiểu rõ hơn về phân phối của các tên , nên bây giờ chúng em dùng str_detect() để xem có bao nhiêu người có tên bắt đầu bằng dữ ‘z’ từ năm 2000
babynames %>%
filter(year > 2000 & str_detect(name, "Z")) %>%
arrange(desc(prop))## # A tibble: 13,018 × 5
## year sex name n prop
## <dbl> <chr> <chr> <int> <dbl>
## 1 2001 M Zachary 18186 0.00880
## 2 2002 M Zachary 16622 0.00805
## 3 2003 M Zachary 15539 0.00740
## 4 2004 M Zachary 13711 0.00649
## 5 2005 M Zachary 12283 0.00578
## 6 2006 M Zachary 11005 0.00502
## 7 2007 M Zachary 10212 0.00461
## 8 2008 M Zachary 9226 0.00424
## 9 2012 F Zoey 7466 0.00386
## 10 2009 M Zachary 8078 0.00381
## # ℹ 13,008 more rowsKết quả đã hiển thì đc rằng: tập dữ liệu này chứa các tên của các em bé sinh sau năm 2000 và chứa ký tự “Z”, được sắp xếp theo thứ tự giảm dần của tỷ lệ prop . Thay vì sắp xếp những tên theo mức độ phổ biến thì chúng em sẽ phân loại xem những tên có nhiều chữ ‘Z’ nhất
babynames %>%
mutate(Z = str_count(babynames$name, "[zZ]")) %>%
arrange(desc(Z))## # A tibble: 1,924,665 × 6
## year sex name n prop Z
## <dbl> <chr> <chr> <int> <dbl> <int>
## 1 2010 M Zzyzx 5 0.00000244 3
## 2 1880 F Lizzie 388 0.00398 2
## 3 1880 F Kizzie 13 0.000133 2
## 4 1881 F Lizzie 396 0.00401 2
## 5 1881 F Kizzie 9 0.0000910 2
## 6 1882 F Lizzie 495 0.00428 2
## 7 1882 F Kizzie 9 0.0000778 2
## 8 1882 F Dezzie 5 0.0000432 2
## 9 1883 F Lizzie 496 0.00413 2
## 10 1883 F Kizzie 14 0.000117 2
## # ℹ 1,924,655 more rowsChúng em đã tạo ra một tập dữ liệu mới bằng cách thêm cột “Z” vào tập dữ liệu ban đầu. Cột “Z” chứa số lượng lần xuất hiện của ký tự “z” hoặc “Z” trong mỗi tên. Sau đó, tập dữ liệu được sắp xếp theo thứ tự giảm dần của cột “Z”.
Ví dụ: dòng đầu tiên cho thấy rằng trong năm 2010, có 5 em bé nam được đặt tên là “Zzyzx”. Tên này có tỷ lệ xuất hiện rất thấp (0.00000244), nhưng lại chứa 3 ký tự “z” hoặc “Z”.
Cuối cùng để xem có bao nhiêu tên có chứa ‘liz’ và vẽ chúng bằng biểu đồ để thấy rõ hơn
babynames %>%
filter(str_detect(babynames$name, "liz") ) %>%
count(name, sort = TRUE) %>%
head(20) %>%
ggplot(aes(reorder(name, n),n)) + geom_col() +
coord_flip()
Nhận xét: nhìn vào biểu đồ ta có thẻ thấy Elizabeth là tên phổ biến nhất trong tên chứa chuỗi “liz”,
3.2 Murders
Để hiểu hỏi về các chức năng trong gói Stringr thì nhóm chúng em sẽ thao tác trên bộ dữ liệu murders. Bộ dữ liệu Murders là dữ liệu được cung cấp bởi gói dữ liệu “dalabs” trong Rstudio. Bộ dữ liệu này chứa thông tin về số lượng vụ ấn giết người của từng tiểu bang ở Hoa Kỳ trong một khoảng thời gian cụ thể. Ở bộ dữ liệu này giúp chúng ta làm việc với các chuỗi nằm trong một cột trong một khung dữ liệu và chúng em sẽ tìm hiểu cách tập hợp một khung dữ liệu theo các chuỗi chúng ta muốn.
Đầu tiên chúng ta sẽ gọi bộ dữ liệu này lên sau khi đã cài đặt package dalabs và tải thư viện nó lên. Bảng dữ liệu bên dưới, mỗi quan sát sẽ cho chúng ta biết thông tin về tên của tiểu bang, tên viết tắt của tiểu bang đó, vùng của tiểu bang, dân số của tiểu bang tương ứng, tổng số vụ án giết người trong tiểu bang trong năm tương ứng.
library(dslabs)## Warning: package 'dslabs' was built under R version 4.2.3data("murders")
datatable(murders)Qua bảng trên chúng ta có thể thấy dataframe này có 2 cột là chuỗi ký tự và cột vùng là hệ số nhưng có thể dễ dàng đổi thành kiểu ký tự. Thông thường chúng ta sẽ chỉ muốn lấy các hàng của khung dữ liệu đáp ứng một tiêu chí nhất định. Để làm điều đó dữ trên chuỗi, chúng em sẽ sử dụng filter() và str_detect(). Bây giờ chúng em sẽ rút ra tất cả các hàng có trạng thái
# Các trạng thái bắt đầu bằng A
murders %>%
filter(str_detect(string = state, pattern = "A"))## state abb region population total
## 1 Alabama AL South 4779736 135
## 2 Alaska AK West 710231 19
## 3 Arizona AZ West 6392017 232
## 4 Arkansas AR South 2915918 93# Các trạng thái bắt đầu bằng A hoặc C
murders %>%
filter(str_detect(string = state, pattern = "A|C"))## state abb region population total
## 1 Alabama AL South 4779736 135
## 2 Alaska AK West 710231 19
## 3 Arizona AZ West 6392017 232
## 4 Arkansas AR South 2915918 93
## 5 California CA West 37253956 1257
## 6 Colorado CO West 5029196 65
## 7 Connecticut CT Northeast 3574097 97
## 8 District of Columbia DC South 601723 99
## 9 North Carolina NC South 9535483 286
## 10 South Carolina SC South 4625364 207Nhận xét: Chúng ta đã lọc ra các tiểu bang có tên chứa ít nhất một trong hai ký tự “A” hoặc “C” từ tập dữ liệu “murders”. Điều này có thể giúp chúng ra có các thông tin về tiểu bang, khu vực, dân số và số vụ án giết người đã được hiển thị chứa các ký tự cụ thể
Một cách khác mà chúng em có thể cần để thao tác với một cột chuỗi ký tự là thay đổi các từ. Ví dụ, trong khung dữ liệu vụ giết người, chúng em sẽ thay đổi tên của các khu vực để tất cả chúng đều là một từ và tất cả đều là chữ thường. Để làm điều này, chúng em sẽ kết hợp các str_c() và chức năng str_replace().
states.of.interest <- c("Texas",
"Louisiana",
"Mississippi",
"Alabama",
"Florida")
states.of.interest <- str_c(states.of.interest, collapse="|")
states.of.interest## [1] "Texas|Louisiana|Mississippi|Alabama|Florida"Đây là một chuỗi biểu diễn của các tên tiểu bang, được nối lại với nhau bằng dấu “|”
murders %>%
filter(str_detect(string = state, pattern = states.of.interest))## state abb region population total
## 1 Alabama AL South 4779736 135
## 2 Florida FL South 19687653 669
## 3 Louisiana LA South 4533372 351
## 4 Mississippi MS South 2967297 120
## 5 Texas TX South 25145561 805Dưới đây là thông tin về các tiểu bang mà tên không chứa ký tự “A” hoặc “C” từ tập dữ liệu “murders”.
murders %>%
filter(str_detect(string = state, pattern = "A|C", negate = TRUE))## state abb region population total
## 1 Delaware DE South 897934 38
## 2 Florida FL South 19687653 669
## 3 Georgia GA South 9920000 376
## 4 Hawaii HI West 1360301 7
## 5 Idaho ID West 1567582 12
## 6 Illinois IL North Central 12830632 364
## 7 Indiana IN North Central 6483802 142
## 8 Iowa IA North Central 3046355 21
## 9 Kansas KS North Central 2853118 63
## 10 Kentucky KY South 4339367 116
## 11 Louisiana LA South 4533372 351
## 12 Maine ME Northeast 1328361 11
## 13 Maryland MD South 5773552 293
## 14 Massachusetts MA Northeast 6547629 118
## 15 Michigan MI North Central 9883640 413
## 16 Minnesota MN North Central 5303925 53
## 17 Mississippi MS South 2967297 120
## 18 Missouri MO North Central 5988927 321
## 19 Montana MT West 989415 12
## 20 Nebraska NE North Central 1826341 32
## 21 Nevada NV West 2700551 84
## 22 New Hampshire NH Northeast 1316470 5
## 23 New Jersey NJ Northeast 8791894 246
## 24 New Mexico NM West 2059179 67
## 25 New York NY Northeast 19378102 517
## 26 North Dakota ND North Central 672591 4
## 27 Ohio OH North Central 11536504 310
## 28 Oklahoma OK South 3751351 111
## 29 Oregon OR West 3831074 36
## 30 Pennsylvania PA Northeast 12702379 457
## 31 Rhode Island RI Northeast 1052567 16
## 32 South Dakota SD North Central 814180 8
## 33 Tennessee TN South 6346105 219
## 34 Texas TX South 25145561 805
## 35 Utah UT West 2763885 22
## 36 Vermont VT Northeast 625741 2
## 37 Virginia VA South 8001024 250
## 38 Washington WA West 6724540 93
## 39 West Virginia WV South 1852994 27
## 40 Wisconsin WI North Central 5686986 97
## 41 Wyoming WY West 563626 5murders %>%
distinct(region)## region
## 1 South
## 2 West
## 3 Northeast
## 4 North CentralKết quả đã trích xuất các giá trị duy nhất từ cột “region” và hiển thị thông tin các khu vực địa lý khác nhau mà các tiểu bang trong tập dữ liệu “murders” thuộc về.
Ở vùng ‘South’ vẫn còn đang là chữ cái hoa đầu, bây giờ em sẽ thay đổi một vùng về lại chữ thường
murders %>%
mutate(region = str_replace(string = region,
pattern = "South",
replacement = "south")) %>%
head()## state abb region population total
## 1 Alabama AL south 4779736 135
## 2 Alaska AK West 710231 19
## 3 Arizona AZ West 6392017 232
## 4 Arkansas AR south 2915918 93
## 5 California CA West 37253956 1257
## 6 Colorado CO West 5029196 65Cuối cùng chúng em sẽ đổi tên tất cả các vùng về chữ thường
murders %>%
mutate(region = str_replace_all(string = region, c("South" = "south",
"West" = "west",
"North Central" = "north_central",
"Northeast" = "northeast"))) %>%
head(n = 20)## state abb region population total
## 1 Alabama AL south 4779736 135
## 2 Alaska AK west 710231 19
## 3 Arizona AZ west 6392017 232
## 4 Arkansas AR south 2915918 93
## 5 California CA west 37253956 1257
## 6 Colorado CO west 5029196 65
## 7 Connecticut CT northeast 3574097 97
## 8 Delaware DE south 897934 38
## 9 District of Columbia DC south 601723 99
## 10 Florida FL south 19687653 669
## 11 Georgia GA south 9920000 376
## 12 Hawaii HI west 1360301 7
## 13 Idaho ID west 1567582 12
## 14 Illinois IL north_central 12830632 364
## 15 Indiana IN north_central 6483802 142
## 16 Iowa IA north_central 3046355 21
## 17 Kansas KS north_central 2853118 63
## 18 Kentucky KY south 4339367 116
## 19 Louisiana LA south 4533372 351
## 20 Maine ME northeast 1328361 114 CHƯƠNG 4: Kết luận
4.1 Kết luận liên quan đến chủ đề
4.1.1 Ưu đ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ớ.
4.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.
4.2 Kết luận cho quá trình làm chủ đề
Trong quá trình làm tiểu luận, chúng em cảm thấy rằng gói Stringr rất hữu ích. Vì nó hiển thị một tập hợp nhỏ của các hàm quan trọng, đã được lựa chọn cẩn thận để xử lý các thao tác phổ biến trên chuỗi. Gói Stringr được thiết kế một cách toàn diện, bao gồm hầu hết các chức năng mà chúng em cần để làm việc với chuỗi với tổng cộng 59 chức năng trong Stringr.
Ngoài ra gói Stringr còn 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