Cos'è il piping?

Le tubazioni possono anche essere riferite al concatenamento.

In R, l'operatore pipe ( %>%) viene utilizzato per passare il risultato di un'operazione come input a un'altra. Fa parte del pacchetto tidyverse e viene utilizzato per creare un codice più leggibile e conciso.

L'operatore pipe consente di concatenare più operazioni in un modo più semplice da leggere e comprendere rispetto alle chiamate di funzioni nidificate. Può rendere il tuo codice più conciso e più facile da mantenere.

Perché usiamo tubi / concatenamento

Le pipe o il concatenamento vengono utilizzati nella programmazione per consentire di eseguire più operazioni su un dato in modo conciso e leggibile. Concatenando più operazioni utilizzando un operatore pipe o un'altra sintassi, è possibile esprimere attività complesse in modo più lineare e comprensibile, anziché dover annidare più chiamate di funzione o scrivere più righe di codice.

Le pipe e il concatenamento possono essere particolarmente utili nelle attività di manipolazione e analisi dei dati, in cui spesso è necessario applicare una serie di operazioni a un set di dati per prepararlo per l'analisi o la visualizzazione . Possono rendere il tuo codice più modulare e più facile da mantenere e possono migliorare la tua produttività consentendoti di scrivere e testare diverse combinazioni di operazioni più rapidamente.

Nel complesso, pipe e concatenamento sono strumenti utili per creare codice più leggibile, modulare e flessibile, che può aiutarti a comprendere e risolvere meglio problemi complessi.

Gli operatori pipe vengono utilizzati per passare i parametri a una funzione in modo semplice ed elegante. Consente al codificatore di eliminare i valori intermedi e rendere le chiamate di funzione più facili da leggere.

Ci sono vantaggi per le tubazioni?

Ci sono diversi vantaggi nell'usare l'operatore pipe:

1. Migliore leggibilità: l'operatore pipe può rendere il tuo codice più leggibile permettendoti di esprimere operazioni complesse in modo più conciso e lineare. Può anche aiutarti a evitare l'annidamento profondo delle chiamate di funzione, che può rendere il tuo codice più difficile da seguire.
2. Maggiore modularità: è possibile utilizzare l'operatore pipe per creare blocchi di codice riutilizzabili che possono essere facilmente combinati in modi diversi per eseguire attività diverse. Questo può rendere il tuo codice più modulare e più facile da mantenere.
3. Collaborazione migliorata: l'operatore pipe è uno strumento ampiamente utilizzato e familiare nella comunità R e il suo utilizzo nel codice può facilitare la comprensione e il contributo degli altri al proprio lavoro.
4. Maggiore flessibilità: l'operatore pipe ti consente di scambiare facilmente diversi componenti del tuo codice e provare diverse combinazioni di operazioni senza dover riscrivere grandi parti del tuo codice. Ciò può farti risparmiare tempo e semplificare la sperimentazione e l'iterazione della tua analisi.

Gli operatori pipe sono utilizzati in numerosi linguaggi di programmazione, tra cui:

1. Shell Unix (come bash): nelle shell Unix, l'operatore pipe ( |) viene utilizzato per reindirizzare l'output di un comando come input a un altro comando. Ad esempio, il comando ls -l | grep "^d"elenca le directory nella directory corrente.
2. R: In R, l'operatore pipe ( %>%) viene utilizzato per passare il risultato di un'operazione come input a un'altra. Fa parte del pacchetto tidyverse e viene utilizzato per creare un codice più leggibile e conciso.
3. Elixir: In Elixir, l'operatore pipe ( |>) viene utilizzato per passare il risultato di una funzione come input a un'altra. È simile all'operatore pipe R.
4. F#: in F#, l'operatore pipe ( |>) viene utilizzato per passare il risultato di una funzione come input a un'altra. È simile agli operatori Elixir e R pipe.
5. PowerShell: in PowerShell, l'operatore pipeline ( |) viene usato per passare l'output di un comando come input a un altro comando. È simile all'operatore pipe di Unix.
6. In Julia, l'operatore pipe ( |>) viene utilizzato per passare il risultato di una funzione come input a un'altra. È simile agli operatori pipe usati in altri linguaggi, come R, Elixir e F#.

Tipi di tubi

Esistono diversi tipi di pipe che vengono utilizzati nella programmazione:

1. Pipe di dati : queste pipe vengono utilizzate per passare l'output di un comando o una funzione come input a un altro. Sono comunemente usati nelle shell Unix (come bash) e nei linguaggi di programmazione che hanno un operatore pipe (come R ed Elixir).
2. Pipe di reindirizzamento : queste pipe vengono utilizzate per reindirizzare l'output di un comando o di una funzione su un file o in un'altra posizione. Sono comunemente usati nelle shell Unix (come bash) e nei linguaggi di programmazione che hanno un operatore di reindirizzamento (come PowerShell).
3. Pipe condizionali : queste pipe vengono utilizzate per passare l'output di un comando o una funzione a un altro comando o funzione solo se viene soddisfatta una determinata condizione. Sono comunemente usati nelle shell Unix (come bash) e nei linguaggi di programmazione che hanno un operatore condizionale (come PowerShell).
4. Pipe di passaggio di messaggi : queste pipe vengono utilizzate per passare messaggi o dati tra processi o thread. Sono comunemente usati nei linguaggi di programmazione concorrente per consentire a diverse parti di un programma di comunicare tra loro.
5. Le forward pipe sono un tipo di operatore pipe che passa l'output di una funzione come input a un'altra funzione. Sono chiamati pipe "forward" perché l'output scorre in avanti attraverso la catena di funzioni, piuttosto che all'indietro.
6. In R, l' %>%operatore è un operatore pipe forward. Viene utilizzato per passare il risultato di un'operazione come primo argomento a un'altra operazione. Per esempio:

Le forward pipe possono essere particolarmente utili nel contesto del tidyverse, una raccolta di pacchetti R per la manipolazione e l'analisi dei dati.

In R, i " feed forward pipe " sono un modo per passare l'output di una funzione come input a un'altra funzione senza assegnare il risultato intermedio a una variabile. Questo viene fatto usando l' %$%operatore, che è simile all'operatore %>%, ma passa l'input al lato destro dell'operatore come argomento alla funzione sul lato sinistro, piuttosto che come primo argomento.

Julia ha anche un operatore " pipe all'indietro " ( <|) che può essere utilizzato per passare l'input a una funzione come primo argomento, anziché come ultimo. Ciò può essere utile nei casi in cui si desidera passare l'input a una funzione che lo prevede come primo argomento, anziché come ultimo.

Nel complesso, l'operatore pipe può essere uno strumento utile per scrivere codice più leggibile e conciso in Julia.

Diamo un'occhiata ad alcuni esempi:

url='https://raw.githubusercontent.com/NicJC/Country-Sales/main/Country_Sales.csv'
data <- read_csv(url,show_col_types = FALSE)
data %>%
  head(10)

      
                

                    
                    
                
            

url='https://raw.githubusercontent.com/NicJC/Country-Sales/main/Country_Sales.csv'

data <- read_csv(url,show_col_types = FALSE)
data %>%

  head(10) %>%

  select(c(1,2,3,6,7))

      
                

                    
                    
                
            

Poiché abbiamo elencato le prime 10 righe del data-frame prima che ulteriori parametri vengano passati al data-frame, avremo solo le prime 10 righe con cui lavorare, che possiamo vedere dall'immagine sopra in quanto ha solo

1-10 di 10 righe

data %>%
  
  select(c(1,2,3,6,7)) %>% 
  
  rename(Units_Sold = 'Units Sold',Item_Type = 'Item Type',Order_Date = 'Order Date')

      
                

                    
                    
                
            

data %>%
  
  select(c(1,2,3,6,7)) %>% 
  
  rename(Units_Sold = 'Units Sold',Item_Type = 'Item Type',Order_Date = 'Order Date') %>%
  
  filter(Country == "Australia" & Item_Type != ("Vegetables"))

      
                

                    
                    
                
            

Nota '==' per allocazione e '!= 'per esclusione.

Ora possiamo aggiungere alcune aggregazioni e raggruppamenti.

data %>%
  
  select(c(1,2,3,6,7)) %>% 
  
  rename(Units_Sold = 'Units Sold',Item_Type = 'Item Type',Order_Date = 'Order Date') %>%
  
  filter(Country == "Australia" & Item_Type != ("Vegetables")) %>%
  
  group_by(Item_Type, Year) %>%
  
  summarise(Avg_Sales = mean(Units_Sold))

      
                

                    
                    
                
            

data %>%
  
  select(c(1,2,3,6,7)) %>% 
  
  rename(Units_Sold = 'Units Sold',Item_Type = 'Item Type',Order_Date = 'Order Date') %>%
  
  filter(Country == "Australia" & Item_Type != ("Vegetables")) %>%
  
  group_by(Item_Type, Year) %>%
  
  summarise(Avg_Sales = mean(Units_Sold)) %>%
  
  ggplot() +
  
  geom_point(mapping = aes(x = Year , Avg_Sales , col = Item_Type)) +
  
  labs( title = "Average sales by item", subtitle = "Australian Sales" , 
        col = "Item Type" , y = "Average sales" , caption = "Vegetables excluded from sales")

Possiamo allocare tutti questi dati manipolati in un nuovo frame di dati che dovrebbe farci risparmiare un po' di tempo:-

df <- dati

questo non ci consentirà di accedere a nessuno dei dati nel data-frame originale.

Questo può essere utile se vogliamo solo conservare i dati manipolati.

df <- data %>%
  
  select(c(1,2,3,6,7)) %>% 
  
  rename(Units_Sold = 'Units Sold',Item_Type = 'Item Type',Order_Date = 'Order Date') %>%
  
  filter(Country == "Australia" & Item_Type != ("Vegetables")) %>%
  
  group_by(Item_Type, Year) %>%
  
  summarise(Avg_Sales = mean(Units_Sold))

df

      
                

                    
                    
                
            

da R per Data Science

La pipa è uno strumento potente, ma non è l'unico a tua disposizione, e non risolve tutti i problemi! Le pipe sono molto utili per riscrivere una sequenza lineare piuttosto breve di operazioni. Penso che dovresti raggiungere un altro strumento quando:

• Le tue pipe sono più lunghe di (diciamo) dieci gradini. In tal caso, crea oggetti intermedi con nomi significativi. Ciò renderà più facile il debug, perché puoi controllare più facilmente i risultati intermedi e semplifica la comprensione del tuo codice, perché i nomi delle variabili possono aiutare a comunicare l'intento.
• Hai più ingressi o uscite. Se non c'è un oggetto principale che viene trasformato, ma due o più oggetti vengono combinati insieme, non usare la pipe.
• Stai iniziando a pensare a un grafico diretto con una struttura di dipendenza complessa. Le pipe sono fondamentalmente lineari e l'espressione di relazioni complesse con esse produrrà in genere codice confuso.

Esistono molti diversi operatori pipe in uso in una varietà di linguaggi di programmazione, ognuno con il proprio set di caratteristiche e capacità.

Potrebbe volerci del tempo per abituarsi a lavorare con le pipe, ma ci sono molti vantaggi nell'usarle, vale a dire:

1. Leggibilità migliorata
2. Flessibilità
3. Debug più semplice
4. Modularità

Il concetto di tubo non è specifico della programmazione e ha una lunga storia in matematica e ingegneria. In un contesto matematico, un tubo è un dispositivo utilizzato per trasmettere un fluido (come acqua o gas) da un luogo a un altro. I tubi sono comunemente usati per convogliare fluidi attraverso un sistema di canali o tubi interconnessi, e sono spesso usati per controllare il flusso e la pressione del fluido da uno stadio all'altro...

Spero ti sia piaciuto l'articolo!

Dai un'occhiata al mio articolo su piping e manipolazione dei dati:

Convogliare i tuoi dati con R - parte 1

Connettiamoci su Linkedin o github