发个学习贴，新手可以进来看看一些问题的理解

superdesolator

36.R中伪数据库的方法

我们知道R把数据存在例如MYSQL的数据库,想要什么拿什么的操作,我们已经可以实现了,COS里很多大牛都介绍过,大致是使用类似SQLquery，connection，fetch之类的函数（前提是你装了MYSQL，和RMYSQL包），这个东西非常赞，1个月前我花了一天时间在COS某大神的指导下弄好了，最后还是32位编译等的问题（哎，这些东西我还是以后慢慢学吧，其实我现在才发现，学R就是学整个计算机技术。。。）

那么我们看看，我们怎么用R来建造伪数据库，以及如何调用，下面是最简单的初步，抛砖引玉:

a.1=1:5<br />
a.2=6:10<br />
a.3=11:15<br />
save(a.1,file='a.1.rda');save(a.2,file='a.2.rda');save(a.3,file='a.3.rda');<br />

然后我们重新开个Rconsole：

{ theob=vector('list',3);<br />
for( i in 1:3) {<br />
 obname=paste('a.',i,sep='')<br />
 load(paste(obname,'.rda',sep=''))<br />
 theob[[i]]=get(obname)<br />
rm(list=obname)<br />
 }<br />
a=do.call('c',theob);}<br />

然后调用a，而且内存中a.1。。都没有不占内存：

R>a<br />
 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15<br />
R>a.1<br />
Error: object 'a.1' not found<br />
R><br />

例子虽然简单，但是其中的方法思想确实是很好！

superdesolator

37.R中向量化初步

由于R是用向量化的,就像MATLAB用矩阵一样.

首先上代码,R中的向量化和矩阵操作的例子:

R>a=matrix(1:4,2)<br />
R>b=matrix(2:5,2)<br />
R>a<br />
     [,1] [,2]<br />
[1,]    1    3<br />
[2,]    2    4<br />
R>b<br />
     [,1] [,2]<br />
[1,]    2    4<br />
[2,]    3    5<br />
R>a*b<br />
     [,1] [,2]<br />
[1,]    2   12<br />
[2,]    6   20<br />
R>a%*%b<br />
     [,1] [,2]<br />
[1,]   11   19<br />
[2,]   16   28<br />
R>a*2<br />
     [,1] [,2]<br />
[1,]    2    6<br />
[2,]    4    8<br />
R>a^2<br />
     [,1] [,2]<br />
[1,]    1    9<br />
[2,]    4   16<br />

可以看到不同于MATLAB的.*,*这里大家要小心注意.

很多函数可以自动把参数当作向量（也许理解有错），但有些不行：

R>sum(1,2,3)<br />
[1] 6<br />
R>mean(1,2,3)<br />
[1] 1<br />
R>mean(c(1,2,3))<br />
[1] 2<br />
R>

如果把if向量化：

R>x=1;<br />
R>if(x<0) y=1 else y=-1<br />
R>y<br />
[1] -1<br />
R>x=1:3;<br />
R>if(x<0) y=1 else y=-1<br />
Warning message:<br />
In if (x < 0) y = 1 else y = -1 :<br />
  the condition has length > 1 and only the first element will be used<br />
R>y=ifelse(x<0,1,-1)<br />
R>y<br />
[1] -1 -1 -1<br />

以及谈到apply系列避免循环，R神曲中说，apply系列定义的时候里面是有循环的。。。。

最后给个比较好的例子，有深度了

<br />
x[is.na(x)]=0<br />
#在矩阵X很大的时候，但行数比列数多的多的时候来的没有下面的方法快<br />
for(i in ncol(x)) x[is.na(x[,i]),i]=0 #我想类似的道理可以用在那些90W行30多列的矩阵中

还有一些注意的：

x=matrix(1:9,3)<br />
apply(x,2,sum)<br />
#与colSums(x)一样，类似的还有rowMeans(x)

PS：这部分我个人感觉比较琐碎，因为我本人到现在也还是没有真正理解到底向量化快还是不快，以及什么时候用了向量化，什么时候没用等问题。。。。不过上面的几点可能都是我们要注意的

再补充下:数据框data.frame它的primary是list,matrix 和 array 的primary的vector,factor的primary是integer,而data.frame,matrix,array,factor都是object,数据框是广义的矩阵，矩阵是特殊的数组。。

有点头晕。。但是你如果你看过前面的S3 classes也许容易理解一些

superdesolator

38.R中的一些帮助函数

help.start()可以出现R帮助文档的页面，注意这不用联网就可以，只不过是HTML格式的而已，具体在options里可以改

help("sum")或？sum 这个不用说了吧

help.search("su")这个是在本地的文档中搜索含有su的关键词的帮助文档

example("sum")顾名思义

RSiteSearch("sum") 这个是以sum为关键词搜索在线文档和邮件列表存档

apropos("sum",mode="function")列出名称中含有sum的所有可用函数

superdesolator

39.attach(),with()函数

相信大家都知道attach()函数的作用了，但如果没读R in action一书的话，我们可能又要出错了，请看下例：

R>a=data.frame(b=c(1:2),c=c("m","f"))<br />
R>a<br />
  b c<br />
1 1 m<br />
2 2 f<br />
R>b<br />
Error: object 'b' not found<br />
R>a$b<br />
[1] 1 2<br />
R>b<br />
Error: object 'b' not found<br />
R>attach(a)<br />
R>b<br />
[1] 1 2<br />
R>#有基础的同学到这里都可以懂,但是下面要注意<br />
R>rm(list=ls())<br />
R>a=data.frame(b=c(1:2),c=c("m","f"))<br />
R>b=c(2:3)<br />
R>attach(a)<br />
The following object is masked _by_ .GlobalEnv:</p>
<p>    b<br />
The following object is masked from a (position 3):</p>
<p>    b, c<br />
R>b<br />
[1] 2 3<br />
R>#可以看出R用的是attach()之前的b，但我们程序比较多的时候，不要轻易使用attach()

那么该怎么对a操作呢，比如我想算b的均值，当然可以mean(a$b),也可以用上面可能会混乱的attach(a),mean(b)，下面我们用with()，之前我一直以为with()不就是对一个东西进行一些操作么，没深入看，现在发现，可以直接在with里用b：

R>b=c(2:3)<br />
R>a=data.frame(b=c(1:2),c=c("m","f"))<br />
R>a<br />
  b c<br />
1 1 m<br />
2 2 f<br />
R>with(a,mean(b))<br />
[1] 1.5

PS:更有兴趣的同学可以查查within(),它还能让你修改数据框

superdesolator

40.数据的标准化处理方法

记得2个月前,我帮别人做回归分析,当时我是知道R用lm，但是有些问题是要把数据标准化之后去lm的，因为存在着量纲等因素的影响，我却不知道怎么把数据标准化，当然土办法，按均值方差的定义对数据框操作也可以，不过2个月前，我可什么都不会，只知道，哦，给我一个数据处理好的数据框，我lm(y~x1+x2+..)就可以了，然后用什么step啊,再看看结果之类的，最后现学了EXCEL操作,你懂的。。。

其实数据标准化就是mean,var的组合，知道R里用自带的函数scale()是关键：

R>x=data.frame(a=c(1:5),b=c(2:4,6,7))<br />
R>x<br />
  a b<br />
1 1 2<br />
2 2 3<br />
3 3 4<br />
4 4 6<br />
5 5 7<br />
R>scale(x)<br />
              a          b<br />
[1,] -1.2649111 -1.1573828<br />
[2,] -0.6324555 -0.6751400<br />
[3,]  0.0000000 -0.1928971<br />
[4,]  0.6324555  0.7715885<br />
[5,]  1.2649111  1.2538313<br />

scale()函数完整的是scale(x,center=TRUE,scale=TURE),一个控中心，一个控标准，统计学的应该很轻松的来理解

scale()默认的是0,1标准那么怎么任意的标准呢，scale()*sd+mu,就行了，统计学背景的又要切了，呵呵。。

最后来看下，不对整个数据框的操作而对想要的某些列标准化：

R>x<br />
  a b<br />
1 1 2<br />
2 2 3<br />
3 3 4<br />
4 4 6<br />
5 5 7<br />
R>transform(x,a=scale(a))<br />
           a b<br />
1 -1.2649111 2<br />
2 -0.6324555 3<br />
3  0.0000000 4<br />
4  0.6324555 6<br />
5  1.2649111 7<br />
R>

能够学会灵活处理标准化了，自然对于我们做多元线性回归是极其有用的。。2个月前我知道这样做的话，就不用折腾EXCEL了。。。

superdesolator

41.R中日期问题的处理方法

很多时候，我们都会对日期进行处理，特别是数据从EXCEL导入的时候，大部分都带时间日期，而我们要做的，可能就是根据这些时间日期来进行处理，比如算2010-07-09到2010-07-18内的某个列的平均值之类的事情,下面我就来简单介绍下适合初级入门的R中时间日期的处理方法。

首先是format函数，大家可以?foramt然后看下面

R>format(Sys.time(), "%a %b %d %X %Y %Z")<br />
[1] "周四 十月 31 16:04:22 2013 CST"

大家可以对照着?format中自己找%加个字母都表示的什么意思，相信大家通过format函数可以了解R中日期时间的格式了

下面我们就问了，如果我的格式是

R>date <- c("02/27/92")<br />
R>date<br />
[1] "02/27/92"

我怎么写成我想要的格式呢，比如写成

"1992-02-27 "

这就要用到上面的format格式的%字母的意思和strptime函数了，对上面的问题，我们如下：

R>newdate=strptime(date,"%m/%d/%y")<br />
R>newdate<br />
[1] "1992-02-27"

聪明的你很快发现，啊，原来是指定02是%m,如果我们指定02是%d呢？他就变成了天数了！同样对于小时，分，秒我们都可以指定

有了这2个函数其实我们已经可以做很多事了，下面我们来看个具体的例子（这个例子也是COS里有人问过的）：

他要完成的事情是算出，每一天每小时，出现的code有多少种，代码如下：

x <- data.frame(time= strptime(c('2013-01-01 06:13:23', '2013-01-01 06:25:32', '2013-01-01 08:12:28', '2013-01-01 08:13:23', '2013-01-01 08:34:47', '2013-01-01 08:43:56' ),format= "%Y-%m-%d %H:%M:%S"),<br />
code= c('a','b','a','a','a','a')<br />
)<br />
x$day <- as.factor(format(x$time, "%Y-%m-%d"))<br />
x$hour <-as.factor(format(x$time, "%H"))<br />
tapply(x$code, list(x$day, x$hour), unique)

我们可以看到，先指定格式，告诉R，%m代表什么，%H代表什么等等，然后用年，月，日作为一个整体当做因子，小时当作因子，这样我们就可以区分每一天，和一天中的每小时的区别了，这就是上面介绍的2个函数加上一些因子变量的强大功能！大家可以仔细研究下这个例子，非常有价值

这个时候，问题又来了，大家可能也注意到了，上面的日期是字符串啊，我们顶多把字符串当做因子做一些事情，可具体比较2个日期的大小，该怎么比呢？？

比如我要比较

”2013-07-08"和"2013-07-09"

其实准确来说，我们通常都会做日期介于哪2个日期之间的事情，而不是比较大小，显然我们不可能通过字符串直接得到信息，一个简单的办法是用strsplit把日期拆成年，月，日再转成numeric比较，另一个方法就是让R自己找出来！方法就是as.POSIXIlt这个函数

R>now <- as.POSIXlt(Sys.time())<br />
R>now<br />
[1] "2013-10-31 17:13:03 CST"<br />
R>now$year<br />
[1] 113<br />
R>now$mon<br />
[1] 9<br />
R>now$mday<br />
[1] 31<br />

这可都是numeric的数值，再比较大小，就很好比较了吧？如果想知道更多如now$wday，就?POSIXIlt看吧！

基本到这里就结束了，但是有高手介绍了一个xts的包，挺适合“懒'的人。。。大家可以点这里

superdesolator

42.R中...的含义

以下内容搬砖：

泛型用的吧。简单来说就是mean是个泛型函数，换句话说只是个空壳，它的真正作用是调用变量x所属的数据类型的mean方法。这意味着对于不同类型的变量x，mean将分别调用不同的真实函数。因为实际执行的方法，也就是真实的函数不同，这些函数所要求的参数表也不同，而这些不同的函数对参数的不同要求不可能全部放在mean这个空壳子泛型函数的参数名单里，所以只好用...占位，表示针对不同类型的x，...这里可以按照真实的函数的要求写入不同的附加参数值。

举个例子，比方说我现在把一个numeric的向量分别包装成两个S3类，一个叫foo类，一个叫bar类。然后给这两个类分别指定mean方法：

fooA<-barA<-1:10

class(fooA)='foo'

class(barA)='bar'

mean.foo=function(fooX,numFoo) mean(as.numeric(fooX))*numFoo

mean.bar=function(barX,numBar) mean(as.numeric(fooX))/numBar这时候执行mean(fooA)就会直接调用mean.foo(fooA,...)，执行mean(barA)就会直接调用mean.bar(barA,...)了。而我们看到mean.foo和mean.bar这两个函数都需要两个参数，而表达式mean(fooA)中只给了一个参数，解释器不知道numtFoo和numBar的值，就会报错。所以我们就要在执行mean这个空壳的泛型函数时用...把实际所调用的方法所额外需要的其他参数值传递进去。所以mean函数实际过程中就应该如下方法使用：

> mean(fooA,numFoo=2) #i.e. mean.foo(fooA,numFoo=2)

[1] 11

> mean(barA,numBar=2) #i.e. mean.bar(barA,numBar=2)

[1] 2.75

点这里看原贴

superdesolator

43.R中内存机制的讨论初步

点这里看10楼,就不复制粘贴

了

max

好贴，顶顶顶！！！

superdesolator

44.R语言lexical scope浅谈

稍微查了下资料，我觉得lexical scope貌似与static scope是一个意思？（如果错了，希望高手纠正）它们有别于dynamic scope.下面跟着我简单熟悉下R的lexical scope（词法作用域）(资料大部分整理自网络，加上自己的理解）

首先，先上例子

 n=3<br />
cube <- function(n) {<br />
sq <- function() n*n<br />
 n*sq()}<br />
cube(2)

这个例子，大多数学过c/c++,java等语言的同学可以一眼看出答案，没错是8

我们再看：

h = function () {<br />
  f = function () {<br />
  g = function () a+b<br />
 a = 10<br />
 g()<br />
}<br />
a = 100<br />
b=200<br />
 f()<br />
}<br />
b=3<br />
h()<br />

这个例子就比较复杂了，但要慢慢推理还是可以推出答案是210，如果我去掉b=200呢，那答案就是13，如果同学们看到这里没理解的，务必要理解，这里的概念只有函数作用域和全局作用域，可比加上一个类作用域的C++要简单多了吧..函数里面找不到就一直往外找，找到了就是，所以a=10在f里面找到，b=200没去掉,则在h里面找到，去掉则在全局找到b=3

上面的理解透了，下面就是重点了：

b=1</p>
<p>f = function ()<br />
{<br />
  g = function () a+b<br />
  a = 10<br />
 g()<br />
}</p>
<p>h = function () {<br />
a = 100<br />
  b = 200<br />
    f()<br />
}<br />
h()

这个时候答案是多少？？嘿嘿！答案是11.别慌！这就是lexical scope的精髓了，为什么是11而不是210呢？

词法就是程序文本，词法作用域就是根据程序文本来确定作用域，那我们的f定义在了全局作用域，编译的时候它的b的值就绑定到了b=1上面，所以运行的时候就是11，而上个例子其实本质是f定义在了h里，它的b编译的时候绑定到了b=200，大多数语言都是用这个lexical scope（或者static scope?)，比如C：

<br />
#include  <stdio.h><br />
int x= 5;<br />
int f(){<br />
return x;<br />
}</p>
<p>int g(){<br />
int x = 1;<br />
return f();<br />
}</p>
<p>

g()答案就是5，而如果采用动态作用域规则答案就是1（这里不讨论dynamic scope咱水平没到那个地步）

好了，更深入的理解大家可以自己搜搜去研究研究，总之它的核心就是根据程序文本，编译的时候绑定变量的值[s:11]

reedom

多谢分享，学习了！

superdesolator

45.Advanced R programming手记

by yiluheihei

这个帖子是作者摘自Advanced R programming一书的一些心得，我觉得非常好，只是我自己还没时间去看这本书，以后是一定会去看的

原贴的地址

tina_007

回复第72楼的 superdesolator：楼主用的什么软件？语法高亮做的很好，RStudio没有。

superdesolator

回复第73楼的 tina_007：代码可以放到

标签中，数据可以放到[data][/data]标签中

tina_007

回复第74楼的 superdesolator：

<br />
m=matrix(NA)<br />
for (i in 1:5)<br />
m[i]=paste0(i,"%")<br />

<bblatex>x^2+y^2=1</bblatex>

应该是这样，果然有效果了，谢大佬最初的帖子里有写，刚细读看到了。

superdesolator

46.R中类型的一些概念

纯搬砖，原帖地址点这里

R中一般可以使用 typeof 或者 class 来判定类别。

对于 typeof，返回的值只可能是R中定义的那几种，"logical", "integer", "double", "complex" ... 所以并不是面向对象的。重要的是，factor 并不在这几种之内。

class 可以被用作定义/判定面向对象的类型。例子，

</p>
<p>a <- factor(c("a", "b", "c"))<br />
class(a)<br />
typeof(a)<br />

而 inherits 对应的是 class 中定义的类别，例子（接上），

<br />
class(a) <- c("myClass")<br />
class(a)<br />
class(a) == "myClass"<br />
inherits(a, "myClass")

但是，用 inherits 要好于用 == 判别，因为一个 object 可以对应多个 S3 类型，举例（接上），

<br />
class(a) <- c("myClass1", "myClass2")<br />
class(a) == "myClass1"<br />
inherits(a, "myClass1")

所以 inherits 更类似于

</p>
<p>"myClass1" %in% class(a)

superdesolator

47.如何为R类添加类方法初步

本来我是想把这个链接直接放在55楼34s3初步那里的，但怎奈没办法编辑，只好另开一贴：

原贴传送地址

holydudu

有两个小问题

一个是关于do.call(f,x)的速度，有种感觉，当x的size大到一定程度时候，就特别慢了

举个例子，

<br />
do.call(rbind, datalist)<br />

当datalist长度1，000以内的话，基本都是1秒内就完成了

当datalist长度为100，000时话，这时候就要好久，大概要30分钟左右吧

我觉得1秒×100应该是很快就执行完了，这是这里明显不是这么可加性的时间关系，大概是超可加性吧。

二是，关于楼主提到的R神曲是什么，apply家族系列是什么样的循环，我很好奇，希望楼主分享一下。

谢谢！

superdesolator

第一个问题我无力回答，第二，你提到的英文名 The R Inferno by Patrick Burns,apply你可以去学R语言艺术，R语言实战等都应该提到或者你直接打?apply

holydudu

回复第79楼的 superdesolator：

多谢提供，又发现一个神奇的R参考书，apply系列我倒是一直在用，只是一直盲目的认为apply是为了避免循环，里面就肯定不会有循环，值得学习的地方还是很多啊