Was ist Rohrleitung?

Rohrleitungen können auch als Verkettungen bezeichnet werden.

In R wird der Pipe-Operator ( %>%) verwendet, um das Ergebnis einer Operation als Eingabe an eine andere zu übergeben. Es ist Teil des Tidyverse-Pakets und wird verwendet, um einen besser lesbaren und prägnanteren Code zu erstellen.

Mit dem Pipe-Operator können Sie mehrere Vorgänge auf eine Weise verketten, die einfacher zu lesen und zu verstehen ist als verschachtelte Funktionsaufrufe. Dadurch kann Ihr Code prägnanter und einfacher zu warten sein.

Warum verwenden wir Rohre/Ketten?

Pipes oder Verkettungen werden in der Programmierung verwendet, um es Ihnen zu ermöglichen, mehrere Operationen an einem Datenelement auf prägnante und lesbare Weise auszuführen. Durch die Verkettung mehrerer Vorgänge mithilfe eines Pipe-Operators oder einer anderen Syntax können Sie komplexe Aufgaben linearer und verständlicher ausdrücken, anstatt mehrere Funktionsaufrufe verschachteln oder mehrere Codezeilen schreiben zu müssen.

Pipes und Verkettungen können besonders bei Datenmanipulations- und Analyseaufgaben nützlich sein, bei denen Sie häufig eine Reihe von Vorgängen auf einen Datensatz anwenden müssen, um ihn für die Analyse oder Visualisierung vorzubereiten . Sie können Ihren Code modularer und einfacher zu warten machen und Ihre Produktivität steigern, indem sie es Ihnen ermöglichen, verschiedene Kombinationen von Vorgängen schneller zu schreiben und zu testen.

Insgesamt sind Pipes und Chaining nützliche Werkzeuge zum Erstellen besser lesbaren, modularen und flexiblen Codes, der Ihnen helfen kann, komplexe Probleme besser zu verstehen und zu lösen.

Pipe-Operatoren werden verwendet, um auf einfache und elegante Weise Parameter an eine Funktion zu übergeben. Dadurch kann der Programmierer Zwischenwerte eliminieren und Funktionsaufrufe leichter lesbar machen.

Gibt es Vorteile bei Rohrleitungen?

Die Verwendung des Pipe-Operators bietet mehrere Vorteile:

1. Verbesserte Lesbarkeit: Der Pipe-Operator kann Ihren Code lesbarer machen, indem er Ihnen ermöglicht, komplexe Vorgänge prägnanter und linearer auszudrücken. Es kann Ihnen auch dabei helfen, eine tiefe Verschachtelung von Funktionsaufrufen zu vermeiden, die die Verständlichkeit Ihres Codes erschweren kann.
2. Erhöhte Modularität: Sie können den Pipe-Operator verwenden, um wiederverwendbare Codeblöcke zu erstellen, die leicht auf unterschiedliche Weise kombiniert werden können, um verschiedene Aufgaben auszuführen. Dadurch kann Ihr Code modularer und einfacher zu warten sein.
3. Verbesserte Zusammenarbeit: Der Pipe-Operator ist ein weit verbreitetes und bekanntes Werkzeug in der R-Community. Wenn Sie ihn in Ihrem Code verwenden, können andere Ihre Arbeit leichter verstehen und dazu beitragen.
4. Größere Flexibilität: Mit dem Pipe-Operator können Sie problemlos verschiedene Komponenten Ihres Codes austauschen und verschiedene Kombinationen von Vorgängen ausprobieren, ohne große Teile Ihres Codes neu schreiben zu müssen. Dies kann Ihnen Zeit sparen und das Experimentieren und Iterationieren Ihrer Analyse erleichtern.

Pipe-Operatoren werden in einer Reihe von Programmiersprachen verwendet, darunter:

1. Unix-Shells (z. B. Bash): In Unix-Shells wird der Pipe-Operator ( |) verwendet, um die Ausgabe eines Befehls als Eingabe in einen anderen Befehl umzuleiten. Der Befehl listet beispielsweise ls -l | grep "^d"die Verzeichnisse im aktuellen Verzeichnis auf.
2. R: In R %>%wird der Pipe-Operator () verwendet, um das Ergebnis einer Operation als Eingabe an eine andere zu übergeben. Es ist Teil des Tidyverse-Pakets und wird verwendet, um einen besser lesbaren und prägnanteren Code zu erstellen.
3. Elixir: In Elixir |>wird der Pipe-Operator () verwendet, um das Ergebnis einer Funktion als Eingabe an eine andere zu übergeben. Es ähnelt dem R-Pipe-Operator.
4. F#: In F# |>wird der Pipe-Operator () verwendet, um das Ergebnis einer Funktion als Eingabe an eine andere zu übergeben. Es ähnelt den Pipe-Operatoren Elixir und R.
5. PowerShell: In PowerShell |wird der Pipeline-Operator () verwendet, um die Ausgabe eines Befehls als Eingabe an einen anderen Befehl zu übergeben. Es ähnelt dem Unix-Pipe-Operator.
6. In Julia wird der Pipe-Operator ( |>) verwendet, um das Ergebnis einer Funktion als Eingabe an eine andere zu übergeben. Es ähnelt den Pipe-Operatoren, die in anderen Sprachen wie R, Elixir und F# verwendet werden.

Arten von Rohren

Es gibt verschiedene Arten von Pipes, die bei der Programmierung verwendet werden:

1. Datenpipes : Diese Pipes werden verwendet, um die Ausgabe eines Befehls oder einer Funktion als Eingabe an einen anderen zu übergeben. Sie werden häufig in Unix-Shells (z. B. Bash) und in Programmiersprachen verwendet, die über einen Pipe-Operator verfügen (z. B. R und Elixir).
2. Umleitungspipes : Diese Pipes werden verwendet, um die Ausgabe eines Befehls oder einer Funktion in eine Datei oder an einen anderen Speicherort umzuleiten. Sie werden häufig in Unix-Shells (z. B. Bash) und in Programmiersprachen verwendet, die über einen Umleitungsoperator verfügen (z. B. PowerShell).
3. Bedingte Pipes : Diese Pipes werden verwendet, um die Ausgabe eines Befehls oder einer Funktion nur dann an einen anderen Befehl oder eine andere Funktion weiterzuleiten, wenn eine bestimmte Bedingung erfüllt ist. Sie werden häufig in Unix-Shells (z. B. Bash) und in Programmiersprachen verwendet, die über einen bedingten Operator verfügen (z. B. PowerShell).
4. Nachrichtenübermittlungspipes : Diese Pipes werden verwendet, um Nachrichten oder Daten zwischen Prozessen oder Threads zu übertragen. Sie werden häufig in gleichzeitigen Programmiersprachen verwendet, um die Kommunikation verschiedener Teile eines Programms miteinander zu ermöglichen.
5. Forward-Pipes sind eine Art Pipe-Operator, der die Ausgabe einer Funktion als Eingabe an eine andere Funktion weitergibt. Sie werden „Vorwärts“-Pipes genannt, weil die Ausgabe vorwärts durch die Funktionskette fließt und nicht rückwärts.
6. In R %>%ist der Operator ein Forward-Pipe-Operator. Es wird verwendet, um das Ergebnis einer Operation als erstes Argument an eine andere Operation zu übergeben. Zum Beispiel:

Forward-Pipes können besonders nützlich im Kontext von Tidyverse sein, einer Sammlung von R-Paketen zur Datenmanipulation und -analyse.

In R sind „ Feed Forward Pipes “ eine Möglichkeit, die Ausgabe einer Funktion als Eingabe an eine andere Funktion zu übergeben, ohne das Zwischenergebnis einer Variablen zuzuweisen. Dies geschieht mithilfe des %$%Operators, der dem Operator ähnelt %>%, aber die Eingabe auf der rechten Seite des Operators als Argument an die Funktion auf der linken Seite und nicht als erstes Argument übergibt.

Julia verfügt außerdem über einen „ Rückwärts-Pipe “-Operator ( <|), mit dem die Eingabe als erstes Argument und nicht als letztes an eine Funktion übergeben werden kann. Dies kann in Fällen nützlich sein, in denen Sie die Eingabe an eine Funktion übergeben möchten, die sie als erstes und nicht als letztes Argument erwartet.

Insgesamt kann der Pipe-Operator ein nützliches Werkzeug sein, um in Julia besser lesbaren und prägnanteren Code zu schreiben.

Schauen wir uns einige Beispiele an:

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))

      
                

                    
                    
                
            

Da wir die obersten 10 Zeilen des Datenrahmens aufgelistet haben, bevor weitere Parameter an den Datenrahmen übergeben wurden, können wir nur mit den ersten 10 Zeilen arbeiten, was wir aus der obigen Abbildung sehen können, da dies nur der Fall ist

1–10 von 10 Reihen

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"))

      
                

                    
                    
                
            

Beachten Sie das „==“ für die Zuweisung und „!=“ für den Ausschluss.

Wir können jetzt etwas Aggregation und Gruppierung hinzufügen.

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")

Wir können all diese manipulierten Daten einem neuen Datenrahmen zuordnen, was uns etwas Zeit sparen sollte:-

df <- Daten

Dadurch können wir nicht auf die Daten im ursprünglichen Datenrahmen zugreifen.

Dies kann hilfreich sein, wenn wir nur die manipulierten Daten behalten möchten.

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

      
                

                    
                    
                
            

von R für Data Science

Die Pfeife ist ein mächtiges Werkzeug, aber sie ist nicht das einzige Werkzeug, das Ihnen zur Verfügung steht, und sie löst nicht jedes Problem! Pipes eignen sich am besten zum Umschreiben einer relativ kurzen linearen Abfolge von Operationen. Ich denke, Sie sollten zu einem anderen Tool greifen, wenn:

• Ihre Pfeifen sind länger als (sagen wir) zehn Schritte. Erstellen Sie in diesem Fall Zwischenobjekte mit aussagekräftigen Namen. Dadurch wird das Debuggen einfacher, da Sie die Zwischenergebnisse einfacher überprüfen können, und es wird einfacher, Ihren Code zu verstehen, da die Variablennamen dabei helfen können, die Absicht zu kommunizieren.
• Sie haben mehrere Ein- oder Ausgänge. Wenn nicht ein primäres Objekt transformiert wird, sondern zwei oder mehr Objekte miteinander kombiniert werden, verwenden Sie die Pipe nicht.
• Sie beginnen, über einen gerichteten Graphen mit einer komplexen Abhängigkeitsstruktur nachzudenken. Pipes sind grundsätzlich linear und der Ausdruck komplexer Beziehungen mit ihnen führt normalerweise zu verwirrendem Code.

Es werden viele verschiedene Pipe-Operatoren in verschiedenen Programmiersprachen verwendet, von denen jede über eigene Funktionen und Fähigkeiten verfügt.

Es kann einige Zeit dauern, sich an die Arbeit mit Rohren zu gewöhnen, aber ihre Verwendung bietet viele Vorteile, nämlich:

1. Verbesserte Lesbarkeit
2. Flexibilität
3. Einfacheres Debuggen
4. Modularität

Das Konzept einer Pipe ist nicht spezifisch für die Programmierung und hat eine lange Geschichte in Mathematik und Ingenieurwesen. Im mathematischen Kontext ist ein Rohr ein Gerät, das dazu dient, eine Flüssigkeit (z. B. Wasser oder Gas) von einem Ort zum anderen zu transportieren. Rohre werden üblicherweise verwendet, um Flüssigkeiten durch ein System miteinander verbundener Kanäle oder Rohre zu transportieren, und sie werden oft verwendet, um den Fluss und den Druck der Flüssigkeit von einer Stufe zur nächsten zu steuern …

Ich hoffe, Ihnen hat der Artikel gefallen!

Schauen Sie sich meinen Artikel über Datenweiterleitung und -manipulation an:

Weiterleiten Ihrer Daten mit R – Teil 1

Lassen Sie uns über Linkedin oder Github eine Verbindung herstellen