3.6 Základní datové struktury

Základní datové struktury lze roztřídit podle dvou charakteristik: 1) podle jejich dimensionality (jednorozměrné, dvourozměrné atd.) a 2) zda jsou všechny jejich položky stejného datového typu (tj. struktura je homogenní), nebo zda je heterogenní.

dimenze	homogenní	heterogenní
1	atomický vektor	seznam
2	matice	dataset
více	pole	\(\strut\)

3.6.1 Atomické vektory

Nejzákladnější datovou strukturou je v R atomický vektor. R nemá datovou strukturu pro skalár (jedinou logickou hodnotu, jediné číslo, znak nebo řetězec) – každý skalár je ve skutečnosti atomický vektor s jediným prvkem.

Atomický vektor je vektor hodnot, jehož všechny prvky mají stejný typ (např. celé číslo). Atomické vektory se vytvářejí funkcí c() (od “concatenate”), která “slepí” jednotlivé hodnoty dohromady, přičemž provede automatickou konverzi (pokud je potřeba).

x <- c(1, 2, 3, 17)
print(x)

## [1]  1  2  3 17

Pomocí funkce c() je možné “slepit” i celé vektory:

x1 <- c(1, 2, 3)
x2 <- c(4, 5, 6, NA)
x <- c(x1, x2)
print(x)

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

Všechny prvky atomického vektoru musejí mít stejný typ. Pokud tedy při tvorbě atomického vektoru smícháte proměnné různých typů, dojde k automatické konverzi:

c(TRUE, 1, "ahoj")  # výsledek je vektor tří řetězců

## [1] "TRUE" "1"    "ahoj"

Jednotlivé prvky atomických vektorů mohou mít jména. Jména jsou uložena jako atribut names. Je možné je zadat třemi způsoby: přímo ve funkci c(), pomocí funkce attr() nebo pomocí speciální funkce names():

x <- c(a = 1, "good parameter" = 7, c = 17)
x

##              a good parameter              c 
##              1              7             17

attr(x, "names") <- c("A", "Good Parameter", "C")
x

##              A Good Parameter              C 
##              1              7             17

names(x) <- c("aa", "bb", "cc")
names(x)

## [1] "aa" "bb" "cc"

x

## aa bb cc 
##  1  7 17

Pokud mají jednotlivé prvky vektorů přiřazená jména, vypisují se na obrazovku nad vlastní hodnoty.

Délku vektoru je možné zjistit pomocí funkce length():

length(x)

## [1] 3

Pozor: atomický vektor může mít i nulovou délku, pokud neobsahuje žádné prvky. (Podobně i další datové struktury mohou mít nulové rozměry, např. nulový počet řádků apod.) Prázdný vektor vznikne často tak, že z existujícího vektoru vyberete hodnoty pomocí podmínky, kterou žádný prvek vektoru nesplní (jak se vybírá část datové struktury uvidíte později):

x <- 1:9
y <- x[x > 10]  # vybereme prvky větší než 10, viz dále
length(y)

## [1] 0

y

## integer(0)

Prázdný vektor je možné vytvořit pomocí konstruktorových funkcí logical(), integer(), numeric(), character() apod., které mají jediný parametr: počet prvků. Pokud je zadaný počet prvků nulový, funkce vrátí prázdný vektor.

z <- numeric(0)  # parametr je délka vektoru

Některé vektory obsahují předvídatelné sekvence čísel. Pro vytváření takových vektorů existuje operátor dvojtečka (:) a speciální funkce:

1:10   # vektor celých čísel 1 až 10

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

10:1   # vektor celých čísel sestupně 10 až 1

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

# sekvence od ... do
seq(from = 1, to = 10, by = 3)  # s daným krokem

## [1]  1  4  7 10

seq(from = 1, to = 10, length.out = 4)  # s danou délkou výsledku

## [1]  1  4  7 10

seq_along(c(1, 3, 17, 31))  # celá čísla od 1 do délky zadaného vektoru

## [1] 1 2 3 4

seq_len(7)  # celá čísla od 1 nahoru se zadanou nezápornou délkou

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

# opakování hodnot ve vektoru
rep(c(1, 3), times = 5)  # celý vektor 5 krát

##  [1] 1 3 1 3 1 3 1 3 1 3

rep_len(c(1, 3), length.out = 5)  # celý vektor do délky 5

## [1] 1 3 1 3 1

rep(c(1, 3), each = 3)  # každý prvek 3 krát

## [1] 1 1 1 3 3 3

rep(1:6, each = 2, times = 3)

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

Složitější varianty použití funkce rep() viz dokumentace.

Pozor! Konstrukce vektorů pomocí operátoru dvojtečka je někdy nebezpečná. Řekněme, že chcete provést nějakou operaci pro každý prvek vektoru x a že to chcete udělat pomocí cyklu for (viz později). Při psaní cyklů se často prochází hodnoty pomocného vektoru k = 1:length(x). Pokud má vektor x kladnou délku, je vše v pořádku. Pokud však vektor x neobsahuje žádné hodnoty, pak má nulovou délku. Čekali bychom, že pomocný vektor k bude mít také nulovou délku, takže cyklus neproběhne ani jednou. To však není pravda. Vektor k je v tomto případě zkonstruován jako 1:0, má tedy hodnotu c(1, 0) a délku 2! Taková věc je zdrojem špatně dohledatelných chyb. Je lepší použít k = seq_along(x). Ještě lepší je cyklům se vyhýbat. R k tomu má velmi užitečné funkce typu apply(), viz dále.

Na obrazovku se vektory vypisují tak, že se jejich jednotlivé hodnoty skládají vedle sebe do řádku. Pokud se všechny hodnoty na řádek nevejdou, začne se vypisovat na dalším řádku. Každý řádek je uvozen číslem v hranatých závorkách. To je index prvního prvku vektoru na daném řádku. Protože jsou prvky vektorů číslované přirozenými čísly (tj. první prvek má index 1), bude první řádek začínat [1]. Pokud další řádek začíná např. [31], znamená to, že první číslo na daném řádku je 31. prvek daného vektoru atd.

Poznámka: I když se vektory vypisují na obrazovku po řádcích, neznamená to že jsou v R vektory řádkové – nejsou ani řádkové, ani sloupcové (jako je to implicitně třeba v Matlabu). Hodnoty se vypisují po řádcích prostě pro úsporu místa.

Veškeré aritmetické a logické operace se na vektorech provádí po prvcích:

x <- 1:6
y <- 2:7
x * y

## [1]  2  6 12 20 30 42

x ^ 2

## [1]  1  4  9 16 25 36

Pozor: pokud se délka vektorů liší, pak R automaticky “recykluje” kratší vektor, tj. opakuje jeho hodnoty znovu a znovu (při tom vydá R varování jen v případě, že délka delšího vektoru není celočíselným násobkem délky kratšího vektoru):

x <- 1:2
y <- 1:6
x + y

## [1] 2 4 4 6 6 8

x * y

## [1]  1  4  3  8  5 12

y <- 1:7
x + y

## Warning in x + y: longer object length is not a multiple of shorter object
## length

## [1] 2 4 4 6 6 8 8

K otestování, zda je proměnná atomický vektor slouží funkce is.atomic():

is.atomic(x)

## [1] TRUE

Pozor: existuje i funkce is.vector(). Ta však vrací logickou hodnotu TRUE nejen pro atomický vektor, ale i pro neatomický vektor (seznam), viz dále:

is.vector(x)

## [1] TRUE

3.6.2 Atomické matice

Atomická matice je matice (tj. dvourozměrná tabulka), jejíž všechny prvky mají stejný datový typ (např. celé číslo). Pro datovou analýzu nejsou matice příliš důležité, někdy se však hodí pro rychlou maticovou algebru a také některé funkce vracejí nebo očekávají jako vstup matice.

Nejjednodušší způsob, jak vytvořit atomickou matici je pomocí funkce matrix(). Prvním parametrem je vektor, který obsahuje data. Další parametry určují počet řádků a počet sloupců matice, způsob, jak budou data do matice skládaná (zda podle řádků či sloupců; implicitně se data do matic skládají po sloupcích) a pojmenování dimenzí matice. Není potřeba zadávat všechny parametry, pokud je jasné, jaké budou.

matrix(1:12, nrow = 3)  # matice se třemi řádky a čtyřmi sloupci, po sloupcích

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

matrix(1:12, ncol = 4, byrow = TRUE)  # stejný rozměr, data po řádcích

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

Při tvorbě matic R recykluje data. To znamená, že pokud je zadaných hodnot méně, než vyžadují rozměry matice, R začne číst datový vektor znovu od začátku. To může být zdrojem nepříjemných chyb. Naštěstí R vypíše varování.

matrix(1:9, nrow = 3, ncol = 4)

## Warning in matrix(1:9, nrow = 3, ncol = 4): data length [9] is not a sub-
## multiple or multiple of the number of columns [4]

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

Otestovat, zda je objekt matice, je možné pomocí funkce is.matrix(); převést data na matici je možné pomocí konverzní funkce as.matrix().

Zjistit rozměry matice je možné pomocí následujících funkcí: nrow() vrátí počet řádků matice, ncol() vrátí počet sloupců matice, dim() vrací vektor s počtem řádků a sloupců matice a length() vrací počet prvků matice. (Pro vektory vrací funkce nrow(), ncol() a dim() hodnotu NULL.)

m <- matrix(1:12, nrow = 3)
m

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

nrow(m)

## [1] 3

ncol(m)

## [1] 4

dim(m)

## [1] 3 4

length(m)

## [1] 12

Matice a podobné objekty je možné skládat pomocí funkcí rbind() a cbind(). První spojuje matice po řádcích (tj. skládá je pod sebe), druhá po sloupcích (tj. skládá je vedle sebe):

A <- matrix(1:12, nrow = 3)
B <- matrix(101:112, nrow = 3)
rbind(A, B)

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## [4,]  101  104  107  110
## [5,]  102  105  108  111
## [6,]  103  106  109  112

cbind(A, B)

##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
## [1,]    1    4    7   10  101  104  107  110
## [2,]    2    5    8   11  102  105  108  111
## [3,]    3    6    9   12  103  106  109  112

Matice mohou mít následující atributy: dim je celočíselný vektor rozměrů (viz výše), jména řádků (čte i nastavuje se funkcí rownames()), jména sloupců (čte i nastavuje se funkcí colnames()) a jména dimenzí včetně jmen řádků a sloupců (čte i nastavuje se funkcí dimnames()):

rownames(A) <- c("a", "b", "c")
colnames(A) <- c("alpha", "beta", "gamma", "delta")
A

##   alpha beta gamma delta
## a     1    4     7    10
## b     2    5     8    11
## c     3    6     9    12

dimnames(A) <- list(id = c("A", "B", "C"), variables = c("Alpha", "Beta", "Gamma", "Delta"))
A

##    variables
## id  Alpha Beta Gamma Delta
##   A     1    4     7    10
##   B     2    5     8    11
##   C     3    6     9    12

attributes(A)

## $dim
## [1] 3 4
## 
## $dimnames
## $dimnames$id
## [1] "A" "B" "C"
## 
## $dimnames$variables
## [1] "Alpha" "Beta"  "Gamma" "Delta"

Atomická matice je implementována jako atomický vektor, který má přiřazený atribut dim, který je celočíselný vektor délky dva:

M <- 1:12
M

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12

dim(M) <- c(3, 4)
M

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

is.matrix(M)

## [1] TRUE

Podobně lze zrušením atributu dim převést matici zpět na vektor (matice se vektorizuje po sloupcích).

dim(M) <- NULL
M

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12

Protože matice je atomický vektor, který má přiřazený atribut dim, funkce is.atomic() vrací pro matici hodnotu TRUE; funkce is.vector() však vrací překvapivě FALSE, protože testuje, zda je v proměnné uložen vektor.

M <- matrix(1:12, nrow = 3)
is.atomic(M)

## [1] TRUE

is.vector(M)

## [1] FALSE

3.6.2.1 Maticová aritmetika

Obyčejné symboly násobení (*), dělení (/) a umocňování (^) pracují “po prvcích”. Při násobení se např. vynásobí odpovídající prvky matice. Matice tedy musejí mít stejné rozměry (stejný počet řádků a sloupců).

A * B

##    variables
## id  Alpha Beta Gamma Delta
##   A   101  416   749  1100
##   B   204  525   864  1221
##   C   309  636   981  1344

A ^ 2

##    variables
## id  Alpha Beta Gamma Delta
##   A     1   16    49   100
##   B     4   25    64   121
##   C     9   36    81   144

Pro skutečné maticové násobení se používá operátor %*%. Inverzní matici vrací funkce solve() (obecně tato funkce řeší soustavy lineárních rovnic). K transponování matice slouží funkce t(). Hlavní diagonálu matice vrací funkce diag().

Speciální matice:

diag(1, nrow = 3, ncol = 3)  # jednotková matice

##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1

matrix(0, nrow = 3, ncol = 3)  # nulová matice (využívá recyklace)

##      [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    0    0    0
## [3,]    0    0    0

Příklad inverze:

M <- matrix(c(1:8, 0), nrow = 3)
invM <- solve(M)
E <- diag(1, nrow = nrow(M), ncol = ncol(M))
all.equal(M %*% invM, E)

## [1] TRUE

all.equal(invM %*% M, E)

## [1] TRUE

3.6.3 Atomická pole

Atomické pole je vícerozměrná tabulka (tabulka, která má víc než dva rozměry), jehož všechny prvky mají stejný datový typ.

Atomická pole se konstruují pomocí funkce array(). Zbytek viz dokumentace.

array(1:27, dim = c(3, 3, 3))

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]   10   13   16
## [2,]   11   14   17
## [3,]   12   15   18
## 
## , , 3
## 
##      [,1] [,2] [,3]
## [1,]   19   22   25
## [2,]   20   23   26
## [3,]   21   24   27

3.6.4 Neatomické vektory (seznamy)

Neatomické vektory (častěji nazývané seznamy) jsou vektory, jejichž jednotlivé prvky mohou mít různé datové typy, třeba i jiné seznamy. Seznamy se vytvářejí pomocí funkce list():

l <- list(1L, 11, 1:3, "ahoj", list(1, 1:3, "ahoj"))
l

## [[1]]
## [1] 1
## 
## [[2]]
## [1] 11
## 
## [[3]]
## [1] 1 2 3
## 
## [[4]]
## [1] "ahoj"
## 
## [[5]]
## [[5]][[1]]
## [1] 1
## 
## [[5]][[2]]
## [1] 1 2 3
## 
## [[5]][[3]]
## [1] "ahoj"

Stejně jako atomické vektory, i seznamy mohou mít atribut names, tj. jednotlivé prvky seznamu mohou mít svá jména. Ta se přiřazují stejně jako v případě atomických vektorů:

l <- list(a = 1, b = "ahoj", c = 1:3, d = list(1:3, "ahoj"))
names(l)

## [1] "a" "b" "c" "d"

l

## $a
## [1] 1
## 
## $b
## [1] "ahoj"
## 
## $c
## [1] 1 2 3
## 
## $d
## $d[[1]]
## [1] 1 2 3
## 
## $d[[2]]
## [1] "ahoj"

Délku seznamu zjistíme pomocí funkce length():

length(l)

## [1] 4

K otestování, zda je proměnná seznam, slouží funkce is.list(l).

is.list(l)

## [1] TRUE

is.vector(l)

## [1] TRUE

Pozor: Funkce is.vector() vrací hodnotu TRUE i pro seznamy.

Seznamy jsou někdy užitečné samy o sobě; jejich hlavní význam však spočívá v tom, že se používají jako základ pro tvoru většiny objektů (v rámci objektů tříd typu S3).

3.6.4.1 Neatomické matice a pole

Pokud přiřadíme seznamu atribut dim, pak se seznam změní na neatomickou matici nebo pole. Je to obskurní struktura, ale někdy by se mohla hodit:

dim(l) <- c(2, 2)
l

##      [,1]   [,2]     
## [1,] 1      Integer,3
## [2,] "ahoj" List,2

Při výpisu na obrazovku jsou vektory vypsány jako typ a délka (např. Integer,3 znamená vektor celých čísel délky 3).

3.6.5 Datasety

Pro analýzu dat jsou nejdůležitější datovou strukturou datasety. R má několik implementací datasetů, základní se nazývá data.frame. Datasety jsou tabulky, jejichž řádky představují jednotlivá pozorování a sloupce jednotlivé proměnné. Fakticky se jedná o seznam atomických vektorů o stejné délce, které jsou spojené vedle sebe. Každý vektor (sloupec tabulky) může obsahovat proměnné jiného typu.

Řekněme, že chceme zaznamenat údaje o subjektech, které se zúčastnily nějakého experimentu. Pro každý subjekt pozorujeme jeho id, výšku a váhu. Pokud máme čtyři subjekty, můžeme vytvořit dataset např. takto:

experiment <- data.frame(id = c(1, 2, 3, 41),
                         vyska = c(158, 174, 167, 203),
                         vaha = c(51, 110, 68, 97))
experiment

##   id vyska vaha
## 1  1   158   51
## 2  2   174  110
## 3  3   167   68
## 4 41   203   97

Při zadávání vektorů do datasetu můžeme zadat jejich jména, která pak R vypíše. R samo přidá jména řádků (automaticky jim dá přirozená čísla od 1 do počtu pozorování).

Počet řádků datasetu zjistíme pomocí funkce nrow(), počet sloupců funkcí ncol() nebo length(); funguje i funkce dim():

nrow(experiment)    # počet řádků

## [1] 4

ncol(experiment)    # počet sloupců

## [1] 3

length(experiment)  # počet sloupců

## [1] 3

dim(experiment)     # vektor počtu řádků a sloupců

## [1] 4 3

I při konstrukci datasetů R recykluje proměnné, pokud není zadáno dost hodnot. Pokud jsou všechny naše subjekty muži, stačí zadat tuto hodnotu jen jednou – R ji zrecykluje.

experiment <- data.frame(id = c(1, 2, 3, 41),
                         gender = "muž",
                         vyska = c(158, 174, 167, 203),
                         vaha = c(51, 110, 68, 97),
                         zdravy = c(TRUE, TRUE, FALSE, TRUE),
                         stringsAsFactors = FALSE)
experiment

##   id gender vyska vaha zdravy
## 1  1    muž   158   51   TRUE
## 2  2    muž   174  110   TRUE
## 3  3    muž   167   68  FALSE
## 4 41    muž   203   97   TRUE

Při zadání dat do dataset pomocí funkce data.frame() R převede všechny řetězce na faktory. Této konverzi zabrání parametr stringsAsFactors = FALSE.

Datasety mají standardně tři atributy: class (jméno třídy – data set je totiž objekt), names obsahuje jména sloupců (tj. jednotlivých proměnných) a row.names obsahuje jména jednotlivých řádků (tj. pozorování, implicitně mají hodnoty 1, 2 atd.).

attributes(experiment)

## $names
## [1] "id"     "gender" "vyska"  "vaha"   "zdravy"
## 
## $row.names
## [1] 1 2 3 4
## 
## $class
## [1] "data.frame"

Jména řádků můžete zjistit i změnit pomocí funkcí rownames() a row.names(), jména sloupců pomocí funkcí colnames() nebo names():

colnames(experiment) <- c("id", "sex", "height", "weight", "healthy")
experiment

##   id sex height weight healthy
## 1  1 muž    158     51    TRUE
## 2  2 muž    174    110    TRUE
## 3  3 muž    167     68   FALSE
## 4 41 muž    203     97    TRUE

Jména řádků vypadají na první pohled jako dobrý způsob, jak uložit nějakou identifikaci pozorování, např. id subjektu v experimentu. Nedělejte to! Veškeré informace o pozorování ukládejte přímo do datasetu (do tabulky). Je to filosoficky správnější a i praktičtější: některé funkce, které se používají ke zpracování datasetů jména řádků odstraní. Stejně tak některé formáty, do kterých se data ukládají, jména řádků nepodporují, takže byste přišli o důležité informace. Naproti tomu jména sloupců (tj. proměnných) jsou bezpečná.

Pozor: R vám dovolí změnit i třídu objektu tím, že přepíšete atribut class (bud pomocí funkce attr() nebo funkce class()). Pak se však budou pro daný objekt volat jiné funkce a výsledek může být podivný. Nedělejte to, pokud nevíte, co děláte.

Někdy je užitečné moci převést dataset na matici a matici na dataset. K převodu datasetu na matici slouží funkce as.matrix() a data.matrix(). První převede všechny sloupce datasetu automatickou konverzí na stejný typ, a pak na matici. Druhá převede explicitní konverzí všechny sloupce na reálná čísla, a pak na matici. Při automatické konverzi můžeme skončit s řetězci, což nemusí být žádoucí; se explicitní konverzí na reálná čísla můžeme řetězce ztratit a faktory mohou být zavádějící (faktory se převedou na čísla jako při konverzi na celé číslo).

as.matrix(experiment)    # použije automatickou konverzi na stejný typ

##      id   sex   height weight healthy
## [1,] " 1" "muž" "158"  " 51"  " TRUE"
## [2,] " 2" "muž" "174"  "110"  " TRUE"
## [3,] " 3" "muž" "167"  " 68"  "FALSE"
## [4,] "41" "muž" "203"  " 97"  " TRUE"

data.matrix(experiment)  # použije explicitní konverzi na reálná čísla

## Warning in data.matrix(experiment): NAs introduced by coercion

##      id sex height weight healthy
## [1,]  1  NA    158     51       1
## [2,]  2  NA    174    110       1
## [3,]  3  NA    167     68       0
## [4,] 41  NA    203     97       1

Matici lze převést na dataset pomocí funkcí as.data.frame() i data.frame(). Pokud má matice pojmenované sloupce, jejich jména jsou v datasetu zachována; v opačném případě je R samo pojmenuje V1, V2 atd nebo X1, X2 atd.

M <- matrix(1:12, nrow = 3)
as.data.frame(M)

##   V1 V2 V3 V4
## 1  1  4  7 10
## 2  2  5  8 11
## 3  3  6  9 12

data.frame(M)

##   X1 X2 X3 X4
## 1  1  4  7 10
## 2  2  5  8 11
## 3  3  6  9 12

colnames(M) <- c("a", "b", "c", "d")
as.data.frame(M)

##   a b c  d
## 1 1 4 7 10
## 2 2 5 8 11
## 3 3 6 9 12

data.frame(M)

##   a b c  d
## 1 1 4 7 10
## 2 2 5 8 11
## 3 3 6 9 12

Někdy se hodí vytvořit dataset, který obsahuje všechny možné kombinace hodnot nějakého vektoru. K tomu slouží funkce expand.grid():

expand.grid(x = 1:3, y = factor(c("male", "female")), z = c(TRUE, FALSE))

##    x      y     z
## 1  1   male  TRUE
## 2  2   male  TRUE
## 3  3   male  TRUE
## 4  1 female  TRUE
## 5  2 female  TRUE
## 6  3 female  TRUE
## 7  1   male FALSE
## 8  2   male FALSE
## 9  3   male FALSE
## 10 1 female FALSE
## 11 2 female FALSE
## 12 3 female FALSE

3.6.6 Zjištění obsahu datové strukury

Ke zjištění struktury a obsahu datové struktury slouží funkce str(). Funkce vypíše třídu proměnné a zobrazí její strukturu.

n <- 1:12
str(n)

##  int [1:12] 1 2 3 4 5 6 7 8 9 10 ...

l <- list(a = 1, b = 1:3, "ahoj", d = list(1, 1:2, TRUE))
str(l)

## List of 4
##  $ a: num 1
##  $ b: int [1:3] 1 2 3
##  $  : chr "ahoj"
##  $ d:List of 3
##   ..$ : num 1
##   ..$ : int [1:2] 1 2
##   ..$ : logi TRUE

d <- data.frame(x = 1:12, y = c(TRUE, FALSE))
str(d)

## 'data.frame':    12 obs. of  2 variables:
##  $ x: int  1 2 3 4 5 6 7 8 9 10 ...
##  $ y: logi  TRUE FALSE TRUE FALSE TRUE FALSE ...