R programming for data science pdf free download

What You Will Learn Explore the basic functions in R and familiarize yourself with common data structures Work with data in R using basic functions of statistics, data mining, data visualization, root solving, and optimization Get acquainted with R's evaluation model with environments and meta-programming techniques with symbol, call, formula, and expression Get to grips with object-oriented programming in R: including the S3, S4, RC, and R6 systems Access relational databases such as SQLite and non-relational databases such as MongoDB and Redis Get to know high performance computing techniques such as parallel computing and Rcpp Use web scraping techniques to extract information Create RMarkdown, an interactive app with Shiny, DiagramR, interactive charts, ggvis, and more In Detail R is a high-level functional language and one of the must-know tools for data science and statistics.

Powerful but complex, R can be challenging for beginners and those unfamiliar with its unique behaviors. Learning R Programming is the solution - an easy and practical way to learn R and develop a broad and consistent understanding of the language. Through hands-on examples you'll discover powerful R tools, and R best practices that will give you a deeper understanding of working with data. You'll get to grips with R's data structures and data processing techniques, as.

It is a useful addition to the body of work already available to guide project managers of data science projects. It's also a guide for executives and investors to get maximum value from their investment in AI. Beginners in data science can also get the most out of this book. Is it not surprising to know when data science and AI are in the top trend?

If you are looking for a career in data science or looking for leadership, these insights may disturb you. Each day counts. So as your steps. Step up immediately and begin your journey to your dreams of data science and AI. In addition, the book covers why you shouldn't use recursion when loops are more efficient and how you can get the best of both worlds.

Functional programming is a style of programming, like object-oriented programming, but one that focuses on data transformations and calculations rather than objects and state. Where in object-oriented programming you model your programs by describing which states an object can be in and how methods will reveal or modify that state, in functional programming you model programs by describing how functions translate input data to output data.

Functions themselves are considered to be data you can manipulate and much of the strength of functional programming comes from manipulating functions; that is, building more complex functions by combining simpler functions. What You'll Learn Write functions in R including infix operators and replacement functions Create higher order functions Pass functions to other functions and start using functions as data you can manipulate Use Filer, Map and Reduce functions to express the intent behind code clearly and safely Build new functions from existing functions without necessarily writing any new functions, using point-free programming Create functions that carry data along with them Who This Book Is For Those with at least some experience with programming in R.

In the last few years, the methodology of extracting insights from data or "data science" has emerged as a discipline in its own right. The R programming language has become one-stop solution for all types of data analysis. The growing popularity of R is due its statistical roots and a vast open source package library.

The book attempts to strike a balance between the how: specific processes and methodologies, and understanding the why: going over the intuition behind how a particular technique works, so that the reader can apply it to the problem at hand. This book will be useful for readers who are not familiar with statistics and the R programming language. This book gives an introduction to object-oriented programming in the R programming language and shows you how to use and apply R in an object-oriented manner.

You will then be able to use this powerful programming style in your own statistical programming projects to write flexible and extendable software. After reading Advanced Object-Oriented Programming in R, you'll come away with a practical project that you can reuse in your own analytics coding endeavors.

Your projects will benefit from the high degree of flexibility provided by polymorphism, where the choice of concrete method to execute depends on the type of data being manipulated. What You'll Learn Define and use classes and generic functions using R Work with the R class hierarchies Benefit from implementation reuse Handle operator overloading Apply the S4 and R6 classes Who This Book Is For Experienced programmers and for those with at least some prior experience with R programming language.

Popular Books. The Becoming by Nora Roberts. Fear No Evil by James Patterson. The fundamentals of the S language itself has not changed dramatically since the publication of the Green Book by John Chambers in The R language came to use quite a bit after S had been developed. In the first announcement of R was made to the public.

Ross Ihaka and Robert Gentleman. R: A language for data analysis and graphics. Journal of Computational and Graphical Statistics, 5 3 —, This was critical because it allowed for the source code for the entire R system to be accessible to anyone who wanted to tinker with it more on free software later.

Currently, the core group controls the source code for R and is solely able to check in changes to the main R source tree. Finally, in R version 1. Save my name, email, and website in this browser for the next time I comment.

Notify me of follow-up comments by email. Notify me of new posts by email. This site uses Akismet to reduce spam. Data frames must be properly formatted and annotated for this to all be useful. In short, there should be one observation per row, and each column should represent a feature or characteristic of that observation.

The GitHub repository will usually contain the latest updates to the package and the development version. For now you can ignore the warnings. The dataset is available from my web site. After unzipping the archive, you can load the data into R using the readRDS function. The select function can be used to select columns of a data frame that you want to focus on.

The select function allows you to get the few columns you might need. Suppose we wanted to take the first 3 columns only. There are a few ways to do this. We could for example use numerical indices.

But we can also use the names directly. You can also omit variables using the select function by using the negative sign. The select function also allows a special syntax that allows you to specify variable names based on patterns. You can also use more general regular expressions if necessary. See the help page? This function is similar to the existing subset function in R but is quite a bit faster in my experience. Suppose we wanted to extract the rows of the chicago data frame where the levels of PM2.

You can see that there are now only rows in the data frame and the distribution of the pm25tmean2 values is. Median Mean 3rd Qu. Reordering rows of a data frame while preserving corresponding order of other columns is normally a pain to do in R.

The arrange function simplifies the process quite a bit. Here we can order the rows of the data frame by date, so that the first row is the earliest oldest observation and the last row is the latest most recent observation.

The rename function is designed to make this process easier. Here you can see the names of the first five variables in the chicago data frame. However, these names are pretty obscure or awkward and probably be renamed to something more sensible. I leave it as an exercise for the reader to figure how you do this in base R without dplyr. Managing Data Frames with the dplyr package 57 mutate The mutate function exists to compute transformations of variables in a data frame.

Often, you want to create new variables that are derived from existing variables and mutate provides a clean interface for doing that. For example, with air pollution data, we often want to detrend the data by subtracting the mean from the data. Here we create a pm25detrend variable that subtracts the mean from the pm25 variable. Here we detrend the PM10 and ozone O3 variables.

For example, in this air pollution dataset, you might want to know what the average annual level of PM2. So the stratum is the year, and that is something we can derive from the date variable. First, we can create a year varible using as.

In a slightly more complicated example, we might want to know what are the average levels of ozone o3 and nitrogen dioxide no2 within quintiles of pm First, we can create a categorical variable of pm25 divided into quintiles. More sophisticated statistical modeling can help to provide precise answers to these questions, but a simple application of dplyr functions can often get you most of the way there. Notice above that every time we wanted to apply more than one function, the sequence gets buried in a sequence of nested function calls that is difficult to read, i.

There we had to 1. Another example might be computing the average pollutant level by month. This could be useful to see if there are any seasonal trends in the data. Summary The dplyr package provides a concise set of operations for managing data frames. With these functions we can do a number of complex operations in just a few lines of code. Control structures allow you to respond to inputs or to features of the data and execute different R expressions accordingly. For starters, you can just use the if statement.

If you have an action you want to execute when the condition is false, then you need an else clause. This expression can also be written a different, but equivalent, way in R. Which one you use will depend on your preference and perhaps those of the team you may be working with. Of course, the else clause is not necessary. You could have a series of if clauses that always get executed if their respective conditions are true.

In R, for loops take an interator variable and assign it successive values from a sequence or vector. For loops are most commonly used for iterating over the elements of an object list, vector, etc. The following three loops all have the same behavior. Nested for loops for loops can be nested inside of each other.

Be careful with nesting though. If you find yourself in need of a large number of nested loops, you may want to break up the loops by using functions discussed later. If it is true, then they execute the loop body.

Once the loop body is executed, the condition is tested again, and so forth, until the condition is false, after which the loop exits. Use with care! Sometimes there will be more than one condition in the test.

For example, in the above code, if z were less than 3, the second test would not have been evaluated. These are not commonly used in statistical or data analysis applications but they do have their uses. The only way to exit a repeat loop is to call break. You could get in a situation where the values of x0 and x1 oscillate back and forth and never converge. Better to set a hard limit on the number of iterations by using a for loop and then report whether convergence was achieved or not.

Functions Writing functions is a core activity of an R programmer. Functions are often used to encapsulate a sequence of expressions that need to be executed numerous times, perhaps under slightly different conditions. Functions are also often written when code must be shared with others or the public. The writing of a function allows a developer to create an interface to the code, that is explicitly specified with a set of parameters.

This interface provides an abstraction of the code to potential users. In addition, the creation of an interface allows the developer to communicate to the user the aspects of the code that are important or are most relevant. This is very handy for the various apply funtions, like lapply and sapply. However, they are really important in R and can be useful for data analysis. Your First Function Functions are defined using the function directive and are stored as R objects just like anything else.

The next thing we can do is create a function that actually has a non-trivial function body. The last aspect of a basic function is the function arguments. These are the options that you can specify to the user that the user may explicity set. Hello, world! Obviously, we could have just cut-and-pasted the cat "Hello, world! But often it is useful if a function returns something that perhaps can be fed into another section of code.

This next function returns the total number of characters printed to the console. In R, the return value of a function is always the very last expression that is evaluated. Because the chars variable is the last expression that is evaluated in this function, that becomes the return value of the function. Note that there is a return function that can be used to return an explicity value from a function, but it is rarely used in R we will discuss it a bit later in this chapter.

Finally, in the above function, the user must specify the value of the argument num. If it is not specified by the user, R will throw an error. Any function argument can have a default value, if you wish to specify it. Sometimes, argument values are rarely modified except in special cases and it makes sense to set a default value for that argument.

This relieves the user from having to specify the value of that argument every single time the function is called. The formal arguments are the arguments included in the function definition. Because all function arguments have names, they can be specified using their name.

Functions 74 Argument Matching Calling an R function with arguments can be done in a variety of ways. R functions arguments can be matched positionally or by name. Positional matching just means that R assigns the first value to the first argument, the second value to second argument, etc.

The following calls to the sd function which computes the empirical standard deviation of a vector of numbers are all equivalent. Note that sd has two arguments: x indicates the vector of numbers and na.

In the example below, we specify the na. Below is the argument list for the lm function, which fits linear models to a dataset. NULL The following two calls are equivalent. Most of the time, named arguments are useful on the command line when you have a long argument list and you want to use the defaults for everything except for an argument near the end of the list.

Named arguments also help if you can remember the name of the argument and not its position on the argument list. For example, plotting functions often have a lot of options to allow for customization, but this makes it difficult to remember exactly the position of every argument on the argument list. Function arguments can also be partially matched, which is useful for interactive work.

The order of operations when given an argument is 1. Check for exact match for a named argument 2. Check for a partial match 3. Check for a positional match Partial matching should be avoided when writing longer code or programs, because it may lead to confusion if someone is reading the code. However, partial matching is very useful when calling functions interactively that have very long argument names.

In addition to not specifying a default value, you can also set an argument value to NULL. It is sometimes useful to allow an argument to take the NULL value, which might indicate that the function should take some specific action.

Lazy Evaluation Arguments to functions are evaluated lazily, so they are evaluated only as needed in the body of the function. In this example, the function f has two arguments: a and b. This behavior can be good or bad. This example also shows lazy evaluation at work, but does eventually result in an error. This is because b did not have to be evaluated until after print a. Once the function tried to evaluate print b the function had to throw an error. Functions 77 The Argument There is a special argument in R known as the Pass ' This is clear in functions like paste and cat.

So the first argument to either function is Arguments Coming After the Argument One catch with Take a look at the arguments to the paste function.

When R tries to bind a value to a symbol, it searches through a series of environments to find the appropriate value. When you are working on the command line and need to retrieve the value of an R object, the order in which things occur is roughly 1.

Search the global environment i. Search the namespaces of each of the packages on the search list The search list can be found by using the search function. For better or for worse, the order of the packages on the search list matters, particularly if there are multiple objects with the same name in different packages. Users can configure which packages get loaded on startup so if you are writing a function or a package , you cannot assume that there will be a set list of packages available in a given order.

When a user loads a package with library the namespace of that package gets put in position 2 of the search list by default and everything else gets shifted down the list.

The scoping rules of a language determine how a value is associated with a free variable in a function. An alternative to lexical scoping is dynamic scoping which is implemented by some languages. Lexical scoping turns out to be particularly useful for simplifying statistical computations Related to the scoping rules is how R uses the search list to bind a value to a symbol Consider the following function. In the body of the function there is another symbol z. In this case z is called a free variable.

The scoping rules of a language determine how values are assigned to free variables. Free variables are not formal arguments and are not local variables assigned insided the function body. Lexical scoping in R means that the values of free variables are searched for in the environment in which the function was defined.

Okay then, what is an environment? An environment is a collection of symbol, value pairs, i. The only environment without a parent is the empty environment. A function, together with an environment, makes up what is called a closure or function closure. How do we associate a value to a free variable? If a value for a given symbol cannot be found once the empty environment is arrived at, then an error is thrown.

One implication of this search process is that it can be affected by the number of packages you have attached to the search list. The more packages you have attached, the more symbols R has to sort through in order to assign a value. Now things get interesting—in this case the environment in which a function is defined is the body of another function!

Here is an example of a function that returns another function as its return value. Remember, in R functions are treated like any other object and so this is perfectly valid. What is the value of n here? Well, its value is taken from the environment where the function was defined. When I defined the cube function it was when I called make. We can explore the environment of a function to see what objects are there and their values. Dynamic Scoping We can use the following example to demonstrate the difference between lexical and dynamic scoping rules.

With dynamic scoping, the value of y is looked up in the environment from which the function was called sometimes referred to as the calling environment. In R the calling environment is known as the parent frame. In this case, the value of y would be 2. When a function is defined in the global environment and is subsequently called from the global environment, then the defining environment and the calling environment are the same.

This can sometimes give the appearance of dynamic scoping. Consider this example. Lexical scoping in R has consequences beyond how free variables are looked up. This is because all functions must carry a pointer to their respective defining environments, which could be anywhere.

If you do not have such knowledge, feel free to skip this section. Why is any of this information about lexical scoping useful? Optimization routines in R like optim , nlm , and optimize require you to pass a function whose argument is a vector of parameters e. However, an objective function that needst to be minimized might depend on a host of other things besides its parameters like data. When writing software which does optimization, it may also be desirable to allow the user to hold certain parameters fixed.

The scoping rules of R allow you to abstract away much of the complexity involved in these kinds of problems. Now w ecan generate some data and then construct our negative log-likelihood. We can also try to estimate one parameter while holding another parameter fixed. Here we fix sigma to be equal to 2. We can also try to estimate sigma while holding mu fixed at 1. Here is the function when mu is fixed. Nevertheless, I will just give you the standards that I use and the rationale behind them.

I think we can all agree on this one. Using text files and a text editor is fundamental to coding. Interactive development environments like RStudio have nice text editors built in, but there are many others out there. Indent your code. Indenting is very important for the readability of your code. Some programming languages actually require it as part of their syntax, but R does not.

Nevertheless, indenting is very important. How much you should indent is up for debate, but I think each indent should be a minimum of 4 spaces, and ideally it should be 8 spaces. Limit the width of your code. This limitation, along with the 8 space indentation, forces you to write code that is clean, readable, and naturally broken down into modular units. In particular, this combination limits your ability to write very long functions with many different levels of nesting. Limit the length of individual functions.

Typically, purpose of a function is to execute one activity or idea. If your function is doing lots of things, it probably needs to be broken into multiple functions. My rule of thumb is that a function should not take up more than one page of your editor of course, this depends on the size of your monitor. Multi-line expressions with curly braces are just not that easy to sort through when working on the command line.

R has some functions which implement looping in a compact form to make your life easier. This function takes three arguments: 1 a list X; 2 a function or the name of a function FUN; 3 other arguments via its If X is not a list, it will be coerced to a list using as. The body of the lapply function can be seen here. If the original list has names, the the names will be preserved in the output. Functions in R can be used this way and can be passed back and forth as arguments just like any other object.

When you pass a function to another function, you do not need to include the open and closed parentheses like you do when you are calling a function. Here is another example of using lapply. Below, is an example where I call the runif function to generate uniformly distributed random variables four times, each time generating a different number of random numbers.

In the above example, the first argument of runif is n, and so the elements of the sequence all got passed to the n argument of runif. Functions that you pass to lapply may have other arguments. For example, the runif function has a min and max argument too. In the example above I used the default values for min and max.

How would you be able to specify different values for that in the context of lapply? Here is where the Any arguments that you place in the The lapply function and its friends make heavy use of anonymous functions.

Once the call to lapply is finished, the function disappears and does not appear in the workspace. Here I am creating a list that contains two matrices. I could write an anonymous function for extracting the first column of each matrix.

This is perfectly legal and acceptable. For example, I could have done the following. Whether you use an anonymous function or you define a function first depends on your context. The basic idea is that you can take a data structure, split it into subsets defined by another variable, and apply a function over those subsets.

The results of applying tha function over the subsets are then collated and returned as an object. Here we simulate some data and split it according to a factor variable. R: int [] NA NA 99 19 R: int [] Loop Functions R: int [] 95 92 Then we can take the column means for Ozone, Solar.

R, and Wind for each sub-data frame. R Wind NA R NA However, we can tell the colMeans function to remove the NAs before computing the mean. R We can do this by creating an interaction of the variables with the interaction function. But we can drop empty levels when we call the split function. It can be thought of as a combination of split and sapply for vectors only. Given a vector of numbers, one simple operation is to take group means.

For functions that return a single value, usually, this is not what we want, but it can be done. In this case, tapply will not simplify the result and will return a list. It is most often used to apply a function to the rows or columns of a matrix which is just a 2-dimensional array.