# R list: Como trabalhar com listas em R

Armazenar dados em listas é algo comum nas linguagens de programação. Em R, especificamente, listas são especialmente úteis para agrupar dados e elementos de diferentes tipos em uma mesma estrutura. Aprenda a criar e a manipular listas em R com o nosso tutorial R list.

## Porque usar listas em R

Listas são estruturas de dados versáteis, além de também serem consideradas um **tipo de dado** pela linguagem de programação R. Elas são especialmente adequadas a ambientes de programação dinâmicos, nos quais elementos com diferentes tipos de dados precisam ser adicionados e removidos flexivelmente. Ao contrário de [vetores em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-vector/), itens de listas em R não fazem distinção entre os tipos de dados contidos. A capacidade de **armazenar diferentes tipos de dados** é uma das principais vantagens oferecidas pela função R `list`: com ela, desenvolvedores conseguem aninhar listas da forma como querem, para que representem estruturas de dados complexas em códigos-fonte.

Dica Quer publicar os programas em R que está desenvolvendo? O [Webspace](https://www.ionos.com/hosting/webspace "Webspace: Get your project online — IONOS") da IONOS oferece o espaço web ideal para armazenar todos os seus projetos. Explore os pacotes disponíveis e escolha o seu.

## Criar lista em R

### Criar R list com a função `list()`

Para criar uma lista em R simples, faça uso da função `list()` seguida dos elementos a serem nela adicionados, como mostra o exemplo:

```R
list <- list(1, TRUE, "Hello world!", c(1,2,3,4))
```

No código acima, criamos uma **lista contendo quatro valores**. Observe que cada valor tem um tipo de dado diferente. Mesmo assim, eles puderam ser agrupados em uma lista.

Também é possível criar uma lista de itens nomeados com a linguagem de programação R. Dessa forma, você consegue acessar itens específicos de listas com facilidade:

```R
person <-list(name = "Max White", age = 27, hobbies = c("Programming, movies"))
```

Você também pode usar listas como elementos de outras listas. Isso pode ser útil, por exemplo, para combinar listas diferentes em um único registro. Observe:

```R
people <- list(list(name = "Max White", age = 27, hobbies = c("Programming, movies")), list(name = "Mia Black", age = 32, hobbies = c("Theater, computer games")), list(name = "Mika Brown", age =23, hobbies = c("Sports, music")))
```

### Criar R list partir de vetores

Em R, você também pode criar listas convertendo vetores. A linguagem de programação disponibiliza uma função específica para essa finalidade:

```R
vector <- c(1,2,3,4)
list <- as.list(vector)
```

## Converter listas em R em outras estruturas de dados

Embora uma lista em R já seja uma estrutura de dados versátil, ainda existe a chance de você ter de transformá-la em um outro tipo de estrutura, como em um vetore ou dataframe, para fins específicos. Se esse for o caso, basta que você converta a sua lista.

### Converter R list em vetor

Se você deseja converter a sua lista em vetor, use a função `unlist()`. Ela é capaz de usar uma lista em R como parâmetro de transferência, e a convertê-la em vetor — listas passadas a essa função também podem ser multidimensionais. Em muitos casos, `unlist()` também se mostra útil para representar hierarquias complexas de uma forma mais simples: por vetor.

```R
list <- list(1, 2, 3, 4)
vector <- unlist(list)
```

Ao converter uma lista que contém dados de diferentes tipos em um vetor, você pode vir a se deparar com algum tipo de comportamento desviante, já que, por padrão, vetores em R só conseguem armazenar dados do mesmo tipo. É por isso que recomendamos o uso de `unlist()` se os **elementos da sua lista** forem do mesmo tipo.

O exemplo de código a seguir converte todos os valores da respectiva lista de armazenamento em um vetor R com o tipo de dado `character`:

```R
list <- list(1, TRUE, "Hello world!", c(1,2,3,4))
vector <- unlist(list)
```

### Converter R list em dataframe

Dataframes em R são usados na **representação tabular de conjuntos de dados**, além de também terem outras funções. Por esse exato motivo, listas multidimensionais podem ser facilmente convertidas em dataframes em R. No entanto, para que isso seja possível, elas precisam ter o mesmo número de itens. Para converter uma R list em dataframe, a linguagem de programação R oferece a função `data.frame()`. Mais especificamente, ela converte listas como parâmetros de passagem.

```R
people <- list(name=c("Max", "Mia", "Mika"), age=c(27, 32, 23))
table <- data.frame(people)
print(table)
```

Este é o dataframe criado com pelo código acima:

```R
name age
1  Max    27
2  Mia    32
3  Mika    23
```

## Acessar itens em listas em R

Para acessar itens de listas em R, faça uso do índice ou do nome do item desejado, caso este tenha sido nomeado.

### Acessar itens de R lists pelo índice

Para acessar itens de uma lista, use o [operador em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/operator-in-r/ "Operadores em R") `[[]]`, inserindo o índice ou nome do item dentro dele:

```R
list <- list(1, TRUE, "Hello world!", c(1,2,3,4))
print(list[[2]])
```

O código acima retornará `TRUE` ou o segundo elemento da lista. Lembre-se que, na linguagem de programação R, o **índice começa com o número 1**. Fique atento a esse detalhe, tanto se você já é experiente em programação quanto se estiver no processo de [aprender a programar](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/aprender-programacao-introducao-basica/). O detalhe evita erros, já que índices costumam começar com zero na maioria das linguagens de programação.

### Acessar itens de R lists pelo nome do elemento

Como já mencionado, itens de listas em R podem ser nomeados. Posteriormente, você pode usar esses nomes para acessar os respectivos itens. Existem duas formas diferentes de se fazer isso: é possível usar colchetes duplos combinados ao nome do elemento, como em uma [string em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-string/ "Como criar e usar strings em R"), ou o símbolo de cifrão seguido do nome do elemento. Acompanhe um exemplo de código que esclarece melhor as instruções:

```R
person <-list(name = "Max White", age = 27, hobbies = c("Programming, movies"))
print(person[["name"]])
print(person$name)
```

Em ambos os casos, a instrução exibe o nome `Max White` na tela.

## Principais funções de listas em R

À medida em que for trabalhando com listas, você descobrirá que existem diversas [funções em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/function-r/ "Funções em R") úteis para a realização de operações. Listamos, a seguir, as mais importantes.

### `append()`

Em R, a função `append()` permite a adição de itens ao final de uma lista. Ela considera a lista na qual a adição será feita como o primeiro parâmetro de passagem, enquanto o elemento que será inserido é entendido como o segundo parâmetro:

```R
list <-list(1,2,3,4)
append(list, 5)
```

Nota Se o elemento a ser inserido tiver um nome, você pode especificá-lo na chamada da função.

A função `append()` não é a única capaz de adicionar itens em listas em R. Em muitos casos, a notação de índice com colchetes duplos, na qual se usa um índice que ainda não existe, é uma opção mais rápida. Veja:

```R
list <-list(1,2,3,4)
list[[5]] <-5
```

### `length()`

Ao chamar o [comando em R](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/commands-in-r/ "Comandos em R") `length()`, você conseguirá descobrir quantos itens existem na respectiva lista. Essa função toma listas como parâmetros de transferência.

```R
list <- list(1,2,3,4)
print(length(list))
```

### Concatenação com `c()`

A linguagem de programação R permite combinar duas listas em uma só. Para fazer isso, faça uso da função `c()`, que toma as duas listas como parâmetro e retorna uma lista concatenada:

```R
list1 <- list(1,2,3,4)
list2 <- list(5,6,7,8)
list_concatenate <- c(list1, list2)
```

### `names()`

Se você criou uma R list nomeada, pode usar a função `names()` para exibir os nomes dos objetos presentes na lista. A função toma a lista como um parâmetro de transferência:

```R
person <-list(name = "Max White", age = 27, hobbies = c("Programming, movies"))
identifier <- names(person)
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-list/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/r-list/) for AI/LLM consumption.