Eine Liste in R-Programmierung ist ein generisches Objekt, das aus einer geordneten Sammlung von Objekten besteht. Listen sind eindimensional , heterogen Datenstrukturen.
Die Liste kann eine Liste von sein Vektoren , eine Liste von Matrizen, eine Liste von Zeichen, eine Liste von Funktionen , und so weiter.
Eine Liste ist ein Vektor, jedoch mit heterogenen Datenelementen. Eine Liste in R wird mit der Verwendung von erstellt list()-Funktion .
R ermöglicht den Zugriff auf Elemente einer R-Liste unter Verwendung des Indexwerts. In R beginnt die Indizierung einer Liste mit 1 statt mit 0.
Erstellen einer Liste
Um eine Liste in R zu erstellen, müssen Sie die aufgerufene Funktion verwenden Liste() .
Mit anderen Worten: Eine Liste ist ein generischer Vektor, der andere Objekte enthält. Um zu veranschaulichen, wie eine Liste aussieht, nehmen wir hier ein Beispiel. Wir möchten eine Liste der Mitarbeiter mit den Details erstellen. Hierfür benötigen wir also Attribute wie ID, Mitarbeitername und die Anzahl der Mitarbeiter.
Beispiel:
R
# R program to create a List> > # The first attributes is a numeric vector> # containing the employee IDs which is created> # using the command here> empId =>c>(1, 2, 3, 4)> > # The second attribute is the employee name> # which is created using this line of code here> # which is the character vector> empName =>c>(>'Debi'>,>'Sandeep'>,>'Subham'>,>'Shiba'>)> > # The third attribute is the number of employees> # which is a single numeric variable.> numberOfEmp = 4> > # We can combine all these three different> # data types into a list> # containing the details of employees> # which can be done using a list command> empList =>list>(empId, empName, numberOfEmp)> > print>(empList)> |
>
>Ausgabe
[[1]] [1] 1 2 3 4 [[2]] [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' [[3]] [1] 4>
Benennungslistenkomponenten
Die Benennung von Listenkomponenten erleichtert den Zugriff darauf.
Befehl chown
Beispiel:
R
# Creating a named list> my_named_list <->list>(name =>'Sudheer'>, age = 25, city =>'Delhi'>)> # Printing the named list> print>(my_named_list)> |
>
>Ausgabe
$name [1] 'Sudheer' $age [1] 25 $city [1] 'Delhi'>
Zugreifen auf R-Listenkomponenten
Wir können auf zwei Arten auf Komponenten einer R-Liste zugreifen.
1. Greifen Sie über Namen auf Komponenten zu:
Alle Komponenten einer Liste können benannt werden und wir können diese Namen verwenden, um mit dem Dollar-Befehl auf die Komponenten der R-Liste zuzugreifen.
Beispiel:
R
# R program to access> # components of a list> # Creating a list by naming all its components> empId =>c>(1, 2, 3, 4)> empName =>c>(>'Debi'>,>'Sandeep'>,>'Subham'>,>'Shiba'>)> numberOfEmp = 4> empList =>list>(> >'ID'> = empId,> >'Names'> = empName,> >'Total Staff'> = numberOfEmp> >)> print>(empList)> # Accessing components by names> cat>(>'Accessing name components using $ command
'>)> print>(empList$Names)> |
>
>Ausgabe
$ID [1] 1 2 3 4 $Names [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' $`Total Staff` [1] 4 Accessing name components using $ command [1] 'Debi' 'Sandeep' 'Subham' 'Shiba'>
2. Greifen Sie über Indizes auf Komponenten zu:
Wir können auch über Indizes auf die Komponenten der R-Liste zugreifen.
Um auf die Komponenten der obersten Ebene einer R-Liste zuzugreifen, müssen wir einen Double-Slicing-Operator verwenden [[ ]] Das sind zwei eckige Klammern, und wenn wir auf die unteren oder inneren Komponenten einer R-Liste zugreifen möchten, müssen wir eine weitere eckige Klammer verwenden [ ] zusammen mit dem Double-Slicing-Operator [[ ]] .
Beispiel:
R
# R program to access> # components of a list> # Creating a list by naming all its components> empId =>c>(1, 2, 3, 4)> empName =>c>(>'Debi'>,>'Sandeep'>,>'Subham'>,>'Shiba'>)> numberOfEmp = 4> empList =>list>(> >'ID'> = empId,> >'Names'> = empName,> >'Total Staff'> = numberOfEmp> >)> print>(empList)> # Accessing a top level components by indices> cat>(>'Accessing name components using indices
'>)> print>(empList[[2]])> # Accessing a inner level components by indices> cat>(>'Accessing Sandeep from name using indices
'>)> print>(empList[[2]][2])> # Accessing another inner level components by indices> cat>(>'Accessing 4 from ID using indices
'>)> print>(empList[[1]][4])> |
>
>Ausgabe
$ID [1] 1 2 3 4 $Names [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' $`Total Staff` [1] 4 Accessing name components using indices [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' Accessing Sandeep from na...>
Komponenten einer Liste ändern
Eine R-Liste kann auch geändert werden, indem auf die Komponenten zugegriffen und sie durch die gewünschten ersetzt werden.
Beispiel:
R
# R program to edit> # components of a list> # Creating a list by naming all its components> empId =>c>(1, 2, 3, 4)> empName =>c>(>'Debi'>,>'Sandeep'>,>'Subham'>,>'Shiba'>)> numberOfEmp = 4> empList =>list>(> >'ID'> = empId,> >'Names'> = empName,> >'Total Staff'> = numberOfEmp> )> cat>(>'Before modifying the list
'>)> print>(empList)> # Modifying the top-level component> empList$`Total Staff` = 5> # Modifying inner level component> empList[[1]][5] = 5> empList[[2]][5] =>'Kamala'> cat>(>'After modified the list
'>)> print>(empList)> |
>
>Ausgabe
Designmuster in Java
Before modifying the list $ID [1] 1 2 3 4 $Names [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' $`Total Staff` [1] 4 After modified the list $ID [1] 1 2 3 4 5 $Names [1] 'Debi' 'Sandeep' 'Subham' ...>
Verkettung von Listen
Mit der Verkettungsfunktion können zwei R-Listen verkettet werden. Wenn wir also zwei Listen verketten möchten, müssen wir den Verkettungsoperator verwenden.
Syntax:
Liste = c(Liste, Liste1)
list = die Originalliste
list1 = die neue Liste
Beispiel:
R
# R program to edit> # components of a list> # Creating a list by naming all its components> empId =>c>(1, 2, 3, 4)> empName =>c>(>'Debi'>,>'Sandeep'>,>'Subham'>,>'Shiba'>)> numberOfEmp = 4> empList =>list>(> >'ID'> = empId,> >'Names'> = empName,> >'Total Staff'> = numberOfEmp> )> cat>(>'Before concatenation of the new list
'>)> print>(empList)> # Creating another list> empAge =>c>(34, 23, 18, 45)> # Concatenation of list using concatenation operator> empList =>c>(empName, empAge)> cat>(>'After concatenation of the new list
'>)> print>(empList)> |
>
>Ausgabe
Before concatenation of the new list $ID [1] 1 2 3 4 $Names [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' $`Total Staff` [1] 4 After concatenation of the new list [1] 'Debi' 'Sandeep' 'Subham' 'S...>
Element zur Liste hinzufügen
Um ein Element am Ende der Liste hinzuzufügen, können wir die Funktion append() verwenden.
R
# creating a list> my_numbers =>c>(1,5,6,3)> #adding number at the end of list> append>(my_numbers, 45)> #printing list> my_numbers> |
>
>Ausgabe
[1] 1 5 6 3 45 [1] 1 5 6 3>
Komponenten einer Liste löschen
Um Komponenten einer R-Liste zu löschen, müssen wir zunächst auf diese Komponenten zugreifen und dann vor diesen Komponenten ein negatives Vorzeichen einfügen. Es zeigt an, dass wir diese Komponente löschen mussten.
Beispiel:
R
# R program to access> # components of a list> # Creating a list by naming all its components> empId =>c>(1, 2, 3, 4)> empName =>c>(>'Debi'>,>'Sandeep'>,>'Subham'>,>'Shiba'>)> numberOfEmp = 4> empList =>list>(> >'ID'> = empId,> >'Names'> = empName,> >'Total Staff'> = numberOfEmp> )> cat>(>'Before deletion the list is
'>)> print>(empList)> # Deleting a top level components> cat>(>'After Deleting Total staff components
'>)> print>(empList[-3])> # Deleting a inner level components> cat>(>'After Deleting sandeep from name
'>)> print>(empList[[2]][-2])> |
>
>Ausgabe
Before deletion the list is $ID [1] 1 2 3 4 $Names [1] 'Debi' 'Sandeep' 'Subham' 'Shiba' $`Total Staff` [1] 4 After Deleting Total staff components $ID [1] 1 2 3 4 $Names [1] 'Debi' 'Sand...>
Liste zusammenführen
Wir können die R-Liste zusammenführen, indem wir alle Listen in einer einzigen Liste zusammenfassen.
R
# Create two lists.> lst1 <->list>(1,2,3)> lst2 <->list>(>'Sun'>,>'Mon'>,>'Tue'>)> # Merge the two lists.> new_list <->c>(lst1,lst2)> # Print the merged list.> print>(new_list)> |
>
Hallo Welt Java
>
Ausgabe:
[[1]] [1] 1 [[2]] [1] 2 [[3]] [1] 3 [[4]] [1] 'Sun' [[5]] [1] 'Mon' [[6]] [1] 'Tue'>
Konvertieren einer Liste in einen Vektor
Hier werden wir die R-Liste in einen Vektor umwandeln. Dazu erstellen wir zunächst eine Liste und entfernen die Liste dann in den Vektor.
R
# Create lists.> lst <->list>(1:5)> print>(lst)> # Convert the lists to vectors.> vec <->unlist>(lst)> print>(vec)> |
>
>Ausgabe
[[1]] [1] 1 2 3 4 5 [1] 1 2 3 4 5>
R-Liste zur Matrix
Wir werden Matrizen mit der Funktion „matrix()“ in der R-Programmierung erstellen. Eine weitere Funktion, die verwendet wird, ist die Funktion unlist(), um die Listen in einen Vektor umzuwandeln.
R
# Defining list> lst1 <->list>(>list>(1, 2, 3),> >list>(4, 5, 6))> # Print list> cat>(>'The list is:
'>)> print>(lst1)> cat>(>'Class:'>,>class>(lst1),>'
'>)> # Convert list to matrix> mat <->matrix>(>unlist>(lst1), nrow = 2, byrow =>TRUE>)> # Print matrix> cat>(>'
After conversion to matrix:
'>)> print>(mat)> cat>(>'Class:'>,>class>(mat),>'
'>)> |
>
>Ausgabe
The list is: [[1]] [[1]][[1]] [1] 1 [[1]][[2]] [1] 2 [[1]][[3]] [1] 3 [[2]] [[2]][[1]] [1] 4 [[2]][[2]] [1] 5 [[2]][[3]] [1] 6 Class: list After conversion to matrix: [,1] [,2] [,3] [1,...>
In diesem Artikel haben wir behandelt Listen in R, Wir haben Listenoperationen wie das Erstellen, Benennen, Zusammenführen und Löschen einer Liste in der Sprache R behandelt. Die R-Liste ist ein wichtiges Konzept und sollte nicht übersprungen werden.
Ich hoffe, Sie haben in diesem Artikel etwas über R-Listen und ihre Funktionsweise erfahren.
Überprüfen Sie auch:
- R-Array
- R-Tupel
- R – Matrizen