Ted Kwartler - Sports Analytics in Practice with R

xVec <- c(xVal, i, newObj, 345,678)

Scaling up from a single vector, one method for arranging multiple columns into a single object is with ` cbind`. The ` cbind` function arranges vectors in a column-wise fashion. Similarly, the ` rbind` function will stack vectors as rows. The resulting object type is no longer a “numeric” or other previous type discussed, but instead “matrix” type. A matrix arranges data into rows and columns within a single object. This code creates ` xMatrix` using ` cbind` and simply repeating the previous vector ` xVec` to create a second column. Once executed the ` xMatrix` variable is in the environment and when called demonstrates a five row by two column arrangement of the data in a single object. Calling ` class` on the object will return “matrix.”

xMatrix <- cbind(xVec, xVec)

R has another method for arranging data as rows and columns called a data frame. The data frame object type is useful when you are working with mixed data types, for example, a player roster with names, as characters, teams as factors, statistics as numeric, and so on. All of these vectors can be organized into a single object using ` data.frame`. This code is a bit more complex because it nests functions when constructing the data frame. Within the ` data.frame` function call, the first column is names “number1.” It is assigned a value of ` xVec` which equates to the numeric values previously constructed. The next column, “logical2,” is separated by a comma and employs the `c` function combining logical values. Next, the “factor3” column is declared. This column has multiple functions including `c` to combine a vector of “a,” “b,” “a,” “b,” and “b” but then it is changed from a simple character vector to factor using ` as.factor`. Finally, the fourth column, “string4,” consists of various character strings. Once instantiated in the console, the ` xDataFrame` object can be called to illustrate the mixed data types held within the single object. Table 1.3shows the results of creating the ` xDataFrame` object.

Table 1.3 The constructed data frame with mixed data types.

xDataFrame <- data.frame(number1 = xVec, logical2 = c(T,T,F,F,T), factor3 = as.factor(c('a','b','a','b','b')), string4 = c('string1', 's2', 's3', 's4', 's5'))

R can employ either a matrix or data frame to arrange data in rows and columns. In both object types, the columns and rows must be complete. For example, you cannot `cbind` a vector with three values to another with two values. This makes the data “ragged” and for matrices r data frames requires you to fill in the cell value with NA. However, some functions require one object class over another. The difference is that a matrix must have all values be of the same data type. For example, each value in all of the columns must all be numeric or all logical. If this is not the case, the matrix function will coerce the data into characters automatically which can cause issues. As a result, most often in this text, the ` data.frame` and object type are used. However, you can coerce either object type to the other using ` as.matrix` or ` as.data.frame` to switch. Just keep in mind the mixed data coercion mentioned previously.

The last data type discussed in this book is a “list” object. There are other object types including time series and arrays but for the most part this book employs mixed data types, with data frames and sparingly lists. If you are familiar with spreadsheets, think of a list as a “workbook” containing multiple “work sheets.” Each tab of the spreadsheet programs can contain different data even single values and different types. A list is similar in that each list “element” can contain a single value, multiple values, matrices, data frames, or even more lists! The following code creates a list object with varying data types and lengths, while Figure 1.7 is a graphical representation of the list.

Figure 1.7 The representation of the list with varying objects.

xList <- list(xDataFrame, fanTweet, teamA, xVec)

In complex R objects, you can get specific sections of the data by name or through indexing. The previous list has four elements, denoted with double square brackets such as ` [[2]]`. To access a specific list element, you can call the object ` xList` along with its specific element index as shown below to select the fourth element, the vector of numbers.

xList[[4]]

The same can be done with matrices or data frames using single brackets. Indexing row and column data requires two inputs separated by a comma. The selection for rows is first followed by the selection for columns. For example, let’s first call the ` xDataFrame` object in its entirety to establish familiarity. Then select the first row and third column which represents a single cell value of the data frame. Next, you can select a different row, column combination on your own within the console to establish this single value is returned.

xDataFrame xDataFrame[1,3]

Indexing also works for entire columns or entire rows. This is done by leaving the rows position blank or the columns position blank on either side of the comma. To call the second column of the data frame simply use single brackets, nothing on the left of the comma and a 2 to the right of the comma as shown.

xDataFrame[, 2]

Similarly, you can switch the index number to the left of the comma to obtain a specific row. Here, the entire fourth row is returned while the column position is left blank.

xDataFrame[4, ]

Besides the ability to have multiple data types, another benefit of the data frame object is the ability to declare a column by its name using the ` $` sign. For example, instead of an index position the column names ` $numer1` will return the entire first column of the data frame object. The two methods, indexing or by name, are equivalent but can be used interchangeably as long as the column has a declared name.

xDataFrame$number1

In fact, indexing can become more complex. You can access a specific list element, then a specific row, column, or single value by utilizing double then single brackets or `$` as shown. First, the fourth element of the list is obtained with `[[4]]`; then the second value is obtained within that vector. Keep in mind there is no need for a comma because a vector does not have rows or column. Instead, a vector merely has a position. In this case, “2” is returned.

# 4th element, vector 2nd position xList[[4]][2]

Next, the first list element is accessed, and as a data frame, the single brackets with a comma refer to the second row.

# 1st element, 2nd row xList[[1]][2,]

Similarly, the same data frame is indexed to return the first column because the “1” is to the right of the comma within the single square brackets.

# 1st element, 1st column xList[[1]][,1]

Of course, you can also use both rows and column positions separated by the comma within the single brackets.