Ricerca…


Osservazioni

dplyr è un'iterazione di plyr che fornisce un flessibile "verbo" basato su funzioni per manipolare i dati in R. L'ultima versione di dplyr può essere scaricata da CRAN usando

install.package("dplyr")

L'oggetto chiave in dplyr è un tbl, una rappresentazione di una struttura dati tabellare. Attualmente dplyr (versione 0.5.0) supporta:

  • cornici di dati
  • tabelle di dati
  • SQLite
  • PostgreSQL / Redshift
  • MySQL / MariaDB
  • BigQuery
  • MonetDB
  • cubi di dati con matrici (implementazione parziale)

i verbi a tavolo unico di dplyr

dplyr introduce una grammatica della manipolazione dei dati in R Fornisce un'interfaccia coerente per lavorare con i dati, indipendentemente da dove sono archiviati: data.frame , data.table o un database . Le parti chiave di dplyr sono scritte usando Rcpp , il che rende molto veloce il lavoro con i dati in memoria.

La filosofia di dplyr è di avere piccole funzioni che facciano bene una cosa. Le cinque funzioni semplici ( filter , arrange , select , mutate , e summarise ) può essere utilizzato per rivelare nuovi modi per descrivere i dati. Se combinate con group_by , queste funzioni possono essere utilizzate per calcolare le statistiche di riepilogo di gruppo.

Elementi comuni della sintassi

Tutte queste funzioni hanno una sintassi simile:

  • Il primo argomento di tutte queste funzioni è sempre un frame di dati
  • Le colonne possono essere indirizzate direttamente usando nomi di variabili spogli (cioè, senza usare $ )
  • Queste funzioni non modificano i dati originali, cioè non hanno effetti collaterali. Quindi, i risultati dovrebbero sempre essere salvati su un oggetto.

Useremo il set di dati mtcars integrato per esplorare i verbi a tabella singola di dplyr . Prima di convertire il tipo di mtcars in tbl_df (dato che rende più pulito la stampa), aggiungiamo i rownames dei rownames del set di dati come una colonna usando la funzione rownames_to_column dal pacchetto tibble .

library(dplyr) # This documentation was written using version 0.5.0

mtcars_tbl <- as_data_frame(tibble::rownames_to_column(mtcars, "cars"))

# examine the structure of data
head(mtcars_tbl)

# A tibble: 6 x 12
#               cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#              <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1         Mazda RX4  21.0     6   160   110  3.90 2.620 16.46     0     1     4     4
#2     Mazda RX4 Wag  21.0     6   160   110  3.90 2.875 17.02     0     1     4     4
#3        Datsun 710  22.8     4   108    93  3.85 2.320 18.61     1     1     4     1
#4    Hornet 4 Drive  21.4     6   258   110  3.08 3.215 19.44     1     0     3     1
#5 Hornet Sportabout  18.7     8   360   175  3.15 3.440 17.02     0     0     3     2
#6           Valiant  18.1     6   225   105  2.76 3.460 20.22     1     0     3     1

filtro

filter aiuta a impostare sottoinsiemi che corrispondono a determinati criteri. Il primo argomento è il nome di data.frame e il secondo (e successivi) argomenti sono i criteri che filtrano i dati (questi criteri dovrebbero valutare sia TRUE che FALSE )

Sottoinsieme tutte le auto che hanno 4 cilindri - cyl :

filter(mtcars_tbl, cyl == 4) 

# A tibble: 11 x 12
#             cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#            <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1      Datsun 710  22.8     4 108.0    93  3.85 2.320 18.61     1     1     4     1
#2       Merc 240D  24.4     4 146.7    62  3.69 3.190 20.00     1     0     4     2
#3        Merc 230  22.8     4 140.8    95  3.92 3.150 22.90     1     0     4     2
#4        Fiat 128  32.4     4  78.7    66  4.08 2.200 19.47     1     1     4     1
#5     Honda Civic  30.4     4  75.7    52  4.93 1.615 18.52     1     1     4     2
# ... with 6 more rows

Possiamo passare più criteri separati da una virgola. Per suddividere le vetture che hanno 4 o 6 cilindri - cyl e con 5 marce - gear :

filter(mtcars_tbl, cyl == 4 | cyl == 6, gear == 5)

# A tibble: 3 x 12
#           cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#          <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1 Porsche 914-2  26.0     4 120.3    91  4.43 2.140  16.7     0     1     5     2
#2  Lotus Europa  30.4     4  95.1   113  3.77 1.513  16.9     1     1     5     2
#3  Ferrari Dino  19.7     6 145.0   175  3.62 2.770  15.5     0     1     5     6

filter seleziona le righe in base ai criteri, per selezionare le righe in base alla posizione, utilizzare la slice . slice accetta solo 2 argomenti: il primo è un data.frame e il secondo è un valore di riga intero.

Per selezionare le righe da 6 a 9:

slice(mtcars_tbl, 6:9)

# A tibble: 4 x 12
#        cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#       <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1    Valiant  18.1     6 225.0   105  2.76  3.46 20.22     1     0     3     1
#2 Duster 360  14.3     8 360.0   245  3.21  3.57 15.84     0     0     3     4
#3  Merc 240D  24.4     4 146.7    62  3.69  3.19 20.00     1     0     4     2
#4   Merc 230  22.8     4 140.8    95  3.92  3.15 22.90     1     0     4     2

O:

slice(mtcars_tbl, -c(1:5, 10:n())) 

Ciò si traduce nello stesso output di slice(mtcars_tbl, 6:9)

n() rappresenta il numero di osservazioni nel gruppo corrente

organizzare

arrange è usato per ordinare i dati da una variabile specificata (s). Proprio come il verbo precedente (e tutte le altre funzioni in dplyr ), il primo argomento è un data.frame , e gli argomenti conseguenti sono usati per ordinare i dati. Se viene passata più di una variabile, i dati vengono prima ordinati dalla prima variabile, quindi dalla seconda variabile e così via.

Per ordinare i dati a potenza - hp

arrange(mtcars_tbl, hp) 

# A tibble: 32 x 12
#             cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#            <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1     Honda Civic  30.4     4  75.7    52  4.93 1.615 18.52     1     1     4     2
#2       Merc 240D  24.4     4 146.7    62  3.69 3.190 20.00     1     0     4     2
#3  Toyota Corolla  33.9     4  71.1    65  4.22 1.835 19.90     1     1     4     1
#4        Fiat 128  32.4     4  78.7    66  4.08 2.200 19.47     1     1     4     1
#5       Fiat X1-9  27.3     4  79.0    66  4.08 1.935 18.90     1     1     4     1
#6   Porsche 914-2  26.0     4 120.3    91  4.43 2.140 16.70     0     1     5     2
# ... with 26 more rows

Per arrange i dati per miglia per gallone - mpg in ordine decrescente, seguito dal numero di cilindri - cyl :

arrange(mtcars_tbl, desc(mpg), cyl)

# A tibble: 32 x 12
#             cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#            <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1  Toyota Corolla  33.9     4  71.1    65  4.22 1.835 19.90     1     1     4     1
#2        Fiat 128  32.4     4  78.7    66  4.08 2.200 19.47     1     1     4     1
#3     Honda Civic  30.4     4  75.7    52  4.93 1.615 18.52     1     1     4     2
#4    Lotus Europa  30.4     4  95.1   113  3.77 1.513 16.90     1     1     5     2
#5       Fiat X1-9  27.3     4  79.0    66  4.08 1.935 18.90     1     1     4     1
#6   Porsche 914-2  26.0     4 120.3    91  4.43 2.140 16.70     0     1     5     2
# ... with 26 more rows

selezionare

select è usato per selezionare solo un sottoinsieme di variabili. Per selezionare solo mpg , disp , wt , qsec e vs da mtcars_tbl :

select(mtcars_tbl, mpg, disp, wt, qsec, vs)

# A tibble: 32 x 5
#     mpg  disp    wt  qsec    vs
#   <dbl> <dbl> <dbl> <dbl> <dbl>
#1   21.0 160.0 2.620 16.46     0
#2   21.0 160.0 2.875 17.02     0
#3   22.8 108.0 2.320 18.61     1
#4   21.4 258.0 3.215 19.44     1
#5   18.7 360.0 3.440 17.02     0
#6   18.1 225.0 3.460 20.22     1
# ... with 26 more rows

: notazione può essere utilizzata per selezionare colonne consecutive. Per selezionare le colonne dalle cars attraverso disp e vs attraverso carb :

select(mtcars_tbl, cars:disp, vs:carb)

# A tibble: 32 x 8
#                cars   mpg   cyl  disp    vs    am  gear  carb
#               <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1          Mazda RX4  21.0     6 160.0     0     1     4     4
#2      Mazda RX4 Wag  21.0     6 160.0     0     1     4     4
#3         Datsun 710  22.8     4 108.0     1     1     4     1
#4     Hornet 4 Drive  21.4     6 258.0     1     0     3     1
#5  Hornet Sportabout  18.7     8 360.0     0     0     3     2
#6            Valiant  18.1     6 225.0     1     0     3     1
# ... with 26 more rows

o select(mtcars_tbl, -(hp:qsec))

Per i set di dati che contengono più colonne, può essere noioso selezionare più colonne per nome. Per semplificarti la vita, ci sono un certo numero di funzioni di supporto (come starts_with() , ends_with() , contains() , matches() , num_range() , one_of() e everything() ) che può essere utilizzato in select . Per saperne di più su come usarli, vedi ?select_helpers e ?select .

Nota : pur facendo riferimento alle colonne direttamente in select() , utilizziamo nomi di colonne spogli, ma le virgolette dovrebbero essere utilizzate mentre ci si riferisce alle colonne nelle funzioni di supporto.

Per rinominare le colonne durante la selezione:

select(mtcars_tbl, cylinders = cyl, displacement = disp) 

# A tibble: 32 x 2
#   cylinders displacement
#       <dbl>        <dbl>
#1          6        160.0
#2          6        160.0
#3          4        108.0
#4          6        258.0
#5          8        360.0
#6          6        225.0
# ... with 26 more rows

Come previsto, questo elimina tutte le altre variabili.

Per rinominare le colonne senza perdere altre variabili, usa rename :

rename(mtcars_tbl, cylinders = cyl, displacement = disp)

# A tibble: 32 x 12
#                cars   mpg cylinders displacement    hp  drat    wt  qsec    vs
#               <chr> <dbl>     <dbl>        <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#1          Mazda RX4  21.0         6        160.0   110  3.90 2.620 16.46     0
#2      Mazda RX4 Wag  21.0         6        160.0   110  3.90 2.875 17.02     0
#3         Datsun 710  22.8         4        108.0    93  3.85 2.320 18.61     1
#4     Hornet 4 Drive  21.4         6        258.0   110  3.08 3.215 19.44     1
#5  Hornet Sportabout  18.7         8        360.0   175  3.15 3.440 17.02     0
#6            Valiant  18.1         6        225.0   105  2.76 3.460 20.22     1
# ... with 26 more rows, and 3 more variables: am <dbl>, gear <dbl>, carb <dbl>

mutare

mutate può essere utilizzato per aggiungere nuove colonne ai dati. Come tutte le altre funzioni in dplyr , mutate non aggiunge le colonne appena create ai dati originali. Le colonne vengono aggiunte alla fine di data.frame .

mutate(mtcars_tbl, weight_ton = wt/2, weight_pounds = weight_ton * 2000)

# A tibble: 32 x 14
#                cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb weight_ton weight_pounds
#               <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>      <dbl>         <dbl>
#1          Mazda RX4  21.0     6 160.0   110  3.90 2.620 16.46     0     1     4     4     1.3100          2620
#2      Mazda RX4 Wag  21.0     6 160.0   110  3.90 2.875 17.02     0     1     4     4     1.4375          2875
#3         Datsun 710  22.8     4 108.0    93  3.85 2.320 18.61     1     1     4     1     1.1600          2320
#4     Hornet 4 Drive  21.4     6 258.0   110  3.08 3.215 19.44     1     0     3     1     1.6075          3215
#5  Hornet Sportabout  18.7     8 360.0   175  3.15 3.440 17.02     0     0     3     2     1.7200          3440
#6            Valiant  18.1     6 225.0   105  2.76 3.460 20.22     1     0     3     1     1.7300          3460
# ... with 26 more rows

Notare l'uso di weight_ton durante la creazione di weight_pounds . A differenza della base R , mutate ci consente di fare riferimento alle colonne che abbiamo appena creato per essere utilizzate per un'operazione successiva.

Per conservare solo le colonne appena create, usa transmute invece di mutate :

transmute(mtcars_tbl, weight_ton = wt/2, weight_pounds = weight_ton * 2000)

# A tibble: 32 x 2
#   weight_ton weight_pounds
#        <dbl>         <dbl>
#1      1.3100          2620
#2      1.4375          2875
#3      1.1600          2320
#4      1.6075          3215
#5      1.7200          3440
#6      1.7300          3460
# ... with 26 more rows

ricapitolare

summarise calcola le statistiche riassuntive delle variabili comprimendo più valori in un singolo valore. Può calcolare più statistiche e possiamo denominare queste colonne di riepilogo nella stessa dichiarazione.

Per calcolare la media e la deviazione standard di mpg e disp di tutte le auto nel set di dati:

summarise(mtcars_tbl, mean_mpg = mean(mpg), sd_mpg = sd(mpg), 
          mean_disp = mean(disp), sd_disp = sd(disp))

# A tibble: 1 x 4
#  mean_mpg   sd_mpg mean_disp  sd_disp
#     <dbl>    <dbl>     <dbl>    <dbl>
#1 20.09062 6.026948  230.7219 123.9387

raggruppa per

group_by può essere utilizzato per eseguire operazioni di gruppo saggio sui dati. Quando i verbi definiti sopra vengono applicati a questi dati raggruppati, vengono applicati automaticamente a ciascun gruppo separatamente.

Per trovare mean e sd di mpg per cyl :

by_cyl <- group_by(mtcars_tbl, cyl)
summarise(by_cyl, mean_mpg = mean(mpg), sd_mpg = sd(mpg))


# A tibble: 3 x 3
#    cyl mean_mpg   sd_mpg
#  <dbl>    <dbl>    <dbl>
#1     4 26.66364 4.509828
#2     6 19.74286 1.453567
#3     8 15.10000 2.560048

Mettendo tutto insieme

Selezioniamo le colonne dalle cars tramite hp e gear , ordiniamo le righe per cyl e dal mpg più alto a quello più basso, raggruppiamo i dati in base alle gear , e infine sottoinsieme solo quelle vetture hanno mpg > 20 e hp > 75

selected <- select(mtcars_tbl, cars:hp, gear)
ordered <- arrange(selected, cyl, desc(mpg))
by_cyl <- group_by(ordered, gear)
filter(by_cyl, mpg > 20, hp > 75)

Source: local data frame [9 x 6]
Groups: gear [3]

#            cars   mpg   cyl  disp    hp  gear
#           <chr> <dbl> <dbl> <dbl> <dbl> <dbl>
#1   Lotus Europa  30.4     4  95.1   113     5
#2  Porsche 914-2  26.0     4 120.3    91     5
#3     Datsun 710  22.8     4 108.0    93     4
#4       Merc 230  22.8     4 140.8    95     4
#5  Toyota Corona  21.5     4 120.1    97     3
# ... with 4 more rows

Forse non siamo interessati ai risultati intermedi, possiamo ottenere lo stesso risultato di cui sopra avvolgendo le chiamate di funzione:

filter(
    group_by(
        arrange(
            select(
                mtcars_tbl, cars:hp
            ), cyl, desc(mpg)
        ), cyl   
    ),mpg > 20, hp > 75 
)

Questo può essere un po 'difficile da leggere. Quindi, dplyr operazioni di dplyr possono essere concatenate usando l'operatore pipe %>% . Il codice sopra riportato si trasforma in:

mtcars_tbl %>% 
    select(cars:hp) %>% 
    arrange(cyl, desc(mpg)) %>%
    group_by(cyl) %>% 
    filter(mpg > 20, hp > 75) 

riepiloga più colonne

dplyr fornisce dplyr summarise_all() per applicare le funzioni a tutte le colonne (non raggruppate).

Per trovare il numero di valori distinti per ogni colonna:

mtcars_tbl %>% 
    summarise_all(n_distinct)

# A tibble: 1 x 12
#   cars   mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
#  <int> <int> <int> <int> <int> <int> <int> <int> <int> <int> <int> <int>
#1    32    25     3    27    22    22    29    30     2     2     3     6

Per trovare il numero di valori distinti per ogni colonna per cyl :

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_all(n_distinct)

# A tibble: 3 x 12
#    cyl  cars   mpg  disp    hp  drat    wt  qsec    vs    am  gear  carb
#  <dbl> <int> <int> <int> <int> <int> <int> <int> <int> <int> <int> <int>
#1     4    11     9    11    10    10    11    11     2     2     3     2
#2     6     7     6     5     4     5     6     7     2     2     3     3
#3     8    14    12    11     9    11    13    14     1     2     2     4

Si noti che abbiamo appena dovuto aggiungere la dichiarazione group_by e il resto del codice è lo stesso. L'output ora consiste di tre righe, una per ogni valore univoco di cyl .

Per summarise colonne multiple specifiche, utilizzare summarise_at

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_at(c("mpg", "disp", "hp"), mean)

# A tibble: 3 x 4
#    cyl      mpg     disp        hp
#  <dbl>    <dbl>    <dbl>     <dbl>
#1     4 26.66364 105.1364  82.63636
#2     6 19.74286 183.3143 122.28571
#3     8 15.10000 353.1000 209.21429

helper funzioni di helper ( ?select_helpers ) possono essere utilizzate al posto dei nomi delle colonne per selezionare colonne specifiche

Per applicare più funzioni, passare i nomi delle funzioni come vettore di caratteri:

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_at(c("mpg", "disp", "hp"), 
                 c("mean", "sd"))

o avvolgerli nei funs :

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_at(c("mpg", "disp", "hp"), 
                 funs(mean, sd))

# A tibble: 3 x 7
#    cyl mpg_mean disp_mean   hp_mean   mpg_sd  disp_sd    hp_sd
#  <dbl>    <dbl>     <dbl>     <dbl>    <dbl>    <dbl>    <dbl>
#1     4 26.66364  105.1364  82.63636 4.509828 26.87159 20.93453
#2     6 19.74286  183.3143 122.28571 1.453567 41.56246 24.26049
#3     8 15.10000  353.1000 209.21429 2.560048 67.77132 50.97689

I nomi delle colonne sono ora associati ai nomi delle funzioni per tenerli distinti. Per cambiare questo, passa il nome da aggiungere alla funzione:

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_at(c("mpg", "disp", "hp"), 
                 c(Mean = "mean", SD = "sd"))

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_at(c("mpg", "disp", "hp"), 
                 funs(Mean = mean, SD = sd))


# A tibble: 3 x 7
#    cyl mpg_Mean disp_Mean   hp_Mean   mpg_SD  disp_SD    hp_SD
#  <dbl>    <dbl>     <dbl>     <dbl>    <dbl>    <dbl>    <dbl>
#1     4 26.66364  105.1364  82.63636 4.509828 26.87159 20.93453
#2     6 19.74286  183.3143 122.28571 1.453567 41.56246 24.26049
#3     8 15.10000  353.1000 209.21429 2.560048 67.77132 50.97689

Per selezionare condizionalmente le colonne, utilizzare summarise_if :

Prendi la mean di tutte le colonne numeric raggruppate per cyl :

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_if(is.numeric, mean) 

# A tibble: 3 x 11
#    cyl      mpg     disp        hp     drat       wt     qsec
#  <dbl>    <dbl>    <dbl>     <dbl>    <dbl>    <dbl>    <dbl>
#1     4 26.66364 105.1364  82.63636 4.070909 2.285727 19.13727
#2     6 19.74286 183.3143 122.28571 3.585714 3.117143 17.97714
#3     8 15.10000 353.1000 209.21429 3.229286 3.999214 16.77214
# ... with 4 more variables: vs <dbl>, am <dbl>, gear <dbl>,
#   carb <dbl>

Tuttavia, alcune variabili sono discrete e la mean di queste variabili non ha senso.

Per prendere la mean di sole variabili continue per cyl :

mtcars_tbl %>% 
    group_by(cyl) %>% 
    summarise_if(function(x) is.numeric(x) & n_distinct(x) > 6, mean)

# A tibble: 3 x 7
#    cyl      mpg     disp        hp     drat       wt     qsec
#  <dbl>    <dbl>    <dbl>     <dbl>    <dbl>    <dbl>    <dbl>
#1     4 26.66364 105.1364  82.63636 4.070909 2.285727 19.13727
#2     6 19.74286 183.3143 122.28571 3.585714 3.117143 17.97714
#3     8 15.10000 353.1000 209.21429 3.229286 3.999214 16.77214

Osservazione sottoinsieme (righe)

dplyr::filter() - Seleziona un sottoinsieme di righe in un frame di dati che soddisfano un criterio logico:

dplyr::filter(iris,Sepal.Length>7)
#       Sepal.Length Sepal.Width Petal.Length Petal.Width   Species
#    1           7.1         3.0          5.9         2.1 virginica
#    2           7.6         3.0          6.6         2.1 virginica
#    3           7.3         2.9          6.3         1.8 virginica
#    4           7.2         3.6          6.1         2.5 virginica
#    5           7.7         3.8          6.7         2.2 virginica
#    6           7.7         2.6          6.9         2.3 virginica
#    7           7.7         2.8          6.7         2.0 virginica
#    8           7.2         3.2          6.0         1.8 virginica
#    9           7.2         3.0          5.8         1.6 virginica
#    10          7.4         2.8          6.1         1.9 virginica
#    11          7.9         3.8          6.4         2.0 virginica
#    12          7.7         3.0          6.1         2.3 virginica

dplyr::distinct() - Rimuovi le righe duplicate:

distinct(iris, Sepal.Length, .keep_all = TRUE)
#       Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
#    1           5.1         3.5          1.4         0.2     setosa
#    2           4.9         3.0          1.4         0.2     setosa
#    3           4.7         3.2          1.3         0.2     setosa
#    4           4.6         3.1          1.5         0.2     setosa
#    5           5.0         3.6          1.4         0.2     setosa
#    6           5.4         3.9          1.7         0.4     setosa
#    7           4.4         2.9          1.4         0.2     setosa
#    8           4.8         3.4          1.6         0.2     setosa
#    9           4.3         3.0          1.1         0.1     setosa
#   10          5.8         4.0          1.2         0.2     setosa
#   11          5.7         4.4          1.5         0.4     setosa
#   12          5.2         3.5          1.5         0.2     setosa
#   13          5.5         4.2          1.4         0.2     setosa
#   14          4.5         2.3          1.3         0.3     setosa
#   15          5.3         3.7          1.5         0.2     setosa
#   16          7.0         3.2          4.7         1.4 versicolor
#   17          6.4         3.2          4.5         1.5 versicolor
#   18          6.9         3.1          4.9         1.5 versicolor
#   19          6.5         2.8          4.6         1.5 versicolor
#   20          6.3         3.3          4.7         1.6 versicolor
#   21          6.6         2.9          4.6         1.3 versicolor
#   22          5.9         3.0          4.2         1.5 versicolor
#   23          6.0         2.2          4.0         1.0 versicolor
#   24          6.1         2.9          4.7         1.4 versicolor
#   25          5.6         2.9          3.6         1.3 versicolor
#   26          6.7         3.1          4.4         1.4 versicolor
#   27          6.2         2.2          4.5         1.5 versicolor
#   28          6.8         2.8          4.8         1.4 versicolor
#   29          7.1         3.0          5.9         2.1  virginica
#   30          7.6         3.0          6.6         2.1  virginica
#   31          7.3         2.9          6.3         1.8  virginica
#   32          7.2         3.6          6.1         2.5  virginica
#   33          7.7         3.8          6.7         2.2  virginica
#   34          7.4         2.8          6.1         1.9  virginica
#   35          7.9         3.8          6.4         2.0  virginica

Aggregazione con%>% (pipe) operatore

L' operatore pipe (%>%) può essere utilizzato in combinazione con dplyr funzioni dplyr . In questo esempio usiamo il set di dati mtcars (vedi help("mtcars") per maggiori informazioni) per mostrare come sumarize un frame di dati e per aggiungere variabili ai dati con il risultato dell'applicazione di una funzione.

library(dplyr)
library(magrittr)
df <- mtcars
df$cars <- rownames(df) #just add the cars names to the df
df <- df[,c(ncol(df),1:(ncol(df)-1))] # and place the names in the first column

1. Riassumi i dati

Per calcolare le statistiche utilizziamo il summarize e le funzioni appropriate. In questo caso, n() viene utilizzato per contare il numero di casi.

 df %>%
  summarize(count=n(),mean_mpg = mean(mpg, na.rm = TRUE),
            min_weight = min(wt),max_weight = max(wt))

#  count mean_mpg min_weight max_weight
#1    32 20.09062      1.513      5.424

2. Calcolare le statistiche per gruppo

È possibile calcolare le statistiche per gruppi di dati. In questo caso per Numero di cilindri e Numero di marce avanti

df %>%
  group_by(cyl, gear) %>%
  summarize(count=n(),mean_mpg = mean(mpg, na.rm = TRUE),
            min_weight = min(wt),max_weight = max(wt))

# Source: local data frame [8 x 6]
# Groups: cyl [?]
#
#    cyl  gear count mean_mpg min_weight max_weight
#  <dbl> <dbl> <int>    <dbl>      <dbl>      <dbl>
#1     4     3     1   21.500      2.465      2.465
#2     4     4     8   26.925      1.615      3.190
#3     4     5     2   28.200      1.513      2.140
#4     6     3     2   19.750      3.215      3.460
#5     6     4     4   19.750      2.620      3.440
#6     6     5     1   19.700      2.770      2.770
#7     8     3    12   15.050      3.435      5.424
#8     8     5     2   15.400      3.170      3.570

Esempi di NSE e variabili stringa in dpylr

dplyr usa Non-Standard Evaluation (NSE), ed è per questo che normalmente possiamo usare i nomi delle variabili senza virgolette. Tuttavia, a volte durante la pipeline dei dati, è necessario ottenere i nomi delle variabili da altre fonti, ad esempio una casella di selezione Lucida. Nel caso di funzioni come select , possiamo semplicemente usare select_ per usare una variabile stringa da selezionare

variable1 <- "Sepal.Length"
variable2 <- "Sepal.Width"
iris %>%
select_(variable1, variable2) %>%
head(n=5)
#  Sepal.Length Sepal.Width
#  1          5.1         3.5
#  2          4.9         3.0
#  3          4.7         3.2
#  4          4.6         3.1
#  5          5.0         3.6

Ma se vogliamo utilizzare altre funzionalità come il riepilogo o il filtro, dobbiamo usare la funzione interp dal pacchetto lazyeval

variable1 <- "Sepal.Length"
variable2 <- "Sepal.Width"
variable3 <- "Species"
iris %>%
select_(variable1, variable2, variable3) %>%
group_by_(variable3) %>%
summarize_(mean1 = lazyeval::interp(~mean(var), var = as.name(variable1)), mean2 = lazyeval::interp(~mean(var), var = as.name(variable2)))
#      Species mean1 mean2
#       <fctr> <dbl> <dbl>
# 1     setosa 5.006 3.428
# 2 versicolor 5.936 2.770
# 3  virginica 6.588 2.974


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow