Listas em R: Como Criar e Selecionar Elementos

O que é lista R?

Lista R é um objeto na programação R que inclui matrizes, vetores, quadros de dados ou listas dentro dele. R List também é usado para armazenar uma coleção de objetos e usá-los quando precisarmos deles. Podemos imaginar a lista R como uma sacola para colocar diversos itens diferentes. Quando precisarmos usar um item, podemos abrir a sacola e utilizá-lo.

O contraste com um vetor é o que torna a sacola útil. Um vetor força cada elemento a ser de um único tipo, então colocar uma palavra ao lado de um número transforma o número em texto. Uma lista não aplica essa regra, e é por isso que ela pode conter um vetor de cinco elementos e uma lista de duas linhas. matriz e um conjunto de dados de 714 linhas lado a lado, sem alterar nenhum deles.

Sintaxe da lista em R

Podemos usar a função list() para criar listas na linguagem de programação R:

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

Cada argumento pode ser passado diretamente ou no formato tag = valorUm argumento simples torna-se um elemento posicional acessível apenas pelo seu número, enquanto um argumento etiquetado também ganha um nome. A referência base do R para Lista() O documento apresenta ambas as formas e observa que unlist() funciona como um inverso aproximado de as.list().

Como criar uma lista em R

Abaixo está um processo passo a passo sobre como criar uma lista em R:

No exemplo abaixo, criaremos três objetos diferentes, um Vetor, uma Matriz e um Quadro de dados usando a função de lista em R.

Etapa 1) Crie um vetor

Use o código abaixo para criar um vetor em R

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

O operador de dois pontos constrói a sequência 1, 2, 3, 4, 5 como um vetor de inteiros, e a seta de atribuição a armazena com o nome vect.

Etapa 2) Crie uma matriz

Agora, crie uma matriz usando o seguinte código.

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

Dois detalhes merecem atenção aqui. Uma grade de duas linhas por cinco colunas precisa de dez valores, mas apenas nove são fornecidos, então o R recicla a sequência e imprime um aviso de que o comprimento dos dados não é um submúltiplo do número de linhas. Esse valor reciclado é o motivo pelo qual a segunda linha da matriz impressa termina em 1 em vez de 10. A chamada para dim() então retorna o formato.

Saída:

## [1] 2 5

Etapa 3) Criar quadro de dados

Crie um quadro de dados em R usando o código abaixo

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

O comentário menciona a décima linha, mas a expressão mantém as linhas de 1 a 10 da série integrada EuStockMarkets. A seleção de subconjuntos também remove a classe de série temporal, então o que é retornado é uma matriz numérica em vez de um data frame verdadeiro, que é exatamente por isso que o resultado impresso abaixo contém rótulos de linha no estilo [1,] em vez de nomes de linha. Envolva a chamada em as.data.frame() sempre que um data frame genuíno for necessário.

Etapa 4) Crie uma lista em R

Agora, podemos colocar os três objetos na lista R usando o código abaixo

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

Saída:

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

Os três cabeçalhos entre colchetes duplos nessa saída representam as posições da lista. Nada foi achatado ou forçado: o primeiro elemento continua sendo um vetor de inteiros, o segundo elemento continua sendo uma matriz e o terceiro elemento ainda contém todas as dez linhas de preços das ações.

Selecione os elementos da lista R

Depois de criarmos nossa lista, podemos acessá-la com bastante facilidade. Precisamos usar o [[index]] para selecionar um elemento na lista. O valor dentro dos colchetes duplos representa a posição do item na lista que queremos acessar.tracPor exemplo, se passarmos 2 dentro dos parênteses, R retorna o segundo elemento listado.

Agora neste Tutorial R, vamos tentar selecionar os segundos itens das listas em R chamados my_list, usamos my_list[[2]]

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

Saída:

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

Os colchetes simples e duplos não são intercambiáveis, e confundi-los é a causa mais comum de erros em listas. Um colchete mantém o elemento que o envolve, dois colchetes o removem.

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

Listas nomeadas em R

Índices posicionais são frágeis: insira um elemento e todos os números subsequentes serão deslocados. Nomear os elementos elimina esse risco e torna o código legível de acordo com os dados que descreve. Os nomes podem ser fornecidos durante a construção da lista ou atribuídos posteriormente com a função `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"

O operador $ e os colchetes duplos diferem em um aspecto que costuma confundir iniciantes. O operador $ realiza uma correspondência parcial, então `named_list$pri` ainda encontra preços, enquanto `named_list[["pri"]]` retorna NULL porque os colchetes duplos correspondem exatamente, a menos que `exact = FALSE` seja passado. A correspondência parcial é conveniente no console, mas insegura em um script; portanto, prefira a forma exata em código salvo.

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

A função str() imprime uma linha por elemento, indicando seu tipo e tamanho, sendo essa a maneira mais rápida de confirmar se uma lista contém o que você espera antes de indexá-la.

Modificar, adicionar e excluir elementos em uma lista R

Uma lista não é fixa depois de criada. Os mesmos acessadores que leem um elemento também escrevem nele, portanto, atualizar, estender e reduzir uma lista usam atribuição comum.

# 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

• Substituir: Atribuir um nome a um elemento existente sobrescreve esse elemento, mantendo sua posição inalterada.
• Adicionar: Atribuir um nome que não existe adiciona um novo elemento ao final da lista.
• Acrescentar: A função append() recebe uma lista como segundo argumento, portanto, envolva um valor vazio em uma lista (list()) antes de passá-lo como argumento.
• Excluir: Atribuir o valor NULL com colchetes duplos remove o elemento e encurta a lista.

Uma consequência que confunde as pessoas regularmente: como NULL significa exclusão, você não pode armazenar um NULL real com colchetes duplos. Use atribuição com colchetes simples, como em named_list["empty"] <- list(NULL), que mantém o espaço e coloca NULL dentro dele.

Listas aninhadas e unlist() em R

Como uma lista pode conter qualquer objeto R, ela também pode conter outra lista. O aninhamento é a forma como objetos de configuração, respostas JSON e resultados de modelos são geralmente representados em R, portanto, acessar e achatar uma lista aninhada são tarefas comuns.

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

O achatamento tem um custo que vale a pena entender. `unlist()` deve retornar um vetor atômico, então ele força cada valor para o tipo mais geral presente, seguindo a ordem lógico, inteiro, double e caractere. Uma lista aninhada que mistura números com texto, portanto, retorna inteiramente como texto. Os nomes do resultado são construídos unindo as tags externas e internas, razão pela qual um elemento chega como `meta.owner` em vez de `owner`.

Passe `use.names = FALSE` quando esses nomes compostos forem indesejados e defina `recursive = FALSE` quando apenas a camada mais externa precisar ser removida. Se os valores precisarem manter seus tipos, deixe a estrutura intacta e percorra a lista em vez de achatá-la.

Quadro de dados integrado em R

Listas são frequentemente preenchidas com dados lidos do disco ou da web, então é útil ver como um dataframe é gerado antes de ser armazenado em um. Antes de criar nosso próprio dataframe, podemos dar uma olhada no conjunto de dados R disponível online. O conjunto de dados `prison` tem dimensões 714×5. Podemos dar uma olhada rápida na parte inferior do dataframe com a função `tail()`. Por analogia, `head()` exibe a parte superior do dataframe. Você pode especificar o número de linhas exibidas com `head(df, 5)`. Aprenderemos mais sobre a função `read.csv()` em outro artigo. Importar dados em R tutorial.

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

Saída:

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

O operador [1:5] que segue read.csv() seleciona as cinco primeiras colunas, não as cinco primeiras linhas, porque um data frame é, em si, uma lista de colunas. A indexação por colchetes simples em uma lista retorna uma lista menor, e aqui essa lista menor ainda é um data frame.

Podemos verificar a estrutura do quadro de dados com str:

# Structure of the data
str(df)

Saída:

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

Todas as variáveis ​​são armazenadas no numérico O prefixo $ em cada linha é o mesmo operador usado anteriormente em listas nomeadas, o que confirma que um data frame é uma lista de colunas de igual comprimento com um rótulo retangular. Tudo o que foi aprendido sobre nomear, selecionar e excluir elementos de listas, portanto, se aplica diretamente a este formato. Tipos de dados em R e para colunas do quadro de dados.

Perguntas Frequentes