Lister i R-programmering: Hvordan opprette og velge elementer

Hva er R List?

R Liste er et objekt i R-programmering som inkluderer matriser, vektorer, datarammer eller lister i det. R List brukes også til å lagre en samling objekter og bruke dem når vi trenger dem. Vi kan forestille oss R-listen som en pose for å sette mange forskjellige varer. Når vi skal bruke en vare, kan vi åpne posen og bruke den.

Kontrasten med en vektor er det som gjør posen nyttig. En vektor tvinger hvert element til én type, så å plassere et ord ved siden av et tall gjør tallet til tekst. En liste bruker ingen slik regel, og det er derfor den kan ha en vektor med fem elementer, en vektor med to rader matrise og en dataramme med 714 rader side om side uten å endre noen av dem.

Syntaks for liste i R

Vi kan bruke list()-funksjonen til å lage 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 uten eller på formen tag = verdiEt rent argument blir et posisjonselement som bare kan nås med nummeret sitt, mens et tagget argument også får et navn. Den grunnleggende R-referansen for liste() dokumenterer både skjemaer og notater som viser at unlist() fungerer som en omtrentlig invers av as.list().

Hvordan lage en liste i R

Nedenfor er en trinnvis prosess for hvordan du oppretter en liste i R:

I eksemplet nedenfor vil vi lage tre forskjellige objekter, en vektor, en matrise og en Dataramme ved å bruke listefunksjonen i R.

Trinn 1) Lag en vektor

Bruk koden nedenfor for å lage en vektor i R

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

Kolonoperatoren bygger sekvensen 1, 2, 3, 4, 5 som en heltallsvektor, og tildelingspilen lagrer den under navnet vect.

Trinn 2) Lag en matrise

Lag nå en matrise ved å bruke følgende kode

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

To detaljer fortjener oppmerksomhet her. Et rutenett med to rader ganger fem kolonner trenger ti verdier, men bare ni er oppgitt, så R resirkulerer sekvensen og skriver ut en advarsel om at datalengden ikke er et delmultiplum av antall rader. Denne resirkulerte verdien er grunnen til at den andre raden i den utskrevne matrisen slutter på 1 i stedet for 10. Kallet til dim() rapporterer deretter formen.

Utgang:

## [1] 2 5

Trinn 3) Lag dataramme

Lag en dataramme i R ved å bruke koden nedenfor

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

Kommentaren nevner den tiende raden, men uttrykket beholder rad 1 til 10 i den innebygde EuStockMarkets-serien. Delsetting fjerner også tidsserieklassen, så det som kommer tilbake er en numerisk matrise i stedet for en ekte dataramme, og det er nettopp derfor det utskrevne resultatet nedenfor har radetiketter i [1,]-stil i stedet for radnavn. Pakk inn kallet i as.data.frame() når en ekte dataramme er nødvendig.

Trinn 4) Lag en liste i R

Nå kan vi sette de tre objektene i R-listen ved å bruke koden nedenfor

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

Utgang:

## [[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 dobbeltparentesoverskriftene i den utdataene er listeposisjonene. Ingenting ble flatet ut eller tvunget: element én er fortsatt en heltallsvektor, element to er fortsatt en matrise, og element tre inneholder fortsatt alle ti radene med aksjekurser.

Velg elementer fra R-listen

Etter at vi har bygget listen vår, kan vi enkelt få tilgang til den. Vi må bruke [[indeks]] for å velge et element i en liste. Verdien i den doble firkantede parentesen representerer posisjonen til elementet i en liste vi ønsker å vise.tract. Hvis vi for eksempel setter 2 i parentesen, returnerer R det andre elementet som er oppført.

Nå i dette R opplæring, la oss prøve å velge de andre elementene i listene i R kalt min_liste, vi bruker min_liste[[2]]

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

Utgang:

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

Enkle og doble parenteser er ikke utskiftbare, og det å blande dem sammen er den vanligste kilden til listefeil. Én parentes beholder omslaget, to parenteser fjerner det.

# 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]

Navngitte lister i R

Posisjonsindekser er sårbare: sett inn ett element, og hvert tall etter det forskyves. Å navngi elementene fjerner denne risikoen og gjør at koden leses som dataene den beskriver. Navn kan oppgis når listen bygges, eller legges ved etterpå 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 den doble parentesen er forskjellige på én måte som fanger nybegynnere opp. $-operatoren utfører delvis samsvar, så named_list$pri finner fortsatt priser, mens named_list[[“pri”]] returnerer NULL fordi doble parenteser samsvarer nøyaktig med mindre exact = FALSE sendes. Delvis samsvar er praktisk i konsollen og usikkert i et skript, så foretrekk den eksakte formen i lagret kode.

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

str() skriver ut én linje per element med type og størrelse, som er den raskeste måten å bekrefte at en liste inneholder det du forventer før du indekserer i den.

Endre, legge til og slette elementer i en R-liste

En liste er ikke fast når den er opprettet. De samme tilgangsprogrammene som leser et element skriver også til det, så oppdatering, utvidelse og krymping av en liste bruker alle vanlig 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: Å tilordne et eksisterende navn overskriver elementet og lar posisjonen være uendret.
• Legg til: Å tilordne et navn som ikke finnes, legger til et nytt element på slutten av listen.
• Legg til: append() tar en liste som sitt andre argument, så pakk inn en ren verdi i list() før den sendes.
• Slett: Å tilordne NULL med doble parenteser fjerner elementet og forkorter listen.

En konsekvens av dette er at folk ofte snubler: fordi NULL betyr sletting, kan du ikke lagre en faktisk NULL med doble parenteser. Bruk tildeling med én parentes i stedet, som i named_list[“empty”] <- list(NULL), som beholder sporet og plasserer NULL inni det.

Nestede lister og unlist() i R

Fordi en liste kan inneholde et hvilket som helst R-objekt, kan den inneholde en annen liste. Nesting er hvordan konfigurasjonsobjekter, JSON-svar og modellresultater vanligvis representeres i R, så det å nå inn i en nestet liste og flate ut en er begge hverdagsoppgaver.

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

Flatning har en kostnad som er verdt å forstå. unlist() må returnere én atomvektor, så den tvinger hver verdi til den mest generelle typen som er tilstede, i rekkefølgen logisk, heltall, dobbel, tegn. En nestet liste som blander tall med tekst kommer derfor tilbake utelukkende som tekst. Navnene på resultatet bygges ved å koble sammen de ytre og indre taggene, og det er derfor et element kommer som meta.owner i stedet for owner.

Gi use.names = FALSE når disse sammensatte navnene er uønskede, og sett recursive = FALSE når bare det ytterste laget skal fjernes. Hvis verdiene må beholde typene sine, la strukturen være intakt og arbeid deg gjennom listen i stedet for å flate den ut.

Innebygd dataramme i R

Lister er ofte fylt med data lest fra disk eller fra nettet, så det hjelper å se hvordan en dataramme ankommer før den lagres i en. Før vi lager vår egen dataramme, kan vi ta en titt på R-datasettet som er tilgjengelig på nettet. Prison-datasettet har en dimensjon på 714 × 5. Vi kan få en rask titt på bunnen av datarammen med tail()-funksjonen. Analogt viser head() toppen av datarammen. Du kan angi antall rader som vises med head(df, 5). Vi vil lære mer om funksjonen read.csv() i importer data i R opplæringen.

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

Utgang:

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

[1:5]-en som følger etter read.csv() velger de første fem kolonnene, ikke de første fem radene, fordi en dataramme i seg selv er en liste med kolonner. Indeksering med én parentes på en liste returnerer en mindre liste, og her er den mindre listen fortsatt en dataramme.

Vi kan sjekke strukturen til datarammen med str:

# Structure of the data
str(df)

Utgang:

## '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 lagret i numerisk format. Prefikset $ på hver linje er den samme operatoren som ble brukt på navngitte lister tidligere, noe som bekrefter at en dataramme er en liste med kolonner av samme lengde som har en rektangulær etikett. Alt som læres om å navngi, velge og slette listeelementer overføres derfor direkte til R-datatyper og til datarammekolonner.

Spørsmål og svar