R语言 lapply函数详解_R语言培训-数据分析

R语言 lapply函数详解

lapply {base} R Documentation R文档

Apply a Function over a List or Vector

对列表或者向量使用某个函数

Description描述

lapply returns a list of the same length as X, each element of which is the result of applying FUN to the corresponding element of X.

lapply()返回一个长度与X一致的列表，每个元素为FUN计算出的结果，且分别对应到X中的每个元素。

sapply is a user-friendly version and wrapper of lapply by default returning a vector, matrix or, if simplify=”array”, an array if appropriate, by applying simplify2array(). sapply(x, f, simplify=FALSE, USE.NAMES=FALSE) is the same as lapply(x,f).

sapply()是一个用户友好版本的lappy()，是lappy()默认返回一个向量、矩阵。如果simplify=“array”，合适的情况下就会通过simplify2array()返回一个阵列。sapply(x, f, simplify=FALSE, USE.NAMES=FALSE)与lapply(x,f)的效果是一样的。

vapply is similar to sapply, but has a pre-specified type of return value, so it can be safer (and sometimes faster) to use.

vapply()与sapply相类似，但是有返回值得预定义类型，所以会更安全、有时会更快。

replicate is a wrapper for the common use of sapply for repeated evaluation of an expression_r(which will usually involve random number generation).

replicate()是sapply()函数对一个表达式的重复评价（涉及随机数生成）。

simplify2array() is the utility called from sapply() when simplify is not false and is similarly called from mapply().

simplify2array()是当sapply()的simplify=”FALSE”，类似的还有mapply()的函数。

Usage用法

lapply(X, FUN, …)

sapply(X, FUN, …, simplify = TRUE, USE.NAMES = TRUE)

vapply(X, FUN, FUN.VALUE, …, USE.NAMES = TRUE)

replicate(n, expr, simplify = “array”)

simplify2array(x, higher=TRUE)

Arguments参数

a vector (atomic or list) or an expression object. Other objects (including classed objects) will be coerced by base::as.list.

一个向量（原子或者列表）或者一个表达是对象。其他对象会通过base::as.list()强制转换

FUN

the function to be applied to each element of X: see ‘Details’. In the case of functions like +, %*%, the function name must be backquoted or quoted.

该函数将被用于X的每个元素：见细节。诸如：+、%*%之类的符号函数必须用反引号和引号

…

optional arguments to FUN.函数的可选参数

simplify

logical or character string; should the result be simplified to a vector, matrix or higher dimensional array if possible? For sapply it must be named and not abbreviated. The default value, TRUE, returns a vector or matrix if appropriate, whereas if simplify = “array” the result may be an array of “rank” (=length(dim(.))) one higher than the result of FUN(X[[i]]).

逻辑或者字符串；如果可能的话结果可以被简化为向量、矩阵或者更高维数组。对于sapply()应该是已命名的且不是缩写。默认值是TRUE，正确的情况下可能返回一个向量或者矩阵，当simplify=“array”时，结果将是数组的排列（=length(dim(.))）,维数将高于FUN(X[[i]])

USE.NAMES

logical; if TRUE and if X is character, use X as names for the result unless it had names already. Since this argument follows … its name cannot be abbreviated.

逻辑值，如果为TRUE，并且X是一个字符值可以将X作为结果名，除非它已经有名字了。由于这个参数follows，所以他的名字可以是缩写

FUN.VALUE

a (generalized) vector; a template for the return value from FUN. See ‘Details’.

一个通用向量；FUN返回值得模板

integer: the number of replications.

整型：重复次数

expr

the expression_r(language object, usually a call) to evaluate repeatedly.

重复评估参数（语言、对象、一般是一次调用）

a list, typically returned from lapply().

列表、典型的是由lapply()返回的

higher

logical; if true, simplify2array() will produce a (“higher rank”) array when appropriate, whereas higher = FALSE would return a matrix (or vector) only. These two cases correspond to sapply(*, simplify = “array”) or simplify = TRUE, respectively.

逻辑值：如果为TRUE，将会由simplify2array()产生一个合适的高阶数组。如果为FALSE，将只返回一个矩阵或者向量。这两项分别对应sapply()。

Details细节

FUN is found by a call to match.fun and typically is specified as a function or a symbol (e.g. a backquoted name) or a character string specifying a function to be searched for from the environment of the call to lapply.

FUN是一个可以由match.fun()查找到的函数、符号或者字符串函数。

Function FUN must be able to accept as input any of the elements of X. If the latter is an atomic vector, FUN will always be passed a length-one vector of the same type as X.

FUN能够接受X的任何元素作为输入参数，如果后者是原子向量，那么FUN将会传递一个与X长度一致的向量

Arguments in … cannot have the same name as any of the other arguments, and care may be needed to avoid partial matching to FUN. In general-purpose code it is good practice to name the first two arguments X and FUN if … is passed through: this both avoids partial matching to FUN and ensures that a sensible error message is given if arguments named X or FUN are passed through ….

…里面的参数不能和其他参数同名，需要避免跟部分FUN的参数一致。一般的通用代码里前两个参数X和FUN的命名是个很好的实践。如果…通过：避免和FUN和X部分一致。

Simplification in sapply is only attempted if X has length greater than zero and if the return values from all elements of X are all of the same (positive) length. If the common length is one the result is a vector, and if greater than one is a matrix with a column corresponding to each element of X.

如果X长度大于0，并且X中所有参数返回的值都长度相同，都为正，那么sapply()就会尝试简化结果。

Simplification is always done in vapply. This function checks that all values of FUN are compatible with the FUN.VALUE, in that they must have the same length and type. (Types may be promoted to a higher type within the ordering logical < integer < real < complex, but not demoted.)

Users of S4 classes should pass a list to lapply and vapply: the internal coercion is done by the as.list in the base namespace and not one defined by a user (e.g. by setting S4 methods on the base function).

lapply and vapply are primitive functions.

Value

For lapply, sapply(simplify = FALSE) and replicate(simplify = FALSE), a list.

For sapply(simplify = TRUE) and replicate(simplify = TRUE): if X has length zero or n = 0, an empty list. Otherwise an atomic vector or matrix or list of the same length as X (of length n for replicate). If simplification occurs, the output type is determined from the highest type of the return values in the hierarchy NULL < raw < logical < integer < real < complex < character < list < expression, after coercion of pairlists to lists.

vapply returns a vector or array of type matching the FUN.VALUE. If length(FUN.VALUE) == 1 a vector of the same length as X is returned, otherwise an array. If FUN.VALUE is not an array, the result is a matrix with length(FUN.VALUE) rows and length(X) columns, otherwise an array a with dim(a) == c(dim(FUN.VALUE), length(X)).

The (Dim)names of the array value are taken from the FUN.VALUE if it is named, otherwise from the result of the first function call. Column names of the matrix or more generally the names of the last dimension of the array value or names of the vector value are set from X as in sapply.

Note

sapply(*, simplify = FALSE, USE.NAMES = FALSE) is equivalent to lapply(*).

For historical reasons, the calls created by lapply are unevaluated, and code has been written (e.g. bquote) that relies on this. This means that the recorded call is always of the form FUN(X[[0L]], …), with 0L replaced by the current integer index. This is not normally a problem, but it can be if FUN uses sys.call or match.call or if it is a primitive function that makes use of the call. This means that it is often safer to call primitive functions with a wrapper, so that e.g. lapply(ll, function(x) is.numeric(x)) is required in R 2.7.1 to ensure that method dispatch for is.numeric occurs correctly.

If expr is a function call, be aware of assumptions about where it is evaluated, and in particular what … might refer to. You can pass additional named arguments to a function call as additional named arguments to replicate: see ‘Examples’.

References

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.