5 album r & b hàng đầu mọi thời đại năm 2022

Có nhiều từ để xử lý dữ liệu. Bạn có thể làm sạch, hack, thao túng, munge, tinh chỉnh và dọn dẹp bộ dữ liệu của bạn, sẵn sàng cho giai đoạn tiếp theo, điển hình là mô hình hóa và trực quan hóa. Mỗi từ nói điều gì đó về nhận thức đối với quy trình: Xử lý dữ liệu thường được coi là công việc bẩn thỉu, một sự cần thiết khó chịu phải chịu đựng trước khi công việc thực sự, thú vị và quan trọng bắt đầu. Nhận thức này là sai. Lấy dữ liệu của bạn ‘Ship Shape, là một đáng kính và trong một số trường hợp kỹ năng quan trọng. Vì lý do này, chúng tôi sử dụng nghề mộc dữ liệu có thuật ngữ đáng ngưỡng mộ hơn.clean, hack, manipulate, munge, refine and tidy your dataset, ready for the next stage, typically modelling and visualisation. Each word says something about perceptions towards the process: data processing is often seen as dirty work, an unpleasant necessity that must be endured before the real, fun and important work begins. This perception is wrong. Getting your data ‘ship shape’ is a respectable and in some cases vital skill. For this reason we use the more admirable term data carpentry.

Phép ẩn dụ này không phải là tình cờ. Thợ mộc là quá trình lấy những miếng gỗ thô và làm việc với sự chăm sóc, siêng năng và chính xác để tạo ra một sản phẩm hoàn chỉnh. Một thợ mộc không hack vào gỗ một cách ngẫu nhiên. Anh ấy hoặc cô ấy sẽ kiểm tra nguyên liệu thô và chọn công cụ phù hợp cho công việc. Theo cách tương tự, nghề mộc dữ liệu là quá trình lấy thô, thô và ở một mức độ nào đó được sắp xếp ngẫu nhiên dữ liệu đầu vào và tạo dữ liệu được tổ chức và gọn gàng gọn gàng. Học kỹ năng của nghề mộc dữ liệu sớm sẽ mang lại lợi ích trong nhiều năm tới. Hãy cho tôi sáu giờ để chặt cây và tôi sẽ dành bốn lần làm sắc nét đầu tiên rìu như câu nói.

Xử lý dữ liệu là một giai đoạn quan trọng trong bất kỳ dự án nào liên quan đến bất kỳ bộ dữ liệu nào từ các nguồn bên ngoài, tức là & nbsp; hầu hết các ứng dụng trong thế giới thực. Theo cùng một cách mà nợ kỹ thuật, được thảo luận trong Chương 5, có thể làm tê liệt quy trình làm việc của bạn, làm việc với dữ liệu lộn xộn có thể dẫn đến địa ngục quản lý dự án.

May mắn thay, được thực hiện một cách hiệu quả, ngay từ đầu dự án của bạn (thay vì nửa chặng đường, khi có thể là quá muộn) và sử dụng các công cụ phù hợp, giai đoạn xử lý dữ liệu này có thể rất bổ ích. Quan trọng hơn từ góc độ hiệu quả, làm việc với dữ liệu sạch sẽ có lợi cho mọi giai đoạn tiếp theo của dự án R. Vì vậy, đối với các ứng dụng chuyên sâu về dữ liệu, đây có thể là chương quan trọng nhất của cuốn sách. Trong đó, chúng tôi đề cập đến các chủ đề sau:

• TIDING dữ liệu với Tidyrtidyr
• Xử lý dữ liệu với DPPLYRdplyr
• Làm việc với cơ sở dữ liệu
• Xử lý dữ liệu với dữ liệu. Có thểdata.table

Điều kiện tiên quyết

Chương này phụ thuộc vào một số gói để làm sạch và xử lý dữ liệu - kiểm tra chúng được cài đặt trên máy tính của bạn và tải chúng với:

library("tibble")
library("tidyr")
library("stringr")
library("readr")
library("dplyr")
library("data.table")

RSQLite và GGMAP cũng được sử dụng trong một vài ví dụ, mặc dù chúng không phải là trung tâm của nội dung chương. and ggmap are also used in a couple of examples, although they are not central to the chapter’s content.

5 lời khuyên hàng đầu cho nghề mộc dữ liệu hiệu quả

1. Thời gian dành cho việc chuẩn bị dữ liệu của bạn lúc đầu có thể tiết kiệm hàng giờ thất vọng trong thời gian dài.
2. Dữ liệu gọn gàng, cung cấp một khái niệm để tổ chức dữ liệu và gói TIDYR cung cấp một số chức năng cho công việc này.tidyr provides some functions for this work.
3. Lớp

   library("efficient")
   data(pew) # see ?pew - dataset from the efficient package
   pew[1:3, 1:4] # take a look at the data
   #> # A tibble: 3 x 4
   #>   religion `<$10k` `$10--20k` `$20--30k`
   #>                     
   #> 1 Agnostic      27         34         60
   #> 2 Atheist       12         27         37
   #> 3 Buddhist      27         21         30

   3 được xác định bởi gói Tibble giúp các bộ dữ liệu hiệu quả để in và dễ làm việc.tibble package makes datasets efficient to print and easy to work with.
4. DPPLYR cung cấp các chức năng xử lý dữ liệu nhanh chóng và trực quan; Data.Table có tốc độ chưa từng có cho một số ứng dụng xử lý dữ liệu. provides fast and intuitive data processing functions; data.table has unmatched speed for some data processing applications.
5. Toán tử

   library("efficient")
   data(pew) # see ?pew - dataset from the efficient package
   pew[1:3, 1:4] # take a look at the data
   #> # A tibble: 3 x 4
   #>   religion `<$10k` `$10--20k` `$20--30k`
   #>                     
   #> 1 Agnostic      27         34         60
   #> 2 Atheist       12         27         37
   #> 3 Buddhist      27         21         30

   4 ’ống có thể giúp làm rõ quy trình xử lý dữ liệu phức tạp.

Khung dữ liệu hiệu quả với Tibble

Tibble là một gói xác định lớp khung dữ liệu mới cho r,

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

Khung dữ liệu Tibble là một đối tượng S3 với ba lớp,

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

Để tạo khung dữ liệu tibbble, chúng tôi sử dụng hàm

dim(pew)
#> [1] 18 10
pewt = pivot_longer(data = pew, -religion, names_to = "income", values_to = "count")
dim(pewt)
#> [1] 162   3
pewt[c(1:3, 50), ]
#> # A tibble: 4 x 3
#>   religion                        income   count
#>                                  
#> 1 Agnostic                        <$10k       27
#> 2 Agnostic                        $10--20k    34
#> 3 Agnostic                        $20--30k    60
#> 4 Evangelical Protestant Churches $40--50k   881

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Ví dụ trên minh họa sự khác biệt chính giữa cách tiếp cận của tibbble và cơ sở R với các khung dữ liệu:tibble and base R approach to data frames:

• Khi được in, Tibble Diff báo cáo lớp của từng biến.

  library("efficient")
  data(pew) # see ?pew - dataset from the efficient package
  pew[1:3, 1:4] # take a look at the data
  #> # A tibble: 3 x 4
  #>   religion `<$10k` `$10--20k` `$20--30k`
  #>                     
  #> 1 Agnostic      27         34         60
  #> 2 Atheist       12         27         37
  #> 3 Buddhist      27         21         30

  6 Các đối tượng không.
• Các vectơ ký tự không bị ép buộc thành các yếu tố khi chúng được tích hợp vào

  library("efficient")
  data(pew) # see ?pew - dataset from the efficient package
  pew[1:3, 1:4] # take a look at the data
  #> # A tibble: 3 x 4
  #>   religion `<$10k` `$10--20k` `$20--30k`
  #>                     
  #> 1 Agnostic      27         34         60
  #> 2 Atheist       12         27         37
  #> 3 Buddhist      27         21         30

  5, như có thể thấy bởi tiêu đề

  dim(pew)
  #> [1] 18 10
  pewt = pivot_longer(data = pew, -religion, names_to = "income", values_to = "count")
  dim(pewt)
  #> [1] 162   3
  pewt[c(1:3, 50), ]
  #> # A tibble: 4 x 3
  #>   religion                        income   count
  #>                                  
  #> 1 Agnostic                        <$10k       27
  #> 2 Agnostic                        $10--20k    34
  #> 3 Agnostic                        $20--30k    60
  #> 4 Evangelical Protestant Churches $40--50k   881

  7 giữa tên biến và cột thứ hai. Ngược lại,

  dim(pew)
  #> [1] 18 10
  pewt = pivot_longer(data = pew, -religion, names_to = "income", values_to = "count")
  dim(pewt)
  #> [1] 162   3
  pewt[c(1:3, 50), ]
  #> # A tibble: 4 x 3
  #>   religion                        income   count
  #>                                  
  #> 1 Agnostic                        <$10k       27
  #> 2 Agnostic                        $10--20k    34
  #> 3 Agnostic                        $20--30k    60
  #> 4 Evangelical Protestant Churches $40--50k   881

  8 ép buộc các ký tự thành các yếu tố có thể gây ra vấn đề xa hơn.
• Khi in một tibbble khác với màn hình, chỉ có mười hàng đầu tiên được hiển thị. Số lượng cột được in phụ thuộc vào kích thước cửa sổ.

Những khác biệt khác có thể được tìm thấy trong trang trợ giúp liên quan -

dim(pew)
#> [1] 18 10
pewt = pivot_longer(data = pew, -religion, names_to = "income", values_to = "count")
dim(pewt)
#> [1] 162   3
pewt[c(1:3, 50), ]
#> # A tibble: 4 x 3
#>   religion                        income   count
#>                                  
#> 1 Agnostic                        <$10k       27
#> 2 Agnostic                        $10--20k    34
#> 3 Agnostic                        $20--30k    60
#> 4 Evangelical Protestant Churches $40--50k   881

Bạn có thể tạo một hàng khung dữ liệu Tibble bằng cách sử dụng hàm

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

Tập thể dục

Tạo khung dữ liệu sau

df_base = data.frame(colA = "A")

Hãy thử và đoán đầu ra của các lệnh sau

print(df_base)
df_base$colA
df_base$col
df_base$colB

Bây giờ tạo một khung dữ liệu tibbble và lặp lại các lệnh trên.

TIDING DỮ LIỆU VỚI TIDYR VÀ Biểu thức chính quy

Một kỹ năng quan trọng trong phân tích dữ liệu là hiểu cấu trúc của các bộ dữ liệu và có thể định hình lại chúng. Điều này rất quan trọng từ góc độ hiệu quả của quy trình công việc: Hơn một nửa thời gian phân tích dữ liệu có thể được dành để định dạng lại các bộ dữ liệu (H. Wickham 2014b), do đó, việc đưa nó trở thành một hình thức phù hợp sớm có thể tiết kiệm giờ trong tương lai. Chuyển đổi dữ liệu thành một hình thức ‘gọn gàng cũng có lợi từ góc độ hiệu quả tính toán: thường nhanh hơn để chạy phân tích và vẽ các lệnh trên dữ liệu gọn gàng.(H. Wickham 2014b), so getting it into a suitable form early could save hours in the future. Converting data into a ‘tidy’ form is also advantageous from a computational efficiency perspective: it is usually faster to run analysis and plotting commands on tidy data.

Việc dọn dẹp dữ liệu bao gồm làm sạch dữ liệu và định hình lại dữ liệu. Làm sạch dữ liệu là quá trình định dạng lại và ghi nhãn dữ liệu lộn xộn. Các gói bao gồm Stringi và StringR có thể giúp cập nhật các chuỗi ký tự lộn xộn bằng cách sử dụng các biểu thức thông thường; Các gói xác nhận và Assertr có thể thực hiện kiểm tra chẩn đoán cho tính toàn vẹn của dữ liệu ngay từ đầu của dự án phân tích dữ liệu. Một tác vụ làm sạch dữ liệu phổ biến là việc chuyển đổi các chuỗi văn bản không chuẩn thành các định dạng ngày như được mô tả trong Vignette Lubridate (xem

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

Bảng 6.1 và 6.2 hiển thị một tập hợp con của các bộ dữ liệu ‘rộng

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

Dữ liệu TIDY có các đặc điểm sau (H. Wickham 2014b):(H. Wickham 2014b):

1. Mỗi biến tạo thành một cột.
2. Mỗi quan sát tạo thành một hàng.
3. Mỗi loại đơn vị quan sát tạo thành một bảng.

Bởi vì chỉ có một đơn vị quan sát trong ví dụ (tôn giáo), nó có thể được mô tả trong một bảng duy nhất. Các bộ dữ liệu lớn và phức tạp thường được đại diện bởi nhiều bảng, với các định danh duy nhất hoặc ‘phím, để kết hợp chúng với nhau (CODD 1979).(Codd 1979).

Hai hoạt động phổ biến được tạo điều kiện bởi TIDYR là thu thập và tách các cột.tidyr are gathering and splitting columns.

Làm cho các bảng rộng dài với pivot_longer(pew, -religion) #> # A tibble: 162 x 3 #> religion name value #> #> 1 Agnostic <$10k 27 #> 2 Agnostic $10--20k 34 #> 3 Agnostic $20--30k 60 #> 4 Agnostic $30--40k 81 #> # … with 158 more rows4

Xoay dài hơn có nghĩa là tạo ra các bảng rộng ’dài, bằng cách chuyển đổi tên cột thành một biến mới. Điều này được thực hiện với hàm

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

dim(pew)
#> [1] 18 10
pewt = pivot_longer(data = pew, -religion, names_to = "income", values_to = "count")
dim(pewt)
#> [1] 162   3
pewt[c(1:3, 50), ]
#> # A tibble: 4 x 3
#>   religion                        income   count
#>                                  
#> 1 Agnostic                        <$10k       27
#> 2 Agnostic                        $10--20k    34
#> 3 Agnostic                        $20--30k    60
#> 4 Evangelical Protestant Churches $40--50k   881

Mã trên cho thấy ba đối số mà

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

1. pivot_longer(pew, -religion)
   #> # A tibble: 162 x 3
   #>   religion name     value
   #>           
   #> 1 Agnostic <$10k       27
   #> 2 Agnostic $10--20k    34
   #> 3 Agnostic $20--30k    60
   #> 4 Agnostic $30--40k    81
   #> # … with 158 more rows

   9, một khung dữ liệu trong đó tên cột sẽ trở thành giá trị hàng.

2. agesex = c("m0-10", "f0-10") # create compound variable
   n = c(3, 5) # create a value for each observation
   agesex_df = tibble(agesex, n) # create a data frame
   separate(agesex_df, agesex, c("sex", "age"), sep = 1)
   #> # A tibble: 2 x 3
   #>   sex   age       n
   #>     
   #> 1 m     0-10      3
   #> 2 f     0-10      5

   0, tên của biến phân loại mà tên cột trong các bộ dữ liệu gốc được chuyển đổi.

3. agesex = c("m0-10", "f0-10") # create compound variable
   n = c(3, 5) # create a value for each observation
   agesex_df = tibble(agesex, n) # create a data frame
   separate(agesex_df, agesex, c("sex", "age"), sep = 1)
   #> # A tibble: 2 x 3
   #>   sex   age       n
   #>     
   #> 1 m     0-10      3
   #> 2 f     0-10      5

   1, tên của các cột giá trị ô.

Cũng như các chức năng khác trong ‘Tidyverse, tất cả các đối số được đưa ra bằng cách sử dụng tên trần, thay vì các chuỗi ký tự. Đối số 2 và 3 có thể được người dùng chỉ định và không có liên quan đến dữ liệu hiện có. Hơn nữa, một đối số bổ sung, được đặt là

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

pivot_longer(pew, -religion)
#> # A tibble: 162 x 3
#>   religion name     value
#>           
#> 1 Agnostic <$10k       27
#> 2 Agnostic $10--20k    34
#> 3 Agnostic $20--30k    60
#> 4 Agnostic $30--40k    81
#> # … with 158 more rows

Phật tử

Splitting means taking a variable that is really two variables combined and creating two separate columns from it. A classic example is age-sex variables (e.g. 

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

M0-10

F0-10tidyr can perform, as described in the package’s vignette (

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

Bảng 6.4: Các biến tuổi và giới tính được phân tách bằng hàm

agesex = c("m0-10", "f0-10") # create compound variable
n = c(3, 5) # create a value for each observation
agesex_df = tibble(agesex, n) # create a data frame
separate(agesex_df, agesex, c("sex", "age"), sep = 1)
#> # A tibble: 2 x 3
#>   sex   age       n
#>     
#> 1 m     0-10      3
#> 2 f     0-10      5

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

Tình dụcdplyr and tidyr function names to allow the use of standard evaluation. Thus the standard evaluation version of

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

tuổi tác

m(e.g. Sanchez 2013), so we’ll just scratch the surface of the topic, and provide a taster of what is possible. Regex is a deep topic. However, knowing the basics can save a huge amount of time from a data tidying perspective, by automating the cleaning of messy strings.

0-10stringr and base R ways of doing pattern matching. The former provides easy to remember function names and consistency. The latter is useful to know as you’ll find lots of base R regex code in other peoples code as stringr is relatively new and not installed by default. The foundational regex operation is to detect whether or not a particular text string exists in an element or not which is done with

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

fstringr does not include a direct replacement for

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

Các chức năng Tidyr khácstringr functions: they all do. This can be efficient because if you want to do some regex work, you just need to type

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

Có các hoạt động dọn dẹp khác mà Tidyr có thể thực hiện, như được mô tả trong gói họa tiết của gói (

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

• Những nguyên tắc tương tự cũng có thể được áp dụng cho việc thể hiện kết quả mô hình. Gói chổi cung cấp định dạng đầu ra tiêu chuẩn cho kết quả mô hình, giảm bớt giải thích (xem họa tiết chổi). Hàm

  library("stringr")
  x = c("Hi I'm Robin.", "DoB 1985")
  
  grepl(pattern = "9", x = x)
  #> [1] FALSE  TRUE
  str_detect(string = x, pattern = "9")
  #> [1] FALSE  TRUE

  1 có thể được áp dụng cho một loạt các đối tượng mô hình và trả về đầu ra của mô hình trong một đầu ra khung dữ liệu được tiêu chuẩn hóa.Grolemund and Wickham (2016).
• Thông thường sẽ hiệu quả hơn khi sử dụng phiên bản đánh giá không chuẩn của các tên biến, vì chúng có thể được tự động hoàn thành bởi RSTudio. Trong một số trường hợp, bạn có thể muốn sử dụng đánh giá tiêu chuẩn và tham khảo các tên biến bằng dấu ngoặc kép. Để thực hiện điều này, việc gắn

  library("stringr")
  x = c("Hi I'm Robin.", "DoB 1985")
  
  grepl(pattern = "9", x = x)
  #> [1] FALSE  TRUE
  str_detect(string = x, pattern = "9")
  #> [1] FALSE  TRUE

  2 có thể được thêm vào các tên hàm DPPLY và TIDYR để cho phép sử dụng đánh giá tiêu chuẩn. Do đó, phiên bản đánh giá tiêu chuẩn của

  library("stringr")
  x = c("Hi I'm Robin.", "DoB 1985")
  
  grepl(pattern = "9", x = x)
  #> [1] FALSE  TRUE
  str_detect(string = x, pattern = "9")
  #> [1] FALSE  TRUE

  3 là

  library("stringr")
  x = c("Hi I'm Robin.", "DoB 1985")
  
  grepl(pattern = "9", x = x)
  #> [1] FALSE  TRUE
  str_detect(string = x, pattern = "9")
  #> [1] FALSE  TRUE

  4.stringr vignette (

  head(pew, 10)
  #> # A tibble: 10 x 10
  #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
  #>                                       
  #> 1 Agnostic      27         34         60         81         76        137
  #> 2 Atheist       12         27         37         52         35         70
  #> 3 Buddhist      27         21         30         34         33         58
  #> 4 Catholic     418        617        732        670        638       1116
  #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
  #> #   >150k 
  data(lnd_geo_df)
  head(lnd_geo_df, 10)
  #>                    name_date population      x      y
  #> 1               Bromley-2001     295535 544362 172379
  #> 2               Bromley-2001     295535 549546 169911
  #> 3               Bromley-2001     295535 539596 160796
  #> 4               Bromley-2001     295535 533693 170730
  #> 5               Bromley-2001     295535 533718 170814
  #> 6               Bromley-2001     295535 534004 171442
  #> 7               Bromley-2001     295535 541105 173356
  #> 8               Bromley-2001     295535 544362 172379
  #> 9  Richmond upon Thames-2001     172330 523605 176321
  #> 10 Richmond upon Thames-2001     172330 521455 172362

  8).
• Biểu cảm thường xuyên(Sanchez 2013).
• Biểu thức chính quy (thường được gọi là Regex) là ngôn ngữ để mô tả và thao tác các chuỗi văn bản. Có những cuốn sách về chủ đề này, và một số hướng dẫn hay về Regex trong R (ví dụ: & NBSP; Sanchez 2013), vì vậy chúng tôi sẽ chỉ làm trầy xước bề mặt của chủ đề và cung cấp một bản mở rộng về những gì có thể. Regex là một chủ đề sâu sắc. Tuy nhiên, biết những điều cơ bản có thể tiết kiệm một lượng lớn thời gian từ góc độ dọn dẹp dữ liệu, bằng cách tự động hóa việc làm sạch các chuỗi lộn xộn.stringi package, on which stringr depends.

Trong phần này, chúng tôi dạy cả hai cách kết hợp chuỗi và cơ sở R. Cái trước cung cấp dễ nhớ tên chức năng và tính nhất quán. Cái sau rất hữu ích để biết khi bạn sẽ tìm thấy rất nhiều mã R Regex cơ sở trong mã người khác vì StringR tương đối mới và không được cài đặt theo mặc định. Hoạt động Regex nền tảng là phát hiện liệu một chuỗi văn bản cụ thể có tồn tại trong một phần tử hay không được thực hiện với

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

5 và

library("stringr")
x = c("Hi I'm Robin.", "DoB 1985")

grepl(pattern = "9", x = x)
#> [1] FALSE  TRUE
str_detect(string = x, pattern = "9")
#> [1] FALSE  TRUE

6 trong cơ sở r và chuỗi tương ứng:

1. Lưu ý: StringR không bao gồm thay thế trực tiếp cho

   library("stringr")
   x = c("Hi I'm Robin.", "DoB 1985")
   
   grepl(pattern = "9", x = x)
   #> [1] FALSE  TRUE
   str_detect(string = x, pattern = "9")
   #> [1] FALSE  TRUE

   7. Bạn có thể sử dụng

   library("stringr")
   x = c("Hi I'm Robin.", "DoB 1985")
   
   grepl(pattern = "9", x = x)
   #> [1] FALSE  TRUE
   str_detect(string = x, pattern = "9")
   #> [1] FALSE  TRUE

   8 thay thế.

2. Lưu ý rằng

   library("stringr")
   x = c("Hi I'm Robin.", "DoB 1985")
   
   grepl(pattern = "9", x = x)
   #> [1] FALSE  TRUE
   str_detect(string = x, pattern = "9")
   #> [1] FALSE  TRUE

   6 bắt đầu với

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   0. Đây là một tính năng phổ biến của các hàm StringR: tất cả đều làm. Điều này có thể hiệu quả bởi vì nếu bạn muốn thực hiện một số công việc Regex, bạn chỉ cần nhập

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   0 và sau đó nhấn Tab để xem danh sách tất cả các tùy chọn. Ngược lại, các tên hàm r regex cơ sở khác nhau khó nhớ hơn, bao gồm

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   2,

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   3 và

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   4. Các tương đương StringR có các tên trực quan hơn liên quan đến ý định của các hàm:

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   5,

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   6 và

   head(pew, 10)
   #> # A tibble: 10 x 10
   #>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
   #>                                       
   #> 1 Agnostic      27         34         60         81         76        137
   #> 2 Atheist       12         27         37         52         35         70
   #> 3 Buddhist      27         21         30         34         33         58
   #> 4 Catholic     418        617        732        670        638       1116
   #> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
   #> #   >150k 
   data(lnd_geo_df)
   head(lnd_geo_df, 10)
   #>                    name_date population      x      y
   #> 1               Bromley-2001     295535 544362 172379
   #> 2               Bromley-2001     295535 549546 169911
   #> 3               Bromley-2001     295535 539596 160796
   #> 4               Bromley-2001     295535 533693 170730
   #> 5               Bromley-2001     295535 533718 170814
   #> 6               Bromley-2001     295535 534004 171442
   #> 7               Bromley-2001     295535 541105 173356
   #> 8               Bromley-2001     295535 544362 172379
   #> 9  Richmond upon Thames-2001     172330 523605 176321
   #> 10 Richmond upon Thames-2001     172330 521455 172362

   7, tương ứng.

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

1. Có nhiều điều khác để nói về chủ đề này nhưng thay vì lặp lại những gì đã được nói ở nơi khác, chúng tôi cảm thấy hiệu quả hơn khi hướng người đọc quan tâm đến các tài nguyên xuất sắc hiện có để học Regex trong R. Chúng tôi khuyên bạn nên đọc theo thứ tự:

2. Chương chuỗi của Grolemund và Wickham (2016).(Wickham 2010):

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Các họa tiết chuỗi (

head(pew, 10)
#> # A tibble: 10 x 10
#>   religion `<$10k` `$10--20k` `$20--30k` `$30--40k` `$40--50k` `$50--75k`
#>                                       
#> 1 Agnostic      27         34         60         81         76        137
#> 2 Atheist       12         27         37         52         35         70
#> 3 Buddhist      27         21         30         34         33         58
#> 4 Catholic     418        617        732        670        638       1116
#> # … with 6 more rows, and 3 more variables: $75--100k , $100--150k ,
#> #   >150k 
data(lnd_geo_df)
head(lnd_geo_df, 10)
#>                    name_date population      x      y
#> 1               Bromley-2001     295535 544362 172379
#> 2               Bromley-2001     295535 549546 169911
#> 3               Bromley-2001     295535 539596 160796
#> 4               Bromley-2001     295535 533693 170730
#> 5               Bromley-2001     295535 533718 170814
#> 6               Bromley-2001     295535 534004 171442
#> 7               Bromley-2001     295535 541105 173356
#> 8               Bromley-2001     295535 544362 172379
#> 9  Richmond upon Thames-2001     172330 523605 176321
#> 10 Richmond upon Thames-2001     172330 521455 172362

• Một vectơ logic báo cáo xem mỗi chuỗi có chứa một số hay không.
• Chỉ hoàn thành các từ, không có ký tự không có chữ cái.

Xử lý dữ liệu hiệu quả với DPPLYR

Sau khi dọn dẹp dữ liệu của bạn, giai đoạn tiếp theo thường là xử lý dữ liệu. Điều này bao gồm việc tạo dữ liệu mới, ví dụ như một cột mới là một số chức năng của các cột hiện có hoặc phân tích dữ liệu, quá trình đặt câu hỏi theo hướng của dữ liệu và xuất kết quả dưới dạng có thể đọc được của người dùng.

Theo lời khuyên trong Phần 4.4, chúng tôi đã chọn cẩn thận một gói thích hợp cho các nhiệm vụ này: DPPLYR, có nghĩa là ‘kìm khung dữ liệu. DPPLYR có một số lợi thế so với cơ sở r và dữ liệu. Các cách tiếp cận có thể sử dụng để xử lý dữ liệu:dplyr, which roughly means ‘data frame pliers’. dplyr has a number of advantages over the base R and data.table approaches to data processing:

• DPPLYR nhanh để chạy (do phụ trợ C ++ của nó) và trực quan để loại is fast to run (due to its C++ backend) and intuitive to type
• DPPLYR hoạt động tốt với dữ liệu gọn gàng, như được mô tả ở trên works well with tidy data, as described above
• DPPPLE hoạt động tốt với cơ sở dữ liệu, cung cấp mức tăng hiệu quả trên các bộ dữ liệu lớn works well with databases, providing efficiency gains on large datasets

Hơn nữa, DPPLYR có hiệu quả để học (xem Chương 10). Nó có một số lượng nhỏ các hàm có tên trực giác, hoặc ‘động từ. Chúng được lấy cảm hứng một phần bởi SQL, một trong những ngôn ngữ được thiết lập lâu nhất để phân tích dữ liệu, kết hợp nhiều hàm đơn giản (như

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Không giống như các chất tương tự R cơ sở, các chức năng xử lý dữ liệu DPPLYR, hoạt động một cách nhất quán. Mỗi hàm lấy một đối tượng khung dữ liệu làm đối số đầu tiên của nó và dẫn đến khung dữ liệu khác. Các biến có thể được gọi trực tiếp mà không cần sử dụng toán tử

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Kết quả, được minh họa trong Bảng 6.6, cho thấy Hoa Kỳ có mức tăng trưởng cao nhất và phát thải trung bình từ ngành vận tải, theo sát là Trung Quốc. Mục đích của đoạn mã này không dành cho bạn bằng cách nào đó đọc nó và hiểu nó: Đó là cung cấp một cú pháp độc đáo của DPPLY, được mô tả chi tiết hơn trong suốt thời gian của phần này.dplyr’s unique syntax, which is described in more detail throughout the duration of this section.

Dựa trên ‘học bằng cách thực hiện đạo đức, phần còn lại của phần này hoạt động thông qua các chức năng này để xử lý và bắt đầu phân tích một bộ dữ liệu về sự bình đẳng kinh tế do Ngân hàng Thế giới cung cấp. Bộ dữ liệu đầu vào có thể được tải như sau:

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

DPPLYR là một gói lớn và có thể được coi là một ngôn ngữ theo đúng nghĩa của nó. Theo nguyên tắc ‘Đi bộ trước khi bạn chạy nguyên tắc, chúng tôi sẽ bắt đầu đơn giản, bằng cách lọc và tổng hợp các hàng. is a large package and can be seen as a language in its own right. Following the ‘walk before you run’ principle, we’ll start simple, by filtering and aggregating rows.

Đổi tên cột

Đổi tên các cột dữ liệu là một nhiệm vụ phổ biến có thể làm cho mã viết nhanh hơn bằng cách sử dụng các tên ngắn, trực quan. Hàm DPPLYR

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Lưu ý trong khối mã này, tên biến được bao quanh bởi các trích dẫn backs (

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Để đổi tên nhiều cột, các tên biến được phân tách bằng dấu phẩy.

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Thay đổi các lớp cột

Lớp đối tượng R là rất quan trọng đối với hiệu suất. Nếu một lớp được chỉ định không chính xác (ví dụ: & nbsp; nếu các số được coi là yếu tố hoặc ký tự), điều này sẽ dẫn đến kết quả không chính xác. Lớp của tất cả các cột trong khung dữ liệu có thể được truy vấn bằng hàm

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Kiểm tra trực quan dữ liệu (ví dụ: & nbsp; thông qua

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Tuy nhiên, mục đích của các ngôn ngữ lập trình là tự động hóa các tác vụ và giảm gõ. Chunk mã sau đây đảm bảo các biến số trong đối tượng

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Một cách khác để đạt được kết quả tương tự là sử dụng

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Mỗi phương pháp (cơ sở r và dplyr) có giá trị của nó. Đối với những người đọc mới đến R, những người có kế hoạch sử dụng các gói Tidyverse khác, chúng tôi sẽ cung cấp một chút hướng tới

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Lọc hàng

DPPLYR cung cấp một cách thay thế để lọc dữ liệu, sử dụng

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

library("efficient")
data(pew) # see ?pew - dataset from the efficient package
pew[1:3, 1:4] # take a look at the data
#> # A tibble: 3 x 4
#>   religion `<$10k` `$10--20k` `$20--30k`
#>                     
#> 1 Agnostic      27         34         60
#> 2 Atheist       12         27         37
#> 3 Buddhist      27         21         30

Có tương đương DPPLYR của nhiều chức năng R cơ sở nhưng chúng thường hoạt động hơi khác nhau. Ví dụ, DPPLYR tương đương với

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Chuỗi hoạt động

Một tính năng thú vị khác của DPPLE là khả năng hoạt động chuỗi của nó cùng nhau. Điều này khắc phục một trong những vấn đề thẩm mỹ với mã r: bạn có thể kết thúc với các lệnh rất dài với nhiều chức năng được lồng vào nhau để trả lời các câu hỏi tương đối đơn giản. Kết hợp với chức năng

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Thường thì cách tốt nhất để học là thử và phá vỡ một cái gì đó, vì vậy hãy thử chạy các lệnh trên với các động từ dplyr khác nhau. Bằng cách giải thích, đây là những gì đã xảy ra:dplyr verbs. By way of explanation, this is what happened:

1. Chỉ các cột

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   20 và

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   23 được chọn, sử dụng

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   50.
2. Một biến mới,

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   51 đã được tạo, để chỉ hiển thị các số liệu thập kỷ (ví dụ: & NBSP; 1989 trở thành năm 1980).
3. Biến mới này đã được sử dụng để nhóm các hàng trong khung dữ liệu với cùng một thập kỷ.
4. Giá trị trung bình mỗi thập kỷ đã được tính toán, minh họa mức độ bất bình đẳng thu nhập trung bình là lớn nhất vào năm 1990 nhưng sau đó đã giảm nhẹ.

Hãy cùng hỏi một câu hỏi khác để xem làm thế nào quy trình làm việc chuỗi DPPLYR có thể được sử dụng để trả lời các câu hỏi tương tác: 5 năm không đồng đều nhất đối với các quốc gia có chứa chữ G là gì? Tại đây, cách thức các chuỗi có thể giúp tổ chức phân tích cần thiết để trả lời câu hỏi này từng bước:dplyr chaining workflow can be used to answer questions interactively: What are the 5 most unequal years for countries containing the letter g? Here’s how chains can help organise the analysis needed to answer this question step-by-step:

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Hàm trên bao gồm 6 giai đoạn, mỗi giai đoạn tương ứng với chức năng dòng mới và DPPLY:dplyr function:

1. Lọc ra các quốc gia mà chúng tôi quan tâm (bất kỳ tiêu chí lựa chọn nào cũng có thể được sử dụng thay cho

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   52).
2. Nhóm sản lượng theo năm.
3. Tóm tắt, cho mỗi năm, chỉ số Gini trung bình.
4. Sắp xếp kết quả bằng chỉ số Gini trung bình
5. Chỉ chọn 5 năm không đồng đều nhất.

Để xem lý do tại sao phương pháp này được ưu tiên hơn so với phương pháp chức năng lồng nhau, hãy xem phương pháp sau. Ngay cả sau khi thụt lề đúng cách, nó trông khủng khiếp và gần như không thể hiểu được!

df_base = data.frame(colA = "A")

Phần này chỉ cung cấp một kỹ năng hơn về những gì có thể có và tại sao nó có ý nghĩa từ các quan điểm hiệu quả viết mã và tính toán. Để biết tài khoản chi tiết hơn về xử lý dữ liệu với R bằng cách sử dụng phương pháp này, chúng tôi khuyên bạn nên sử dụng R cho Khoa học dữ liệu (Grolemund và Wickham 2016).dplyr and why it makes sense from code writing and computational efficiency perspectives. For a more detailed account of data processing with R using this approach we recommend R for Data Science (Grolemund and Wickham 2016).

Bài tập

1. Hãy thử chạy từng ví dụ chuỗi trên từng dòng, vì vậy hai mục đầu tiên cho ví dụ đầu tiên sẽ trông như thế này:

df_base = data.frame(colA = "A")

theo dõi bởi:

df_base = data.frame(colA = "A")

Giải thích bằng lời của bạn những gì thay đổi mỗi lần.

1. Sử dụng các chức năng DPPLYR Chained để trả lời câu hỏi sau: Trong năm nào các quốc gia không có ’một tên trong tên của họ có mức độ bất bình đẳng thấp nhất?dplyr functions to answer the following question: In which year did countries without an ‘a’ in their name have the lowest level of inequality?

Tập hợp dữ liệu

Tập hợp dữ liệu liên quan đến việc tạo các bản tóm tắt dữ liệu dựa trên một biến nhóm, trong một quy trình được gọi là ’-apply-bombine-combine. Kết quả cuối cùng thường có cùng số lượng hàng như có các nhóm. Bởi vì tập hợp là một cách để cô đọng các bộ dữ liệu, nó có thể là một kỹ thuật rất hữu ích để hiểu được các bộ dữ liệu lớn. Mã sau đây tìm thấy số lượng quốc gia duy nhất (quốc gia là biến nhóm) từ bộ dữ liệu

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

df_base = data.frame(colA = "A")

Lưu ý rằng mặc dù có gần như \ (8000 \) hàng, có ít hơn 200 quốc gia: các yếu tố sẽ là một cách lưu trữ dữ liệu của các quốc gia hiệu quả hơn về không gian.\(8000\) rows, there are fewer than 200 countries: factors would have been a more space efficient way of storing the countries data.

Để tổng hợp bộ dữ liệu bằng gói dplyr, bạn chia tác vụ thành hai: để nhóm bộ dữ liệu trước và sau đó để tóm tắt, như được minh họa dưới đây.17dplyr package, you divide the task in two: to group the dataset first and then to summarise, as illustrated below.17

df_base = data.frame(colA = "A")

Ví dụ trên liên quan đến vấn đề lập trình rộng hơn: một chức năng nên làm bao nhiêu công việc? Công việc có thể đã được thực hiện với một cuộc gọi

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Để củng cố điểm, thao tác này cũng được thực hiện dưới đây trên bộ dữ liệu

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

df_base = data.frame(colA = "A")

Lưu ý rằng

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

df_base = data.frame(colA = "A")

Để thể hiện sức mạnh của

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

• số lượng hàng trong mỗi nhóm quốc gia
• Độ lệch chuẩn của các chỉ số Gini
• Tỷ lệ thu nhập trung bình kiếm được từ 10% hàng đầu
• Số năm mà chỉ số Gini lớn hơn 30
• Độ lệch chuẩn của các giá trị chỉ số Gini trên 30
• Phạm vi của các giá trị chỉ số Gini được báo cáo cho mỗi quốc gia.

Bài tập

1. Tham khảo lại ví dụ về khí thải nhà kính vào đầu phần 6.4, trong đó chúng tôi tìm thấy 3 quốc gia hàng đầu về tăng trưởng phát thải trong lĩnh vực vận tải. a) Giải thích bằng lời những gì đang diễn ra trong mỗi dòng. b) Cố gắng tìm 3 quốc gia hàng đầu về mặt khí thải vào năm 2012 - danh sách khác nhau như thế nào?

2. Khám phá tài liệu DPPLYR, bắt đầu với họa tiết giới thiệu, được truy cập bằng cách nhập

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   59.dplyr’s documentation, starting with the introductory vignette, accessed by entering

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   59.

3. Kiểm tra thêm dplyr ‘động từ trên bộ dữ liệu

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   55. (Có thể phát hiện thêm tên họa tiết bằng cách nhập

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   61.)dplyr ‘verbs’ on the

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   55 dataset. (More vignette names can be discovered by typing

   library("tibble")
   tibble(x = 1:3, y = c("A", "B", "C"))
   #> # A tibble: 3 x 2
   #>       x y    
   #>    
   #> 1     1 A    
   #> 2     2 B    
   #> 3     3 C

   61.)

Đánh giá không tiêu chuẩn

Điều cuối cùng để nói về DPPLYR không liên quan đến dữ liệu mà là cú pháp của các chức năng. Lưu ý rằng nhiều đối số trong các ví dụ mã trong phần này được cung cấp dưới dạng tên thô: chúng là tên biến thô, không được bao quanh bởi các dấu ngoặc kép (ví dụ: & nbsp; ________ 118 thay vì

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Điều này là tốt khi sử dụng R tương tác. Nhưng khi bạn muốn sử dụng R không liên quan, mã thường mạnh mẽ hơn khi sử dụng đánh giá tiêu chuẩn: nó giảm thiểu cơ hội tạo các lỗi liên quan đến phạm vi tối nghĩa. Sử dụng đánh giá thường trực cũng tránh phải khai báo các biến toàn cầu nếu bạn đưa mã vào gói. Để khắc phục điều này, khái niệm đánh giá gọn gàng đã được phát triển và thực hiện trong gói RLANG (một phần của Tidyverse) để cung cấp các chức năng để kiểm soát khi các ký hiệu được đánh giá và khi chúng được coi là chuỗi văn bản. Không đi sâu vào chi tiết, mã bên dưới cho thấy cách đánh giá gọn gàng hoạt động (xem họa tiết

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

df_base = data.frame(colA = "A")

Kết hợp bộ dữ liệu

Tính hữu ích của một bộ dữ liệu đôi khi có thể được tăng cường đáng kể bằng cách kết hợp nó với dữ liệu khác. Ví dụ, nếu chúng ta có thể hợp nhất bộ dữ liệu

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

df_base = data.frame(colA = "A")

So sánh trực quan bộ dữ liệu mới này của

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

df_base = data.frame(colA = "A")

Đảm bảo rằng cả hai biến tham gia đều có cùng một lớp (kết hợp các cột

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

Sự chồng chéo giữa

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C

library("tibble")
tibble(x = 1:3, y = c("A", "B", "C"))
#> # A tibble: 3 x 2
#>       x y    
#>    
#> 1     1 A    
#> 2     2 B    
#> 3     3 C