Lister i R-programmering: Sådan opretter og vælger du elementer

⚡ Smart opsummering

R List er et objekt, der gemmer vektorer, matricer, datarammer og endda andre lister i en enkelt container. List()-funktionen bygger den, og dobbelte firkantede parenteser trækker ethvert element ud igen.

  • 🧺 Blandet opbevaring: En liste indeholder objekter af forskellige typer og længder, hvilket en almindelig vektor ikke kan.
  • 🛠️ Byggetrin: list(vect, mat, df) pakker en vektor, en matrix og en dataframe i ét objekt.
  • 🔢 Positionsadgang: my_list[[2]] returnerer selve elementet, mens my_list[2] returnerer en liste med ét element.
  • 🏷️ Navngivne elementer: Mærkning af elementer ved oprettelse giver adgang via $-operatoren eller [[“navn”]].
  • ✏️ Rettelser på stedet: Gentildeling opdaterer et element, og tildeling af NULL fjerner det fra listen.
  • 🔗 Udfladning: unlist() kollapser en indlejret liste til én atomvektor til downstream-analyse.

R-liste Opret en liste i R-programmering og vælg elementer

Hvad er R List?

R Liste er et objekt i R-programmering, som inkluderer matricer, vektorer, datarammer eller lister i det. R List bruges også til at gemme en samling af objekter og bruge dem, når vi har brug for dem. Vi kan forestille os R-listen som en taske til mange forskellige ting. Når vi skal bruge en vare, kan vi åbne posen og bruge den.

Kontrasten til en vektor er det, der gør posen nyttig. En vektor tvinger hvert element til én type, så at placere et ord ved siden af ​​et tal forvandler tallet til tekst. En liste anvender ikke en sådan regel, hvilket gør den til en vektor med fem elementer, en vektor med to rækker matrix og en dataramme med 714 rækker side om side uden at ændre nogen af ​​dem.

Syntaks for List i R

Vi kan bruge list()-funktionen til at oprette lister i R-programmering:

list(element_1, ...)
arguments:
-element_1: store any type of R object
-...: pass as many objects as specifying. each object needs to be separated by a comma

Hvert argument kan sendes enten blot eller i formen tag = værdiEt bart argument bliver et positionselement, der kun kan nås via sit nummer, mens et tagget argument også får et navn. Den grundlæggende R-reference for liste() dokumenterer både formularer og noter, der viser, at unlist() fungerer som en omtrentlig invers af as.list().

Sådan opretter du en liste i R

Nedenfor er en trin for trin proces om, hvordan man opretter en liste i R:

I eksemplet nedenfor vil vi oprette tre forskellige objekter, en vektor, en matrix og en Dataramme ved hjælp af listefunktion i R.

Trin 1) Opret en vektor

Brug nedenstående kode til at oprette en vektor i R

# Vector with numeric from 1 up to 5
vect  <- 1:5

Kolonoperatoren opbygger sekvensen 1, 2, 3, 4, 5 som en heltalsvektor, og tildelingspilen gemmer den under navnet vect.

Trin 2) Opret en matrix

Opret nu en matrix ved hjælp af følgende kode

# A 2x 5 matrix
mat  <- matrix(1:9, ncol = 5)
dim(mat)

To detaljer fortjener opmærksomhed her. Et gitter med to rækker gange fem kolonner kræver ti værdier, men kun ni angives, så R genbruger sekvensen og udskriver en advarsel om, at datalængden ikke er et undermultiplum af antallet af rækker. Denne genbrugte værdi er grunden til, at den anden række i den udskrevne matrix ender på 1 i stedet for 10. Kaldet til dim() rapporterer derefter formen.

Output:

## [1] 2 5

Trin 3) Opret dataramme

Opret en dataramme i R ved hjælp af nedenstående kode

# select the 10th row of the built-in R data set EuStockMarkets
df <- EuStockMarkets[1:10,]

Kommentaren nævner den tiende række, men udtrykket beholder række 1 til 10 i den indbyggede EuStockMarkets-serie. Subsetting fjerner også tidsserieklassen, så det, der kommer tilbage, er en numerisk matrix snarere end en ægte dataramme, hvilket netop er grunden til, at det udskrevne resultat nedenfor har rækkenavne i [1,]-stil i stedet for rækkenavne. Omslut kaldet i as.data.frame(), når en ægte dataramme er nødvendig.

Trin 4) Opret en liste i R

Nu kan vi sætte de tre objekter i R-listen ved hjælp af nedenstående kode

# Construct list with these vec, mat, and df:
my_list <- list(vect, mat, df)
my_list

Output:

## [[1]]
## [1] 1 2 3 4 5

## [[2]]
##       [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8    1

## [[3]]
##          DAX    SMI    CAC   FTSE
##  [1,] 1628.75 1678.1 1772.8 2443.6
##  [2,] 1613.63 1688.5 1750.5 2460.2
##  [3,] 1606.51 1678.6 1718.0 2448.2
##  [4,] 1621.04 1684.1 1708.1 2470.4
##  [5,] 1618.16 1686.6 1723.1 2484.7
##  [6,] 1610.61 1671.6 1714.3 2466.8
##  [7,] 1630.75 1682.9 1734.5 2487.9
##  [8,] 1640.17 1703.6 1757.4 2508.4
##  [9,] 1635.47 1697.5 1754.0 2510.5
##  [10,] 1645.89 1716.3 1754.3 2497.4

De tre dobbeltparentes-overskrifter i det output er listepositionerne. Intet blev fladtrykt eller tvunget: element et er stadig en heltalsvektor, element to er stadig en matrix, og element tre indeholder stadig alle ti rækker med aktiekurser.

Vælg elementer fra R-listen

Når vi har oprettet vores liste, kan vi nemt tilgå den. Vi skal bruge [[indeks]] til at vælge et element i en liste. Værdien i den dobbelte firkantede parentes repræsenterer positionen af ​​det element i en liste, vi vil vise.tract. Hvis vi f.eks. sætter 2 i parentesen, returnerer R det andet element på listen.

Nu i dette R tutorial, lad os prøve at vælge de andre elementer af lister i R med navnet min_liste, vi bruger min_liste[[2]]

# Print second element of the list
my_list[[2]]

Output:

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8    1

Enkelt- og dobbeltparenteser kan ikke erstatte hinanden, og at forveksle dem er den mest almindelige kilde til listefejl. Én parentes bevarer omslaget, to parenteser fjerner det.

Udtryk Hvad kommer tilbage Resultatets klasse Brug det når
min_liste[[2]] Selve det lagrede element Uanset hvad der blev gemt, her en matrix Du skal beregne på ét element
min_liste[2] En underliste, der indeholder det ene element liste Du skal gemme listeindpakningen
min_liste[c(1, 3)] En delliste over de valgte elementer liste Du har brug for flere elementer på én gang
min_liste[-2] Hvert element undtagen det andet liste Du skal slette et element
# Compare the two bracket styles
class(my_list[[2]])   # the matrix itself
class(my_list[2])     # a list of length one

# Several elements, and everything but one element
my_list[c(1, 3)]
my_list[-2]

Navngivne lister i R

Positionsindekser er skrøbelige: indsæt ét element, og hvert tal efter det forskydes. Navngivning af elementerne fjerner denne risiko og får koden til at læse som de data, den beskriver. Navne kan angives, når listen opbygges, eller tilføjes bagefter med names().

# Tag each element at creation time
named_list <- list(numbers = vect, grid = mat, prices = df)

# Three ways to reach the same element
named_list$grid
named_list[["grid"]]
named_list["grid"]      # returns a one-element list

# Read or replace the names later
names(named_list)
names(named_list)[2] <- "grid_2x5"

$-operatoren og dobbeltparentesen adskiller sig på én måde, der fanger begyndere. $-operatoren udfører delvis matchning, så named_list$pri finder stadig priser, mens named_list[[“pri”]] returnerer NULL, fordi dobbeltparenteser matcher nøjagtigt, medmindre exact = FALSE sendes. Delvis matchning er praktisk i konsollen og usikker i et script, så foretræk den nøjagtige form i gemt kode.

# A compact map of the whole structure
str(named_list)

str() udskriver én linje pr. element med dets type og størrelse, hvilket er den hurtigste måde at bekræfte, at en liste indeholder det, du forventer, før du indekserer i den.

Rediger, tilføj og slet elementer i en R-liste

En liste er ikke fast, når den først er oprettet. De samme adgangsfunktioner, der læser et element, skriver også til det, så opdatering, udvidelse og formindskelse af en liste bruger alle almindelig tildeling.

# Replace an element in place
named_list[["numbers"]] <- 1:10

# Add a new element simply by naming it
named_list[["created"]] <- Sys.Date()

# Append without a name: the element lands at the end
named_list <- append(named_list, list(TRUE))

# Delete an element by assigning NULL to it
named_list[["created"]] <- NULL
  • Erstatte: Hvis du tildeler et eksisterende navn, overskrives elementet, og dets position forbliver uændret.
  • Tilføj: Hvis du tildeler et navn, der ikke findes, tilføjes et nyt element i slutningen af ​​listen.
  • Tilføj: append() tager en liste som sit andet argument, så indkapsles en ren værdi i list(), før den sendes.
  • Slette: Tildeling af NULL med dobbelte parenteser fjerner elementet og forkorter listen.

En konsekvens får folk til at støde regelmæssigt: fordi NULL betyder sletning, kan du ikke gemme en faktisk NULL med dobbelte parenteser. Brug i stedet tildeling med en enkelt parentes, som i named_list[“empty”] <- list(NULL), som beholder pladsen og placerer NULL indeni den.

Indlejrede lister og unlist() i R

Fordi en liste kan indeholde ethvert R-objekt, kan den indeholde en anden liste. Indlejring er den måde, konfigurationsobjekter, JSON-svar og modelresultater normalt repræsenteres i R, så det at nå ind i en indlejret liste og udflade en er begge hverdagsopgaver.

# A list whose elements are themselves lists
project <- list(
  meta = list(owner = "analyst", year = 2026),
  data = list(vect, mat)
)

# Chain the accessors to reach an inner value
project$meta$year
project[["data"]][[2]]

# Flatten every level into one atomic vector
flat <- unlist(project)

# Strip a single level and keep the rest as a list
half <- unlist(project, recursive = FALSE)

Samudfladning har en pris, der er værd at forstå. unlist() skal returnere én atomvektor, så den tvinger hver værdi til den mest generelle type, der er til stede, i rækkefølgen logisk, heltal, dobbelt, tegn. En indlejret liste, der blander tal med tekst, returneres derfor udelukkende som tekst. Navnene på resultatet opbygges ved at forbinde de ydre og indre tags, hvilket er grunden til, at et element ankommer som meta.owner i stedet for owner.

Giv use.names = FALSE, når disse sammensatte navne er uønskede, og sæt recursive = FALSE, når kun det yderste lag skal fjernes. Hvis værdierne skal beholde deres typer, skal strukturen lades intakt og arbejdes gennem listen i stedet for at flade den ud.

Indbygget dataramme i R

Lister er ofte fyldt med data læst fra disk eller fra internettet, så det er nyttigt at se, hvordan en dataramme ankommer, før den gemmes i en. Før vi opretter vores egen dataramme, kan vi se på R-datasættet, der er tilgængeligt online. Prison-datasættet har en dimension på 714 × 5. Vi kan hurtigt se nederst på datarammen med funktionen tail(). Analogt viser head() toppen af ​​datarammen. Du kan angive antallet af viste rækker med head(df, 5). Vi vil lære mere om funktionen read.csv() i importer data i R tutorial.

PATH <-'https://raw.githubusercontent.com/guru99-edu/R-Programming/master/prison.csv'
df <- read.csv(PATH)[1:5]
head(df, 5)

Output:

##   X state year govelec black
## 1 1     1   80       0 0.2560
## 2 2     1   81       0 0.2557
## 3 3     1   82       1 0.2554
## 4 4     1   83       0 0.2551
## 5 5     1   84       0 0.2548

Den [1:5]-værdi, der følger efter read.csv(), vælger de første fem kolonner, ikke de første fem rækker, fordi en dataramme i sig selv er en liste af kolonner. Indeksering med én parentes på en liste returnerer en mindre liste, og her er den mindre liste stadig en dataramme.

Vi kan kontrollere strukturen af ​​datarammen med str:

# Structure of the data
str(df)

Output:

## 'data.frame':    714 obs. of  5 variables:
##  $ X      : int  1 2 3 4 5 6 7 8 9 10 ...
##  $ state  : int  1 1 1 1 1 1 1 1 1 1 ...
##  $ year   : int  80 81 82 83 84 85 86 87 88 89 ...
##  $ govelec: int  0 0 1 0 0 0 1 0 0 0 ...
##  $ black  : num  0.256 0.256 0.255 0.255 0.255 ...

Alle variabler er gemt i numerisk format. Præfikset $ på hver linje er den samme operator, der tidligere blev brugt på navngivne lister, hvilket bekræfter, at en dataramme er en liste af kolonner af samme længde, der bærer en rektangulær etiket. Alt, hvad man lærer om navngivning, valg og sletning af listeelementer, overføres derfor direkte til R-datatyper og til dataframe-kolonner.

Ofte Stillede Spørgsmål

En vektor tvinger hvert element til at dele én type, så blanding af tekst og tal tvinger alt til at blive tegn. En liste bevarer hvert element præcis som angivet, inklusive vektorer, matricer og funktioner af forskellig længde. Brug typeof() til at skelne de to fra hinanden.

Kald is.list(x), som returnerer TRUE for lister og parlister. class(x) rapporterer objektklassen, mens typeof(x) returnerer "liste", selv for datarammer, fordi en dataramme er en liste af kolonner af samme længde nedenunder.

length(my_list) tæller kun elementerne på øverste niveau, så en indlejret liste tæller stadig som én. lengths(my_list) rapporterer størrelsen af ​​hvert element i et enkelt kald, hvilket er hurtigere og tydeligere end loo.ping når elementerne er forskellige.

lapply(my_list, FUN) anvender en funktion til hvert element og returnerer en liste. sapply() forenkler resultatet til en vektor eller matrix, hvor det er muligt. En almindelig for-løkke over seq_along(my_list) fungerer også og læses tydeligt.

Når hvert element har samme længde, fungerer as.data.frame(my_list) direkte. For en liste med rækker med samme bredde stabler do.call(rbind, my_list) dem først. dplyr økosystemet tilbyder as_tibble() når kolonnetyper skal overleve uberørt.

Lister har ingen indbygget sortering, så f.eks.tracen sammenlignelig nøgle først: my_list[order(apply(my_list, length))] omarrangerer efter elementstørrelse. For rektangulære data, konverter til en ramme og sorter datarammen med order() i stedet.

AI-assistenter læser str() output og forklarer, hvorfor et indeks returnerede NULL eller en underliste i stedet for en værdi. De foreslår også den korrekte parentesform, udarbejder lapply() pipelines og markerer silent type coercion, før det beskadiger et resultat.

Ja. GitHub Copilot arbejder i RStudio 2023.09.0 og nyere via Værktøjer, Globale Indstillinger og derefter indstillingen Kodeassistent. Den fuldfører list(), names() og unlist() kald fra en kommentar, selvom alle forslag stadig skal gennemgås.

Opsummer dette indlæg med: