introR-WebValley2020-class2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "An R list is an object consisting of an ordered collection of objects known as its components.\n",
    "\n",
    "There is no particular need for the components to be of the same mode or type, and, for example, a list could consist of a numeric vector, a logical value, a matrix, a complex vector, a character array, a function, and so on. Here is a simple example of how to make a list:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lst <- list(name=\"Fred\", wife=\"Mary\", no.children=3, child.ages=c(5,7,10))\n",
    "print(Lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Components are always numbered and may always be referred to as such. Thus if Lst is the name of a list with four components, these may be individually referred to as *Lst[[1]], Lst[[2]], Lst[[3]]* and *Lst[[4]]*. If, further, *Lst[[4]]* is a vector subscripted array then *Lst[[4]][1]* is its first entry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lst[[1]]\n",
    "Lst[[4]][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If Lst is a list, then the function *length(Lst)* gives the number of (top level) components it has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(length(Lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Components of lists may also be named, and in this case the component may be referred to either by giving the component name as a character string in place of the number in double square brackets, or, more conveniently, by giving an expression of the form *name$component_name* for the same thing.\n",
    "\n",
    "This is a very useful convention as it makes it easier to get the right component if you forget the number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lst$name\n",
    "Lst$child.ages[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, one can also use the names of the list components in double square brackets, *i.e., Lst[[\"name\"]]* is the same as *Lst$name*. This is especially useful, when the name of the component to be extracted is stored in another variable as in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n <- \"name\"\n",
    "Lst[[n]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is very important to distinguish *Lst[[1]]* from *Lst[1]*. \n",
    "\n",
    "* *[[…]]* is the operator used to select a single element, thus *Lst[[1]]* is the first object in the list Lst, and if it is a named list the name is not included;\n",
    "* *[…]* is a *general* subscripting operator, so *Lst[1]* is a sublist of the list Lst consisting of the first entry only and if it is a named list, the names are transferred to the sublist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lst[[1]]\n",
    "Lst[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The names of components may be abbreviated down to the minimum number of letters needed to identify them uniquely. Thus *Lst\\$coefficients* may be minimally specified as *Lst\\$coe* and *Lst\\$covariance* as *Lst\\$cov*: the vector of names is in fact simply an attribute of the list like any other and may be handled as such. Other structures besides lists may, of course, similarly be given a names attribute also."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "New lists may be formed from existing objects by the function *list()*. An assignment of the form"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- c(10.4, 5.6, 3.1, 6.4, 21.7)\n",
    "z <- array(1:20, dim=c(4,5))   \n",
    "\n",
    "Lst2 <- list(name_1=x, name_2=z)\n",
    "Lst2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sets up a list Lst of m components using x and z for the components and giving them names as specified by the argument names, (which can be freely chosen). If these names are omitted, the components are numbered only. The components used to form the list are copied when forming the new list and the originals are not affected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists, like any subscripted object, can be extended by specifying additional components. For example\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B<- diag(4)\n",
    "Lst2[5] <- list(matrix=B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the concatenation function *c()* is given list arguments, the result is an object of mode list also, whose components are those of the argument lists joined together in sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.ABC <- c(Lst, Lst2)\n",
    "list.ABC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that with vector objects as arguments the concatenation function similarly joined together all arguments into a single vector structure. In this case all other attributes, such as dim attributes, are discarded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Data frames\n",
    "A data frame is a list with class \"data.frame\". There are restrictions on lists that may be made into data frames, namely:\n",
    "\n",
    "* the components must be vectors (numeric, character, or logical), factors, numeric matrices, lists, or other data frame;\n",
    "* matrices, lists, and data frames provide as many variables to the new data frame as they have columns, elements, or variables, respectively;\n",
    "* numeric vectors, logicals and factors are included as is, and by default18 character vectors are coerced to be factors, whose levels are the unique values appearing in the vector;\n",
    "* vector structures appearing as variables of the data frame must all have the same length, and matrix structures must all have the same row size.\n",
    "\n",
    "A data frame may for many purposes be regarded as a matrix with columns possibly of differing modes and attributes. It may be displayed in matrix form, and its rows and columns extracted using matrix indexing conventions.\n",
    "\n",
    "Objects satisfying the restrictions placed on the columns (components) of a data frame may be used to form one using the function data.frame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l <- c(\"a\", \"b\", \"c\", \"d\", \"e\")\n",
    "df <- data.frame(letter=l, number=x)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list whose components conform to the restrictions of a data frame may be coerced into a data frame using the function *as.data.frame()*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lst3 <- list(letter=l, number=x)\n",
    "df2= as.data.frame(Lst3)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest way to construct a data frame from scratch is to read an entire data frame (table) from an external file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read data from files\n",
    "Large data objects will usually be read as values from external files rather than entered during an R session at the keyboard. \n",
    "\n",
    "To read an entire data frame directly, the external file will ideally have a special form.\n",
    "\n",
    "* The first line of the file should have a name for each variable in the data frame.\n",
    "* Each additional line of the file has as its first item a row label and the values for each variable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default numeric items (except row labels) are read as numeric variables and non-numeric variables as factors. This can be changed if necessary.\n",
    "\n",
    "The functions *read.table()* and *read.csv()* can then be used to read the data frame directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HousePrice <- read.csv(\"channing.csv\", header=TRUE)\n",
    "HousePrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "write.table(HousePrice, file=\"channing.txt\",\n",
    "            quote=T, \n",
    "            sep=\" \", \n",
    "            dec=\".\", \n",
    "            na=\"NA\", \n",
    "            row.names=F, \n",
    "            col.names=T) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HousePrice_txt <- read.table(\"channing.txt\", \n",
    "                             header=TRUE)\n",
    "                             #sep='\\t'\n",
    "                             #skip=6\n",
    "\n",
    "HousePrice_txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The *apply()* family of functions\n",
    "The *apply()* family pertains to the R base package and is populated with functions to manipulate slices of data from matrices, arrays, lists and dataframes in a repetitive way. These functions allow crossing the data in a number of ways and avoid explicit use of loop constructs. They act on an input list, matrix or array and apply a named function with one or several optional arguments.\n",
    "\n",
    "The called function could be:\n",
    "\n",
    "* An aggregating function, like for example the mean, or the sum (that return a number or scalar);\n",
    "* Other transforming or subsetting functions; and\n",
    "* Other vectorized functions, which yield more complex structures like lists, vectors, matrices, and arrays.\n",
    "\n",
    "The *apply()* functions form the basis of more complex combinations and helps to perform operations with very few lines of code. More specifically, the family is made up of the *apply(), lapply() , sapply(), vapply(), mapply(), rapply()*, and *tapply()* functions.\n",
    "\n",
    "The base element of the family, *apply()*, operates on arrays as *apply(X, MARGIN, FUN, ...)* where:\n",
    "\n",
    "* X is an array or a matrix if the dimension of the array is 2;\n",
    "* MARGIN is a variable defining how the function is applied: when MARGIN=1, it applies over rows, whereas with MARGIN=2, it works over columns. Note that when you use the construct MARGIN=c(1,2), it applies to both rows and columns; and\n",
    "* FUN, which is the function that you want to apply to the data. It can be any R function, including a user defined function.\n",
    "\n",
    "Let’s construct a 5 by 6 random matrix and calculate sum the values of each column (the function *runif(n=N,min=m,max=M)* generates a vector of N random decimal number in the interval $[m,M]$):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M <- matrix(runif(n=5*6,min=0,max=1),5,6)\n",
    "print(M)\n",
    "apply(M,2,sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *lapply()* function applies to every element of a list and returns a list as a result. However, \n",
    "\n",
    "* it can be used for other objects like dataframes, lists or vectors; and\n",
    "* the output returned is a list (which explains the “l” in the function name), which has the same number of elements as the object passed to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AA <- matrix(floor(runif(5*5,1,10)),5,5)\n",
    "BB <- matrix(runif(3*6),3,3)\n",
    "CC <- matrix(-runif(4*4),4,4)\n",
    "\n",
    "MyList <- list(AA,BB,CC)\n",
    "print(MyList)\n",
    "lapply(MyList,\"[\", 1,)\n",
    "lapply(MyList,\"[\", ,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something that is often used together with *apply()* functions is *rep()*. When you apply it to a vector or a factor x, the function replicates its values a specified number of times.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=c(\"a\", \"b\", \"c\")\n",
    "x\n",
    "rep(x,c(3,1,2))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}