精通R语言的函数式编程

5星 · 超过95%的资源需积分: 10 136 浏览量更新于2024-07-20 收藏 968KB PDF 举报

"Functional Programming in R" 是一本由 Thomas Mailund 编著的书籍，主要针对已经有一定R语言编程经验的读者。这本书详细介绍了如何在R中应用函数式编程，以提高数据分析和金融分析的效率。在《Functional Programming in R》中，作者探讨了如何使函数变得纯净，即避免副作用，通过编写不改变外部状态的递归函数来替代可能产生副作用的循环。书中还讨论了在某些情况下，虽然递归可能导致效率降低，但如何在保持效率的同时，利用其优点。函数式编程不同于面向对象编程，它关注的是数据转换和计算，而不是对象和状态。函数被视为可操作的数据，通过组合简单的函数构建复杂的函数，这是函数式编程的一大强项。本书将教会你以下内容： 1. 在R中编写函数，包括中缀运算符和替换函数。 2. 创建高阶函数，这些函数可以接收其他函数作为参数，并返回新的函数。 3. 将函数作为数据传递给其他函数，实现对函数的操纵。 4. 使用Filter、Map和Reduce等函数，清晰、安全地表达代码意图。 5. 无需编写新的函数，而是通过无点编程技术，利用现有的函数构建新功能。 6. 创建带有数据载体的函数，使数据能随函数一起流动。本书的目标读者是对R编程有一定基础，希望通过函数式编程提升数据分析和统计建模能力的人士。无论你是数据科学家、分析师还是金融从业者，这本书都将帮助你更好地理解和应用R中的函数式编程概念，以实现更高效、更优雅的代码编写。

Chapter 1 ■ FunCtions in r

f <- function(...) list(...)

g <- function(x, y, ...) f(...)

g(x = 1, y = 2, z = 3, w = 4)

## $z

## [1] 3

## $w

## [1] 4

In the example above, function f creates a list of named elements from ..., and as

you can see it gets the parameters that g doesn’t explicitly takes.

Using ... is not particularly safe. It is often very hard to figure out what it actually

does in a particular piece of code. What is passed on to other functions depends on what

the first function explicitly takes as arguments, and when you call a second function using

it, you pass on all the parameters in it. If the function doesn’t know how to deal with

them, you get an error:

f <- function(w) w

g <- function(x, y, ...) f(...)

g(x = 1, y = 2, z = 3, w = 4)

## Error in f(...): unused argument (z = 3)

In the rescale function, it would have been much better to add the rm.na parameter

explicitly.

That being said, ... is frequently used in R, particularly because many functions

take very many parameters with default values, and adding these parameters to all

functions calling them would be tedious and error-prone. It is also the best way to add

parameters when specializing generic functions, which is a topic for another book in this

series: Object Oriented Programming in R.

To explicitly get hold of the parameters passed along in ..., you can use this

invocation: eval(substitute(alist(...))):

parameters <- function(...) eval(substitute(alist(...)))

parameters(a = 4, b = a**2)

## $a

## [1] 4

## $b

## a^2

The alist function creates a list of names for each parameter and values for the

expressions given:

alist(a = 4, b = a**2)

## $a

## [1] 4

## $b

## a^2

Chapter 1 ■ FunCtions in r

You cannot use the list function for this unless you want all the expression

evaluated. If you try to use list you can get errors like this:

list(a = 4, b = a**2)

## Error in eval(expr, envir, enclos): object 'a' not found

Because R uses so-called lazy evaluation for function parameters, something we

return to shortly, it will be perfectly fine to define a function with default parameters

that are expressions that can’t necessarily be evaluated at the point where the function is

defined, but that can be evaluated inside the function. Inside a function that knows the

parameters a and b, you can evaluate expressions that use these parameters, even when

they are not defined outside the function. So the parameters given to alist above can be

used as default parameters when defining a function. But you cannot create the list using

list because it will try to evaluate the expressions.

The reason you also need to substitute and evaluate is that alist will give you exactly

the parameters you provide it. If you tried to use alist on ... you would just get ... back:

parameters <- function(...) alist(...)

parameters(a = 4, b = x**2)

## [[1]]

## ...

By substituting, we translate ... into the actual parameters given, and by evaluating,

we get the list alist would give us in this context: the list of parameters and their

associated expressions.

Functions Don’t Have Names

The last thing to stress when we talk about defining functions is that functions do not

have names. Variables have names, and variables can refer to functions, but these are two

separate things.

In many languages, such as Java, Python, or C++, you define a function and at the

same time you give it an argument. Whenever possible, you need a special syntax to

define a function without a name.

Not so in R. In R, functions do not have names, and when you define them, you are

not giving them a name. We have given names to all the functions we have used above

by assigning them to variables right where we defined them. We didn’t have to. It is the

function(...) ... syntax that defines a function. We are defining a function whether or

not we assign it to a variable.

We can define a function and call it immediately like this:

(function(x) x**2)(2)

## [1] 4

We would never do this, of course. Anywhere we would want to define an anonymous

function and immediately call it, we could instead just put the body of the function.

Functions that we do want to reuse we have to give a name so we can get to them again.

Chapter 1 ■ FunCtions in r

The syntax for defining functions, however, doesn’t force you to give them names.

When you start to write higher-order functions, that is functions that take other functions

as input or return functions, this is convenient.

Such higher-order functions are an important part of functional programming, and

you will see them used often later in the book.

Lazy Evaluation

Expressions used in a function call are not evaluated before they are passed to the

function. Most common languages have so-called pass-by-value semantics, which means

that all expressions given to parameters of a function are evaluated before the function is

called. In R, the semantic is call-by-promise, also known as lazy evaluation.

When you call a function and give it expressions as its arguments, these are not

evaluated at that point. What the function gets is not the result of evaluating them but

the actual expressions, called promises (they are promises of an evaluation to a value you

can get when you need it). Thus the term call-by-promise. These expressions are only

evaluated when they are actually needed, thus the term lazy evaluation.

This has several consequences for how functions work. First, an expression that isn’t

used in a function isn’t evaluated:

f <- function(a, b) a

f(2, stop("error if evaluated"))

## [1] 2

f(stop("error if evaluated"), 2)

## Error in f(stop("error if evaluated"), 2): error if evaluated

If you have a parameter that can only be meaningfully evaluated in certain contexts,

it is safe enough to have it as a parameter as long as you only refer to it when those

necessary conditions are met.

It is also very useful for default values of parameters. These are evaluated inside the

scope of the function, so you can write default values that depend on other parameters:

f <- function(a, b = a) a + b

f(a = 2)

## [1] 4

This does not mean that all the expressions are evaluated inside the scope of the

function, though. We discuss scopes in chapter 3, but for now, you can think of two

scopes: the global scope where global variables live, and the function scope that has

parameters and local variables as well.

If you call a function like this:

f(a = 2, b = a)

you will get an error if you expect b to be the same as a inside the function. If you are

lucky, and there isn’t any global variable called a, you will get a runtime error. If you are

unlucky and there is a global variable called a, that is what b will be set to. And if you

expect it to be set to 2 here, your code will just give you an incorrect answer.

剩余108页未读，继续阅读

DWcsdnNET

粉丝: 414
资源: 651

精通R语言的函数式编程

Functional Programming in Scala正式版

Functional Programming in Scala

functional programming in scala and impatient.pdf

Functional Data Structures in R Advanced Statistical Programming in R epub

Functional Data Structures in R Advanced Statistical Programming in R 无水印pdf

coursera-functional-programming-principles-in-scala.old:Coursera 的 Scala 函数式编程课程，Martin Odersky, École Polytechnique Fédérale de Lausanne

Performance Enhancements and Functional Upgrades in New Releases

Beginning.R.An.Introduction.to.Statistical.Programming.2nd.Edition.148420

Practical C++ Programming C++编程实践

Seven Concurrency Models in Seven Weeks

最新资源