精华内容
下载资源
问答
  • R语言apply、lapply、sapply、tspply函数 在描述性统计量方面,R语言提供了数不胜数的选择,这里主要讲apply、lapply、sapply、tspply函数的用法和区别。这四者的基本用法非常相似,都是对的行或者列执行同样的运算...
  • 4-1 R语言函数 lapply

    2018-11-11 15:44:00
    #lapply函数 #可以循环处理列表中的每一个元素 #lapply(参数):lapply(列表,函数/函数名,其他参数) #总是返回一个列表 #sapply:简化结果 #结果列表元素长度均为1,返回向量 #结果列表元素长度相同且大于1,返回矩阵...
    #lapply函数
    #可以循环处理列表中的每一个元素
    #lapply(参数):lapply(列表,函数/函数名,其他参数)
    #总是返回一个列表
    
    #sapply:简化结果
    #结果列表元素长度均为1,返回向量
    #结果列表元素长度相同且大于1,返回矩阵
    
    > str(lapply)
    function (X, FUN, ...)  
    
    > ?str
    
    > x <- list(a=1:10,b=c(11,21,31,41,51))
    > x
    $`a`
     [1]  1  2  3  4  5  6  7  8  9 10
    
    $b
    [1] 11 21 31 41 51
    
    > lapply(x,mean)
    $`a`
    [1] 5.5
    
    $b
    [1] 31
    
    > x <- 1:4
    > lapply(x,runif)
    [[1]]
    [1] 0.5754994
    
    [[2]]
    [1] 0.3157821 0.7646459
    
    [[3]]
    [1] 0.2289793 0.1715219 0.6473963
    
    [[4]]
    [1] 0.634688171 0.326673566 0.007179751 0.687418686
    
    > lapply(x,runif,min=0,max=100)
    [[1]]
    [1] 40.30112
    
    [[2]]
    [1] 31.06171 64.75319
    
    [[3]]
    [1] 45.190536  8.243788 98.328863
    
    [[4]]
    [1] 22.22585 18.63806 57.53813 54.82982
    
    > x <- list(a=matrix(1:6,2,3),b=matrix(4:7,2,2))
    > lapply(x,function(m) m[1,])
    $`a`
    [1] 1 3 5
    
    $b
    [1] 4 6
    
    > x <- list(a=1:10,b=c(11,21,31,41,51))
    > lapply(x,mean)
    $`a`
    [1] 5.5
    
    $b
    [1] 31
    
    
    > sapply(x,mean)
       a    b 
     5.5 31.0 
    
    > class(sapply(x, mean))
    [1] "numeric"
    

    转载于:https://www.cnblogs.com/hankleo/p/9942281.html

    展开全文
  • R语言笔记_lapply与apply

    2021-05-10 21:37:56
    lapply与apply是R中循环语句 apply(a,1,function(x)) 对每一行执行命令,并返回结果; apply(a,2,function(x)) 对每一列执行命令,并返回结果; lapply lapply(a,1,function(x)) 指定的函数对列表中每一个向量执行...

    lapply与apply是R中循环语句

    apply(a,1,function(x)) 对每一行执行命令,并返回结果;
    apply(a,2,function(x)) 对每一列执行命令,并返回结果;

    lapply
    lapply(a,1,function(x)) 指定的函数对列表中每一个向量执行命令,并返回结果;

    展开全文
  • R语言对于我们生信人员来讲,再熟悉不过,然而任何一门语言想要学好,必须经过常年的日积月累才可以做到,在这里,我列举R中常用的函数的用法, 供大家学习。1.序列函数seq用法: seq(form,to,length.out(or by))seq...

    R语言对于我们生信人员来讲,再熟悉不过,然而任何一门语言想要学好,必须经过常年的日积月累才可以做到,在这里,我列举R中常用的函数的用法, 供大家学习。

    1.序列函数seq

    用法: seq(form,to,length.out(or by))

    seq(from=3,to=27,by=3)

    [1] 3 6 9 12 15 18 21 24 27

    seq(from=1,to=3,length=3)

    [1] 1 2 3

    2、重复函数rep

    用法:rep(x,times,each)

    rep(x=1,times=2)

    [1] 1 1

    rep(x=c(2,3),times=2)

    [1] 2 3 2 3

    rep(x=c(2,3) ,each=2)

    [1] 2 2 3 3

    3.排序函数sort

    用法:sort(x,decreasing=T/F)

    sort(x=c(1,3,2),decreasing=T)

    [1] 3 2 1

    4.长度函数length

    length(x=c(1,2,3,4))

    [1] 4

    5.prob所有元素向量相乘

    prob(c(1,2,3,4))

    [1] 24

    6.dim 矩阵维度,nrow行数,ncol列数

    data=rbind(c(1,3,4),5:3,c(100,20,90),11:13)

    dim(data)

    4 3

    nrow(data)

    4

    ncol(data)

    3

    dim(data)[2]

    3

    7.rbind行合并和cbind列合并

    rbind(1:3,4:6)#行合并

    1 2 3

    4 5 6

    cbind(1:3,4:6)

    1 4

    2 5

    3 6

    8.t转置

    data=rbind(c(1,2,3),c(4,5,6))

    data

    1 2 3

    4 5 6

    t(data)

    1 4

    2 5

    3 6

    9.which确认TRUE的位置索引

    which(c(T,T,T,F,F))

    1 2 3

    which(x=c(-1,1,2)>0)

    2 3

    data=c(-1,1,2,3,4,5)

    data[which(data>0)]

    1 2 3 4 5

    data[-which(data>0)]

    -1

    10.cat 和 paste连接

    cat(1,2,3,4)

    1 2 3 4

    #直接返回到控制台

    paste(1,2,3,4)

    '1 2 3 4'

    #将内容连接后,返回最终的字符串作为可用的R语言对象

    #这两个函数有一个可选参数sep

    paste(c(1,2,4),'a',sep='+++')

    "1+++a" "2+++a" "4+++a"#返回的是字符串

    paste(c(1,2,3,4),rep(6,times=4),sep='')

    "16" "26" "36" "46"

    11.R语言的循环

    #for 循环

    for (条件){

    do any code in here

    }

    #while循环

    while(条件){

    do any code in here

    }

    12.apply函数家族

    apply(data,MAGERN=1/2,FUN)

    #1表示行,2表示列,3表示层,4表示块

    lapply(X, FUN, ...)

    #通过对x的每一个元素运用函数,生成一个与元素个数相同的值列表

    #X表示一个向量或者表达式对象,其余对象将被通过as.list强制转换为list

    #例:

    x

    lapply(x,mean)

    $a

    [1] 5.5

    $beta

    [1] 4.535125

    $logic

    [1] 0.5

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

    #X表示一个向量或者表达式对象,其余对象将被通过as.list强制转换为list

    # simplify 逻辑值或者字符串,如果可以,结果应该被简化为向量、矩阵或者高维数组。必须是命名的,不能是简写。默认值是TRUE,若合适将会返回一个向量或者矩阵。如果simplify=”array”,结果将返回一个阵列。

    sapply(k, paste,USE.NAMES=FALSE,1:5,sep="...")

    [,1] [,2] [,3]

    [1,] "a...1" "b...1" "c...1"

    [2,] "a...2" "b...2" "c...2"

    [3,] "a...3" "b...3" "c...3"

    [4,] "a...4" "b...4" "c...4"

    [5,] "a...5" "b...5" "c...5"

    13.编写函数

    function(){

    }

    eg:

    zhao=funciton(x,y){

    x+y

    }

    eg:

    zhao=funciton(x=3,y){ # x设为默认值

    x+y

    }

    展开全文
  • 批量处理函数有很重要的apply族函数lapply sapply apply tapply mapply。这些函数底层通过C实现,效率比手工遍历高效。apply族函数是高效能计算的运算向量化(Vectorization)实现方法之一,比起传统的for,while常常...

    简介

    批量处理函数有很重要的apply族函数:lapply sapply apply tapply mapply。这些函数底层通过C实现,效率比手工遍历高效。apply族函数是高效能计算的运算向量化(Vectorization)实现方法之一,比起传统的for,while常常能获得更好的性能。

    1. apply : 用于遍历数组中的行或列,并且使用指定函数来对其元素进行处理。
    2. lapply : 遍历列表向量内的每个元素,并且使用指定函数来对其元素进行处理。返回列表向量
    3. sapply : 与lapply基本相同,只是对返回结果进行了简化,返回的是普通向量
    4. mapply: 支持传入两个以上的列表。
    5. tapply: 接入参数INDEX,对数据分组进行运算,就和SQL中的by group一样。

    apply函数

    对矩阵、数据框、数组(二维、多维)等矩阵型数据,按行或列应用函数FUN进行循环计算,并以返回计算结果。
    apply(X, MARGIN, FUN, …)

    1. X:数组、矩阵、数据框等矩阵型数据
    2. MARGIN:按行计算或按列计算,1表示按行,2表示按列
    3. FUN:自定义的调用函数,如mean/sum等(其结果与colMeans,colSums,rowMeans,rowSums是一样的)
    > a<-matrix(1:12,c(3,4))
    > a
         [,1] [,2] [,3] [,4]
    [1,]    1    4    7   10
    [2,]    2    5    8   11
    [3,]    3    6    9   12
    > apply(a,1,function(x) sum(x)+2)
    [1] 24 28 32
    > apply(a,1,function(x) x^2)
         [,1] [,2] [,3]
    [1,]    1    4    9
    [2,]   16   25   36
    [3,]   49   64   81
    [4,]  100  121  144
    

    lapply函数

    对列表、数据框按列进行循环,输入必须为列表(list),返回值为列表(list)。
    lapply(X, FUN, …)

    1. X:列表、数据框
    2. FUN:自定义的调用函数
    b<-list(x = 1:10, y = matrix(1:12, 3, 4))
    $x
     [1]  1  2  3  4  5  6  7  8  9 10
    
    $y
         [,1] [,2] [,3] [,4]
    [1,]    1    4    7   10
    [2,]    2    5    8   11
    [3,]    3    6    9   12
    
    lapply(b, sum)  #求列表中各元素的和
    $x
    [1] 55
    
    $y
    [1] 78
    
    > a=data.frame(matrix(1:12,c(3,4)))
    > a
      X1 X2 X3 X4
    1  1  4  7 10
    2  2  5  8 11
    3  3  6  9 12
    > names(a)
    [1] "X1" "X2" "X3" "X4"
    > str(a)
    'data.frame':	3 obs. of  4 variables:
     $ X1: int  1 2 3
     $ X2: int  4 5 6
     $ X3: int  7 8 9
     $ X4: int  10 11 12
     > lapply(a, function(x) x+3)
    $X1
    [1] 4 5 6
    
    $X2
    [1] 7 8 9
    
    $X3
    [1] 10 11 12
    
    $X4
    [1] 13 14 15
    
    > a1 <- lapply(a, function(x) sum(x)+3)
    > a1
    $X1
    [1] 9
    
    $X2
    [1] 18
    
    $X3
    [1] 27
    
    $X4
    [1] 36
    > a1[1]
    $X1
    [1] 9
    
    > a1[[1]]
    [1] 9
    

    sapply函数

    类似于lapply函数,但输入为列表(list),返回值为向量。
    sapply(X, FUN, …,simplify )

    1. X:列表、矩阵、数据框
    2. FUN:自定义的调用函数
    3. simplify=F:返回值的类型是list,此时与lapply完全相同
      simplify=T(默认值):返回值的类型由计算结果定,如果函数返回值长度为1,则sapply将list简化为vector;如果返回的列表中每个元素的长度都大于1且长度相同,那么sapply将其简化位一个矩阵
    > a=data.frame(matrix(1:12,c(3,4)))
    > a   #"list"
      X1 X2 X3 X4
    1  1  4  7 10
    2  2  5  8 11
    3  3  6  9 12
    > str(a)
    'data.frame':	3 obs. of  4 variables:
     $ X1: int  1 2 3
     $ X2: int  4 5 6
     $ X3: int  7 8 9
     $ X4: int  10 11 12
    > a2 <- lapply(a, function(x) x+3)
    > a2  #"list"
    $X1
    [1] 4 5 6
    
    $X2
    [1] 7 8 9
    
    $X3
    [1] 10 11 12
    
    $X4
    [1] 13 14 15
    > str(a2)
    List of 4
     $ X1: num [1:3] 4 5 6
     $ X2: num [1:3] 7 8 9
     $ X3: num [1:3] 10 11 12
     $ X4: num [1:3] 13 14 15
    > a3 <- sapply(a, function(x) x^2)
    > a3  #"numeric"
         X1 X2 X3  X4
    [1,]  1 16 49 100
    [2,]  4 25 64 121
    [3,]  9 36 81 144
    > str(a3)
     num [1:3, 1:4] 1 4 9 16 25 36 49 64 81 100 ...
     - attr(*, "dimnames")=List of 2
      ..$ : NULL
      ..$ : chr [1:4] "X1" "X2" "X3" "X4"
    
    > b<-list(x = 1:10, y = matrix(1:12, 3, 4))
    > sapply(b, sum)
     x  y 
    55 78 
    

    sapply函数可提取列表中数据

    y<-c("100-D","100-A","110-c","110-A")
    z<-strsplit(y,"-")
    sapply(z,"[",1) #提取列表第1个元素
    sapply(z,"[",2) #提取列表中第2个元素
    
    第一行:定义一个向量y
    第二行:使用strsplit函数对向量y 按照“-”符号进行分割,得到一个列表z
    第三行:使用sapply函数提取列表z的第1个和第2个位置元素,输出结果如下:
    
    [1] "100" "100" "110" "110"
    > sapply(z,"[",2) #提取列表中第2个元素
    [1] "D" "A" "c" "A"
    

    mapply函数

    mapply是sapply的多变量版本(multivariate sapply)。
    mapply(FUN, …, MoreArgs = NULL, SIMPLIFY = TRUE, USE.NAMES = TRUE)

    > a <- mapply(function(x,y) x^y, c(1:5), c(1:5))
    > a
    [1]    1    4   27  256 3125
    > mode(a)
    [1] "numeric"
    > str(a)
     num [1:5] 1 4 27 256 3125
    > names(a)
    NULL
    > b<-matrix(1:12,c(3,4),dimnames=list(c("a","b","c"),c("A","B","C","D")))
    > b
      A B C  D
    a 1 4 7 10
    b 2 5 8 11
    c 3 6 9 12
    > mapply(sum, b[,1],b[,3],b[,4])
     a  b  c 
    18 21 24 
    > mapply(sum,b[1,],b[2,],b[3,])
     A  B  C  D 
     6 15 24 33 
    

    tapply函数

    将数据按照不同方式分组,生成类似列联表形式的数据结果。
    tapply(X, INDEX, FUN = NULL, …, default = NA, simplify = TRUE)

    1. X:数组、矩阵、数据框等分割型数据向量
    2. INDEX:一个或多个因子的列表(因子列表),每个因子的长度都与x相同
    3. FUN: 自定义的调用函数
    4. simplify指是否简化输入结果(考虑sapply对于lapply的简化)

    代码举例

    manager <- c(1, 2, 3, 4, 5)
    country <- c("US", "US", "UK", "UK", "UK")
    gender <- c("M", "F", "F", "M", "F")
    age <- c(32, 45, 25, 39, 99)
    leadership <- data.frame(manager, country, gender, age)
    tapply(leadership$age, leadership$country, mean)	#求在不同country水平下的age的均值
    
    tapply(leadership$age, list(leadership$country, leadership$gender), mean)   #求在不同country和gender交叉水平下的age的均值, 输出得到矩阵数据
    

    输出结果

         UK       US 
    54.33333 38.50000 
    
        F  M
    UK 62 39
    US 45 32
    
    展开全文
  • R语言提供了批量处理函数,可以循环遍历某个集合内的所有或部分元素,以简化操作。 这些函数底层是通过C来实现的,所以效率也比手工遍历来的高效。 批量处理函数有很重要的apply族函数lapply sapply apply ...
  • 满意答案函数主体可以是一系列表达式,这些表达式需要用大括号括起来:function(param1, ..., paramN) {expr1...exprM}讨论函数的定义告诉R软件“用何种方式进行计算”。例如,R软件没有内置计算变异系数的函数,...
  • R语言基础系列:你知道R中的赋值符号箭头(<-)和等号(=)的区别吗?1数据类型(向量、数组、矩阵、 列表和数据框)2读写数据所需的主要函数、与外部环境交互3数据筛选——提取对象的...
  • R语言apply函数

    2019-11-19 23:50:33
    R语言中的apply函数簇可以不通过for循环方式,实现对象迭代处理。可以有效提高运行效率。 包括:lapply、sapply、vapply、mapply、tapply、apply。 lapply lapply接收一个向量和一个函数作为函数lapply(list,FUN,...
  • R语言是一个擅长处理数据的语言,但是也不可避免的需要处理一些字符串(文本数据)。如何高效地处理文本数据,将看似杂乱无章的数据整理成可以进行统计分析的规则数据,是『数据玩家』必备的一项重要技能。在编程语言...
  • 对数据集进行操作的时候,我们经常需要写循环操作,比如对于矩阵的每一列计算它的平均值等等,而R语言的向量化操作可以节省非常多循环的代码。所以说在R语言里面,当你要写循环的时候,一定要对自己先说三遍,不写...
  • apply函数 对矩阵、数据框、数组(二维、多维)等矩阵型数据,按行或列应用函数FUN进行循环计算,并以返回计算结果 apply(X, MARGIN, FUN, ...) X:数组、矩阵、数据框等矩阵型数据 MARGIN: 按行计算或按按列计算,1...
  • 【数据分析R语言系列】R语言函数函数式编程、作用域和apply 家族
  • 【往期回顾】 R语言 | 第一部分:数据预处理 R语言|第2讲:生成数据 R语言常用的数据输入与输出方法 | 第三讲 R语言数据管理与dplyr、tidyr | 第4讲 R语言 控制流:for、while、ifelse和自定义函数function|...
  • R语言最优秀的是它的向量化编程,这其中apply族函数扮演了非常重要的角色。apply族函数是由apply、sapply、lapply、mapply、tapply等函数组成的。熟练使用apply族函数,能够简化程序,提高代码的运算速度。软件&...
  • R中主要的循环函数(loop functions)有 lapply( )、sapply( )、apply( )、tapply( ) 和 mapply( )。lapply( )lapply( )对列表中每个元素,包括各种类型的对象(向量、矩阵、数据框等),运用函数,返回一个新的列表。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,319
精华内容 527
关键字:

r语言lapply函数