indexing.Rmd

# Indexing

```{r indexsetup, include=FALSE, eval=TRUE, cache=FALSE}
knitr::opts_chunk$set(eval=FALSE)
```

<div class="" style="text-align: center;">
<i class="fas fa-table fa-5x" style = 'color:#990024CC'></i>
</div>

<br>

What follows is probably more of a refresher for those that have used R quite a bit already.  Presumably you've had enough R exposure to be aware of some of this. However, much of data processing regards data frames, or other tables of mixed data types, so more time will be spent on slicing and dicing of data frames instead.  Even so, it would be impossible to use R effectively without knowing how to handle basic data types.

## Slicing Vectors

Taking individual parts of a vector of values is straightforward and something you'll likely need to do a lot. The basic idea is to provide the indices for which elements you want to exract.

```{r vectorSlice, eval=TRUE}
letters[4:6]  # lower case letters a-z
letters[c(13, 10, 3)]
```

## Slicing Matrices/data.frames

With 2-d objects we can specify rows and columns. Rows are indexed to the left of the comma, columns to the right.

```{r matrixSlice}
myMatrix[1, 2:3]  # matrix[rows, columns]
```


## Label-based Indexing

We can do this by name if they are available.

```{r dfindexlabel}
mydf['row1', 'b']
```

## Position-based Indexing

Otherwise we can index by number.

```{r dfindexpos}
mydf[1, 2]
```


## Mixed Indexing

Even both!

```{r dfindexmix}
mydf['row1', 2]
```

If the row/column value is empty, all rows/columns are retained.

```{r dfindexslice}
mydf['row1', ]
mydf[, 'b']
```


## Non-contiguous

Note that the indices supplied do not have to be in order or in sequence.

```{r dfindexnoncont}
mydf[c(1, 3), ]
```

## Boolean

Boolean indexing requires some `TRUE`-`FALSE` indicator.  In the following, if column A has a value greater than or equal to 2, it is `TRUE` and is selected. Otherwise it is `FALSE` and will be dropped.

```{r dfindexbool}
mydf[mydf$a >= 2, ]
```


## List/data.frame Extraction

We have a couple ways to get at elements of a list, and likewise for data frames as they are also lists.

<span class="func">[</span> : grab a slice of elements/columns

<span class="func">[[</span> : grab specific elements/columns

<span class="func">$</span> : grab specific elements/columns

<span class="func">@</span>: extract slot for S4 objects

```{r dflistslice}
my_list_or_df[2:4]
```


```{r dflistextract}
my_list_or_df[['name']]
```

```{r dflistextract2}
my_list_or_df$name
```

```{r dflistextract3}
my_list@name
```


<div class='note'>
In general, position-based indexing should be avoided, except in the case of iterative programming of the sort that will be covered later.  The reason is that these become *magic numbers* when not commented, such that no one will know what they refer to.  In addition, any change to the rows/columns of data will render the numbers incorrect, where labels would still be applicable.
<img class='img-note' src="img/R.ico" style="display:block; margin: 0 auto;"> 
</div>

## Indexing Exercises

This following is a refresher of base R indexing only.

Here is a <span class="objclass">matrix</span>, a <span class="objclass">data.frame</span> and a <span class="objclass">list</span>.

```{r ixex0}
mymatrix = matrix(rnorm(100), 10, 10)
mydf = cars
mylist = list(mymatrix, thisdf = mydf)
```

### Exercise 1

For the <span class="objclass">matrix</span>, in separate operations, take a slice of rows, a selection of columns, and a single element.

```{r ixex1, echo=F}
mymatrix[1:5, ]
mymatrix[, 1:5]
mymatrix[1, 2]
```

### Exercise 2

For the <span class="objclass">data.frame</span>, grab a column in 3 different ways.

```{r ixex2, echo=F}
mydf$disp
mydf[, 2]
mydf['disp']
```

### Exercise 3

For the <span class="objclass">list</span>, grab an element by number and by name.

```{r ixex3, echo=F}
mylist[2]
mylist$thisdf
```

## Python Indexing Notebook

[Available on GitHub](/~https://github.com/m-clark/data-processing-and-visualization/blob/master/jupyter_notebooks/indexing.ipynb)